diff options
54 files changed, 579 insertions, 526 deletions
diff --git a/lib/spack/spack/test/architecture.py b/lib/spack/spack/test/architecture.py index 1656b02695..3e4b0412dc 100644 --- a/lib/spack/spack/test/architecture.py +++ b/lib/spack/spack/test/architecture.py @@ -213,7 +213,9 @@ def test_satisfy_strict_constraint_when_not_concrete(architecture_tuple, constra str(archspec.cpu.host().family) != "x86_64", reason="tests are for x86_64 uarch ranges" ) def test_concretize_target_ranges(root_target_range, dep_target_range, result, monkeypatch): - spec = Spec(f"a %gcc@10 foobar=bar target={root_target_range} ^b target={dep_target_range}") + spec = Spec( + f"pkg-a %gcc@10 foobar=bar target={root_target_range} ^pkg-b target={dep_target_range}" + ) with spack.concretize.disable_compiler_existence_check(): spec.concretize() - assert spec.target == spec["b"].target == result + assert spec.target == spec["pkg-b"].target == result diff --git a/lib/spack/spack/test/build_environment.py b/lib/spack/spack/test/build_environment.py index a44a8c77af..a47fb28811 100644 --- a/lib/spack/spack/test/build_environment.py +++ b/lib/spack/spack/test/build_environment.py @@ -457,14 +457,14 @@ def test_parallel_false_is_not_propagating(default_mock_concretization): # a foobar=bar (parallel = False) # | # b (parallel =True) - s = default_mock_concretization("a foobar=bar") + s = default_mock_concretization("pkg-a foobar=bar") spack.build_environment.set_package_py_globals(s.package, context=Context.BUILD) - assert s["a"].package.module.make_jobs == 1 + assert s["pkg-a"].package.module.make_jobs == 1 - spack.build_environment.set_package_py_globals(s["b"].package, context=Context.BUILD) - assert s["b"].package.module.make_jobs == spack.build_environment.determine_number_of_jobs( - parallel=s["b"].package.parallel + spack.build_environment.set_package_py_globals(s["pkg-b"].package, context=Context.BUILD) + assert s["pkg-b"].package.module.make_jobs == spack.build_environment.determine_number_of_jobs( + parallel=s["pkg-b"].package.parallel ) diff --git a/lib/spack/spack/test/build_systems.py b/lib/spack/spack/test/build_systems.py index 4e856a925d..57516b445c 100644 --- a/lib/spack/spack/test/build_systems.py +++ b/lib/spack/spack/test/build_systems.py @@ -97,7 +97,7 @@ class TestTargets: @pytest.mark.usefixtures("mock_packages") class TestAutotoolsPackage: def test_with_or_without(self, default_mock_concretization): - s = default_mock_concretization("a") + s = default_mock_concretization("pkg-a") options = s.package.with_or_without("foo") # Ensure that values that are not representing a feature @@ -129,7 +129,7 @@ class TestAutotoolsPackage: assert "--without-lorem-ipsum" in options def test_none_is_allowed(self, default_mock_concretization): - s = default_mock_concretization("a foo=none") + s = default_mock_concretization("pkg-a foo=none") options = s.package.with_or_without("foo") # Ensure that values that are not representing a feature diff --git a/lib/spack/spack/test/cmd/ci.py b/lib/spack/spack/test/cmd/ci.py index ff37a00997..c101805032 100644 --- a/lib/spack/spack/test/cmd/ci.py +++ b/lib/spack/spack/test/cmd/ci.py @@ -106,24 +106,24 @@ and then 'd', 'b', and 'a' to be put in the next three stages, respectively. """ builder = repo.MockRepositoryBuilder(tmpdir) - builder.add_package("g") - builder.add_package("f") - builder.add_package("e") - builder.add_package("d", dependencies=[("f", None, None), ("g", None, None)]) - builder.add_package("c") - builder.add_package("b", dependencies=[("d", None, None), ("e", None, None)]) - builder.add_package("a", dependencies=[("b", None, None), ("c", None, None)]) + builder.add_package("pkg-g") + builder.add_package("pkg-f") + builder.add_package("pkg-e") + builder.add_package("pkg-d", dependencies=[("pkg-f", None, None), ("pkg-g", None, None)]) + builder.add_package("pkg-c") + builder.add_package("pkg-b", dependencies=[("pkg-d", None, None), ("pkg-e", None, None)]) + builder.add_package("pkg-a", dependencies=[("pkg-b", None, None), ("pkg-c", None, None)]) with repo.use_repositories(builder.root): - spec_a = Spec("a").concretized() + spec_a = Spec("pkg-a").concretized() spec_a_label = ci._spec_ci_label(spec_a) - spec_b_label = ci._spec_ci_label(spec_a["b"]) - spec_c_label = ci._spec_ci_label(spec_a["c"]) - spec_d_label = ci._spec_ci_label(spec_a["d"]) - spec_e_label = ci._spec_ci_label(spec_a["e"]) - spec_f_label = ci._spec_ci_label(spec_a["f"]) - spec_g_label = ci._spec_ci_label(spec_a["g"]) + spec_b_label = ci._spec_ci_label(spec_a["pkg-b"]) + spec_c_label = ci._spec_ci_label(spec_a["pkg-c"]) + spec_d_label = ci._spec_ci_label(spec_a["pkg-d"]) + spec_e_label = ci._spec_ci_label(spec_a["pkg-e"]) + spec_f_label = ci._spec_ci_label(spec_a["pkg-f"]) + spec_g_label = ci._spec_ci_label(spec_a["pkg-g"]) spec_labels, dependencies, stages = ci.stage_spec_jobs([spec_a]) @@ -1290,7 +1290,7 @@ def test_ci_generate_override_runner_attrs( spack: specs: - flatten-deps - - a + - pkg-a mirrors: some-mirror: https://my.fake.mirror ci: @@ -1307,12 +1307,12 @@ spack: - match: - dependency-install - match: - - a + - pkg-a build-job: tags: - specific-a-2 - match: - - a + - pkg-a build-job-remove: tags: - toplevel2 @@ -1372,8 +1372,8 @@ spack: assert global_vars["SPACK_CHECKOUT_VERSION"] == git_version or "v0.20.0.test0" for ci_key in yaml_contents.keys(): - if ci_key.startswith("a"): - # Make sure a's attributes override variables, and all the + if ci_key.startswith("pkg-a"): + # Make sure pkg-a's attributes override variables, and all the # scripts. Also, make sure the 'toplevel' tag doesn't # appear twice, but that a's specific extra tag does appear the_elt = yaml_contents[ci_key] @@ -1781,7 +1781,7 @@ def test_ci_generate_read_broken_specs_url( tmpdir, mutable_mock_env_path, install_mockery, mock_packages, monkeypatch, ci_base_environment ): """Verify that `broken-specs-url` works as intended""" - spec_a = Spec("a") + spec_a = Spec("pkg-a") spec_a.concretize() a_dag_hash = spec_a.dag_hash() @@ -1807,7 +1807,7 @@ def test_ci_generate_read_broken_specs_url( spack: specs: - flatten-deps - - a + - pkg-a mirrors: some-mirror: https://my.fake.mirror ci: @@ -1815,9 +1815,9 @@ spack: pipeline-gen: - submapping: - match: - - a + - pkg-a - flatten-deps - - b + - pkg-b - dependency-install build-job: tags: diff --git a/lib/spack/spack/test/cmd/common/arguments.py b/lib/spack/spack/test/cmd/common/arguments.py index 80688d2e19..167130816f 100644 --- a/lib/spack/spack/test/cmd/common/arguments.py +++ b/lib/spack/spack/test/cmd/common/arguments.py @@ -80,42 +80,42 @@ def test_match_spec_env(mock_packages, mutable_mock_env_path): """ # Initial sanity check: we are planning on choosing a non-default # value, so make sure that is in fact not the default. - check_defaults = spack.cmd.parse_specs(["a"], concretize=True)[0] + check_defaults = spack.cmd.parse_specs(["pkg-a"], concretize=True)[0] assert not check_defaults.satisfies("foobar=baz") e = ev.create("test") - e.add("a foobar=baz") + e.add("pkg-a foobar=baz") e.concretize() with e: - env_spec = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["a"])[0]) + env_spec = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-a"])[0]) assert env_spec.satisfies("foobar=baz") assert env_spec.concrete def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path): e = ev.create("test") - e.add("a foobar=baz") - e.add("a foobar=fee") + e.add("pkg-a foobar=baz") + e.add("pkg-a foobar=fee") e.concretize() with e: with pytest.raises(ev.SpackEnvironmentError) as exc_info: - spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["a"])[0]) + spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-a"])[0]) assert "matches multiple specs" in exc_info.value.message def test_root_and_dep_match_returns_root(mock_packages, mutable_mock_env_path): e = ev.create("test") - e.add("b@0.9") - e.add("a foobar=bar") # Depends on b, should choose b@1.0 + e.add("pkg-b@0.9") + e.add("pkg-a foobar=bar") # Depends on b, should choose b@1.0 e.concretize() with e: # This query matches the root b and b as a dependency of a. In that # case the root instance should be preferred. - env_spec1 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["b"])[0]) + env_spec1 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-b"])[0]) assert env_spec1.satisfies("@0.9") - env_spec2 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["b@1.0"])[0]) + env_spec2 = spack.cmd.matching_spec_from_env(spack.cmd.parse_specs(["pkg-b@1.0"])[0]) assert env_spec2 diff --git a/lib/spack/spack/test/cmd/concretize.py b/lib/spack/spack/test/cmd/concretize.py index f7a286b93e..806675a07c 100644 --- a/lib/spack/spack/test/cmd/concretize.py +++ b/lib/spack/spack/test/cmd/concretize.py @@ -51,8 +51,8 @@ def test_concretize_root_test_dependencies_are_concretized(unify, mutable_mock_e with ev.read("test") as e: e.unify = unify - add("a") - add("b") + add("pkg-a") + add("pkg-b") concretize("--test", "root") assert e.matching_spec("test-dependency") diff --git a/lib/spack/spack/test/cmd/deconcretize.py b/lib/spack/spack/test/cmd/deconcretize.py index 0296ff93c9..06dbd39458 100644 --- a/lib/spack/spack/test/cmd/deconcretize.py +++ b/lib/spack/spack/test/cmd/deconcretize.py @@ -15,26 +15,26 @@ deconcretize = SpackCommand("deconcretize") def test_env(mutable_mock_env_path, mock_packages): ev.create("test") with ev.read("test") as e: - e.add("a@2.0 foobar=bar ^b@1.0") - e.add("a@1.0 foobar=bar ^b@0.9") + e.add("pkg-a@2.0 foobar=bar ^pkg-b@1.0") + e.add("pkg-a@1.0 foobar=bar ^pkg-b@0.9") e.concretize() e.write() def test_deconcretize_dep(test_env): with ev.read("test") as e: - deconcretize("-y", "b@1.0") + deconcretize("-y", "pkg-b@1.0") specs = [s for s, _ in e.concretized_specs()] assert len(specs) == 1 - assert specs[0].satisfies("a@1.0") + assert specs[0].satisfies("pkg-a@1.0") def test_deconcretize_all_dep(test_env): with ev.read("test") as e: with pytest.raises(SpackCommandError): - deconcretize("-y", "b") - deconcretize("-y", "--all", "b") + deconcretize("-y", "pkg-b") + deconcretize("-y", "--all", "pkg-b") specs = [s for s, _ in e.concretized_specs()] assert len(specs) == 0 @@ -42,27 +42,27 @@ def test_deconcretize_all_dep(test_env): def test_deconcretize_root(test_env): with ev.read("test") as e: - output = deconcretize("-y", "--root", "b@1.0") + output = deconcretize("-y", "--root", "pkg-b@1.0") assert "No matching specs to deconcretize" in output assert len(e.concretized_order) == 2 - deconcretize("-y", "--root", "a@2.0") + deconcretize("-y", "--root", "pkg-a@2.0") specs = [s for s, _ in e.concretized_specs()] assert len(specs) == 1 - assert specs[0].satisfies("a@1.0") + assert specs[0].satisfies("pkg-a@1.0") def test_deconcretize_all_root(test_env): with ev.read("test") as e: with pytest.raises(SpackCommandError): - deconcretize("-y", "--root", "a") + deconcretize("-y", "--root", "pkg-a") - output = deconcretize("-y", "--root", "--all", "b") + output = deconcretize("-y", "--root", "--all", "pkg-b") assert "No matching specs to deconcretize" in output assert len(e.concretized_order) == 2 - deconcretize("-y", "--root", "--all", "a") + deconcretize("-y", "--root", "--all", "pkg-a") specs = [s for s, _ in e.concretized_specs()] assert len(specs) == 0 diff --git a/lib/spack/spack/test/cmd/edit.py b/lib/spack/spack/test/cmd/edit.py index dc367d2537..93b4bd7949 100644 --- a/lib/spack/spack/test/cmd/edit.py +++ b/lib/spack/spack/test/cmd/edit.py @@ -15,9 +15,9 @@ edit = SpackCommand("edit") def test_edit_packages(monkeypatch, mock_packages: spack.repo.RepoPath): - """Test spack edit a b""" - path_a = mock_packages.filename_for_package_name("a") - path_b = mock_packages.filename_for_package_name("b") + """Test spack edit pkg-a pkg-b""" + path_a = mock_packages.filename_for_package_name("pkg-a") + path_b = mock_packages.filename_for_package_name("pkg-b") called = False def editor(*args: str, **kwargs): @@ -27,7 +27,7 @@ def test_edit_packages(monkeypatch, mock_packages: spack.repo.RepoPath): assert args[1] == path_b monkeypatch.setattr(spack.util.editor, "editor", editor) - edit("a", "b") + edit("pkg-a", "pkg-b") assert called diff --git a/lib/spack/spack/test/cmd/env.py b/lib/spack/spack/test/cmd/env.py index e65fc7a3db..e4c5b24780 100644 --- a/lib/spack/spack/test/cmd/env.py +++ b/lib/spack/spack/test/cmd/env.py @@ -28,7 +28,9 @@ import spack.modules import spack.package_base import spack.paths import spack.repo +import spack.store import spack.util.spack_json as sjson +import spack.util.spack_yaml from spack.cmd.env import _env_create from spack.main import SpackCommand, SpackCommandError from spack.spec import Spec @@ -501,7 +503,7 @@ def test_env_install_two_specs_same_dep(install_mockery, mock_fetch, tmpdir, cap """\ spack: specs: - - a + - pkg-a - depb """ ) @@ -520,8 +522,8 @@ spack: depb = spack.store.STORE.db.query_one("depb", installed=True) assert depb, "Expected depb to be installed" - a = spack.store.STORE.db.query_one("a", installed=True) - assert a, "Expected a to be installed" + a = spack.store.STORE.db.query_one("pkg-a", installed=True) + assert a, "Expected pkg-a to be installed" def test_remove_after_concretize(): @@ -824,7 +826,7 @@ def test_env_view_external_prefix(tmp_path, mutable_database, mock_packages): """\ spack: specs: - - a + - pkg-a view: true """ ) @@ -832,9 +834,9 @@ spack: external_config = io.StringIO( """\ packages: - a: + pkg-a: externals: - - spec: a@2.0 + - spec: pkg-a@2.0 prefix: {a_prefix} buildable: false """.format( diff --git a/lib/spack/spack/test/cmd/install.py b/lib/spack/spack/test/cmd/install.py index 67d49cf2c2..5f8119f017 100644 --- a/lib/spack/spack/test/cmd/install.py +++ b/lib/spack/spack/test/cmd/install.py @@ -89,7 +89,7 @@ def test_install_runtests_all(monkeypatch, mock_packages, install_mockery): assert pkg.run_tests monkeypatch.setattr(spack.package_base.PackageBase, "unit_test_check", check) - install("--test=all", "a") + install("--test=all", "pkg-a") def test_install_package_already_installed( @@ -553,61 +553,58 @@ def test_cdash_upload_build_error(tmpdir, mock_fetch, install_mockery, capfd): @pytest.mark.disable_clean_stage_check def test_cdash_upload_clean_build(tmpdir, mock_fetch, install_mockery, capfd): # capfd interferes with Spack's capturing of e.g., Build.xml output - with capfd.disabled(): - with tmpdir.as_cwd(): - install("--log-file=cdash_reports", "--log-format=cdash", "a") - report_dir = tmpdir.join("cdash_reports") - assert report_dir in tmpdir.listdir() - report_file = report_dir.join("a_Build.xml") - assert report_file in report_dir.listdir() - content = report_file.open().read() - assert "</Build>" in content - assert "<Text>" not in content + with capfd.disabled(), tmpdir.as_cwd(): + install("--log-file=cdash_reports", "--log-format=cdash", "pkg-a") + report_dir = tmpdir.join("cdash_reports") + assert report_dir in tmpdir.listdir() + report_file = report_dir.join("pkg-a_Build.xml") + assert report_file in report_dir.listdir() + content = report_file.open().read() + assert "</Build>" in content + assert "<Text>" not in content @pytest.mark.disable_clean_stage_check def test_cdash_upload_extra_params(tmpdir, mock_fetch, install_mockery, capfd): # capfd interferes with Spack's capture of e.g., Build.xml output - with capfd.disabled(): - with tmpdir.as_cwd(): - install( - "--log-file=cdash_reports", - "--log-format=cdash", - "--cdash-build=my_custom_build", - "--cdash-site=my_custom_site", - "--cdash-track=my_custom_track", - "a", - ) - report_dir = tmpdir.join("cdash_reports") - assert report_dir in tmpdir.listdir() - report_file = report_dir.join("a_Build.xml") - assert report_file in report_dir.listdir() - content = report_file.open().read() - assert 'Site BuildName="my_custom_build - a"' in content - assert 'Name="my_custom_site"' in content - assert "-my_custom_track" in content + with capfd.disabled(), tmpdir.as_cwd(): + install( + "--log-file=cdash_reports", + "--log-format=cdash", + "--cdash-build=my_custom_build", + "--cdash-site=my_custom_site", + "--cdash-track=my_custom_track", + "pkg-a", + ) + report_dir = tmpdir.join("cdash_reports") + assert report_dir in tmpdir.listdir() + report_file = report_dir.join("pkg-a_Build.xml") + assert report_file in report_dir.listdir() + content = report_file.open().read() + assert 'Site BuildName="my_custom_build - pkg-a"' in content + assert 'Name="my_custom_site"' in content + assert "-my_custom_track" in content @pytest.mark.disable_clean_stage_check def test_cdash_buildstamp_param(tmpdir, mock_fetch, install_mockery, capfd): # capfd interferes with Spack's capture of e.g., Build.xml output - with capfd.disabled(): - with tmpdir.as_cwd(): - cdash_track = "some_mocked_track" - buildstamp_format = "%Y%m%d-%H%M-{0}".format(cdash_track) - buildstamp = time.strftime(buildstamp_format, time.localtime(int(time.time()))) - install( - "--log-file=cdash_reports", - "--log-format=cdash", - "--cdash-buildstamp={0}".format(buildstamp), - "a", - ) - report_dir = tmpdir.join("cdash_reports") - assert report_dir in tmpdir.listdir() - report_file = report_dir.join("a_Build.xml") - assert report_file in report_dir.listdir() - content = report_file.open().read() - assert buildstamp in content + with capfd.disabled(), tmpdir.as_cwd(): + cdash_track = "some_mocked_track" + buildstamp_format = "%Y%m%d-%H%M-{0}".format(cdash_track) + buildstamp = time.strftime(buildstamp_format, time.localtime(int(time.time()))) + install( + "--log-file=cdash_reports", + "--log-format=cdash", + "--cdash-buildstamp={0}".format(buildstamp), + "pkg-a", + ) + report_dir = tmpdir.join("cdash_reports") + assert report_dir in tmpdir.listdir() + report_file = report_dir.join("pkg-a_Build.xml") + assert report_file in report_dir.listdir() + content = report_file.open().read() + assert buildstamp in content @pytest.mark.disable_clean_stage_check @@ -615,38 +612,37 @@ def test_cdash_install_from_spec_json( tmpdir, mock_fetch, install_mockery, capfd, mock_packages, mock_archive ): # capfd interferes with Spack's capturing - with capfd.disabled(): - with tmpdir.as_cwd(): - spec_json_path = str(tmpdir.join("spec.json")) - - pkg_spec = Spec("a") - pkg_spec.concretize() - - with open(spec_json_path, "w") as fd: - fd.write(pkg_spec.to_json(hash=ht.dag_hash)) - - install( - "--log-format=cdash", - "--log-file=cdash_reports", - "--cdash-build=my_custom_build", - "--cdash-site=my_custom_site", - "--cdash-track=my_custom_track", - "-f", - spec_json_path, - ) + with capfd.disabled(), tmpdir.as_cwd(): + spec_json_path = str(tmpdir.join("spec.json")) - report_dir = tmpdir.join("cdash_reports") - assert report_dir in tmpdir.listdir() - report_file = report_dir.join("a_Configure.xml") - assert report_file in report_dir.listdir() - content = report_file.open().read() - install_command_regex = re.compile( - r"<ConfigureCommand>(.+)</ConfigureCommand>", re.MULTILINE | re.DOTALL - ) - m = install_command_regex.search(content) - assert m - install_command = m.group(1) - assert "a@" in install_command + pkg_spec = Spec("pkg-a") + pkg_spec.concretize() + + with open(spec_json_path, "w") as fd: + fd.write(pkg_spec.to_json(hash=ht.dag_hash)) + + install( + "--log-format=cdash", + "--log-file=cdash_reports", + "--cdash-build=my_custom_build", + "--cdash-site=my_custom_site", + "--cdash-track=my_custom_track", + "-f", + spec_json_path, + ) + + report_dir = tmpdir.join("cdash_reports") + assert report_dir in tmpdir.listdir() + report_file = report_dir.join("pkg-a_Configure.xml") + assert report_file in report_dir.listdir() + content = report_file.open().read() + install_command_regex = re.compile( + r"<ConfigureCommand>(.+)</ConfigureCommand>", re.MULTILINE | re.DOTALL + ) + m = install_command_regex.search(content) + assert m + install_command = m.group(1) + assert "pkg-a@" in install_command @pytest.mark.disable_clean_stage_check @@ -778,15 +774,15 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock # ^libdwarf # ^mpich # libelf@0.8.10 - # a~bvv - # ^b - # a - # ^b + # pkg-a~bvv + # ^pkg-b + # pkg-a + # ^pkg-b e = ev.create("test", with_view=False) e.add("mpileaks") e.add("libelf@0.8.10") # so env has both root and dep libelf specs - e.add("a") - e.add("a ~bvv") + e.add("pkg-a") + e.add("pkg-a ~bvv") e.concretize() e.write() env_specs = e.all_specs() @@ -797,9 +793,9 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock # First find and remember some target concrete specs in the environment for e_spec in env_specs: - if e_spec.satisfies(Spec("a ~bvv")): + if e_spec.satisfies(Spec("pkg-a ~bvv")): a_spec = e_spec - elif e_spec.name == "b": + elif e_spec.name == "pkg-b": b_spec = e_spec elif e_spec.satisfies(Spec("mpi")): mpi_spec = e_spec @@ -822,8 +818,8 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock assert "You can add specs to the environment with 'spack add " in inst_out # Without --add, ensure that two packages "a" get installed - inst_out = install("a", output=str) - assert len([x for x in e.all_specs() if x.installed and x.name == "a"]) == 2 + inst_out = install("pkg-a", output=str) + assert len([x for x in e.all_specs() if x.installed and x.name == "pkg-a"]) == 2 # Install an unambiguous dependency spec (that already exists as a dep # in the environment) and make sure it gets installed (w/ deps), @@ -856,7 +852,7 @@ def test_install_no_add_in_env(tmpdir, mock_fetch, install_mockery, mutable_mock # root of the environment as well as installed. assert b_spec not in e.roots() - install("--add", "b") + install("--add", "pkg-b") assert b_spec in e.roots() assert b_spec not in e.uninstalled_specs() @@ -891,7 +887,7 @@ def test_cdash_auth_token(tmpdir, mock_fetch, install_mockery, monkeypatch, capf # capfd interferes with Spack's capturing with tmpdir.as_cwd(), capfd.disabled(): monkeypatch.setenv("SPACK_CDASH_AUTH_TOKEN", "asdf") - out = install("-v", "--log-file=cdash_reports", "--log-format=cdash", "a") + out = install("-v", "--log-file=cdash_reports", "--log-format=cdash", "pkg-a") assert "Using CDash auth token from environment" in out @@ -899,26 +895,25 @@ def test_cdash_auth_token(tmpdir, mock_fetch, install_mockery, monkeypatch, capf @pytest.mark.disable_clean_stage_check def test_cdash_configure_warning(tmpdir, mock_fetch, install_mockery, capfd): # capfd interferes with Spack's capturing of e.g., Build.xml output - with capfd.disabled(): - with tmpdir.as_cwd(): - # Test would fail if install raised an error. - - # Ensure that even on non-x86_64 architectures, there are no - # dependencies installed - spec = spack.spec.Spec("configure-warning").concretized() - spec.clear_dependencies() - specfile = "./spec.json" - with open(specfile, "w") as f: - f.write(spec.to_json()) - - install("--log-file=cdash_reports", "--log-format=cdash", specfile) - # Verify Configure.xml exists with expected contents. - report_dir = tmpdir.join("cdash_reports") - assert report_dir in tmpdir.listdir() - report_file = report_dir.join("Configure.xml") - assert report_file in report_dir.listdir() - content = report_file.open().read() - assert "foo: No such file or directory" in content + with capfd.disabled(), tmpdir.as_cwd(): + # Test would fail if install raised an error. + + # Ensure that even on non-x86_64 architectures, there are no + # dependencies installed + spec = Spec("configure-warning").concretized() + spec.clear_dependencies() + specfile = "./spec.json" + with open(specfile, "w") as f: + f.write(spec.to_json()) + + install("--log-file=cdash_reports", "--log-format=cdash", specfile) + # Verify Configure.xml exists with expected contents. + report_dir = tmpdir.join("cdash_reports") + assert report_dir in tmpdir.listdir() + report_file = report_dir.join("Configure.xml") + assert report_file in report_dir.listdir() + content = report_file.open().read() + assert "foo: No such file or directory" in content @pytest.mark.not_on_windows("ArchSpec gives test platform debian rather than windows") @@ -930,7 +925,7 @@ def test_compiler_bootstrap( assert CompilerSpec("gcc@=12.0") not in compilers.all_compiler_specs() # Test succeeds if it does not raise an error - install("a%gcc@=12.0") + install("pkg-a%gcc@=12.0") @pytest.mark.not_on_windows("Binary mirrors not supported on windows") @@ -964,8 +959,8 @@ def test_compiler_bootstrap_from_binary_mirror( # Now make sure that when the compiler is installed from binary mirror, # it also gets configured as a compiler. Test succeeds if it does not # raise an error - install("--no-check-signature", "--cache-only", "--only", "dependencies", "b%gcc@=10.2.0") - install("--no-cache", "--only", "package", "b%gcc@10.2.0") + install("--no-check-signature", "--cache-only", "--only", "dependencies", "pkg-b%gcc@=10.2.0") + install("--no-cache", "--only", "package", "pkg-b%gcc@10.2.0") @pytest.mark.not_on_windows("ArchSpec gives test platform debian rather than windows") @@ -980,7 +975,7 @@ def test_compiler_bootstrap_already_installed( # Test succeeds if it does not raise an error install("gcc@=12.0") - install("a%gcc@=12.0") + install("pkg-a%gcc@=12.0") def test_install_fails_no_args(tmpdir): @@ -1156,7 +1151,7 @@ def test_report_filename_for_cdash(install_mockery, mock_fetch): parser = argparse.ArgumentParser() spack.cmd.install.setup_parser(parser) args = parser.parse_args( - ["--cdash-upload-url", "https://blahblah/submit.php?project=debugging", "a"] + ["--cdash-upload-url", "https://blahblah/submit.php?project=debugging", "pkg-a"] ) specs = spack.cmd.install.concrete_specs_from_cli(args, {}) filename = spack.cmd.install.report_filename(args, specs) diff --git a/lib/spack/spack/test/cmd/maintainers.py b/lib/spack/spack/test/cmd/maintainers.py index 2724d7ec83..3928bebff1 100644 --- a/lib/spack/spack/test/cmd/maintainers.py +++ b/lib/spack/spack/test/cmd/maintainers.py @@ -121,7 +121,7 @@ def test_maintainers_list_packages(mock_packages, capfd): def test_maintainers_list_fails(mock_packages, capfd): - out = maintainers("a", fail_on_error=False) + out = maintainers("pkg-a", fail_on_error=False) assert not out assert maintainers.returncode == 1 diff --git a/lib/spack/spack/test/cmd/module.py b/lib/spack/spack/test/cmd/module.py index 7462bdbad0..4b460eb90a 100644 --- a/lib/spack/spack/test/cmd/module.py +++ b/lib/spack/spack/test/cmd/module.py @@ -11,6 +11,7 @@ import pytest import spack.config import spack.main import spack.modules +import spack.spec import spack.store module = spack.main.SpackCommand("module") @@ -178,8 +179,8 @@ def test_setdefault_command(mutable_database, mutable_config): } } spack.config.set("modules", data) - # Install two different versions of a package - other_spec, preferred = "a@1.0", "a@2.0" + # Install two different versions of pkg-a + other_spec, preferred = "pkg-a@1.0", "pkg-a@2.0" spack.spec.Spec(other_spec).concretized().package.do_install(fake=True) spack.spec.Spec(preferred).concretized().package.do_install(fake=True) diff --git a/lib/spack/spack/test/cmd/pkg.py b/lib/spack/spack/test/cmd/pkg.py index ecf30f0518..c6db5693c7 100644 --- a/lib/spack/spack/test/cmd/pkg.py +++ b/lib/spack/spack/test/cmd/pkg.py @@ -29,8 +29,8 @@ class {name}(Package): pass """ -abc = set(("pkg-a", "pkg-b", "pkg-c")) -abd = set(("pkg-a", "pkg-b", "pkg-d")) +abc = {"mockpkg-a", "mockpkg-b", "mockpkg-c"} +abd = {"mockpkg-a", "mockpkg-b", "mockpkg-d"} # Force all tests to use a git repository *in* the mock packages repo. @@ -55,27 +55,33 @@ def mock_pkg_git_repo(git, tmp_path_factory): git("config", "user.name", "Spack Testing") git("-c", "commit.gpgsign=false", "commit", "-m", "initial mock repo commit") - # add commit with pkg-a, pkg-b, pkg-c packages - mkdirp("pkg-a", "pkg-b", "pkg-c") - with open("pkg-a/package.py", "w") as f: + # add commit with mockpkg-a, mockpkg-b, mockpkg-c packages + mkdirp("mockpkg-a", "mockpkg-b", "mockpkg-c") + with open("mockpkg-a/package.py", "w") as f: f.write(pkg_template.format(name="PkgA")) - with open("pkg-b/package.py", "w") as f: + with open("mockpkg-b/package.py", "w") as f: f.write(pkg_template.format(name="PkgB")) - with open("pkg-c/package.py", "w") as f: + with open("mockpkg-c/package.py", "w") as f: f.write(pkg_template.format(name="PkgC")) - git("add", "pkg-a", "pkg-b", "pkg-c") - git("-c", "commit.gpgsign=false", "commit", "-m", "add pkg-a, pkg-b, pkg-c") - - # remove pkg-c, add pkg-d - with open("pkg-b/package.py", "a") as f: - f.write("\n# change pkg-b") - git("add", "pkg-b") - mkdirp("pkg-d") - with open("pkg-d/package.py", "w") as f: + git("add", "mockpkg-a", "mockpkg-b", "mockpkg-c") + git("-c", "commit.gpgsign=false", "commit", "-m", "add mockpkg-a, mockpkg-b, mockpkg-c") + + # remove mockpkg-c, add mockpkg-d + with open("mockpkg-b/package.py", "a") as f: + f.write("\n# change mockpkg-b") + git("add", "mockpkg-b") + mkdirp("mockpkg-d") + with open("mockpkg-d/package.py", "w") as f: f.write(pkg_template.format(name="PkgD")) - git("add", "pkg-d") - git("rm", "-rf", "pkg-c") - git("-c", "commit.gpgsign=false", "commit", "-m", "change pkg-b, remove pkg-c, add pkg-d") + git("add", "mockpkg-d") + git("rm", "-rf", "mockpkg-c") + git( + "-c", + "commit.gpgsign=false", + "commit", + "-m", + "change mockpkg-b, remove mockpkg-c, add mockpkg-d", + ) with spack.repo.use_repositories(str(repo_dir)): yield mock_repo_packages @@ -88,12 +94,11 @@ def mock_pkg_names(): # Be sure to include virtual packages since packages with stand-alone # tests may inherit additional tests from the virtuals they provide, # such as packages that implement `mpi`. - names = set( + return { name for name in repo.all_package_names(include_virtuals=True) - if not name.startswith("pkg-") - ) - return names + if not name.startswith("mockpkg-") + } def split(output): @@ -115,17 +120,17 @@ def test_mock_packages_path(mock_packages): def test_pkg_add(git, mock_pkg_git_repo): with working_dir(mock_pkg_git_repo): - mkdirp("pkg-e") - with open("pkg-e/package.py", "w") as f: + mkdirp("mockpkg-e") + with open("mockpkg-e/package.py", "w") as f: f.write(pkg_template.format(name="PkgE")) - pkg("add", "pkg-e") + pkg("add", "mockpkg-e") with working_dir(mock_pkg_git_repo): try: - assert "A pkg-e/package.py" in git("status", "--short", output=str) + assert "A mockpkg-e/package.py" in git("status", "--short", output=str) finally: - shutil.rmtree("pkg-e") + shutil.rmtree("mockpkg-e") # Removing a package mid-run disrupts Spack's caching if spack.repo.PATH.repos[0]._fast_package_checker: spack.repo.PATH.repos[0]._fast_package_checker.invalidate() @@ -140,10 +145,10 @@ def test_pkg_list(mock_pkg_git_repo, mock_pkg_names): assert sorted(mock_pkg_names) == sorted(out) out = split(pkg("list", "HEAD^")) - assert sorted(mock_pkg_names.union(["pkg-a", "pkg-b", "pkg-c"])) == sorted(out) + assert sorted(mock_pkg_names.union(["mockpkg-a", "mockpkg-b", "mockpkg-c"])) == sorted(out) out = split(pkg("list", "HEAD")) - assert sorted(mock_pkg_names.union(["pkg-a", "pkg-b", "pkg-d"])) == sorted(out) + assert sorted(mock_pkg_names.union(["mockpkg-a", "mockpkg-b", "mockpkg-d"])) == sorted(out) # test with three dots to make sure pkg calls `git merge-base` out = split(pkg("list", "HEAD^^...")) @@ -153,25 +158,25 @@ def test_pkg_list(mock_pkg_git_repo, mock_pkg_names): @pytest.mark.not_on_windows("stdout format conflict") def test_pkg_diff(mock_pkg_git_repo, mock_pkg_names): out = split(pkg("diff", "HEAD^^", "HEAD^")) - assert out == ["HEAD^:", "pkg-a", "pkg-b", "pkg-c"] + assert out == ["HEAD^:", "mockpkg-a", "mockpkg-b", "mockpkg-c"] out = split(pkg("diff", "HEAD^^", "HEAD")) - assert out == ["HEAD:", "pkg-a", "pkg-b", "pkg-d"] + assert out == ["HEAD:", "mockpkg-a", "mockpkg-b", "mockpkg-d"] out = split(pkg("diff", "HEAD^", "HEAD")) - assert out == ["HEAD^:", "pkg-c", "HEAD:", "pkg-d"] + assert out == ["HEAD^:", "mockpkg-c", "HEAD:", "mockpkg-d"] @pytest.mark.not_on_windows("stdout format conflict") def test_pkg_added(mock_pkg_git_repo): out = split(pkg("added", "HEAD^^", "HEAD^")) - assert ["pkg-a", "pkg-b", "pkg-c"] == out + assert ["mockpkg-a", "mockpkg-b", "mockpkg-c"] == out out = split(pkg("added", "HEAD^^", "HEAD")) - assert ["pkg-a", "pkg-b", "pkg-d"] == out + assert ["mockpkg-a", "mockpkg-b", "mockpkg-d"] == out out = split(pkg("added", "HEAD^", "HEAD")) - assert ["pkg-d"] == out + assert ["mockpkg-d"] == out out = split(pkg("added", "HEAD", "HEAD")) assert out == [] @@ -186,7 +191,7 @@ def test_pkg_removed(mock_pkg_git_repo): assert out == [] out = split(pkg("removed", "HEAD^", "HEAD")) - assert out == ["pkg-c"] + assert out == ["mockpkg-c"] @pytest.mark.not_on_windows("stdout format conflict") @@ -198,34 +203,34 @@ def test_pkg_changed(mock_pkg_git_repo): assert out == [] out = split(pkg("changed", "--type", "a", "HEAD^^", "HEAD^")) - assert out == ["pkg-a", "pkg-b", "pkg-c"] + assert out == ["mockpkg-a", "mockpkg-b", "mockpkg-c"] out = split(pkg("changed", "--type", "r", "HEAD^^", "HEAD^")) assert out == [] out = split(pkg("changed", "--type", "ar", "HEAD^^", "HEAD^")) - assert out == ["pkg-a", "pkg-b", "pkg-c"] + assert out == ["mockpkg-a", "mockpkg-b", "mockpkg-c"] out = split(pkg("changed", "--type", "arc", "HEAD^^", "HEAD^")) - assert out == ["pkg-a", "pkg-b", "pkg-c"] + assert out == ["mockpkg-a", "mockpkg-b", "mockpkg-c"] out = split(pkg("changed", "HEAD^", "HEAD")) - assert out == ["pkg-b"] + assert out == ["mockpkg-b"] out = split(pkg("changed", "--type", "c", "HEAD^", "HEAD")) - assert out == ["pkg-b"] + assert out == ["mockpkg-b"] out = split(pkg("changed", "--type", "a", "HEAD^", "HEAD")) - assert out == ["pkg-d"] + assert out == ["mockpkg-d"] out = split(pkg("changed", "--type", "r", "HEAD^", "HEAD")) - assert out == ["pkg-c"] + assert out == ["mockpkg-c"] out = split(pkg("changed", "--type", "ar", "HEAD^", "HEAD")) - assert out == ["pkg-c", "pkg-d"] + assert out == ["mockpkg-c", "mockpkg-d"] out = split(pkg("changed", "--type", "arc", "HEAD^", "HEAD")) - assert out == ["pkg-b", "pkg-c", "pkg-d"] + assert out == ["mockpkg-b", "mockpkg-c", "mockpkg-d"] # invalid type argument with pytest.raises(spack.main.SpackCommandError): @@ -291,7 +296,7 @@ def test_pkg_canonical_source(mock_packages): def test_pkg_hash(mock_packages): - output = pkg("hash", "a", "b").strip().split() + output = pkg("hash", "pkg-a", "pkg-b").strip().split() assert len(output) == 2 and all(len(elt) == 32 for elt in output) output = pkg("hash", "multimethod").strip().split() diff --git a/lib/spack/spack/test/cmd/spec.py b/lib/spack/spack/test/cmd/spec.py index 2712540d1a..11d88dbc4c 100644 --- a/lib/spack/spack/test/cmd/spec.py +++ b/lib/spack/spack/test/cmd/spec.py @@ -58,7 +58,7 @@ def test_spec_concretizer_args(mutable_database, do_not_check_runtimes_on_reuse) def test_spec_parse_dependency_variant_value(): """Verify that we can provide multiple key=value variants to multiple separate packages within a spec string.""" - output = spec("multivalue-variant fee=barbaz ^ a foobar=baz") + output = spec("multivalue-variant fee=barbaz ^ pkg-a foobar=baz") assert "fee=barbaz" in output assert "foobar=baz" in output diff --git a/lib/spack/spack/test/cmd/test.py b/lib/spack/spack/test/cmd/test.py index 24ad2e5b8a..3cfaa5b58f 100644 --- a/lib/spack/spack/test/cmd/test.py +++ b/lib/spack/spack/test/cmd/test.py @@ -10,10 +10,14 @@ import pytest from llnl.util.filesystem import copy_tree +import spack.cmd.common.arguments import spack.cmd.install +import spack.cmd.test import spack.config +import spack.install_test import spack.package_base import spack.paths +import spack.spec import spack.store from spack.install_test import TestStatus from spack.main import SpackCommand diff --git a/lib/spack/spack/test/concretize.py b/lib/spack/spack/test/concretize.py index ee204dd909..e1076abd10 100644 --- a/lib/spack/spack/test/concretize.py +++ b/lib/spack/spack/test/concretize.py @@ -24,6 +24,7 @@ import spack.hash_types as ht import spack.platforms import spack.repo import spack.solver.asp +import spack.store import spack.util.file_cache import spack.util.libc import spack.variant as vt @@ -410,7 +411,7 @@ class TestConcretize: def test_compiler_flags_differ_identical_compilers(self, mutable_config, clang12_with_flags): mutable_config.set("compilers", [clang12_with_flags]) # Correct arch to use test compiler that has flags - spec = Spec("a %clang@12.2.0 platform=test os=fe target=fe") + spec = Spec("pkg-a %clang@12.2.0 platform=test os=fe target=fe") # Get the compiler that matches the spec ( compiler = spack.compilers.compiler_for_spec("clang@=12.2.0", spec.architecture) @@ -487,7 +488,7 @@ class TestConcretize: assert s.architecture.target == spec.architecture.target def test_compiler_flags_from_user_are_grouped(self): - spec = Spec('a%gcc cflags="-O -foo-flag foo-val" platform=test') + spec = Spec('pkg-a%gcc cflags="-O -foo-flag foo-val" platform=test') spec.concretize() cflags = spec.compiler_flags["cflags"] assert any(x == "-foo-flag foo-val" for x in cflags) @@ -595,20 +596,20 @@ class TestConcretize: spec = Spec("multivalue-variant foo==baz,fee") spec.concretize() - assert spec.satisfies("^a foo=baz,fee") - assert spec.satisfies("^b foo=baz,fee") - assert not spec.satisfies("^a foo=bar") - assert not spec.satisfies("^b foo=bar") + assert spec.satisfies("^pkg-a foo=baz,fee") + assert spec.satisfies("^pkg-b foo=baz,fee") + assert not spec.satisfies("^pkg-a foo=bar") + assert not spec.satisfies("^pkg-b foo=bar") def test_no_matching_compiler_specs(self, mock_low_high_config): # only relevant when not building compilers as needed with spack.concretize.enable_compiler_existence_check(): - s = Spec("a %gcc@=0.0.0") + s = Spec("pkg-a %gcc@=0.0.0") with pytest.raises(spack.concretize.UnavailableCompilerVersionError): s.concretize() def test_no_compilers_for_arch(self): - s = Spec("a arch=linux-rhel0-x86_64") + s = Spec("pkg-a arch=linux-rhel0-x86_64") with pytest.raises(spack.error.SpackError): s.concretize() @@ -818,7 +819,7 @@ class TestConcretize: # The string representation of a spec containing # an explicit multi-valued variant and a dependency # might be parsed differently than the originating spec - s = Spec("a foobar=bar ^b") + s = Spec("pkg-a foobar=bar ^pkg-b") t = Spec(str(s)) s.concretize() @@ -1196,14 +1197,14 @@ class TestConcretize: [ # Check that True is treated correctly and attaches test deps # to all nodes in the DAG - ("a", True, ["a"], []), - ("a foobar=bar", True, ["a", "b"], []), + ("pkg-a", True, ["pkg-a"], []), + ("pkg-a foobar=bar", True, ["pkg-a", "pkg-b"], []), # Check that a list of names activates the dependency only for # packages in that list - ("a foobar=bar", ["a"], ["a"], ["b"]), - ("a foobar=bar", ["b"], ["b"], ["a"]), + ("pkg-a foobar=bar", ["pkg-a"], ["pkg-a"], ["pkg-b"]), + ("pkg-a foobar=bar", ["pkg-b"], ["pkg-b"], ["pkg-a"]), # Check that False disregard test dependencies - ("a foobar=bar", False, [], ["a", "b"]), + ("pkg-a foobar=bar", False, [], ["pkg-a", "pkg-b"]), ], ) def test_activating_test_dependencies(self, spec_str, tests_arg, with_dep, without_dep): @@ -1262,7 +1263,7 @@ class TestConcretize: "compilers", [compiler_factory(spec="gcc@10foo", operating_system="redhat6")] ) monkeypatch.setattr(spack.compiler.Compiler, "real_version", "10.2.1") - s = Spec("a %gcc@10foo os=redhat6").concretized() + s = Spec("pkg-a %gcc@10foo os=redhat6").concretized() assert "%gcc@10foo" in s def test_all_patches_applied(self): @@ -1406,10 +1407,10 @@ class TestConcretize: @pytest.mark.only_clingo("Use case not supported by the original concretizer") def test_reuse_with_flags(self, mutable_database, mutable_config): spack.config.set("concretizer:reuse", True) - spec = Spec("a cflags=-g cxxflags=-g").concretized() + spec = Spec("pkg-a cflags=-g cxxflags=-g").concretized() spack.store.STORE.db.add(spec, None) - testspec = Spec("a cflags=-g") + testspec = Spec("pkg-a cflags=-g") testspec.concretize() assert testspec == spec @@ -1752,31 +1753,31 @@ class TestConcretize: self, temporary_store, mock_custom_repository ): with spack.repo.use_repositories(mock_custom_repository, override=False): - s = Spec("c").concretized() + s = Spec("pkg-c").concretized() assert s.namespace != "builtin.mock" s.package.do_install(fake=True, explicit=True) with spack.config.override("concretizer:reuse", True): - s = Spec("c").concretized() + s = Spec("pkg-c").concretized() assert s.namespace == "builtin.mock" @pytest.mark.regression("28259") def test_reuse_with_unknown_package_dont_raise(self, tmpdir, temporary_store, monkeypatch): builder = spack.repo.MockRepositoryBuilder(tmpdir.mkdir("mock.repo"), namespace="myrepo") - builder.add_package("c") + builder.add_package("pkg-c") with spack.repo.use_repositories(builder.root, override=False): - s = Spec("c").concretized() + s = Spec("pkg-c").concretized() assert s.namespace == "myrepo" s.package.do_install(fake=True, explicit=True) - del sys.modules["spack.pkg.myrepo.c"] + del sys.modules["spack.pkg.myrepo.pkg-c"] del sys.modules["spack.pkg.myrepo"] - builder.remove("c") + builder.remove("pkg-c") with spack.repo.use_repositories(builder.root, override=False) as repos: # TODO (INJECT CONFIGURATION): unclear why the cache needs to be invalidated explicitly repos.repos[0]._pkg_checker.invalidate() with spack.config.override("concretizer:reuse", True): - s = Spec("c").concretized() + s = Spec("pkg-c").concretized() assert s.namespace == "builtin.mock" @pytest.mark.parametrize( @@ -1907,20 +1908,20 @@ class TestConcretize: @pytest.mark.only_clingo("Use case not supported by the original concretizer") def test_version_weight_and_provenance(self): """Test package preferences during coconcretization.""" - reusable_specs = [Spec(spec_str).concretized() for spec_str in ("b@0.9", "b@1.0")] - root_spec = Spec("a foobar=bar") + reusable_specs = [Spec(spec_str).concretized() for spec_str in ("pkg-b@0.9", "pkg-b@1.0")] + root_spec = Spec("pkg-a foobar=bar") with spack.config.override("concretizer:reuse", True): solver = spack.solver.asp.Solver() setup = spack.solver.asp.SpackSolverSetup() result, _, _ = solver.driver.solve(setup, [root_spec], reuse=reusable_specs) - # The result here should have a single spec to build ('a') - # and it should be using b@1.0 with a version badness of 2 + # The result here should have a single spec to build ('pkg-a') + # and it should be using pkg-b@1.0 with a version badness of 2 # The provenance is: - # version_declared("b","1.0",0,"package_py"). - # version_declared("b","0.9",1,"package_py"). - # version_declared("b","1.0",2,"installed"). - # version_declared("b","0.9",3,"installed"). + # version_declared("pkg-b","1.0",0,"package_py"). + # version_declared("pkg-b","0.9",1,"package_py"). + # version_declared("pkg-b","1.0",2,"installed"). + # version_declared("pkg-b","0.9",3,"installed"). # # Depending on the target, it may also use gnuconfig result_spec = result.specs[0] @@ -1934,11 +1935,11 @@ class TestConcretize: for criterion in criteria: assert criterion in result.criteria, criterion - assert result_spec.satisfies("^b@1.0") + assert result_spec.satisfies("^pkg-b@1.0") @pytest.mark.only_clingo("Use case not supported by the original concretizer") def test_reuse_succeeds_with_config_compatible_os(self): - root_spec = Spec("b") + root_spec = Spec("pkg-b") s = root_spec.concretized() other_os = s.copy() mock_os = "ubuntu2204" @@ -2202,7 +2203,7 @@ class TestConcretize: "specs", [ ["mpileaks^ callpath ^dyninst@8.1.1:8 ^mpich2@1.3:1"], - ["multivalue-variant ^a@2:2"], + ["multivalue-variant ^pkg-a@2:2"], ["v1-consumer ^conditional-provider@1:1 +disable-v1"], ], ) @@ -2241,9 +2242,9 @@ class TestConcretize: def test_clear_error_when_unknown_compiler_requested(self, mock_packages): """Tests that the solver can report a case where the compiler cannot be set""" with pytest.raises( - spack.error.UnsatisfiableSpecError, match="Cannot set the required compiler: a%foo" + spack.error.UnsatisfiableSpecError, match="Cannot set the required compiler: pkg-a%foo" ): - Spec("a %foo").concretized() + Spec("pkg-a %foo").concretized() @pytest.mark.regression("36339") def test_compiler_match_constraints_when_selected(self): @@ -2279,7 +2280,7 @@ class TestConcretize: }, ] spack.config.set("compilers", compiler_configuration) - s = Spec("a %gcc@:11").concretized() + s = Spec("pkg-a %gcc@:11").concretized() assert s.compiler.version == ver("=11.1.0"), s @pytest.mark.regression("36339") @@ -2300,7 +2301,7 @@ class TestConcretize: } ] spack.config.set("compilers", compiler_configuration) - s = Spec("a %gcc@foo").concretized() + s = Spec("pkg-a %gcc@foo").concretized() assert s.compiler.version == ver("=foo") @pytest.mark.regression("36628") @@ -2326,7 +2327,7 @@ class TestConcretize: ] with spack.config.override("compilers", compiler_configuration): - s = spack.spec.Spec("a").concretized() + s = Spec("pkg-a").concretized() assert s.satisfies("%gcc@12.1.0") @pytest.mark.parametrize("spec_str", ["mpileaks", "mpileaks ^mpich"]) @@ -2361,7 +2362,7 @@ class TestConcretize: with pytest.raises(spack.error.UnsatisfiableSpecError): # normally spack concretizes to @=3.0 if it's not defined in package.py, except # when checksums are required - Spec("a@=3.0").concretized() + Spec("pkg-a@=3.0").concretized() @pytest.mark.regression("39570") @pytest.mark.db @@ -2461,7 +2462,7 @@ class TestConcretize: spack.util.libc, "libc_from_current_python_process", lambda: Spec("glibc@=2.28") ) mutable_config.set("config:install_missing_compilers", True) - s = Spec("a %gcc@=13.2.0").concretized() + s = Spec("pkg-a %gcc@=13.2.0").concretized() assert s.satisfies("%gcc@13.2.0") @pytest.mark.regression("43267") @@ -2594,17 +2595,17 @@ class TestConcretize: # We install b@1 ^glibc@2.30, and b@0 ^glibc@2.28. The former is not host compatible, the # latter is. - fst = Spec("b@1").concretized() + fst = Spec("pkg-b@1").concretized() fst._mark_concrete(False) fst.dependencies("glibc")[0].versions = VersionList(["=2.30"]) fst._mark_concrete(True) - snd = Spec("b@0").concretized() + snd = Spec("pkg-b@0").concretized() # The spec b@1 ^glibc@2.30 is "more optimal" than b@0 ^glibc@2.28, but due to glibc # incompatibility, it should not be reused. solver = spack.solver.asp.Solver() setup = spack.solver.asp.SpackSolverSetup() - result, _, _ = solver.driver.solve(setup, [Spec("b")], reuse=[fst, snd]) + result, _, _ = solver.driver.solve(setup, [Spec("pkg-b")], reuse=[fst, snd]) assert len(result.specs) == 1 assert result.specs[0] == snd @@ -2809,7 +2810,9 @@ def test_drop_moving_targets(v_str, v_opts, checksummed): class TestConcreteSpecsByHash: """Tests the container of concrete specs""" - @pytest.mark.parametrize("input_specs", [["a"], ["a foobar=bar", "b"], ["a foobar=baz", "b"]]) + @pytest.mark.parametrize( + "input_specs", [["pkg-a"], ["pkg-a foobar=bar", "pkg-b"], ["pkg-a foobar=baz", "pkg-b"]] + ) def test_adding_specs(self, input_specs, default_mock_concretization): """Tests that concrete specs in the container are equivalent, but stored as different objects in memory. diff --git a/lib/spack/spack/test/concretize_compiler_runtimes.py b/lib/spack/spack/test/concretize_compiler_runtimes.py index c1859c3dae..5b7968ed20 100644 --- a/lib/spack/spack/test/concretize_compiler_runtimes.py +++ b/lib/spack/spack/test/concretize_compiler_runtimes.py @@ -9,6 +9,7 @@ import pytest import archspec.cpu +import spack.config import spack.paths import spack.repo import spack.solver.asp @@ -47,8 +48,8 @@ def enable_runtimes(): def test_correct_gcc_runtime_is_injected_as_dependency(runtime_repo): - s = spack.spec.Spec("a%gcc@10.2.1 ^b%gcc@9.4.0").concretized() - a, b = s["a"], s["b"] + s = spack.spec.Spec("pkg-a%gcc@10.2.1 ^pkg-b%gcc@9.4.0").concretized() + a, b = s["pkg-a"], s["pkg-b"] # Both a and b should depend on the same gcc-runtime directly assert a.dependencies("gcc-runtime") == b.dependencies("gcc-runtime") @@ -61,16 +62,16 @@ def test_correct_gcc_runtime_is_injected_as_dependency(runtime_repo): def test_external_nodes_do_not_have_runtimes(runtime_repo, mutable_config, tmp_path): """Tests that external nodes don't have runtime dependencies.""" - packages_yaml = {"b": {"externals": [{"spec": "b@1.0", "prefix": f"{str(tmp_path)}"}]}} + packages_yaml = {"pkg-b": {"externals": [{"spec": "pkg-b@1.0", "prefix": f"{str(tmp_path)}"}]}} spack.config.set("packages", packages_yaml) - s = spack.spec.Spec("a%gcc@10.2.1").concretized() + s = spack.spec.Spec("pkg-a%gcc@10.2.1").concretized() - a, b = s["a"], s["b"] + a, b = s["pkg-a"], s["pkg-b"] # Since b is an external, it doesn't depend on gcc-runtime assert a.dependencies("gcc-runtime") - assert a.dependencies("b") + assert a.dependencies("pkg-b") assert not b.dependencies("gcc-runtime") @@ -78,23 +79,36 @@ def test_external_nodes_do_not_have_runtimes(runtime_repo, mutable_config, tmp_p "root_str,reused_str,expected,nruntime", [ # The reused runtime is older than we need, thus we'll add a more recent one for a - ("a%gcc@10.2.1", "b%gcc@9.4.0", {"a": "gcc-runtime@10.2.1", "b": "gcc-runtime@9.4.0"}, 2), + ( + "pkg-a%gcc@10.2.1", + "pkg-b%gcc@9.4.0", + {"pkg-a": "gcc-runtime@10.2.1", "pkg-b": "gcc-runtime@9.4.0"}, + 2, + ), # The root is compiled with an older compiler, thus we'll NOT reuse the runtime from b - ("a%gcc@9.4.0", "b%gcc@10.2.1", {"a": "gcc-runtime@9.4.0", "b": "gcc-runtime@9.4.0"}, 1), + ( + "pkg-a%gcc@9.4.0", + "pkg-b%gcc@10.2.1", + {"pkg-a": "gcc-runtime@9.4.0", "pkg-b": "gcc-runtime@9.4.0"}, + 1, + ), # Same as before, but tests that we can reuse from a more generic target pytest.param( - "a%gcc@9.4.0", - "b%gcc@10.2.1 target=x86_64", - {"a": "gcc-runtime@9.4.0", "b": "gcc-runtime@9.4.0"}, + "pkg-a%gcc@9.4.0", + "pkg-b%gcc@10.2.1 target=x86_64", + {"pkg-a": "gcc-runtime@9.4.0", "pkg-b": "gcc-runtime@9.4.0"}, 1, marks=pytest.mark.skipif( str(archspec.cpu.host().family) != "x86_64", reason="test data is x86_64 specific" ), ), pytest.param( - "a%gcc@10.2.1", - "b%gcc@9.4.0 target=x86_64", - {"a": "gcc-runtime@10.2.1 target=x86_64", "b": "gcc-runtime@9.4.0 target=x86_64"}, + "pkg-a%gcc@10.2.1", + "pkg-b%gcc@9.4.0 target=x86_64", + { + "pkg-a": "gcc-runtime@10.2.1 target=x86_64", + "pkg-b": "gcc-runtime@9.4.0 target=x86_64", + }, 2, marks=pytest.mark.skipif( str(archspec.cpu.host().family) != "x86_64", reason="test data is x86_64 specific" @@ -112,9 +126,9 @@ def test_reusing_specs_with_gcc_runtime(root_str, reused_str, expected, nruntime root, reused_spec = _concretize_with_reuse(root_str=root_str, reused_str=reused_str) runtime_a = root.dependencies("gcc-runtime")[0] - assert runtime_a.satisfies(expected["a"]) - runtime_b = root["b"].dependencies("gcc-runtime")[0] - assert runtime_b.satisfies(expected["b"]) + assert runtime_a.satisfies(expected["pkg-a"]) + runtime_b = root["pkg-b"].dependencies("gcc-runtime")[0] + assert runtime_b.satisfies(expected["pkg-b"]) runtimes = [x for x in root.traverse() if x.name == "gcc-runtime"] assert len(runtimes) == nruntime @@ -125,7 +139,7 @@ def test_reusing_specs_with_gcc_runtime(root_str, reused_str, expected, nruntime [ # Ensure that, whether we have multiple runtimes in the DAG or not, # we always link only the latest version - ("a%gcc@10.2.1", "b%gcc@9.4.0", ["gcc-runtime@10.2.1"], ["gcc-runtime@9.4.0"]) + ("pkg-a%gcc@10.2.1", "pkg-b%gcc@9.4.0", ["gcc-runtime@10.2.1"], ["gcc-runtime@9.4.0"]) ], ) def test_views_can_handle_duplicate_runtime_nodes( diff --git a/lib/spack/spack/test/concretize_preferences.py b/lib/spack/spack/test/concretize_preferences.py index 6748b845aa..d0ecc8f599 100644 --- a/lib/spack/spack/test/concretize_preferences.py +++ b/lib/spack/spack/test/concretize_preferences.py @@ -516,5 +516,5 @@ mpich: packages.yaml doesn't fail with an error. """ with spack.config.override("packages:all", {"variants": "+foo"}): - s = Spec("a").concretized() + s = Spec("pkg-a").concretized() assert s.satisfies("foo=bar") diff --git a/lib/spack/spack/test/concretize_requirements.py b/lib/spack/spack/test/concretize_requirements.py index 3b3b564691..3ec086d962 100644 --- a/lib/spack/spack/test/concretize_requirements.py +++ b/lib/spack/spack/test/concretize_requirements.py @@ -927,9 +927,9 @@ def test_default_requirements_semantic(packages_yaml, concretize_scope, mock_pac Spec("zlib ~shared").concretized() # A spec without the shared variant still concretize - s = Spec("a").concretized() - assert not s.satisfies("a +shared") - assert not s.satisfies("a ~shared") + s = Spec("pkg-a").concretized() + assert not s.satisfies("pkg-a +shared") + assert not s.satisfies("pkg-a ~shared") @pytest.mark.parametrize( diff --git a/lib/spack/spack/test/config.py b/lib/spack/spack/test/config.py index 817cfeb40d..b0cf6bac65 100644 --- a/lib/spack/spack/test/config.py +++ b/lib/spack/spack/test/config.py @@ -1241,13 +1241,13 @@ def test_license_dir_config(mutable_config, mock_packages): expected_dir = spack.paths.default_license_dir assert spack.config.get("config:license_dir") == expected_dir assert spack.package_base.PackageBase.global_license_dir == expected_dir - assert spack.repo.PATH.get_pkg_class("a").global_license_dir == expected_dir + assert spack.repo.PATH.get_pkg_class("pkg-a").global_license_dir == expected_dir rel_path = os.path.join(os.path.sep, "foo", "bar", "baz") spack.config.set("config:license_dir", rel_path) assert spack.config.get("config:license_dir") == rel_path assert spack.package_base.PackageBase.global_license_dir == rel_path - assert spack.repo.PATH.get_pkg_class("a").global_license_dir == rel_path + assert spack.repo.PATH.get_pkg_class("pkg-a").global_license_dir == rel_path @pytest.mark.regression("22547") diff --git a/lib/spack/spack/test/conftest.py b/lib/spack/spack/test/conftest.py index cebd89e49e..37fabe3f0b 100644 --- a/lib/spack/spack/test/conftest.py +++ b/lib/spack/spack/test/conftest.py @@ -603,7 +603,7 @@ def mutable_mock_repo(mock_repo_path, request): def mock_custom_repository(tmpdir, mutable_mock_repo): """Create a custom repository with a single package "c" and return its path.""" builder = spack.repo.MockRepositoryBuilder(tmpdir.mkdir("myrepo")) - builder.add_package("c") + builder.add_package("pkg-c") return builder.root diff --git a/lib/spack/spack/test/database.py b/lib/spack/spack/test/database.py index edd025d742..91eab857f4 100644 --- a/lib/spack/spack/test/database.py +++ b/lib/spack/spack/test/database.py @@ -58,16 +58,22 @@ def upstream_and_downstream_db(tmpdir, gen_mock_layout): @pytest.mark.parametrize( "install_tree,result", - [("all", ["b", "c"]), ("upstream", ["c"]), ("local", ["b"]), ("{u}", ["c"]), ("{d}", ["b"])], + [ + ("all", ["pkg-b", "pkg-c"]), + ("upstream", ["pkg-c"]), + ("local", ["pkg-b"]), + ("{u}", ["pkg-c"]), + ("{d}", ["pkg-b"]), + ], ) def test_query_by_install_tree( install_tree, result, upstream_and_downstream_db, mock_packages, monkeypatch, config ): up_write_db, up_db, up_layout, down_db, down_layout = upstream_and_downstream_db - # Set the upstream DB to contain "c" and downstream to contain "b") - b = spack.spec.Spec("b").concretized() - c = spack.spec.Spec("c").concretized() + # Set the upstream DB to contain "pkg-c" and downstream to contain "pkg-b") + b = spack.spec.Spec("pkg-b").concretized() + c = spack.spec.Spec("pkg-c").concretized() up_write_db.add(c, up_layout) up_db._read() down_db.add(b, down_layout) @@ -86,7 +92,7 @@ def test_spec_installed_upstream( # a known installed spec should say that it's installed with spack.repo.use_repositories(mock_custom_repository): - spec = spack.spec.Spec("c").concretized() + spec = spack.spec.Spec("pkg-c").concretized() assert not spec.installed assert not spec.installed_upstream @@ -848,7 +854,7 @@ def test_query_virtual_spec(database): def test_failed_spec_path_error(database): """Ensure spec not concrete check is covered.""" - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") with pytest.raises(AssertionError, match="concrete spec required"): spack.store.STORE.failure_tracker.mark(s) @@ -863,7 +869,7 @@ def test_clear_failure_keep(mutable_database, monkeypatch, capfd): # Pretend the spec has been failure locked monkeypatch.setattr(spack.database.FailureTracker, "lock_taken", _is) - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() spack.store.STORE.failure_tracker.clear(s) out = capfd.readouterr()[0] assert "Retaining failure marking" in out @@ -881,7 +887,7 @@ def test_clear_failure_forced(mutable_database, monkeypatch, capfd): # Ensure raise OSError when try to remove the non-existent marking monkeypatch.setattr(spack.database.FailureTracker, "persistent_mark", _is) - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() spack.store.STORE.failure_tracker.clear(s, force=True) out = capfd.readouterr()[1] assert "Removing failure marking despite lock" in out @@ -896,14 +902,14 @@ def test_mark_failed(mutable_database, monkeypatch, tmpdir, capsys): raise lk.LockTimeoutError("write", "/mock-lock", 1.234, 10) with tmpdir.as_cwd(): - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() # Ensure attempt to acquire write lock on the mark raises the exception monkeypatch.setattr(lk.Lock, "acquire_write", _raise_exc) spack.store.STORE.failure_tracker.mark(s) out = str(capsys.readouterr()[1]) - assert "Unable to mark a as failed" in out + assert "Unable to mark pkg-a as failed" in out spack.store.STORE.failure_tracker.clear_all() @@ -912,7 +918,7 @@ def test_mark_failed(mutable_database, monkeypatch, tmpdir, capsys): def test_prefix_failed(mutable_database, monkeypatch): """Add coverage to failed operation.""" - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() # Confirm the spec is not already marked as failed assert not spack.store.STORE.failure_tracker.has_failed(s) @@ -936,7 +942,7 @@ def test_prefix_write_lock_error(mutable_database, monkeypatch): def _raise(db, spec): raise lk.LockError("Mock lock error") - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() # Ensure subsequent lock operations fail monkeypatch.setattr(lk.Lock, "acquire_write", _raise) @@ -1112,7 +1118,7 @@ def test_database_read_works_with_trailing_data(tmp_path, default_mock_concretiz # Populate a database root = str(tmp_path) db = spack.database.Database(root) - spec = default_mock_concretization("a") + spec = default_mock_concretization("pkg-a") db.add(spec, directory_layout=None) specs_in_db = db.query_local() assert spec in specs_in_db diff --git a/lib/spack/spack/test/directives.py b/lib/spack/spack/test/directives.py index 6ae60b4f39..40e4b06243 100644 --- a/lib/spack/spack/test/directives.py +++ b/lib/spack/spack/test/directives.py @@ -31,7 +31,7 @@ def test_true_directives_exist(mock_packages): assert cls.dependencies assert "extendee" in cls.dependencies[spack.spec.Spec()] - assert "b" in cls.dependencies[spack.spec.Spec()] + assert "pkg-b" in cls.dependencies[spack.spec.Spec()] assert cls.resources assert spack.spec.Spec() in cls.resources @@ -44,7 +44,7 @@ def test_constraints_from_context(mock_packages): pkg_cls = spack.repo.PATH.get_pkg_class("with-constraint-met") assert pkg_cls.dependencies - assert "b" in pkg_cls.dependencies[spack.spec.Spec("@1.0")] + assert "pkg-b" in pkg_cls.dependencies[spack.spec.Spec("@1.0")] assert pkg_cls.conflicts assert (spack.spec.Spec("%gcc"), None) in pkg_cls.conflicts[spack.spec.Spec("+foo@1.0")] @@ -55,7 +55,7 @@ def test_constraints_from_context_are_merged(mock_packages): pkg_cls = spack.repo.PATH.get_pkg_class("with-constraint-met") assert pkg_cls.dependencies - assert "c" in pkg_cls.dependencies[spack.spec.Spec("@0.14:15 ^b@3.8:4.0")] + assert "pkg-c" in pkg_cls.dependencies[spack.spec.Spec("@0.14:15 ^pkg-b@3.8:4.0")] @pytest.mark.regression("27754") @@ -69,7 +69,7 @@ def test_extends_spec(config, mock_packages): @pytest.mark.regression("34368") def test_error_on_anonymous_dependency(config, mock_packages): - pkg = spack.repo.PATH.get_pkg_class("a") + pkg = spack.repo.PATH.get_pkg_class("pkg-a") with pytest.raises(spack.directives.DependencyError): spack.directives._depends_on(pkg, "@4.5") diff --git a/lib/spack/spack/test/env.py b/lib/spack/spack/test/env.py index 326b81a5ea..c09393376a 100644 --- a/lib/spack/spack/test/env.py +++ b/lib/spack/spack/test/env.py @@ -381,10 +381,10 @@ spack: """ ) env = ev.Environment(tmp_path) - env.add("a") + env.add("pkg-a") assert len(env.user_specs) == 1 - assert env.manifest.yaml_content["spack"]["specs"] == ["a"] + assert env.manifest.yaml_content["spack"]["specs"] == ["pkg-a"] @pytest.mark.parametrize( @@ -582,7 +582,7 @@ def test_conflicts_with_packages_that_are_not_dependencies( spack: specs: - {spec_str} - - b + - pkg-b concretizer: unify: true """ @@ -710,7 +710,7 @@ def test_variant_propagation_with_unify_false(tmp_path, mock_packages, config): spack: specs: - parent-foo ++foo - - c + - pkg-c concretizer: unify: false """ @@ -795,10 +795,10 @@ def test_deconcretize_then_concretize_does_not_error(mutable_mock_env_path, mock """spack: specs: # These two specs concretize to the same hash - - c - - c@1.0 + - pkg-c + - pkg-c@1.0 # Spec used to trigger the bug - - a + - pkg-a concretizer: unify: true """ @@ -806,10 +806,10 @@ def test_deconcretize_then_concretize_does_not_error(mutable_mock_env_path, mock e = ev.Environment(mutable_mock_env_path) with e: e.concretize() - e.deconcretize(spack.spec.Spec("a"), concrete=False) + e.deconcretize(spack.spec.Spec("pkg-a"), concrete=False) e.concretize() assert len(e.concrete_roots()) == 3 - all_root_hashes = set(x.dag_hash() for x in e.concrete_roots()) + all_root_hashes = {x.dag_hash() for x in e.concrete_roots()} assert len(all_root_hashes) == 2 diff --git a/lib/spack/spack/test/installer.py b/lib/spack/spack/test/installer.py index 53ce7314eb..1ca3982dd6 100644 --- a/lib/spack/spack/test/installer.py +++ b/lib/spack/spack/test/installer.py @@ -99,7 +99,7 @@ def test_hms(sec, result): def test_get_dependent_ids(install_mockery, mock_packages): # Concretize the parent package, which handle dependency too - spec = spack.spec.Spec("a") + spec = spack.spec.Spec("pkg-a") spec.concretize() assert spec.concrete @@ -190,11 +190,11 @@ def test_process_binary_cache_tarball_tar(install_mockery, monkeypatch, capfd): # Skip database updates monkeypatch.setattr(spack.database.Database, "add", _noop) - spec = spack.spec.Spec("a").concretized() + spec = spack.spec.Spec("pkg-a").concretized() assert inst._process_binary_cache_tarball(spec.package, explicit=False, unsigned=False) out = capfd.readouterr()[0] - assert "Extracting a" in out + assert "Extracting pkg-a" in out assert "from binary cache" in out @@ -243,7 +243,7 @@ def test_installer_prune_built_build_deps(install_mockery, monkeypatch, tmpdir): @property def _mock_installed(self): - return self.name in ["c"] + return self.name == "pkg-c" # Mock the installed property to say that (b) is installed monkeypatch.setattr(spack.spec.Spec, "installed", _mock_installed) @@ -251,23 +251,24 @@ def test_installer_prune_built_build_deps(install_mockery, monkeypatch, tmpdir): # Create mock repository with packages (a), (b), (c), (d), and (e) builder = spack.repo.MockRepositoryBuilder(tmpdir.mkdir("mock-repo")) - builder.add_package("a", dependencies=[("b", "build", None), ("c", "build", None)]) - builder.add_package("b", dependencies=[("d", "build", None)]) + builder.add_package("pkg-a", dependencies=[("pkg-b", "build", None), ("pkg-c", "build", None)]) + builder.add_package("pkg-b", dependencies=[("pkg-d", "build", None)]) builder.add_package( - "c", dependencies=[("d", "build", None), ("e", "all", None), ("f", "build", None)] + "pkg-c", + dependencies=[("pkg-d", "build", None), ("pkg-e", "all", None), ("pkg-f", "build", None)], ) - builder.add_package("d") - builder.add_package("e") - builder.add_package("f") + builder.add_package("pkg-d") + builder.add_package("pkg-e") + builder.add_package("pkg-f") with spack.repo.use_repositories(builder.root): - installer = create_installer(["a"]) + installer = create_installer(["pkg-a"]) installer._init_queue() # Assert that (c) is not in the build_pq - result = set([task.pkg_id[0] for _, task in installer.build_pq]) - expected = set(["a", "b", "c", "d", "e"]) + result = {task.pkg_id[:5] for _, task in installer.build_pq} + expected = {"pkg-a", "pkg-b", "pkg-c", "pkg-d", "pkg-e"} assert result == expected @@ -379,8 +380,7 @@ def test_ensure_locked_have(install_mockery, tmpdir, capsys): @pytest.mark.parametrize("lock_type,reads,writes", [("read", 1, 0), ("write", 0, 1)]) def test_ensure_locked_new_lock(install_mockery, tmpdir, lock_type, reads, writes): - pkg_id = "a" - installer = create_installer([pkg_id], {}) + installer = create_installer(["pkg-a"], {}) spec = installer.build_requests[0].pkg.spec with tmpdir.as_cwd(): ltype, lock = installer._ensure_locked(lock_type, spec.package) @@ -398,8 +398,7 @@ def test_ensure_locked_new_warn(install_mockery, monkeypatch, tmpdir, capsys): lock.default_timeout = 1e-9 if timeout is None else None return lock - pkg_id = "a" - installer = create_installer([pkg_id], {}) + installer = create_installer(["pkg-a"], {}) spec = installer.build_requests[0].pkg.spec monkeypatch.setattr(spack.database.SpecLocker, "lock", _pl) @@ -453,7 +452,7 @@ def test_packages_needed_to_bootstrap_compiler_packages(install_mockery, monkeyp spec.concretize() def _conc_spec(compiler): - return spack.spec.Spec("a").concretized() + return spack.spec.Spec("pkg-a").concretized() # Ensure we can get past functions that are precluding obtaining # packages. @@ -561,7 +560,7 @@ def test_clear_failures_success(tmpdir): """Test the clear_failures happy path.""" failures = spack.database.FailureTracker(str(tmpdir), default_timeout=0.1) - spec = spack.spec.Spec("a") + spec = spack.spec.Spec("pkg-a") spec._mark_concrete() # Set up a test prefix failure lock @@ -587,7 +586,7 @@ def test_clear_failures_success(tmpdir): def test_clear_failures_errs(tmpdir, capsys): """Test the clear_failures exception paths.""" failures = spack.database.FailureTracker(str(tmpdir), default_timeout=0.1) - spec = spack.spec.Spec("a") + spec = spack.spec.Spec("pkg-a") spec._mark_concrete() failures.mark(spec) @@ -649,11 +648,11 @@ def test_check_deps_status_install_failure(install_mockery): """Tests that checking the dependency status on a request to install 'a' fails, if we mark the dependency as failed. """ - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() for dep in s.traverse(root=False): spack.store.STORE.failure_tracker.mark(dep) - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) request = installer.build_requests[0] with pytest.raises(inst.InstallError, match="install failure"): @@ -661,7 +660,7 @@ def test_check_deps_status_install_failure(install_mockery): def test_check_deps_status_write_locked(install_mockery, monkeypatch): - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) request = installer.build_requests[0] # Ensure the lock is not acquired @@ -672,7 +671,7 @@ def test_check_deps_status_write_locked(install_mockery, monkeypatch): def test_check_deps_status_external(install_mockery, monkeypatch): - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) request = installer.build_requests[0] # Mock the dependencies as external so assumed to be installed @@ -684,7 +683,7 @@ def test_check_deps_status_external(install_mockery, monkeypatch): def test_check_deps_status_upstream(install_mockery, monkeypatch): - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) request = installer.build_requests[0] # Mock the known dependencies as installed upstream @@ -756,7 +755,7 @@ def test_install_task_add_compiler(install_mockery, monkeypatch, capfd): def _add(_compilers): tty.msg(config_msg) - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) task = create_build_task(installer.build_requests[0].pkg) task.compiler = True @@ -792,7 +791,7 @@ def test_release_lock_write_n_exception(install_mockery, tmpdir, capsys): @pytest.mark.parametrize("installed", [True, False]) def test_push_task_skip_processed(install_mockery, installed): """Test to ensure skip re-queueing a processed package.""" - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) assert len(list(installer.build_tasks)) == 0 # Mark the package as installed OR failed @@ -809,7 +808,7 @@ def test_push_task_skip_processed(install_mockery, installed): def test_requeue_task(install_mockery, capfd): """Test to ensure cover _requeue_task.""" - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) task = create_build_task(installer.build_requests[0].pkg) # temporarily set tty debug messages on so we can test output @@ -826,7 +825,7 @@ def test_requeue_task(install_mockery, capfd): assert qtask.attempts == task.attempts + 1 out = capfd.readouterr()[1] - assert "Installing a" in out + assert "Installing pkg-a" in out assert " in progress by another process" in out @@ -839,16 +838,16 @@ def test_cleanup_all_tasks(install_mockery, monkeypatch): def _rmtask(installer, pkg_id): raise RuntimeError("Raise an exception to test except path") - installer = create_installer(["a"], {}) + installer = create_installer(["pkg-a"], {}) spec = installer.build_requests[0].pkg.spec # Cover task removal happy path - installer.build_tasks["a"] = _mktask(spec.package) + installer.build_tasks["pkg-a"] = _mktask(spec.package) installer._cleanup_all_tasks() assert len(installer.build_tasks) == 0 # Cover task removal exception path - installer.build_tasks["a"] = _mktask(spec.package) + installer.build_tasks["pkg-a"] = _mktask(spec.package) monkeypatch.setattr(inst.PackageInstaller, "_remove_task", _rmtask) installer._cleanup_all_tasks() assert len(installer.build_tasks) == 1 @@ -938,7 +937,7 @@ def test_install_uninstalled_deps(install_mockery, monkeypatch, capsys): def test_install_failed(install_mockery, monkeypatch, capsys): """Test install with failed install.""" - installer = create_installer(["b"], {}) + installer = create_installer(["pkg-b"], {}) # Make sure the package is identified as failed monkeypatch.setattr(spack.database.FailureTracker, "has_failed", _true) @@ -953,7 +952,7 @@ def test_install_failed(install_mockery, monkeypatch, capsys): def test_install_failed_not_fast(install_mockery, monkeypatch, capsys): """Test install with failed install.""" - installer = create_installer(["a"], {"fail_fast": False}) + installer = create_installer(["pkg-a"], {"fail_fast": False}) # Make sure the package is identified as failed monkeypatch.setattr(spack.database.FailureTracker, "has_failed", _true) @@ -963,12 +962,12 @@ def test_install_failed_not_fast(install_mockery, monkeypatch, capsys): out = str(capsys.readouterr()) assert "failed to install" in out - assert "Skipping build of a" in out + assert "Skipping build of pkg-a" in out def test_install_fail_on_interrupt(install_mockery, monkeypatch): """Test ctrl-c interrupted install.""" - spec_name = "a" + spec_name = "pkg-a" err_msg = "mock keyboard interrupt for {0}".format(spec_name) def _interrupt(installer, task, install_status, **kwargs): @@ -985,13 +984,13 @@ def test_install_fail_on_interrupt(install_mockery, monkeypatch): with pytest.raises(KeyboardInterrupt, match=err_msg): installer.install() - assert "b" in installer.installed # ensure dependency of a is 'installed' + assert "pkg-b" in installer.installed # ensure dependency of pkg-a is 'installed' assert spec_name not in installer.installed def test_install_fail_single(install_mockery, monkeypatch): """Test expected results for failure of single package.""" - spec_name = "a" + spec_name = "pkg-a" err_msg = "mock internal package build error for {0}".format(spec_name) class MyBuildException(Exception): @@ -1011,13 +1010,13 @@ def test_install_fail_single(install_mockery, monkeypatch): with pytest.raises(MyBuildException, match=err_msg): installer.install() - assert "b" in installer.installed # ensure dependency of a is 'installed' + assert "pkg-b" in installer.installed # ensure dependency of a is 'installed' assert spec_name not in installer.installed def test_install_fail_multi(install_mockery, monkeypatch): """Test expected results for failure of multiple packages.""" - spec_name = "c" + spec_name = "pkg-c" err_msg = "mock internal package build error" class MyBuildException(Exception): @@ -1029,7 +1028,7 @@ def test_install_fail_multi(install_mockery, monkeypatch): else: installer.installed.add(task.pkg.name) - installer = create_installer([spec_name, "a"], {}) + installer = create_installer([spec_name, "pkg-a"], {}) # Raise a KeyboardInterrupt error to trigger early termination monkeypatch.setattr(inst.PackageInstaller, "_install_task", _install) @@ -1037,13 +1036,13 @@ def test_install_fail_multi(install_mockery, monkeypatch): with pytest.raises(inst.InstallError, match="Installation request failed"): installer.install() - assert "a" in installer.installed # ensure the the second spec installed + assert "pkg-a" in installer.installed # ensure the the second spec installed assert spec_name not in installer.installed def test_install_fail_fast_on_detect(install_mockery, monkeypatch, capsys): """Test fail_fast install when an install failure is detected.""" - b, c = spack.spec.Spec("b").concretized(), spack.spec.Spec("c").concretized() + b, c = spack.spec.Spec("pkg-b").concretized(), spack.spec.Spec("pkg-c").concretized() b_id, c_id = inst.package_id(b), inst.package_id(c) installer = create_installer([b, c], {"fail_fast": True}) @@ -1056,7 +1055,7 @@ def test_install_fail_fast_on_detect(install_mockery, monkeypatch, capsys): installer.install() assert b_id in installer.failed, "Expected b to be marked as failed" - assert c_id not in installer.failed, "Expected no attempt to install c" + assert c_id not in installer.failed, "Expected no attempt to install pkg-c" assert f"{b_id} failed to install" in capsys.readouterr().err @@ -1070,7 +1069,7 @@ def _test_install_fail_fast_on_except_patch(installer, **kwargs): @pytest.mark.disable_clean_stage_check def test_install_fail_fast_on_except(install_mockery, monkeypatch, capsys): """Test fail_fast install when an install failure results from an error.""" - installer = create_installer(["a"], {"fail_fast": True}) + installer = create_installer(["pkg-a"], {"fail_fast": True}) # Raise a non-KeyboardInterrupt exception to trigger fast failure. # @@ -1084,7 +1083,7 @@ def test_install_fail_fast_on_except(install_mockery, monkeypatch, capsys): installer.install() out = str(capsys.readouterr()) - assert "Skipping build of a" in out + assert "Skipping build of pkg-a" in out def test_install_lock_failures(install_mockery, monkeypatch, capfd): @@ -1093,7 +1092,7 @@ def test_install_lock_failures(install_mockery, monkeypatch, capfd): def _requeued(installer, task, install_status): tty.msg("requeued {0}".format(task.pkg.spec.name)) - installer = create_installer(["b"], {}) + installer = create_installer(["pkg-b"], {}) # Ensure never acquire a lock monkeypatch.setattr(inst.PackageInstaller, "_ensure_locked", _not_locked) @@ -1112,7 +1111,7 @@ def test_install_lock_failures(install_mockery, monkeypatch, capfd): def test_install_lock_installed_requeue(install_mockery, monkeypatch, capfd): """Cover basic install handling for installed package.""" - b = spack.spec.Spec("b").concretized() + b = spack.spec.Spec("pkg-b").concretized() b_pkg_id = inst.package_id(b) installer = create_installer([b]) @@ -1166,7 +1165,7 @@ def test_install_read_locked_requeue(install_mockery, monkeypatch, capfd): # Ensure don't continually requeue the task monkeypatch.setattr(inst.PackageInstaller, "_requeue_task", _requeued) - installer = create_installer(["b"], {}) + installer = create_installer(["pkg-b"], {}) with pytest.raises(inst.InstallError, match="request failed"): installer.install() @@ -1181,7 +1180,7 @@ def test_install_read_locked_requeue(install_mockery, monkeypatch, capfd): def test_install_skip_patch(install_mockery, mock_fetch): """Test the path skip_patch install path.""" - installer = create_installer(["b"], {"fake": False, "skip_patch": True}) + installer = create_installer(["pkg-b"], {"fake": False, "skip_patch": True}) installer.install() assert inst.package_id(installer.build_requests[0].pkg.spec) in installer.installed @@ -1202,7 +1201,7 @@ def test_overwrite_install_backup_success(temporary_store, config, mock_packages of the original prefix, and leave the original spec marked installed. """ # Get a build task. TODO: refactor this to avoid calling internal methods - installer = create_installer(["b"]) + installer = create_installer(["pkg-b"]) installer._init_queue() task = installer._pop_task() @@ -1262,7 +1261,7 @@ def test_overwrite_install_backup_failure(temporary_store, config, mock_packages self.called = True # Get a build task. TODO: refactor this to avoid calling internal methods - installer = create_installer(["b"]) + installer = create_installer(["pkg-b"]) installer._init_queue() task = installer._pop_task() @@ -1290,8 +1289,8 @@ def test_term_status_line(): # accept that. `with log_output(buf)` doesn't really work because it trims output # and we actually want to test for escape sequences etc. x = inst.TermStatusLine(enabled=True) - x.add("a") - x.add("b") + x.add("pkg-a") + x.add("pkg-b") x.clear() diff --git a/lib/spack/spack/test/mirror.py b/lib/spack/spack/test/mirror.py index eeed5b2630..1379ad92cf 100644 --- a/lib/spack/spack/test/mirror.py +++ b/lib/spack/spack/test/mirror.py @@ -289,8 +289,8 @@ def test_mirror_cache_symlinks(tmpdir): @pytest.mark.parametrize( "specs,expected_specs", [ - (["a"], ["a@=1.0", "a@=2.0"]), - (["a", "brillig"], ["a@=1.0", "a@=2.0", "brillig@=1.0.0", "brillig@=2.0.0"]), + (["pkg-a"], ["pkg-a@=1.0", "pkg-a@=2.0"]), + (["pkg-a", "brillig"], ["pkg-a@=1.0", "pkg-a@=2.0", "brillig@=1.0.0", "brillig@=2.0.0"]), ], ) def test_get_all_versions(specs, expected_specs): diff --git a/lib/spack/spack/test/optional_deps.py b/lib/spack/spack/test/optional_deps.py index 8d1c7e37e8..bc3596220d 100644 --- a/lib/spack/spack/test/optional_deps.py +++ b/lib/spack/spack/test/optional_deps.py @@ -13,28 +13,44 @@ from spack.spec import Spec # Normalize simple conditionals ("optional-dep-test", {"optional-dep-test": None}), ("optional-dep-test~a", {"optional-dep-test~a": None}), - ("optional-dep-test+a", {"optional-dep-test+a": {"a": None}}), - ("optional-dep-test a=true", {"optional-dep-test a=true": {"a": None}}), - ("optional-dep-test a=true", {"optional-dep-test+a": {"a": None}}), - ("optional-dep-test@1.1", {"optional-dep-test@1.1": {"b": None}}), - ("optional-dep-test%intel", {"optional-dep-test%intel": {"c": None}}), - ("optional-dep-test%intel@64.1", {"optional-dep-test%intel@64.1": {"c": None, "d": None}}), + ("optional-dep-test+a", {"optional-dep-test+a": {"pkg-a": None}}), + ("optional-dep-test a=true", {"optional-dep-test a=true": {"pkg-a": None}}), + ("optional-dep-test a=true", {"optional-dep-test+a": {"pkg-a": None}}), + ("optional-dep-test@1.1", {"optional-dep-test@1.1": {"pkg-b": None}}), + ("optional-dep-test%intel", {"optional-dep-test%intel": {"pkg-c": None}}), + ( + "optional-dep-test%intel@64.1", + {"optional-dep-test%intel@64.1": {"pkg-c": None, "pkg-d": None}}, + ), ( "optional-dep-test%intel@64.1.2", - {"optional-dep-test%intel@64.1.2": {"c": None, "d": None}}, + {"optional-dep-test%intel@64.1.2": {"pkg-c": None, "pkg-d": None}}, ), - ("optional-dep-test%clang@35", {"optional-dep-test%clang@35": {"e": None}}), + ("optional-dep-test%clang@35", {"optional-dep-test%clang@35": {"pkg-e": None}}), # Normalize multiple conditionals - ("optional-dep-test+a@1.1", {"optional-dep-test+a@1.1": {"a": None, "b": None}}), - ("optional-dep-test+a%intel", {"optional-dep-test+a%intel": {"a": None, "c": None}}), - ("optional-dep-test@1.1%intel", {"optional-dep-test@1.1%intel": {"b": None, "c": None}}), + ("optional-dep-test+a@1.1", {"optional-dep-test+a@1.1": {"pkg-a": None, "pkg-b": None}}), + ( + "optional-dep-test+a%intel", + {"optional-dep-test+a%intel": {"pkg-a": None, "pkg-c": None}}, + ), + ( + "optional-dep-test@1.1%intel", + {"optional-dep-test@1.1%intel": {"pkg-b": None, "pkg-c": None}}, + ), ( "optional-dep-test@1.1%intel@64.1.2+a", - {"optional-dep-test@1.1%intel@64.1.2+a": {"a": None, "b": None, "c": None, "d": None}}, + { + "optional-dep-test@1.1%intel@64.1.2+a": { + "pkg-a": None, + "pkg-b": None, + "pkg-c": None, + "pkg-d": None, + } + }, ), ( "optional-dep-test@1.1%clang@36.5+a", - {"optional-dep-test@1.1%clang@36.5+a": {"b": None, "a": None, "e": None}}, + {"optional-dep-test@1.1%clang@36.5+a": {"pkg-b": None, "pkg-a": None, "pkg-e": None}}, ), # Chained MPI ( @@ -44,7 +60,10 @@ from spack.spec import Spec # Each of these dependencies comes from a conditional # dependency on another. This requires iterating to evaluate # the whole chain. - ("optional-dep-test+f", {"optional-dep-test+f": {"f": None, "g": None, "mpi": None}}), + ( + "optional-dep-test+f", + {"optional-dep-test+f": {"pkg-f": None, "pkg-g": None, "mpi": None}}, + ), ] ) def spec_and_expected(request): @@ -63,12 +82,12 @@ def test_normalize(spec_and_expected, config, mock_packages): def test_default_variant(config, mock_packages): spec = Spec("optional-dep-test-3") spec.concretize() - assert "a" in spec + assert "pkg-a" in spec spec = Spec("optional-dep-test-3~var") spec.concretize() - assert "a" in spec + assert "pkg-a" in spec spec = Spec("optional-dep-test-3+var") spec.concretize() - assert "b" in spec + assert "pkg-b" in spec diff --git a/lib/spack/spack/test/package_class.py b/lib/spack/spack/test/package_class.py index f3426e23ce..07a82c5358 100644 --- a/lib/spack/spack/test/package_class.py +++ b/lib/spack/spack/test/package_class.py @@ -21,6 +21,7 @@ import spack.deptypes as dt import spack.install_test import spack.package_base import spack.repo +import spack.spec from spack.build_systems.generic import Package from spack.installer import InstallError @@ -142,19 +143,19 @@ def setup_install_test(source_paths, test_root): "spec,sources,extras,expect", [ ( - "a", + "pkg-a", ["example/a.c"], # Source(s) ["example/a.c"], # Extra test source ["example/a.c"], ), # Test install dir source(s) ( - "b", + "pkg-b", ["test/b.cpp", "test/b.hpp", "example/b.txt"], # Source(s) ["test"], # Extra test source ["test/b.cpp", "test/b.hpp"], ), # Test install dir source ( - "c", + "pkg-c", ["examples/a.py", "examples/b.py", "examples/c.py", "tests/d.py"], ["examples/b.py", "tests"], ["examples/b.py", "tests/d.py"], @@ -202,7 +203,7 @@ def test_cache_extra_sources(install_mockery, spec, sources, extras, expect): def test_cache_extra_sources_fails(install_mockery): - s = spack.spec.Spec("a").concretized() + s = spack.spec.Spec("pkg-a").concretized() s.package.spec.concretize() with pytest.raises(InstallError) as exc_info: @@ -226,7 +227,7 @@ def test_package_url_and_urls(): url = "https://www.example.com/url-package-1.0.tgz" urls = ["https://www.example.com/archive"] - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") with pytest.raises(ValueError, match="defines both"): URLsPackage(s) @@ -236,7 +237,7 @@ def test_package_license(): extendees = None # currently a required attribute for is_extension() license_files = None - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") pkg = LicensedPackage(s) assert pkg.global_license_file is None @@ -249,21 +250,21 @@ class BaseTestPackage(Package): def test_package_version_fails(): - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") pkg = BaseTestPackage(s) with pytest.raises(ValueError, match="does not have a concrete version"): pkg.version() def test_package_tester_fails(): - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") pkg = BaseTestPackage(s) with pytest.raises(ValueError, match="without concrete version"): pkg.tester() def test_package_fetcher_fails(): - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") pkg = BaseTestPackage(s) with pytest.raises(ValueError, match="without concrete version"): pkg.fetcher @@ -275,7 +276,7 @@ def test_package_test_no_compilers(mock_packages, monkeypatch, capfd): monkeypatch.setattr(spack.compilers, "compilers_for_spec", compilers) - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") pkg = BaseTestPackage(s) pkg.test_requires_compiler = True pkg.do_test() diff --git a/lib/spack/spack/test/packaging.py b/lib/spack/spack/test/packaging.py index d8a19b2e47..aa1e50468a 100644 --- a/lib/spack/spack/test/packaging.py +++ b/lib/spack/spack/test/packaging.py @@ -515,7 +515,7 @@ def test_manual_download(mock_download, default_mock_concretization, monkeypatch def _instr(pkg): return f"Download instructions for {pkg.spec.name}" - spec = default_mock_concretization("a") + spec = default_mock_concretization("pkg-a") spec.package.manual_download = manual if instr: monkeypatch.setattr(spack.package_base.PackageBase, "download_instr", _instr) @@ -539,14 +539,14 @@ def fetching_not_allowed(monkeypatch): def test_fetch_without_code_is_noop(default_mock_concretization, fetching_not_allowed): """do_fetch for packages without code should be a no-op""" - pkg = default_mock_concretization("a").package + pkg = default_mock_concretization("pkg-a").package pkg.has_code = False pkg.do_fetch() def test_fetch_external_package_is_noop(default_mock_concretization, fetching_not_allowed): """do_fetch for packages without code should be a no-op""" - spec = default_mock_concretization("a") + spec = default_mock_concretization("pkg-a") spec.external_path = "/some/where" assert spec.external spec.package.do_fetch() diff --git a/lib/spack/spack/test/repo.py b/lib/spack/spack/test/repo.py index 6bb2c2625e..e08d148289 100644 --- a/lib/spack/spack/test/repo.py +++ b/lib/spack/spack/test/repo.py @@ -10,6 +10,8 @@ import pytest import spack.package_base import spack.paths import spack.repo +import spack.spec +import spack.util.file_cache @pytest.fixture(params=["packages", "", "foo"]) @@ -38,25 +40,25 @@ repo: def test_repo_getpkg(mutable_mock_repo): - mutable_mock_repo.get_pkg_class("a") - mutable_mock_repo.get_pkg_class("builtin.mock.a") + mutable_mock_repo.get_pkg_class("pkg-a") + mutable_mock_repo.get_pkg_class("builtin.mock.pkg-a") def test_repo_multi_getpkg(mutable_mock_repo, extra_repo): mutable_mock_repo.put_first(extra_repo[0]) - mutable_mock_repo.get_pkg_class("a") - mutable_mock_repo.get_pkg_class("builtin.mock.a") + mutable_mock_repo.get_pkg_class("pkg-a") + mutable_mock_repo.get_pkg_class("builtin.mock.pkg-a") def test_repo_multi_getpkgclass(mutable_mock_repo, extra_repo): mutable_mock_repo.put_first(extra_repo[0]) - mutable_mock_repo.get_pkg_class("a") - mutable_mock_repo.get_pkg_class("builtin.mock.a") + mutable_mock_repo.get_pkg_class("pkg-a") + mutable_mock_repo.get_pkg_class("builtin.mock.pkg-a") def test_repo_pkg_with_unknown_namespace(mutable_mock_repo): with pytest.raises(spack.repo.UnknownNamespaceError): - mutable_mock_repo.get_pkg_class("unknown.a") + mutable_mock_repo.get_pkg_class("unknown.pkg-a") def test_repo_unknown_pkg(mutable_mock_repo): @@ -150,14 +152,14 @@ def test_get_all_mock_packages(mock_packages): def test_repo_path_handles_package_removal(tmpdir, mock_packages): builder = spack.repo.MockRepositoryBuilder(tmpdir, namespace="removal") - builder.add_package("c") + builder.add_package("pkg-c") with spack.repo.use_repositories(builder.root, override=False) as repos: - r = repos.repo_for_pkg("c") + r = repos.repo_for_pkg("pkg-c") assert r.namespace == "removal" - builder.remove("c") + builder.remove("pkg-c") with spack.repo.use_repositories(builder.root, override=False) as repos: - r = repos.repo_for_pkg("c") + r = repos.repo_for_pkg("pkg-c") assert r.namespace == "builtin.mock" diff --git a/lib/spack/spack/test/spec_dag.py b/lib/spack/spack/test/spec_dag.py index c3126d3c29..398741a6cf 100644 --- a/lib/spack/spack/test/spec_dag.py +++ b/lib/spack/spack/test/spec_dag.py @@ -138,19 +138,19 @@ def test_specify_preinstalled_dep(tmpdir, monkeypatch): transitive dependency that is only supplied by the preinstalled package. """ builder = spack.repo.MockRepositoryBuilder(tmpdir) - builder.add_package("c") - builder.add_package("b", dependencies=[("c", None, None)]) - builder.add_package("a", dependencies=[("b", None, None)]) + builder.add_package("pkg-c") + builder.add_package("pkg-b", dependencies=[("pkg-c", None, None)]) + builder.add_package("pkg-a", dependencies=[("pkg-b", None, None)]) with spack.repo.use_repositories(builder.root): - b_spec = Spec("b").concretized() - monkeypatch.setattr(Spec, "installed", property(lambda x: x.name != "a")) + b_spec = Spec("pkg-b").concretized() + monkeypatch.setattr(Spec, "installed", property(lambda x: x.name != "pkg-a")) - a_spec = Spec("a") + a_spec = Spec("pkg-a") a_spec._add_dependency(b_spec, depflag=dt.BUILD | dt.LINK, virtuals=()) a_spec.concretize() - assert set(x.name for x in a_spec.traverse()) == set(["a", "b", "c"]) + assert {x.name for x in a_spec.traverse()} == {"pkg-a", "pkg-b", "pkg-c"} @pytest.mark.usefixtures("config") @@ -1007,15 +1007,15 @@ def test_synthetic_construction_of_split_dependencies_from_same_package(mock_pac # Construct in a synthetic way (i.e. without using the solver) # the following spec: # - # b + # pkg-b # build / \ link,run - # c@2.0 c@1.0 + # pkg-c@2.0 pkg-c@1.0 # # To demonstrate that a spec can now hold two direct # dependencies from the same package - root = Spec("b").concretized() - link_run_spec = Spec("c@=1.0").concretized() - build_spec = Spec("c@=2.0").concretized() + root = Spec("pkg-b").concretized() + link_run_spec = Spec("pkg-c@=1.0").concretized() + build_spec = Spec("pkg-c@=2.0").concretized() root.add_dependency_edge(link_run_spec, depflag=dt.LINK, virtuals=()) root.add_dependency_edge(link_run_spec, depflag=dt.RUN, virtuals=()) @@ -1023,10 +1023,10 @@ def test_synthetic_construction_of_split_dependencies_from_same_package(mock_pac # Check dependencies from the perspective of root assert len(root.dependencies()) == 2 - assert all(x.name == "c" for x in root.dependencies()) + assert all(x.name == "pkg-c" for x in root.dependencies()) - assert "@2.0" in root.dependencies(name="c", deptype=dt.BUILD)[0] - assert "@1.0" in root.dependencies(name="c", deptype=dt.LINK | dt.RUN)[0] + assert "@2.0" in root.dependencies(name="pkg-c", deptype=dt.BUILD)[0] + assert "@1.0" in root.dependencies(name="pkg-c", deptype=dt.LINK | dt.RUN)[0] # Check parent from the perspective of the dependencies assert len(build_spec.dependents()) == 1 @@ -1038,30 +1038,30 @@ def test_synthetic_construction_of_split_dependencies_from_same_package(mock_pac def test_synthetic_construction_bootstrapping(mock_packages, config): # Construct the following spec: # - # b@2.0 + # pkg-b@2.0 # | build - # b@1.0 + # pkg-b@1.0 # - root = Spec("b@=2.0").concretized() - bootstrap = Spec("b@=1.0").concretized() + root = Spec("pkg-b@=2.0").concretized() + bootstrap = Spec("pkg-b@=1.0").concretized() root.add_dependency_edge(bootstrap, depflag=dt.BUILD, virtuals=()) assert len(root.dependencies()) == 1 - assert root.dependencies()[0].name == "b" - assert root.name == "b" + assert root.dependencies()[0].name == "pkg-b" + assert root.name == "pkg-b" def test_addition_of_different_deptypes_in_multiple_calls(mock_packages, config): # Construct the following spec: # - # b@2.0 + # pkg-b@2.0 # | build,link,run - # b@1.0 + # pkg-b@1.0 # # with three calls and check we always have a single edge - root = Spec("b@=2.0").concretized() - bootstrap = Spec("b@=1.0").concretized() + root = Spec("pkg-b@=2.0").concretized() + bootstrap = Spec("pkg-b@=1.0").concretized() for current_depflag in (dt.BUILD, dt.LINK, dt.RUN): root.add_dependency_edge(bootstrap, depflag=current_depflag, virtuals=()) @@ -1088,9 +1088,9 @@ def test_addition_of_different_deptypes_in_multiple_calls(mock_packages, config) def test_adding_same_deptype_with_the_same_name_raises( mock_packages, config, c1_depflag, c2_depflag ): - p = Spec("b@=2.0").concretized() - c1 = Spec("b@=1.0").concretized() - c2 = Spec("b@=2.0").concretized() + p = Spec("pkg-b@=2.0").concretized() + c1 = Spec("pkg-b@=1.0").concretized() + c2 = Spec("pkg-b@=2.0").concretized() p.add_dependency_edge(c1, depflag=c1_depflag, virtuals=()) with pytest.raises(spack.error.SpackError): diff --git a/lib/spack/spack/test/spec_semantics.py b/lib/spack/spack/test/spec_semantics.py index 171c194dc0..b21f0e7ac9 100644 --- a/lib/spack/spack/test/spec_semantics.py +++ b/lib/spack/spack/test/spec_semantics.py @@ -373,7 +373,7 @@ class TestSpecSemantics: https://github.com/spack/spack/pull/2386#issuecomment-282147639 is handled correctly. """ - a = Spec("a foobar=bar") + a = Spec("pkg-a foobar=bar") a.concretize() assert a.satisfies("foobar=bar") @@ -390,21 +390,21 @@ class TestSpecSemantics: assert "foo=bar" in a # Check that conditional dependencies are treated correctly - assert "^b" in a + assert "^pkg-b" in a def test_unsatisfied_single_valued_variant(self): - a = Spec("a foobar=baz") + a = Spec("pkg-a foobar=baz") a.concretize() - assert "^b" not in a + assert "^pkg-b" not in a mv = Spec("multivalue-variant") mv.concretize() - assert "a@1.0" not in mv + assert "pkg-a@1.0" not in mv def test_indirect_unsatisfied_single_valued_variant(self): spec = Spec("singlevalue-variant-dependent") spec.concretize() - assert "a@1.0" not in spec + assert "pkg-a@1.0" not in spec def test_unsatisfiable_multi_value_variant(self, default_mock_concretization): # Semantics for a multi-valued variant is different @@ -986,8 +986,8 @@ class TestSpecSemantics: spec.splice(dep, transitive) def test_spec_override(self): - init_spec = Spec("a foo=baz foobar=baz cflags=-O3 cxxflags=-O1") - change_spec = Spec("a foo=fee cflags=-O2") + init_spec = Spec("pkg-a foo=baz foobar=baz cflags=-O3 cxxflags=-O1") + change_spec = Spec("pkg-a foo=fee cflags=-O2") new_spec = Spec.override(init_spec, change_spec) new_spec.concretize() assert "foo=fee" in new_spec @@ -1269,15 +1269,15 @@ def test_spec_installed(default_mock_concretization, database): spec = Spec("not-a-real-package") assert not spec.installed - # 'a' is not in the mock DB and is not installed - spec = default_mock_concretization("a") + # pkg-a is not in the mock DB and is not installed + spec = default_mock_concretization("pkg-a") assert not spec.installed @pytest.mark.regression("30678") def test_call_dag_hash_on_old_dag_hash_spec(mock_packages, default_mock_concretization): # create a concrete spec - a = default_mock_concretization("a") + a = default_mock_concretization("pkg-a") dag_hashes = {spec.name: spec.dag_hash() for spec in a.traverse()} # make it look like an old DAG hash spec with no package hash on the spec. @@ -1336,8 +1336,8 @@ def test_unsupported_compiler(): def test_package_hash_affects_dunder_and_dag_hash(mock_packages, default_mock_concretization): - a1 = default_mock_concretization("a") - a2 = default_mock_concretization("a") + a1 = default_mock_concretization("pkg-a") + a2 = default_mock_concretization("pkg-a") assert hash(a1) == hash(a2) assert a1.dag_hash() == a2.dag_hash() @@ -1361,8 +1361,8 @@ def test_intersects_and_satisfies_on_concretized_spec(default_mock_concretizatio """Test that a spec obtained by concretizing an abstract spec, satisfies the abstract spec but not vice-versa. """ - a1 = default_mock_concretization("a@1.0") - a2 = Spec("a@1.0") + a1 = default_mock_concretization("pkg-a@1.0") + a2 = Spec("pkg-a@1.0") assert a1.intersects(a2) assert a2.intersects(a1) @@ -1488,17 +1488,17 @@ def test_constrain(factory, lhs_str, rhs_str, result, constrained_str): def test_abstract_hash_intersects_and_satisfies(default_mock_concretization): - concrete: Spec = default_mock_concretization("a") + concrete: Spec = default_mock_concretization("pkg-a") hash = concrete.dag_hash() hash_5 = hash[:5] hash_6 = hash[:6] # abstract hash that doesn't have a common prefix with the others. hash_other = f"{'a' if hash_5[0] == 'b' else 'b'}{hash_5[1:]}" - abstract_5 = Spec(f"a/{hash_5}") - abstract_6 = Spec(f"a/{hash_6}") - abstract_none = Spec(f"a/{hash_other}") - abstract = Spec("a") + abstract_5 = Spec(f"pkg-a/{hash_5}") + abstract_6 = Spec(f"pkg-a/{hash_6}") + abstract_none = Spec(f"pkg-a/{hash_other}") + abstract = Spec("pkg-a") def assert_subset(a: Spec, b: Spec): assert a.intersects(b) and b.intersects(a) and a.satisfies(b) and not b.satisfies(a) @@ -1535,6 +1535,6 @@ def test_edge_equality_does_not_depend_on_virtual_order(): def test_old_format_strings_trigger_error(default_mock_concretization): - s = Spec("a").concretized() + s = Spec("pkg-a").concretized() with pytest.raises(SpecFormatStringError): s.format("${PACKAGE}-${VERSION}-${HASH}") diff --git a/lib/spack/spack/test/spec_syntax.py b/lib/spack/spack/test/spec_syntax.py index f411faf005..e17ed724a4 100644 --- a/lib/spack/spack/test/spec_syntax.py +++ b/lib/spack/spack/test/spec_syntax.py @@ -759,7 +759,7 @@ def test_spec_by_hash_tokens(text, tokens): @pytest.mark.db def test_spec_by_hash(database, monkeypatch, config): mpileaks = database.query_one("mpileaks ^zmpi") - b = spack.spec.Spec("b").concretized() + b = spack.spec.Spec("pkg-b").concretized() monkeypatch.setattr(spack.binary_distribution, "update_cache_and_get_specs", lambda: [b]) hash_str = f"/{mpileaks.dag_hash()}" @@ -856,7 +856,7 @@ def test_ambiguous_hash(mutable_database): In the past this ambiguity error would happen during parse time.""" # This is a very sketchy as manually setting hashes easily breaks invariants - x1 = spack.spec.Spec("a").concretized() + x1 = spack.spec.Spec("pkg-a").concretized() x2 = x1.copy() x1._hash = "xyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy" x1._process_hash = "xyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy" @@ -874,7 +874,7 @@ def test_ambiguous_hash(mutable_database): s1.lookup_hash() # ambiguity in first hash character AND spec name - s2 = SpecParser("a/x").next_spec() + s2 = SpecParser("pkg-a/x").next_spec() with pytest.raises(spack.spec.AmbiguousHashError): s2.lookup_hash() diff --git a/lib/spack/spack/test/spec_yaml.py b/lib/spack/spack/test/spec_yaml.py index df63fdf72e..3f20e5626e 100644 --- a/lib/spack/spack/test/spec_yaml.py +++ b/lib/spack/spack/test/spec_yaml.py @@ -316,23 +316,23 @@ def test_save_dependency_spec_jsons_subset(tmpdir, config): output_path = str(tmpdir.mkdir("spec_jsons")) builder = spack.repo.MockRepositoryBuilder(tmpdir.mkdir("mock-repo")) - builder.add_package("g") - builder.add_package("f") - builder.add_package("e") - builder.add_package("d", dependencies=[("f", None, None), ("g", None, None)]) - builder.add_package("c") - builder.add_package("b", dependencies=[("d", None, None), ("e", None, None)]) - builder.add_package("a", dependencies=[("b", None, None), ("c", None, None)]) + builder.add_package("pkg-g") + builder.add_package("pkg-f") + builder.add_package("pkg-e") + builder.add_package("pkg-d", dependencies=[("pkg-f", None, None), ("pkg-g", None, None)]) + builder.add_package("pkg-c") + builder.add_package("pkg-b", dependencies=[("pkg-d", None, None), ("pkg-e", None, None)]) + builder.add_package("pkg-a", dependencies=[("pkg-b", None, None), ("pkg-c", None, None)]) with spack.repo.use_repositories(builder.root): - spec_a = Spec("a").concretized() - b_spec = spec_a["b"] - c_spec = spec_a["c"] + spec_a = Spec("pkg-a").concretized() + b_spec = spec_a["pkg-b"] + c_spec = spec_a["pkg-c"] - save_dependency_specfiles(spec_a, output_path, [Spec("b"), Spec("c")]) + save_dependency_specfiles(spec_a, output_path, [Spec("pkg-b"), Spec("pkg-c")]) - assert check_specs_equal(b_spec, os.path.join(output_path, "b.json")) - assert check_specs_equal(c_spec, os.path.join(output_path, "c.json")) + assert check_specs_equal(b_spec, os.path.join(output_path, "pkg-b.json")) + assert check_specs_equal(c_spec, os.path.join(output_path, "pkg-c.json")) def test_legacy_yaml(tmpdir, install_mockery, mock_packages): diff --git a/lib/spack/spack/test/test_suite.py b/lib/spack/spack/test/test_suite.py index 200709587d..8820abe602 100644 --- a/lib/spack/spack/test/test_suite.py +++ b/lib/spack/spack/test/test_suite.py @@ -513,7 +513,7 @@ def test_find_required_file(tmpdir): def test_packagetest_fails(mock_packages): MyPackage = collections.namedtuple("MyPackage", ["spec"]) - s = spack.spec.Spec("a") + s = spack.spec.Spec("pkg-a") pkg = MyPackage(s) with pytest.raises(ValueError, match="require a concrete package"): spack.install_test.PackageTest(pkg) diff --git a/lib/spack/spack/test/views.py b/lib/spack/spack/test/views.py index 68fb286f9c..d32d8e0150 100644 --- a/lib/spack/spack/test/views.py +++ b/lib/spack/spack/test/views.py @@ -33,8 +33,8 @@ def test_view_with_spec_not_contributing_files(mock_packages, tmpdir): layout = DirectoryLayout(view_dir) view = SimpleFilesystemView(view_dir, layout) - a = Spec("a") - b = Spec("b") + a = Spec("pkg-a") + b = Spec("pkg-b") a.prefix = os.path.join(tmpdir, "a") b.prefix = os.path.join(tmpdir, "b") a._mark_concrete() diff --git a/var/spack/repos/builtin.mock/packages/depb/package.py b/var/spack/repos/builtin.mock/packages/depb/package.py index 7022e3472b..82661560b4 100644 --- a/var/spack/repos/builtin.mock/packages/depb/package.py +++ b/var/spack/repos/builtin.mock/packages/depb/package.py @@ -14,7 +14,7 @@ class Depb(AutotoolsPackage): version("1.0", md5="0123456789abcdef0123456789abcdef") - depends_on("b") + depends_on("pkg-b") def install(self, spec, prefix): # sanity_check_prefix requires something in the install directory diff --git a/var/spack/repos/builtin.mock/packages/external-buildable-with-variant/package.py b/var/spack/repos/builtin.mock/packages/external-buildable-with-variant/package.py index 1ec1561a67..28421bad1a 100644 --- a/var/spack/repos/builtin.mock/packages/external-buildable-with-variant/package.py +++ b/var/spack/repos/builtin.mock/packages/external-buildable-with-variant/package.py @@ -15,4 +15,4 @@ class ExternalBuildableWithVariant(Package): variant("baz", default=False, description="nope") - depends_on("c@1.0", when="@0.9") + depends_on("pkg-c@1.0", when="@0.9") diff --git a/var/spack/repos/builtin.mock/packages/missing-dependency/package.py b/var/spack/repos/builtin.mock/packages/missing-dependency/package.py index 043ab79813..630e32927f 100644 --- a/var/spack/repos/builtin.mock/packages/missing-dependency/package.py +++ b/var/spack/repos/builtin.mock/packages/missing-dependency/package.py @@ -18,4 +18,4 @@ class MissingDependency(Package): depends_on("this-is-a-missing-dependency") # this one is a "real" mock dependency - depends_on("a") + depends_on("pkg-a") diff --git a/var/spack/repos/builtin.mock/packages/multivalue-variant/package.py b/var/spack/repos/builtin.mock/packages/multivalue-variant/package.py index 1921cfd810..70ab8306a3 100644 --- a/var/spack/repos/builtin.mock/packages/multivalue-variant/package.py +++ b/var/spack/repos/builtin.mock/packages/multivalue-variant/package.py @@ -40,5 +40,5 @@ class MultivalueVariant(Package): depends_on("mpi") depends_on("callpath") - depends_on("a") - depends_on("a@1.0", when="fee=barbaz") + depends_on("pkg-a") + depends_on("pkg-a@1.0", when="fee=barbaz") diff --git a/var/spack/repos/builtin.mock/packages/optional-dep-test-3/package.py b/var/spack/repos/builtin.mock/packages/optional-dep-test-3/package.py index 48fa846fdd..1e77b601f0 100644 --- a/var/spack/repos/builtin.mock/packages/optional-dep-test-3/package.py +++ b/var/spack/repos/builtin.mock/packages/optional-dep-test-3/package.py @@ -16,5 +16,5 @@ class OptionalDepTest3(Package): variant("var", default=False) - depends_on("a", when="~var") - depends_on("b", when="+var") + depends_on("pkg-a", when="~var") + depends_on("pkg-b", when="+var") diff --git a/var/spack/repos/builtin.mock/packages/optional-dep-test/package.py b/var/spack/repos/builtin.mock/packages/optional-dep-test/package.py index ae80765046..b7f87f490f 100644 --- a/var/spack/repos/builtin.mock/packages/optional-dep-test/package.py +++ b/var/spack/repos/builtin.mock/packages/optional-dep-test/package.py @@ -19,14 +19,14 @@ class OptionalDepTest(Package): variant("f", default=False) variant("mpi", default=False) - depends_on("a", when="+a") - depends_on("b", when="@1.1") - depends_on("c", when="%intel") - depends_on("d", when="%intel@64.1") - depends_on("e", when="%clang@34:40") - - depends_on("f", when="+f") - depends_on("g", when="^f") - depends_on("mpi", when="^g") + depends_on("pkg-a", when="+a") + depends_on("pkg-b", when="@1.1") + depends_on("pkg-c", when="%intel") + depends_on("pkg-d", when="%intel@64.1") + depends_on("pkg-e", when="%clang@34:40") + + depends_on("pkg-f", when="+f") + depends_on("pkg-g", when="^pkg-f") + depends_on("mpi", when="^pkg-g") depends_on("mpi", when="+mpi") diff --git a/var/spack/repos/builtin.mock/packages/a/package.py b/var/spack/repos/builtin.mock/packages/pkg-a/package.py index 3cc2144610..d1ecba835d 100644 --- a/var/spack/repos/builtin.mock/packages/a/package.py +++ b/var/spack/repos/builtin.mock/packages/pkg-a/package.py @@ -6,7 +6,7 @@ import spack.build_systems.autotools from spack.package import * -class A(AutotoolsPackage): +class PkgA(AutotoolsPackage): """Simple package with one optional dependency""" homepage = "http://www.example.com" @@ -25,7 +25,7 @@ class A(AutotoolsPackage): variant("bvv", default=True, description="The good old BV variant") - depends_on("b", when="foobar=bar") + depends_on("pkg-b", when="foobar=bar") depends_on("test-dependency", type="test") parallel = False diff --git a/var/spack/repos/builtin.mock/packages/b/package.py b/var/spack/repos/builtin.mock/packages/pkg-b/package.py index f5d212d3d4..bc20950ebc 100644 --- a/var/spack/repos/builtin.mock/packages/b/package.py +++ b/var/spack/repos/builtin.mock/packages/pkg-b/package.py @@ -6,7 +6,7 @@ from spack.package import * -class B(Package): +class PkgB(Package): """Simple package with no dependencies""" homepage = "http://www.example.com" diff --git a/var/spack/repos/builtin.mock/packages/c/package.py b/var/spack/repos/builtin.mock/packages/pkg-c/package.py index 2e066242af..2c76f1ea51 100644 --- a/var/spack/repos/builtin.mock/packages/c/package.py +++ b/var/spack/repos/builtin.mock/packages/pkg-c/package.py @@ -6,7 +6,7 @@ from spack.package import * -class C(Package): +class PkgC(Package): """Simple package with no dependencies""" homepage = "http://www.example.com" diff --git a/var/spack/repos/builtin.mock/packages/e/package.py b/var/spack/repos/builtin.mock/packages/pkg-e/package.py index eb0fb0e2ce..d49de9e6fb 100644 --- a/var/spack/repos/builtin.mock/packages/e/package.py +++ b/var/spack/repos/builtin.mock/packages/pkg-e/package.py @@ -6,7 +6,7 @@ from spack.package import * -class E(Package): +class PkgE(Package): """Simple package with no dependencies""" homepage = "http://www.example.com" diff --git a/var/spack/repos/builtin.mock/packages/test-dep-with-imposed-conditions/package.py b/var/spack/repos/builtin.mock/packages/test-dep-with-imposed-conditions/package.py index bcea98c529..a34e504bab 100644 --- a/var/spack/repos/builtin.mock/packages/test-dep-with-imposed-conditions/package.py +++ b/var/spack/repos/builtin.mock/packages/test-dep-with-imposed-conditions/package.py @@ -14,4 +14,4 @@ class TestDepWithImposedConditions(Package): version("1.0", md5="0123456789abcdef0123456789abcdef") - depends_on("c@1.0", type="test") + depends_on("pkg-c@1.0", type="test") diff --git a/var/spack/repos/builtin.mock/packages/vendorsb/package.py b/var/spack/repos/builtin.mock/packages/vendorsb/package.py index ebf9c92e55..4ad440a10e 100644 --- a/var/spack/repos/builtin.mock/packages/vendorsb/package.py +++ b/var/spack/repos/builtin.mock/packages/vendorsb/package.py @@ -15,5 +15,5 @@ class Vendorsb(Package): version("1.1", md5="0123456789abcdef0123456789abcdef") version("1.0", md5="0123456789abcdef0123456789abcdef") - # b is not a dependency - conflicts("b", when="@=1.1") + # pkg-b is not a dependency + conflicts("pkg-b", when="@=1.1") diff --git a/var/spack/repos/builtin.mock/packages/when-directives-false/package.py b/var/spack/repos/builtin.mock/packages/when-directives-false/package.py index d29d9d83a7..5f094b3da9 100644 --- a/var/spack/repos/builtin.mock/packages/when-directives-false/package.py +++ b/var/spack/repos/builtin.mock/packages/when-directives-false/package.py @@ -20,7 +20,7 @@ class WhenDirectivesFalse(Package): when=False, ) extends("extendee", when=False) - depends_on("b", when=False) + depends_on("pkg-b", when=False) conflicts("@1.0", when=False) resource( url="http://www.example.com/example-1.0-resource.tar.gz", diff --git a/var/spack/repos/builtin.mock/packages/when-directives-true/package.py b/var/spack/repos/builtin.mock/packages/when-directives-true/package.py index 3681b02687..83119b9124 100644 --- a/var/spack/repos/builtin.mock/packages/when-directives-true/package.py +++ b/var/spack/repos/builtin.mock/packages/when-directives-true/package.py @@ -20,7 +20,7 @@ class WhenDirectivesTrue(Package): when=True, ) extends("extendee", when=True) - depends_on("b", when=True) + depends_on("pkg-b", when=True) conflicts("@1.0", when=True) resource( url="http://www.example.com/example-1.0-resource.tar.gz", diff --git a/var/spack/repos/builtin.mock/packages/with-constraint-met/package.py b/var/spack/repos/builtin.mock/packages/with-constraint-met/package.py index a4f6e916bb..e300a0fd36 100644 --- a/var/spack/repos/builtin.mock/packages/with-constraint-met/package.py +++ b/var/spack/repos/builtin.mock/packages/with-constraint-met/package.py @@ -16,8 +16,8 @@ class WithConstraintMet(Package): version("1.0", md5="0123456789abcdef0123456789abcdef") with when("@1.0"): - depends_on("b") + depends_on("pkg-b") conflicts("%gcc", when="+foo") - with when("@0.14: ^b@:4.0"): - depends_on("c", when="@:15 ^b@3.8:") + with when("@0.14: ^pkg-b@:4.0"): + depends_on("pkg-c", when="@:15 ^pkg-b@3.8:") diff --git a/var/spack/repos/builtin.mock/packages/wrong-variant-in-depends-on/package.py b/var/spack/repos/builtin.mock/packages/wrong-variant-in-depends-on/package.py index cef5aafe47..98fb4a95c0 100644 --- a/var/spack/repos/builtin.mock/packages/wrong-variant-in-depends-on/package.py +++ b/var/spack/repos/builtin.mock/packages/wrong-variant-in-depends-on/package.py @@ -13,4 +13,4 @@ class WrongVariantInDependsOn(Package): version("1.0", md5="0123456789abcdef0123456789abcdef") - depends_on("b+doesnotexist") + depends_on("pkg-b+doesnotexist") diff --git a/var/spack/repos/compiler_runtime.test/packages/a/package.py b/var/spack/repos/compiler_runtime.test/packages/pkg-a/package.py index 01cb6fe3cc..22ca47cf13 100644 --- a/var/spack/repos/compiler_runtime.test/packages/a/package.py +++ b/var/spack/repos/compiler_runtime.test/packages/pkg-a/package.py @@ -5,9 +5,9 @@ from spack.package import * -class A(Package): +class PkgA(Package): homepage = "http://www.example.com" has_code = False version("1.0") - depends_on("b") + depends_on("pkg-b") diff --git a/var/spack/repos/compiler_runtime.test/packages/b/package.py b/var/spack/repos/compiler_runtime.test/packages/pkg-b/package.py index e840a363a5..d4147bf47e 100644 --- a/var/spack/repos/compiler_runtime.test/packages/b/package.py +++ b/var/spack/repos/compiler_runtime.test/packages/pkg-b/package.py @@ -5,7 +5,7 @@ from spack.package import * -class B(Package): +class PkgB(Package): homepage = "http://www.example.com" has_code = False |