1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
# Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)
import os
import os.path
import spack
from spack.spec import Spec
from spack.cmd.external import ExternalPackageEntry
from spack.main import SpackCommand
def test_find_external_single_package(mock_executable):
pkgs_to_check = [spack.repo.get('cmake')]
cmake_path = mock_executable("cmake", output='echo "cmake version 1.foo"')
system_path_to_exe = {cmake_path: 'cmake'}
pkg_to_entries = spack.cmd.external._get_external_packages(
pkgs_to_check, system_path_to_exe)
pkg, entries = next(iter(pkg_to_entries.items()))
single_entry = next(iter(entries))
assert single_entry.spec == Spec('cmake@1.foo')
def test_find_external_two_instances_same_package(mock_executable):
pkgs_to_check = [spack.repo.get('cmake')]
# Each of these cmake instances is created in a different prefix
cmake_path1 = mock_executable(
"cmake", output='echo "cmake version 1.foo"', subdir=('base1', 'bin')
)
cmake_path2 = mock_executable(
"cmake", output='echo "cmake version 3.17.2"', subdir=('base2', 'bin')
)
system_path_to_exe = {
cmake_path1: 'cmake',
cmake_path2: 'cmake'}
pkg_to_entries = spack.cmd.external._get_external_packages(
pkgs_to_check, system_path_to_exe)
pkg, entries = next(iter(pkg_to_entries.items()))
spec_to_path = dict((e.spec, e.base_dir) for e in entries)
assert spec_to_path[Spec('cmake@1.foo')] == (
spack.cmd.external._determine_base_dir(os.path.dirname(cmake_path1)))
assert spec_to_path[Spec('cmake@3.17.2')] == (
spack.cmd.external._determine_base_dir(os.path.dirname(cmake_path2)))
def test_find_external_update_config(mutable_config):
entries = [
ExternalPackageEntry(Spec.from_detection('cmake@1.foo'), '/x/y1/'),
ExternalPackageEntry(Spec.from_detection('cmake@3.17.2'), '/x/y2/'),
]
pkg_to_entries = {'cmake': entries}
spack.cmd.external._update_pkg_config(pkg_to_entries, False)
pkgs_cfg = spack.config.get('packages')
cmake_cfg = pkgs_cfg['cmake']
cmake_externals = cmake_cfg['externals']
assert {'spec': 'cmake@1.foo', 'prefix': '/x/y1/'} in cmake_externals
assert {'spec': 'cmake@3.17.2', 'prefix': '/x/y2/'} in cmake_externals
def test_get_executables(working_env, mock_executable):
cmake_path1 = mock_executable("cmake", output="echo cmake version 1.foo")
os.environ['PATH'] = ':'.join([os.path.dirname(cmake_path1)])
path_to_exe = spack.cmd.external._get_system_executables()
assert path_to_exe[cmake_path1] == 'cmake'
external = SpackCommand('external')
def test_find_external_cmd(mutable_config, working_env, mock_executable):
"""Test invoking 'spack external find' with additional package arguments,
which restricts the set of packages that Spack looks for.
"""
cmake_path1 = mock_executable("cmake", output="echo cmake version 1.foo")
prefix = os.path.dirname(os.path.dirname(cmake_path1))
os.environ['PATH'] = ':'.join([os.path.dirname(cmake_path1)])
external('find', 'cmake')
pkgs_cfg = spack.config.get('packages')
cmake_cfg = pkgs_cfg['cmake']
cmake_externals = cmake_cfg['externals']
assert {'spec': 'cmake@1.foo', 'prefix': prefix} in cmake_externals
def test_find_external_cmd_not_buildable(
mutable_config, working_env, mock_executable):
"""When the user invokes 'spack external find --not-buildable', the config
for any package where Spack finds an external version should be marked as
not buildable.
"""
cmake_path1 = mock_executable("cmake", output="echo cmake version 1.foo")
os.environ['PATH'] = ':'.join([os.path.dirname(cmake_path1)])
external('find', '--not-buildable', 'cmake')
pkgs_cfg = spack.config.get('packages')
assert not pkgs_cfg['cmake']['buildable']
def test_find_external_cmd_full_repo(
mutable_config, working_env, mock_executable, mutable_mock_repo):
"""Test invoking 'spack external find' with no additional arguments, which
iterates through each package in the repository.
"""
exe_path1 = mock_executable(
"find-externals1-exe", output="echo find-externals1 version 1.foo"
)
prefix = os.path.dirname(os.path.dirname(exe_path1))
os.environ['PATH'] = ':'.join([os.path.dirname(exe_path1)])
external('find')
pkgs_cfg = spack.config.get('packages')
pkg_cfg = pkgs_cfg['find-externals1']
pkg_externals = pkg_cfg['externals']
assert {'spec': 'find-externals1@1.foo', 'prefix': prefix} in pkg_externals
def test_find_external_merge(mutable_config, mutable_mock_repo):
"""Check that 'spack find external' doesn't overwrite an existing spec
entry in packages.yaml.
"""
pkgs_cfg_init = {
'find-externals1': {
'externals': [{
'spec': 'find-externals1@1.1',
'prefix': '/preexisting-prefix/'
}],
'buildable': False
}
}
mutable_config.update_config('packages', pkgs_cfg_init)
entries = [
ExternalPackageEntry(
Spec.from_detection('find-externals1@1.1'), '/x/y1/'
),
ExternalPackageEntry(
Spec.from_detection('find-externals1@1.2'), '/x/y2/'
)
]
pkg_to_entries = {'find-externals1': entries}
spack.cmd.external._update_pkg_config(pkg_to_entries, False)
pkgs_cfg = spack.config.get('packages')
pkg_cfg = pkgs_cfg['find-externals1']
pkg_externals = pkg_cfg['externals']
assert {'spec': 'find-externals1@1.1',
'prefix': '/preexisting-prefix/'} in pkg_externals
assert {'spec': 'find-externals1@1.2',
'prefix': '/x/y2/'} in pkg_externals
def test_list_detectable_packages(mutable_config, mutable_mock_repo):
external("list")
assert external.returncode == 0
def test_packages_yaml_format(mock_executable, mutable_config, monkeypatch):
# Prepare an environment to detect a fake gcc
gcc_exe = mock_executable('gcc', output="echo 4.2.1")
prefix = os.path.dirname(gcc_exe)
monkeypatch.setenv('PATH', prefix)
# Find the external spec
external('find', 'gcc')
# Check entries in 'packages.yaml'
packages_yaml = spack.config.get('packages')
assert 'gcc' in packages_yaml
assert 'externals' in packages_yaml['gcc']
externals = packages_yaml['gcc']['externals']
assert len(externals) == 1
external_gcc = externals[0]
assert external_gcc['spec'] == 'gcc@4.2.1 languages=c'
assert external_gcc['prefix'] == os.path.dirname(prefix)
assert 'extra_attributes' in external_gcc
extra_attributes = external_gcc['extra_attributes']
assert 'prefix' not in extra_attributes
assert extra_attributes['compilers']['c'] == gcc_exe
def test_overriding_prefix(mock_executable, mutable_config, monkeypatch):
# Prepare an environment to detect a fake gcc that
# override its external prefix
gcc_exe = mock_executable('gcc', output="echo 4.2.1")
prefix = os.path.dirname(gcc_exe)
monkeypatch.setenv('PATH', prefix)
@classmethod
def _determine_variants(cls, exes, version_str):
return 'languages=c', {
'prefix': '/opt/gcc/bin',
'compilers': {'c': exes[0]}
}
gcc_cls = spack.repo.path.get_pkg_class('gcc')
monkeypatch.setattr(gcc_cls, 'determine_variants', _determine_variants)
# Find the external spec
external('find', 'gcc')
# Check entries in 'packages.yaml'
packages_yaml = spack.config.get('packages')
assert 'gcc' in packages_yaml
assert 'externals' in packages_yaml['gcc']
externals = packages_yaml['gcc']['externals']
assert len(externals) == 1
assert externals[0]['prefix'] == '/opt/gcc/bin'
def test_new_entries_are_reported_correctly(
mock_executable, mutable_config, monkeypatch
):
# Prepare an environment to detect a fake gcc
gcc_exe = mock_executable('gcc', output="echo 4.2.1")
prefix = os.path.dirname(gcc_exe)
monkeypatch.setenv('PATH', prefix)
# The first run will find and add the external gcc
output = external('find', 'gcc')
assert 'The following specs have been' in output
# The second run should report that no new external
# has been found
output = external('find', 'gcc')
assert 'No new external packages detected' in output
|
