zhangyiss/spack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix conflicting use of config and mutable_config fixtures in unit tests (#45106)

Browse Source 
and add a fixture to detect use of conflicting fixtures
This commit is contained in:
Massimiliano Culpo 2024-07-09 09:51:04 +02:00 committed by GitHub
parent 7c5fbee327
commit 15efcbe042
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
31 changed files with 122 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/spack/spack/test/build_environment.py
View File

@ -177,7 +177,7 @@ def _set_wrong_cc(x):
def test_setup_dependent_package_inherited_modules( def test_setup_dependent_package_inherited_modules(
config, working_env, mock_packages, install_mockery, mock_fetch working_env, mock_packages, install_mockery, mock_fetch
): ):
# This will raise on regression # This will raise on regression
s = spack.spec.Spec("cmake-client-inheritor").concretized() s = spack.spec.Spec("cmake-client-inheritor").concretized()

26
lib/spack/spack/test/build_systems.py
View File

@ -94,7 +94,7 @@ def test_negative_ninja_check(self, input_dir, test_dir, concretize_and_setup):
@pytest.mark.not_on_windows("autotools not available on windows") @pytest.mark.not_on_windows("autotools not available on windows")
@pytest.mark.usefixtures("config", "mock_packages") @pytest.mark.usefixtures("mock_packages")
class TestAutotoolsPackage: class TestAutotoolsPackage:
def test_with_or_without(self, default_mock_concretization): def test_with_or_without(self, default_mock_concretization):
s = default_mock_concretization("a") s = default_mock_concretization("a")
@ -139,11 +139,9 @@ def test_none_is_allowed(self, default_mock_concretization):
assert "--without-baz" in options assert "--without-baz" in options
assert "--no-fee" in options assert "--no-fee" in options
def test_libtool_archive_files_are_deleted_by_default( def test_libtool_archive_files_are_deleted_by_default(self, mutable_database):
self, default_mock_concretization, mutable_database
):
# Install a package that creates a mock libtool archive # Install a package that creates a mock libtool archive
s = default_mock_concretization("libtool-deletion") s = Spec("libtool-deletion").concretized()
s.package.do_install(explicit=True) s.package.do_install(explicit=True)
# Assert the libtool archive is not there and we have # Assert the libtool archive is not there and we have
@ -154,25 +152,23 @@ def test_libtool_archive_files_are_deleted_by_default(
assert libtool_deletion_log assert libtool_deletion_log
def test_libtool_archive_files_might_be_installed_on_demand( def test_libtool_archive_files_might_be_installed_on_demand(
self, mutable_database, monkeypatch, default_mock_concretization self, mutable_database, monkeypatch
): ):
# Install a package that creates a mock libtool archive, # Install a package that creates a mock libtool archive,
# patch its package to preserve the installation # patch its package to preserve the installation
s = default_mock_concretization("libtool-deletion") s = Spec("libtool-deletion").concretized()
monkeypatch.setattr(type(s.package.builder), "install_libtool_archives", True) monkeypatch.setattr(type(s.package.builder), "install_libtool_archives", True)
s.package.do_install(explicit=True) s.package.do_install(explicit=True)
# Assert libtool archives are installed # Assert libtool archives are installed
assert os.path.exists(s.package.builder.libtool_archive_file) assert os.path.exists(s.package.builder.libtool_archive_file)
def test_autotools_gnuconfig_replacement(self, default_mock_concretization, mutable_database): def test_autotools_gnuconfig_replacement(self, mutable_database):
""" """
Tests whether only broken config.sub and config.guess are replaced with Tests whether only broken config.sub and config.guess are replaced with
files from working alternatives from the gnuconfig package. files from working alternatives from the gnuconfig package.
""" """
s = default_mock_concretization( s = Spec("autotools-config-replacement +patch_config_files +gnuconfig").concretized()
"autotools-config-replacement +patch_config_files +gnuconfig"
)
s.package.do_install() s.package.do_install()
with open(os.path.join(s.prefix.broken, "config.sub")) as f: with open(os.path.join(s.prefix.broken, "config.sub")) as f:
@ -187,15 +183,11 @@ def test_autotools_gnuconfig_replacement(self, default_mock_concretization, muta
with open(os.path.join(s.prefix.working, "config.guess")) as f: with open(os.path.join(s.prefix.working, "config.guess")) as f:
assert "gnuconfig version of config.guess" not in f.read() assert "gnuconfig version of config.guess" not in f.read()
def test_autotools_gnuconfig_replacement_disabled( def test_autotools_gnuconfig_replacement_disabled(self, mutable_database):
self, default_mock_concretization, mutable_database
):
""" """
Tests whether disabling patch_config_files Tests whether disabling patch_config_files
""" """
s = default_mock_concretization( s = Spec("autotools-config-replacement ~patch_config_files +gnuconfig").concretized()
"autotools-config-replacement ~patch_config_files +gnuconfig"
)
s.package.do_install() s.package.do_install()
with open(os.path.join(s.prefix.broken, "config.sub")) as f: with open(os.path.join(s.prefix.broken, "config.sub")) as f:

12
lib/spack/spack/test/ci.py
View File

@ -199,7 +199,7 @@ def __call__(self, *args, **kwargs):
assert "Unable to merge {0}".format(c1) in err assert "Unable to merge {0}".format(c1) in err
def test_get_spec_filter_list(mutable_mock_env_path, config, mutable_mock_repo): def test_get_spec_filter_list(mutable_mock_env_path, mutable_mock_repo):
"""Test that given an active environment and list of touched pkgs, """Test that given an active environment and list of touched pkgs,
we get the right list of possibly-changed env specs""" we get the right list of possibly-changed env specs"""
e1 = ev.create("test") e1 = ev.create("test")
@ -253,7 +253,7 @@ def test_get_spec_filter_list(mutable_mock_env_path, config, mutable_mock_repo):
@pytest.mark.regression("29947") @pytest.mark.regression("29947")
def test_affected_specs_on_first_concretization(mutable_mock_env_path, mock_packages, config): def test_affected_specs_on_first_concretization(mutable_mock_env_path, mock_packages):
e = ev.create("first_concretization") e = ev.create("first_concretization")
e.add("mpileaks~shared") e.add("mpileaks~shared")
e.add("mpileaks+shared") e.add("mpileaks+shared")
@ -322,12 +322,12 @@ def test_ci_run_standalone_tests_missing_requirements(
@pytest.mark.not_on_windows("Reliance on bash script not supported on Windows") @pytest.mark.not_on_windows("Reliance on bash script not supported on Windows")
def test_ci_run_standalone_tests_not_installed_junit( def test_ci_run_standalone_tests_not_installed_junit(
tmp_path, repro_dir, working_env, default_mock_concretization, mock_test_stage, capfd tmp_path, repro_dir, working_env, mock_test_stage, capfd, mock_packages
): ):
log_file = tmp_path / "junit.xml" log_file = tmp_path / "junit.xml"
args = { args = {
"log_file": str(log_file), "log_file": str(log_file),
"job_spec": default_mock_concretization("printing-package"), "job_spec": spack.spec.Spec("printing-package").concretized(),
"repro_dir": str(repro_dir), "repro_dir": str(repro_dir),
"fail_fast": True, "fail_fast": True,
} }
@ -340,13 +340,13 @@ def test_ci_run_standalone_tests_not_installed_junit(
@pytest.mark.not_on_windows("Reliance on bash script not supported on Windows") @pytest.mark.not_on_windows("Reliance on bash script not supported on Windows")
def test_ci_run_standalone_tests_not_installed_cdash( def test_ci_run_standalone_tests_not_installed_cdash(
tmp_path, repro_dir, working_env, default_mock_concretization, mock_test_stage, capfd tmp_path, repro_dir, working_env, mock_test_stage, capfd, mock_packages
): ):
"""Test run_standalone_tests with cdash and related options.""" """Test run_standalone_tests with cdash and related options."""
log_file = tmp_path / "junit.xml" log_file = tmp_path / "junit.xml"
args = { args = {
"log_file": str(log_file), "log_file": str(log_file),
"job_spec": default_mock_concretization("printing-package"), "job_spec": spack.spec.Spec("printing-package").concretized(),
"repro_dir": str(repro_dir), "repro_dir": str(repro_dir),
} }

3
lib/spack/spack/test/cmd/common/arguments.py
View File

@ -72,7 +72,6 @@ def test_parse_spec_flags_with_spaces(specs, cflags, propagation, negated_varian
assert "~{0}".format(v) in s assert "~{0}".format(v) in s
@pytest.mark.usefixtures("config")
def test_match_spec_env(mock_packages, mutable_mock_env_path): def test_match_spec_env(mock_packages, mutable_mock_env_path):
""" """
Concretize a spec with non-default options in an environment. Make Concretize a spec with non-default options in an environment. Make
@ -93,7 +92,6 @@ def test_match_spec_env(mock_packages, mutable_mock_env_path):
assert env_spec.concrete assert env_spec.concrete
@pytest.mark.usefixtures("config")
def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path): def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path):
e = ev.create("test") e = ev.create("test")
e.add("a foobar=baz") e.add("a foobar=baz")
@ -106,7 +104,6 @@ def test_multiple_env_match_raises_error(mock_packages, mutable_mock_env_path):
assert "matches multiple specs" in exc_info.value.message assert "matches multiple specs" in exc_info.value.message
@pytest.mark.usefixtures("config")
def test_root_and_dep_match_returns_root(mock_packages, mutable_mock_env_path): def test_root_and_dep_match_returns_root(mock_packages, mutable_mock_env_path):
e = ev.create("test") e = ev.create("test")
e.add("b@0.9") e.add("b@0.9")

2
lib/spack/spack/test/cmd/concretize.py
View File

@ -10,7 +10,7 @@
from spack import spack_version from spack import spack_version
from spack.main import SpackCommand from spack.main import SpackCommand
pytestmark = pytest.mark.usefixtures("config", "mutable_mock_repo") pytestmark = pytest.mark.usefixtures("mutable_config", "mutable_mock_repo")
env = SpackCommand("env") env = SpackCommand("env")
add = SpackCommand("add") add = SpackCommand("add")

2
lib/spack/spack/test/cmd/deconcretize.py
View File

@ -12,7 +12,7 @@
@pytest.fixture(scope="function") @pytest.fixture(scope="function")
def test_env(mutable_mock_env_path, config, mock_packages): def test_env(mutable_mock_env_path, mock_packages):
ev.create("test") ev.create("test")
with ev.read("test") as e: with ev.read("test") as e:
e.add("a@2.0 foobar=bar ^b@1.0") e.add("a@2.0 foobar=bar ^b@1.0")

17
lib/spack/spack/test/cmd/env.py
View File

@ -40,7 +40,7 @@
# TODO-27021 # TODO-27021
# everything here uses the mock_env_path # everything here uses the mock_env_path
pytestmark = [ pytestmark = [
pytest.mark.usefixtures("mutable_mock_env_path", "config", "mutable_mock_repo"), pytest.mark.usefixtures("mutable_config", "mutable_mock_env_path", "mutable_mock_repo"),
pytest.mark.maybeslow, pytest.mark.maybeslow,
pytest.mark.not_on_windows("Envs unsupported on Window"), pytest.mark.not_on_windows("Envs unsupported on Window"),
] ]
@ -812,7 +812,6 @@ def test_init_from_yaml(environment_from_manifest):
assert not e2.specs_by_hash assert not e2.specs_by_hash
@pytest.mark.usefixtures("config")
def test_env_view_external_prefix(tmp_path, mutable_database, mock_packages): def test_env_view_external_prefix(tmp_path, mutable_database, mock_packages):
fake_prefix = tmp_path / "a-prefix" fake_prefix = tmp_path / "a-prefix"
fake_bin = fake_prefix / "bin" fake_bin = fake_prefix / "bin"
@ -1559,7 +1558,6 @@ def test_uninstall_removes_from_env(mock_stage, mock_fetch, install_mockery):
assert not test.user_specs assert not test.user_specs
@pytest.mark.usefixtures("config")
def test_indirect_build_dep(tmp_path): def test_indirect_build_dep(tmp_path):
"""Simple case of X->Y->Z where Y is a build/link dep and Z is a """Simple case of X->Y->Z where Y is a build/link dep and Z is a
build-only dep. Make sure this concrete DAG is preserved when writing the build-only dep. Make sure this concrete DAG is preserved when writing the
@ -1587,7 +1585,6 @@ def test_indirect_build_dep(tmp_path):
assert x_env_spec == x_concretized assert x_env_spec == x_concretized
@pytest.mark.usefixtures("config")
def test_store_different_build_deps(tmp_path): def test_store_different_build_deps(tmp_path):
r"""Ensure that an environment can store two instances of a build-only r"""Ensure that an environment can store two instances of a build-only
dependency:: dependency::
@ -2328,7 +2325,7 @@ def test_stack_yaml_force_remove_from_matrix(tmpdir):
assert mpileaks_spec not in after_conc assert mpileaks_spec not in after_conc
def test_stack_concretize_extraneous_deps(tmpdir, config, mock_packages): def test_stack_concretize_extraneous_deps(tmpdir, mock_packages):
# FIXME: The new concretizer doesn't handle yet soft # FIXME: The new concretizer doesn't handle yet soft
# FIXME: constraints for stacks # FIXME: constraints for stacks
# FIXME: This now works for statically-determinable invalid deps # FIXME: This now works for statically-determinable invalid deps
@ -2367,7 +2364,7 @@ def test_stack_concretize_extraneous_deps(tmpdir, config, mock_packages):
assert concrete.satisfies("^mpi") assert concrete.satisfies("^mpi")
def test_stack_concretize_extraneous_variants(tmpdir, config, mock_packages): def test_stack_concretize_extraneous_variants(tmpdir, mock_packages):
filename = str(tmpdir.join("spack.yaml")) filename = str(tmpdir.join("spack.yaml"))
with open(filename, "w") as f: with open(filename, "w") as f:
f.write( f.write(
@ -2399,7 +2396,7 @@ def test_stack_concretize_extraneous_variants(tmpdir, config, mock_packages):
assert concrete.variants["shared"].value == user.variants["shared"].value assert concrete.variants["shared"].value == user.variants["shared"].value
def test_stack_concretize_extraneous_variants_with_dash(tmpdir, config, mock_packages): def test_stack_concretize_extraneous_variants_with_dash(tmpdir, mock_packages):
filename = str(tmpdir.join("spack.yaml")) filename = str(tmpdir.join("spack.yaml"))
with open(filename, "w") as f: with open(filename, "w") as f:
f.write( f.write(
@ -3750,7 +3747,7 @@ def test_environment_query_spec_by_hash(mock_stage, mock_fetch, install_mockery)
@pytest.mark.parametrize("lockfile", ["v1", "v2", "v3"]) @pytest.mark.parametrize("lockfile", ["v1", "v2", "v3"])
def test_read_old_lock_and_write_new(config, tmpdir, lockfile): def test_read_old_lock_and_write_new(tmpdir, lockfile):
# v1 lockfiles stored by a coarse DAG hash that did not include build deps. # v1 lockfiles stored by a coarse DAG hash that did not include build deps.
# They could not represent multiple build deps with different build hashes. # They could not represent multiple build deps with different build hashes.
# #
@ -3816,7 +3813,7 @@ def test_read_old_lock_and_write_new(config, tmpdir, lockfile):
assert old_hashes == hashes assert old_hashes == hashes
def test_read_v1_lock_creates_backup(config, tmp_path): def test_read_v1_lock_creates_backup(tmp_path):
"""When reading a version-1 lockfile, make sure that a backup of that file """When reading a version-1 lockfile, make sure that a backup of that file
is created. is created.
""" """
@ -4199,7 +4196,7 @@ def test_env_include_packages_url(
assert "openmpi" in cfg["all"]["providers"]["mpi"] assert "openmpi" in cfg["all"]["providers"]["mpi"]
def test_relative_view_path_on_command_line_is_made_absolute(tmp_path, config): def test_relative_view_path_on_command_line_is_made_absolute(tmp_path):
with fs.working_dir(str(tmp_path)): with fs.working_dir(str(tmp_path)):
env("create", "--with-view", "view", "--dir", "env") env("create", "--with-view", "view", "--dir", "env")
environment = ev.Environment(os.path.join(".", "env")) environment = ev.Environment(os.path.join(".", "env"))

2
lib/spack/spack/test/cmd/extensions.py
View File

@ -24,7 +24,7 @@ def python_database(mock_packages, mutable_database):
@pytest.mark.not_on_windows("All Fetchers Failed") @pytest.mark.not_on_windows("All Fetchers Failed")
@pytest.mark.db @pytest.mark.db
def test_extensions(mock_packages, python_database, config, capsys): def test_extensions(mock_packages, python_database, capsys):
ext2 = Spec("py-extension2").concretized() ext2 = Spec("py-extension2").concretized()
def check_output(ni): def check_output(ni):

4
lib/spack/spack/test/cmd/fetch.py
View File

@ -9,7 +9,9 @@
from spack.main import SpackCommand, SpackCommandError from spack.main import SpackCommand, SpackCommandError
# everything here uses the mock_env_path # everything here uses the mock_env_path
pytestmark = pytest.mark.usefixtures("mutable_mock_env_path", "config", "mutable_mock_repo") pytestmark = pytest.mark.usefixtures(
"mutable_mock_env_path", "mutable_config", "mutable_mock_repo"
)
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check

8
lib/spack/spack/test/cmd/find.py
View File

@ -337,7 +337,7 @@ def test_find_command_basic_usage(database):
@pytest.mark.not_on_windows("envirnment is not yet supported on windows") @pytest.mark.not_on_windows("envirnment is not yet supported on windows")
@pytest.mark.regression("9875") @pytest.mark.regression("9875")
def test_find_prefix_in_env( def test_find_prefix_in_env(
mutable_mock_env_path, install_mockery, mock_fetch, mock_packages, mock_archive, config mutable_mock_env_path, install_mockery, mock_fetch, mock_packages, mock_archive
): ):
"""Test `find` formats requiring concrete specs work in environments.""" """Test `find` formats requiring concrete specs work in environments."""
env("create", "test") env("create", "test")
@ -349,7 +349,7 @@ def test_find_prefix_in_env(
# Would throw error on regression # Would throw error on regression
def test_find_specs_include_concrete_env(mutable_mock_env_path, config, mutable_mock_repo, tmpdir): def test_find_specs_include_concrete_env(mutable_mock_env_path, mutable_mock_repo, tmpdir):
path = tmpdir.join("spack.yaml") path = tmpdir.join("spack.yaml")
with tmpdir.as_cwd(): with tmpdir.as_cwd():
@ -393,9 +393,7 @@ def test_find_specs_include_concrete_env(mutable_mock_env_path, config, mutable_
assert "libelf" in output assert "libelf" in output
def test_find_specs_nested_include_concrete_env( def test_find_specs_nested_include_concrete_env(mutable_mock_env_path, mutable_mock_repo, tmpdir):
mutable_mock_env_path, config, mutable_mock_repo, tmpdir
):
path = tmpdir.join("spack.yaml") path = tmpdir.join("spack.yaml")
with tmpdir.as_cwd(): with tmpdir.as_cwd():

16
lib/spack/spack/test/cmd/gc.py
View File

@ -20,13 +20,13 @@
@pytest.mark.db @pytest.mark.db
def test_gc_without_build_dependency(config, mutable_database): def test_gc_without_build_dependency(mutable_database):
assert "There are no unused specs." in gc("-yb") assert "There are no unused specs." in gc("-yb")
assert "There are no unused specs." in gc("-y") assert "There are no unused specs." in gc("-y")
@pytest.mark.db @pytest.mark.db
def test_gc_with_build_dependency(config, mutable_database): def test_gc_with_build_dependency(mutable_database):
s = spack.spec.Spec("simple-inheritance") s = spack.spec.Spec("simple-inheritance")
s.concretize() s.concretize()
s.package.do_install(fake=True, explicit=True) s.package.do_install(fake=True, explicit=True)
@ -37,7 +37,7 @@ def test_gc_with_build_dependency(config, mutable_database):
@pytest.mark.db @pytest.mark.db
def test_gc_with_environment(config, mutable_database, mutable_mock_env_path): def test_gc_with_environment(mutable_database, mutable_mock_env_path):
s = spack.spec.Spec("simple-inheritance") s = spack.spec.Spec("simple-inheritance")
s.concretize() s.concretize()
s.package.do_install(fake=True, explicit=True) s.package.do_install(fake=True, explicit=True)
@ -53,7 +53,7 @@ def test_gc_with_environment(config, mutable_database, mutable_mock_env_path):
@pytest.mark.db @pytest.mark.db
def test_gc_with_build_dependency_in_environment(config, mutable_database, mutable_mock_env_path): def test_gc_with_build_dependency_in_environment(mutable_database, mutable_mock_env_path):
s = spack.spec.Spec("simple-inheritance") s = spack.spec.Spec("simple-inheritance")
s.concretize() s.concretize()
s.package.do_install(fake=True, explicit=True) s.package.do_install(fake=True, explicit=True)
@ -78,7 +78,7 @@ def test_gc_with_build_dependency_in_environment(config, mutable_database, mutab
@pytest.mark.db @pytest.mark.db
def test_gc_except_any_environments(config, mutable_database, mutable_mock_env_path): def test_gc_except_any_environments(mutable_database, mutable_mock_env_path):
"""Tests whether the garbage collector can remove all specs except those still needed in some """Tests whether the garbage collector can remove all specs except those still needed in some
environment (needed in the sense of roots + link/run deps).""" environment (needed in the sense of roots + link/run deps)."""
assert mutable_database.query_local("zmpi") assert mutable_database.query_local("zmpi")
@ -105,7 +105,7 @@ def test_gc_except_any_environments(config, mutable_database, mutable_mock_env_p
@pytest.mark.db @pytest.mark.db
def test_gc_except_specific_environments(config, mutable_database, mutable_mock_env_path): def test_gc_except_specific_environments(mutable_database, mutable_mock_env_path):
s = spack.spec.Spec("simple-inheritance") s = spack.spec.Spec("simple-inheritance")
s.concretize() s.concretize()
s.package.do_install(fake=True, explicit=True) s.package.do_install(fake=True, explicit=True)
@ -125,14 +125,14 @@ def test_gc_except_specific_environments(config, mutable_database, mutable_mock_
@pytest.mark.db @pytest.mark.db
def test_gc_except_nonexisting_dir_env(config, mutable_database, mutable_mock_env_path, tmpdir): def test_gc_except_nonexisting_dir_env(mutable_database, mutable_mock_env_path, tmpdir):
output = gc("-ye", tmpdir.strpath, fail_on_error=False) output = gc("-ye", tmpdir.strpath, fail_on_error=False)
assert "No such environment" in output assert "No such environment" in output
gc.returncode == 1 gc.returncode == 1
@pytest.mark.db @pytest.mark.db
def test_gc_except_specific_dir_env(config, mutable_database, mutable_mock_env_path, tmpdir): def test_gc_except_specific_dir_env(mutable_database, mutable_mock_env_path, tmpdir):
s = spack.spec.Spec("simple-inheritance") s = spack.spec.Spec("simple-inheritance")
s.concretize() s.concretize()
s.package.do_install(fake=True, explicit=True) s.package.do_install(fake=True, explicit=True)

47
lib/spack/spack/test/cmd/install.py
View File

@ -49,7 +49,7 @@ def noop(*args, **kwargs):
def test_install_package_and_dependency( def test_install_package_and_dependency(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
): ):
log = "test" log = "test"
with tmpdir.as_cwd(): with tmpdir.as_cwd():
@ -93,7 +93,7 @@ def check(pkg):
def test_install_package_already_installed( def test_install_package_already_installed(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
): ):
with tmpdir.as_cwd(): with tmpdir.as_cwd():
install("libdwarf") install("libdwarf")
@ -149,7 +149,7 @@ def test_package_output(tmpdir, capsys, install_mockery, mock_fetch):
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
def test_install_output_on_build_error( def test_install_output_on_build_error(
mock_packages, mock_archive, mock_fetch, config, install_mockery, capfd mock_packages, mock_archive, mock_fetch, install_mockery, capfd
): ):
""" """
This test used to assume receiving full output, but since we've updated This test used to assume receiving full output, but since we've updated
@ -163,9 +163,7 @@ def test_install_output_on_build_error(
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
def test_install_output_on_python_error( def test_install_output_on_python_error(mock_packages, mock_archive, mock_fetch, install_mockery):
mock_packages, mock_archive, mock_fetch, config, install_mockery
):
out = install("failing-build", fail_on_error=False) out = install("failing-build", fail_on_error=False)
assert isinstance(install.error, spack.build_environment.ChildError) assert isinstance(install.error, spack.build_environment.ChildError)
assert install.error.name == "InstallError" assert install.error.name == "InstallError"
@ -173,7 +171,7 @@ def test_install_output_on_python_error(
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
def test_install_with_source(mock_packages, mock_archive, mock_fetch, config, install_mockery): def test_install_with_source(mock_packages, mock_archive, mock_fetch, install_mockery):
"""Verify that source has been copied into place.""" """Verify that source has been copied into place."""
install("--source", "--keep-stage", "trivial-install-test-package") install("--source", "--keep-stage", "trivial-install-test-package")
spec = Spec("trivial-install-test-package").concretized() spec = Spec("trivial-install-test-package").concretized()
@ -183,7 +181,7 @@ def test_install_with_source(mock_packages, mock_archive, mock_fetch, config, in
) )
def test_install_env_variables(mock_packages, mock_archive, mock_fetch, config, install_mockery): def test_install_env_variables(mock_packages, mock_archive, mock_fetch, install_mockery):
spec = Spec("libdwarf") spec = Spec("libdwarf")
spec.concretize() spec.concretize()
install("libdwarf") install("libdwarf")
@ -191,9 +189,7 @@ def test_install_env_variables(mock_packages, mock_archive, mock_fetch, config,
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
def test_show_log_on_error( def test_show_log_on_error(mock_packages, mock_archive, mock_fetch, install_mockery, capfd):
mock_packages, mock_archive, mock_fetch, config, install_mockery, capfd
):
""" """
Make sure --show-log-on-error works. Make sure --show-log-on-error works.
""" """
@ -206,7 +202,7 @@ def test_show_log_on_error(
assert "See build log for details:" in out assert "See build log for details:" in out
def test_install_overwrite(mock_packages, mock_archive, mock_fetch, config, install_mockery): def test_install_overwrite(mock_packages, mock_archive, mock_fetch, install_mockery):
# Try to install a spec and then to reinstall it. # Try to install a spec and then to reinstall it.
spec = Spec("libdwarf") spec = Spec("libdwarf")
spec.concretize() spec.concretize()
@ -240,9 +236,7 @@ def test_install_overwrite(mock_packages, mock_archive, mock_fetch, config, inst
assert fs.hash_directory(spec.prefix, ignore=ignores) != bad_md5 assert fs.hash_directory(spec.prefix, ignore=ignores) != bad_md5
def test_install_overwrite_not_installed( def test_install_overwrite_not_installed(mock_packages, mock_archive, mock_fetch, install_mockery):
mock_packages, mock_archive, mock_fetch, config, install_mockery
):
# Try to install a spec and then to reinstall it. # Try to install a spec and then to reinstall it.
spec = Spec("libdwarf") spec = Spec("libdwarf")
spec.concretize() spec.concretize()
@ -277,9 +271,7 @@ def test_install_commit(mock_git_version_info, install_mockery, mock_packages, m
assert content == "[0]" # contents are weird for another test assert content == "[0]" # contents are weird for another test
def test_install_overwrite_multiple( def test_install_overwrite_multiple(mock_packages, mock_archive, mock_fetch, install_mockery):
mock_packages, mock_archive, mock_fetch, config, install_mockery
):
# Try to install a spec and then to reinstall it. # Try to install a spec and then to reinstall it.
libdwarf = Spec("libdwarf") libdwarf = Spec("libdwarf")
libdwarf.concretize() libdwarf.concretize()
@ -337,18 +329,14 @@ def test_install_overwrite_multiple(
assert cm_hash != bad_cmake_md5 assert cm_hash != bad_cmake_md5
@pytest.mark.usefixtures( @pytest.mark.usefixtures("mock_packages", "mock_archive", "mock_fetch", "install_mockery")
"mock_packages", "mock_archive", "mock_fetch", "config", "install_mockery"
)
def test_install_conflicts(conflict_spec): def test_install_conflicts(conflict_spec):
# Make sure that spec with conflicts raises a SpackError # Make sure that spec with conflicts raises a SpackError
with pytest.raises(SpackError): with pytest.raises(SpackError):
install(conflict_spec) install(conflict_spec)
@pytest.mark.usefixtures( @pytest.mark.usefixtures("mock_packages", "mock_archive", "mock_fetch", "install_mockery")
"mock_packages", "mock_archive", "mock_fetch", "config", "install_mockery"
)
def test_install_invalid_spec(invalid_spec): def test_install_invalid_spec(invalid_spec):
# Make sure that invalid specs raise a SpackError # Make sure that invalid specs raise a SpackError
with pytest.raises(SpecSyntaxError, match="unexpected tokens"): with pytest.raises(SpecSyntaxError, match="unexpected tokens"):
@ -390,9 +378,7 @@ def test_install_from_file(spec, concretize, error_code, tmpdir):
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
@pytest.mark.usefixtures( @pytest.mark.usefixtures("mock_packages", "mock_archive", "mock_fetch", "install_mockery")
"mock_packages", "mock_archive", "mock_fetch", "config", "install_mockery"
)
@pytest.mark.parametrize( @pytest.mark.parametrize(
"exc_typename,msg", "exc_typename,msg",
[("RuntimeError", "something weird happened"), ("ValueError", "spec is not concrete")], [("RuntimeError", "something weird happened"), ("ValueError", "spec is not concrete")],
@ -448,7 +434,6 @@ def test_junit_output_with_errors(
mock_archive, mock_archive,
mock_fetch, mock_fetch,
install_mockery, install_mockery,
config,
tmpdir, tmpdir,
monkeypatch, monkeypatch,
): ):
@ -509,9 +494,7 @@ def test_install_mix_cli_and_files(clispecs, filespecs, tmpdir):
assert install.returncode == 0 assert install.returncode == 0
def test_extra_files_are_archived( def test_extra_files_are_archived(mock_packages, mock_archive, mock_fetch, install_mockery):
mock_packages, mock_archive, mock_fetch, config, install_mockery
):
s = Spec("archive-files") s = Spec("archive-files")
s.concretize() s.concretize()
@ -629,7 +612,7 @@ def test_cdash_buildstamp_param(tmpdir, mock_fetch, install_mockery, capfd):
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
def test_cdash_install_from_spec_json( def test_cdash_install_from_spec_json(
tmpdir, mock_fetch, install_mockery, capfd, mock_packages, mock_archive, config tmpdir, mock_fetch, install_mockery, capfd, mock_packages, mock_archive
): ):
# capfd interferes with Spack's capturing # capfd interferes with Spack's capturing
with capfd.disabled(): with capfd.disabled():

2
lib/spack/spack/test/cmd/location.py
View File

@ -17,7 +17,7 @@
# Everything here uses (or can use) the mock config and database. # Everything here uses (or can use) the mock config and database.
pytestmark = [ pytestmark = [
pytest.mark.usefixtures("config", "database"), pytest.mark.usefixtures("mutable_config", "mutable_database"),
pytest.mark.not_on_windows("does not run on windows"), pytest.mark.not_on_windows("does not run on windows"),
] ]
# location prints out "locations of packages and spack directories" # location prints out "locations of packages and spack directories"

2
lib/spack/spack/test/cmd/mirror.py
View File

@ -35,7 +35,7 @@ def test_regression_8083(tmpdir, capfd, mock_packages, mock_fetch, config):
@pytest.mark.regression("12345") @pytest.mark.regression("12345")
def test_mirror_from_env(tmp_path, mock_packages, mock_fetch, config, mutable_mock_env_path): def test_mirror_from_env(tmp_path, mock_packages, mock_fetch, mutable_mock_env_path):
mirror_dir = str(tmp_path / "mirror") mirror_dir = str(tmp_path / "mirror")
env_name = "test" env_name = "test"

4
lib/spack/spack/test/cmd/module.py
View File

@ -139,7 +139,7 @@ def test_find_recursive():
@pytest.mark.db @pytest.mark.db
def test_find_recursive_excluded(database, module_configuration): def test_find_recursive_excluded(mutable_database, module_configuration):
module_configuration("exclude") module_configuration("exclude")
module("lmod", "refresh", "-y", "--delete-tree") module("lmod", "refresh", "-y", "--delete-tree")
@ -147,7 +147,7 @@ def test_find_recursive_excluded(database, module_configuration):
@pytest.mark.db @pytest.mark.db
def test_loads_recursive_excluded(database, module_configuration): def test_loads_recursive_excluded(mutable_database, module_configuration):
module_configuration("exclude") module_configuration("exclude")
module("lmod", "refresh", "-y", "--delete-tree") module("lmod", "refresh", "-y", "--delete-tree")

6
lib/spack/spack/test/cmd/spec.py
View File

@ -14,7 +14,7 @@
import spack.store import spack.store
from spack.main import SpackCommand, SpackCommandError from spack.main import SpackCommand, SpackCommandError
pytestmark = pytest.mark.usefixtures("config", "mutable_mock_repo") pytestmark = pytest.mark.usefixtures("mutable_config", "mutable_mock_repo")
spec = SpackCommand("spec") spec = SpackCommand("spec")
@ -31,7 +31,7 @@ def test_spec():
@pytest.mark.only_clingo("Known failure of the original concretizer") @pytest.mark.only_clingo("Known failure of the original concretizer")
def test_spec_concretizer_args(mutable_config, mutable_database, do_not_check_runtimes_on_reuse): def test_spec_concretizer_args(mutable_database, do_not_check_runtimes_on_reuse):
"""End-to-end test of CLI concretizer prefs. """End-to-end test of CLI concretizer prefs.
It's here to make sure that everything works from CLI It's here to make sure that everything works from CLI
@ -97,7 +97,7 @@ def test_spec_json():
assert "mpich" in mpileaks assert "mpich" in mpileaks
def test_spec_format(database, config): def test_spec_format(mutable_database):
output = spec("--format", "{name}-{^mpi.name}", "mpileaks^mpich") output = spec("--format", "{name}-{^mpi.name}", "mpileaks^mpich")
assert output.rstrip("\n") == "mpileaks-mpich" assert output.rstrip("\n") == "mpileaks-mpich"

8
lib/spack/spack/test/cmd/test.py
View File

@ -25,13 +25,7 @@
def test_test_package_not_installed( def test_test_package_not_installed(
tmpdir, tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery, mock_test_stage
mock_packages,
mock_archive,
mock_fetch,
config,
install_mockery_mutable_config,
mock_test_stage,
): ):
output = spack_test("run", "libdwarf") output = spack_test("run", "libdwarf")

2
lib/spack/spack/test/cmd/uninstall.py
View File

@ -222,7 +222,7 @@ class TestUninstallFromEnv:
@pytest.fixture(scope="function") @pytest.fixture(scope="function")
def environment_setup( def environment_setup(
self, mutable_mock_env_path, config, mock_packages, mutable_database, install_mockery self, mutable_mock_env_path, mock_packages, mutable_database, install_mockery
): ):
TestUninstallFromEnv.env("create", "e1") TestUninstallFromEnv.env("create", "e1")
e1 = spack.environment.read("e1") e1 = spack.environment.read("e1")

4
lib/spack/spack/test/cmd/verify.py
View File

@ -63,9 +63,7 @@ def test_single_file_verify_cmd(tmpdir):
assert sorted(errors) == sorted(expected) assert sorted(errors) == sorted(expected)
def test_single_spec_verify_cmd( def test_single_spec_verify_cmd(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery):
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery
):
# Test the verify command interface to verify a single spec # Test the verify command interface to verify a single spec
install("libelf") install("libelf")
s = spack.spec.Spec("libelf").concretized() s = spack.spec.Spec("libelf").concretized()

30
lib/spack/spack/test/cmd/view.py
View File

@ -28,9 +28,7 @@ def create_projection_file(tmpdir, projection):
@pytest.mark.parametrize("cmd", ["hardlink", "symlink", "hard", "add", "copy", "relocate"]) @pytest.mark.parametrize("cmd", ["hardlink", "symlink", "hard", "add", "copy", "relocate"])
def test_view_link_type( def test_view_link_type(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery, cmd):
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery, cmd
):
install("libdwarf") install("libdwarf")
viewpath = str(tmpdir.mkdir("view_{0}".format(cmd))) viewpath = str(tmpdir.mkdir("view_{0}".format(cmd)))
view(cmd, viewpath, "libdwarf") view(cmd, viewpath, "libdwarf")
@ -44,7 +42,7 @@ def test_view_link_type(
@pytest.mark.parametrize("add_cmd", ["hardlink", "symlink", "hard", "add", "copy", "relocate"]) @pytest.mark.parametrize("add_cmd", ["hardlink", "symlink", "hard", "add", "copy", "relocate"])
def test_view_link_type_remove( def test_view_link_type_remove(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery, add_cmd tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery, add_cmd
): ):
install("needs-relocation") install("needs-relocation")
viewpath = str(tmpdir.mkdir("view_{0}".format(add_cmd))) viewpath = str(tmpdir.mkdir("view_{0}".format(add_cmd)))
@ -57,9 +55,7 @@ def test_view_link_type_remove(
@pytest.mark.parametrize("cmd", ["hardlink", "symlink", "hard", "add", "copy", "relocate"]) @pytest.mark.parametrize("cmd", ["hardlink", "symlink", "hard", "add", "copy", "relocate"])
def test_view_projections( def test_view_projections(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery, cmd):
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery, cmd
):
install("libdwarf@20130207") install("libdwarf@20130207")
viewpath = str(tmpdir.mkdir("view_{0}".format(cmd))) viewpath = str(tmpdir.mkdir("view_{0}".format(cmd)))
@ -76,7 +72,7 @@ def test_view_projections(
def test_view_multiple_projections( def test_view_multiple_projections(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
): ):
install("libdwarf@20130207") install("libdwarf@20130207")
install("extendee@1.0%gcc") install("extendee@1.0%gcc")
@ -96,7 +92,7 @@ def test_view_multiple_projections(
def test_view_multiple_projections_all_first( def test_view_multiple_projections_all_first(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
): ):
install("libdwarf@20130207") install("libdwarf@20130207")
install("extendee@1.0%gcc") install("extendee@1.0%gcc")
@ -115,14 +111,14 @@ def test_view_multiple_projections_all_first(
assert os.path.exists(extendee_prefix) assert os.path.exists(extendee_prefix)
def test_view_external(tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery): def test_view_external(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery):
install("externaltool") install("externaltool")
viewpath = str(tmpdir.mkdir("view")) viewpath = str(tmpdir.mkdir("view"))
output = view("symlink", viewpath, "externaltool") output = view("symlink", viewpath, "externaltool")
assert "Skipping external package: externaltool" in output assert "Skipping external package: externaltool" in output
def test_view_extension(tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery): def test_view_extension(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery):
install("extendee") install("extendee")
install("extension1@1.0") install("extension1@1.0")
install("extension1@2.0") install("extension1@2.0")
@ -136,9 +132,7 @@ def test_view_extension(tmpdir, mock_packages, mock_archive, mock_fetch, config,
assert os.path.exists(os.path.join(viewpath, "bin", "extension1")) assert os.path.exists(os.path.join(viewpath, "bin", "extension1"))
def test_view_extension_remove( def test_view_extension_remove(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery):
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery
):
install("extendee") install("extendee")
install("extension1@1.0") install("extension1@1.0")
viewpath = str(tmpdir.mkdir("view")) viewpath = str(tmpdir.mkdir("view"))
@ -149,9 +143,7 @@ def test_view_extension_remove(
assert not os.path.exists(os.path.join(viewpath, "bin", "extension1")) assert not os.path.exists(os.path.join(viewpath, "bin", "extension1"))
def test_view_extension_conflict( def test_view_extension_conflict(tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery):
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery
):
install("extendee") install("extendee")
install("extension1@1.0") install("extension1@1.0")
install("extension1@2.0") install("extension1@2.0")
@ -162,7 +154,7 @@ def test_view_extension_conflict(
def test_view_extension_conflict_ignored( def test_view_extension_conflict_ignored(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery
): ):
install("extendee") install("extendee")
install("extension1@1.0") install("extension1@1.0")
@ -184,7 +176,7 @@ def test_view_fails_with_missing_projections_file(tmpdir):
@pytest.mark.parametrize("with_projection", [False, True]) @pytest.mark.parametrize("with_projection", [False, True])
@pytest.mark.parametrize("cmd", ["symlink", "copy"]) @pytest.mark.parametrize("cmd", ["symlink", "copy"])
def test_view_files_not_ignored( def test_view_files_not_ignored(
tmpdir, mock_packages, mock_archive, mock_fetch, config, install_mockery, cmd, with_projection tmpdir, mock_packages, mock_archive, mock_fetch, install_mockery, cmd, with_projection
): ):
spec = Spec("view-not-ignored").concretized() spec = Spec("view-not-ignored").concretized()
pkg = spec.package pkg = spec.package

18
lib/spack/spack/test/concretize.py
View File

@ -1593,7 +1593,7 @@ def test_non_default_provider_of_multiple_virtuals(self):
) )
@pytest.mark.only_clingo("Use case not supported by the original concretizer") @pytest.mark.only_clingo("Use case not supported by the original concretizer")
def test_concrete_specs_are_not_modified_on_reuse( def test_concrete_specs_are_not_modified_on_reuse(
self, mutable_database, spec_str, expect_installed, config self, mutable_database, spec_str, expect_installed
): ):
# Test the internal consistency of solve + DAG reconstruction # Test the internal consistency of solve + DAG reconstruction
# when reused specs are added to the mix. This prevents things # when reused specs are added to the mix. This prevents things
@ -1856,7 +1856,7 @@ def test_best_effort_coconcretize_preferences(self, specs, expected_spec, occura
assert counter == occurances, concrete_specs assert counter == occurances, concrete_specs
@pytest.mark.only_clingo("Original concretizer cannot concretize in rounds") @pytest.mark.only_clingo("Original concretizer cannot concretize in rounds")
def test_solve_in_rounds_all_unsolved(self, monkeypatch, mock_packages, config): def test_solve_in_rounds_all_unsolved(self, monkeypatch, mock_packages):
specs = [Spec(x) for x in ["libdwarf%gcc", "libdwarf%clang"]] specs = [Spec(x) for x in ["libdwarf%gcc", "libdwarf%clang"]]
solver = spack.solver.asp.Solver() solver = spack.solver.asp.Solver()
solver.reuse = False solver.reuse = False
@ -2219,7 +2219,7 @@ def test_result_specs_is_not_empty(self, specs):
assert result.specs assert result.specs
@pytest.mark.regression("38664") @pytest.mark.regression("38664")
def test_unsolved_specs_raises_error(self, monkeypatch, mock_packages, config): def test_unsolved_specs_raises_error(self, monkeypatch, mock_packages):
"""Check that the solver raises an exception when input specs are not """Check that the solver raises an exception when input specs are not
satisfied. satisfied.
""" """
@ -2239,7 +2239,7 @@ def test_unsolved_specs_raises_error(self, monkeypatch, mock_packages, config):
@pytest.mark.regression("43141") @pytest.mark.regression("43141")
@pytest.mark.only_clingo("Use case not supported by the original concretizer") @pytest.mark.only_clingo("Use case not supported by the original concretizer")
def test_clear_error_when_unknown_compiler_requested(self, mock_packages, config): 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""" """Tests that the solver can report a case where the compiler cannot be set"""
with pytest.raises( with pytest.raises(
spack.error.UnsatisfiableSpecError, match="Cannot set the required compiler: a%foo" spack.error.UnsatisfiableSpecError, match="Cannot set the required compiler: a%foo"
@ -2331,9 +2331,9 @@ def test_concretization_with_compilers_supporting_target_any(self):
assert s.satisfies("%gcc@12.1.0") assert s.satisfies("%gcc@12.1.0")
@pytest.mark.parametrize("spec_str", ["mpileaks", "mpileaks ^mpich"]) @pytest.mark.parametrize("spec_str", ["mpileaks", "mpileaks ^mpich"])
def test_virtuals_are_annotated_on_edges(self, spec_str, default_mock_concretization): def test_virtuals_are_annotated_on_edges(self, spec_str):
"""Tests that information on virtuals is annotated on DAG edges""" """Tests that information on virtuals is annotated on DAG edges"""
spec = default_mock_concretization(spec_str) spec = Spec(spec_str).concretized()
mpi_provider = spec["mpi"].name mpi_provider = spec["mpi"].name
edges = spec.edges_to_dependencies(name=mpi_provider) edges = spec.edges_to_dependencies(name=mpi_provider)
@ -2347,7 +2347,7 @@ def test_virtuals_are_annotated_on_edges(self, spec_str, default_mock_concretiza
"spec_str,mpi_name", "spec_str,mpi_name",
[("mpileaks", "mpich"), ("mpileaks ^mpich2", "mpich2"), ("mpileaks ^zmpi", "zmpi")], [("mpileaks", "mpich"), ("mpileaks ^mpich2", "mpich2"), ("mpileaks ^zmpi", "zmpi")],
) )
def test_virtuals_are_reconstructed_on_reuse(self, spec_str, mpi_name, database): def test_virtuals_are_reconstructed_on_reuse(self, spec_str, mpi_name, mutable_database):
"""Tests that when we reuse a spec, virtual on edges are reconstructed correctly""" """Tests that when we reuse a spec, virtual on edges are reconstructed correctly"""
with spack.config.override("concretizer:reuse", True): with spack.config.override("concretizer:reuse", True):
spec = Spec(spec_str).concretized() spec = Spec(spec_str).concretized()
@ -3006,7 +3006,7 @@ def test_concretization_version_order():
), ),
], ],
) )
@pytest.mark.usefixtures("database", "mock_store") @pytest.mark.usefixtures("mutable_database", "mock_store")
@pytest.mark.not_on_windows("Expected length is different on Windows") @pytest.mark.not_on_windows("Expected length is different on Windows")
def test_filtering_reused_specs( def test_filtering_reused_specs(
roots, reuse_yaml, expected, not_expected, expected_length, mutable_config, monkeypatch roots, reuse_yaml, expected, not_expected, expected_length, mutable_config, monkeypatch
@ -3027,7 +3027,7 @@ def test_filtering_reused_specs(
assert all(not x.satisfies(constraint) for x in specs) assert all(not x.satisfies(constraint) for x in specs)
@pytest.mark.usefixtures("database", "mock_store") @pytest.mark.usefixtures("mutable_database", "mock_store")
@pytest.mark.parametrize( @pytest.mark.parametrize(
"reuse_yaml,expected_length", "reuse_yaml,expected_length",
[({"from": [{"type": "local"}]}, 17), ({"from": [{"type": "buildcache"}]}, 0)], [({"from": [{"type": "local"}]}, 17), ({"from": [{"type": "buildcache"}]}, 0)],

2
lib/spack/spack/test/concretize_compiler_runtimes.py
View File

@ -32,7 +32,7 @@ def _concretize_with_reuse(*, root_str, reused_str):
@pytest.fixture @pytest.fixture
def runtime_repo(config): def runtime_repo(mutable_config):
repo = os.path.join(spack.paths.repos_path, "compiler_runtime.test") repo = os.path.join(spack.paths.repos_path, "compiler_runtime.test")
with spack.repo.use_repositories(repo) as mock_repo: with spack.repo.use_repositories(repo) as mock_repo:
yield mock_repo yield mock_repo

6
lib/spack/spack/test/conftest.py
View File

@ -63,6 +63,12 @@
from spack.util.pattern import Bunch from spack.util.pattern import Bunch
@pytest.fixture(autouse=True)
def check_config_fixture(request):
if "config" in request.fixturenames and "mutable_config" in request.fixturenames:
raise RuntimeError("'config' and 'mutable_config' are both requested")
def ensure_configuration_fixture_run_before(request): def ensure_configuration_fixture_run_before(request):
"""Ensure that fixture mutating the configuration run before the one where """Ensure that fixture mutating the configuration run before the one where
the function is called. the function is called.

24
lib/spack/spack/test/database.py
View File

@ -870,7 +870,7 @@ def _is(self, spec):
@pytest.mark.db @pytest.mark.db
def test_clear_failure_forced(default_mock_concretization, mutable_database, monkeypatch, capfd): def test_clear_failure_forced(mutable_database, monkeypatch, capfd):
"""Add test coverage for clear_failure operation when force.""" """Add test coverage for clear_failure operation when force."""
def _is(self, spec): def _is(self, spec):
@ -881,7 +881,7 @@ def _is(self, spec):
# Ensure raise OSError when try to remove the non-existent marking # Ensure raise OSError when try to remove the non-existent marking
monkeypatch.setattr(spack.database.FailureTracker, "persistent_mark", _is) monkeypatch.setattr(spack.database.FailureTracker, "persistent_mark", _is)
s = default_mock_concretization("a") s = spack.spec.Spec("a").concretized()
spack.store.STORE.failure_tracker.clear(s, force=True) spack.store.STORE.failure_tracker.clear(s, force=True)
out = capfd.readouterr()[1] out = capfd.readouterr()[1]
assert "Removing failure marking despite lock" in out assert "Removing failure marking despite lock" in out
@ -889,19 +889,19 @@ def _is(self, spec):
@pytest.mark.db @pytest.mark.db
def test_mark_failed(default_mock_concretization, mutable_database, monkeypatch, tmpdir, capsys): def test_mark_failed(mutable_database, monkeypatch, tmpdir, capsys):
"""Add coverage to mark_failed.""" """Add coverage to mark_failed."""
def _raise_exc(lock): def _raise_exc(lock):
raise lk.LockTimeoutError("write", "/mock-lock", 1.234, 10) raise lk.LockTimeoutError("write", "/mock-lock", 1.234, 10)
# Ensure attempt to acquire write lock on the mark raises the exception
monkeypatch.setattr(lk.Lock, "acquire_write", _raise_exc)
with tmpdir.as_cwd(): with tmpdir.as_cwd():
s = default_mock_concretization("a") s = spack.spec.Spec("a").concretized()
spack.store.STORE.failure_tracker.mark(s)
# 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]) out = str(capsys.readouterr()[1])
assert "Unable to mark a as failed" in out assert "Unable to mark a as failed" in out
@ -909,10 +909,10 @@ def _raise_exc(lock):
@pytest.mark.db @pytest.mark.db
def test_prefix_failed(default_mock_concretization, mutable_database, monkeypatch): def test_prefix_failed(mutable_database, monkeypatch):
"""Add coverage to failed operation.""" """Add coverage to failed operation."""
s = default_mock_concretization("a") s = spack.spec.Spec("a").concretized()
# Confirm the spec is not already marked as failed # Confirm the spec is not already marked as failed
assert not spack.store.STORE.failure_tracker.has_failed(s) assert not spack.store.STORE.failure_tracker.has_failed(s)
@ -930,13 +930,13 @@ def test_prefix_failed(default_mock_concretization, mutable_database, monkeypatc
assert spack.store.STORE.failure_tracker.has_failed(s) assert spack.store.STORE.failure_tracker.has_failed(s)
def test_prefix_write_lock_error(default_mock_concretization, mutable_database, monkeypatch): def test_prefix_write_lock_error(mutable_database, monkeypatch):
"""Cover the prefix write lock exception.""" """Cover the prefix write lock exception."""
def _raise(db, spec): def _raise(db, spec):
raise lk.LockError("Mock lock error") raise lk.LockError("Mock lock error")
s = default_mock_concretization("a") s = spack.spec.Spec("a").concretized()
# Ensure subsequent lock operations fail # Ensure subsequent lock operations fail
monkeypatch.setattr(lk.Lock, "acquire_write", _raise) monkeypatch.setattr(lk.Lock, "acquire_write", _raise)

6
lib/spack/spack/test/env.py
View File

@ -96,7 +96,7 @@ def test_env_change_spec(tmp_path, mock_packages, config):
""" """
def test_env_change_spec_in_definition(tmp_path, mock_packages, config, mutable_mock_env_path): def test_env_change_spec_in_definition(tmp_path, mock_packages, mutable_mock_env_path):
manifest_file = tmp_path / ev.manifest_name manifest_file = tmp_path / ev.manifest_name
manifest_file.write_text(_test_matrix_yaml) manifest_file.write_text(_test_matrix_yaml)
e = ev.create("test", manifest_file) e = ev.create("test", manifest_file)
@ -118,9 +118,7 @@ def test_env_change_spec_in_definition(tmp_path, mock_packages, config, mutable_
assert not any(x.intersects("mpileaks@2.1%gcc") for x in e.user_specs) assert not any(x.intersects("mpileaks@2.1%gcc") for x in e.user_specs)
def test_env_change_spec_in_matrix_raises_error( def test_env_change_spec_in_matrix_raises_error(tmp_path, mock_packages, mutable_mock_env_path):
tmp_path, mock_packages, config, mutable_mock_env_path
):
manifest_file = tmp_path / ev.manifest_name manifest_file = tmp_path / ev.manifest_name
manifest_file.write_text(_test_matrix_yaml) manifest_file.write_text(_test_matrix_yaml)
e = ev.create("test", manifest_file) e = ev.create("test", manifest_file)

4
lib/spack/spack/test/mirror.py
View File

@ -200,13 +200,13 @@ def test_invalid_json_mirror_collection(invalid_json, error_message):
assert error_message in exc_msg assert error_message in exc_msg
def test_mirror_archive_paths_no_version(mock_packages, config, mock_archive): def test_mirror_archive_paths_no_version(mock_packages, mock_archive):
spec = Spec("trivial-install-test-package@=nonexistingversion").concretized() spec = Spec("trivial-install-test-package@=nonexistingversion").concretized()
fetcher = spack.fetch_strategy.URLFetchStrategy(mock_archive.url) fetcher = spack.fetch_strategy.URLFetchStrategy(mock_archive.url)
spack.mirror.mirror_archive_paths(fetcher, "per-package-ref", spec) spack.mirror.mirror_archive_paths(fetcher, "per-package-ref", spec)
def test_mirror_with_url_patches(mock_packages, config, monkeypatch): def test_mirror_with_url_patches(mock_packages, monkeypatch):
spec = Spec("patch-several-dependencies") spec = Spec("patch-several-dependencies")
spec.concretize() spec.concretize()

3
lib/spack/spack/test/modules/lmod.py
View File

@ -48,7 +48,7 @@ def provider(request):
return request.param return request.param
@pytest.mark.usefixtures("config", "mock_packages") @pytest.mark.usefixtures("mutable_config", "mock_packages")
class TestLmod: class TestLmod:
@pytest.mark.regression("37788") @pytest.mark.regression("37788")
@pytest.mark.parametrize("modules_config", ["core_compilers", "core_compilers_at_equal"]) @pytest.mark.parametrize("modules_config", ["core_compilers", "core_compilers_at_equal"])
@ -355,7 +355,6 @@ def test_override_template_in_modules_yaml(
content = modulefile_content(f"mpileaks target={host_architecture_str}") content = modulefile_content(f"mpileaks target={host_architecture_str}")
assert "Override even better!" in content assert "Override even better!" in content
@pytest.mark.usefixtures("config")
def test_external_configure_args(self, factory): def test_external_configure_args(self, factory):
# If this package is detected as an external, its configure option line # If this package is detected as an external, its configure option line
# in the module file starts with 'unknown' # in the module file starts with 'unknown'

11
lib/spack/spack/test/modules/tcl.py
View File

@ -26,7 +26,7 @@
] ]
@pytest.mark.usefixtures("config", "mock_packages", "mock_module_filename") @pytest.mark.usefixtures("mutable_config", "mock_packages", "mock_module_filename")
class TestTcl: class TestTcl:
def test_simple_case(self, modulefile_content, module_configuration): def test_simple_case(self, modulefile_content, module_configuration):
"""Tests the generation of a simple Tcl module file.""" """Tests the generation of a simple Tcl module file."""
@ -439,19 +439,19 @@ def test_extend_context(self, modulefile_content, module_configuration):
@pytest.mark.regression("4400") @pytest.mark.regression("4400")
@pytest.mark.db @pytest.mark.db
def test_hide_implicits_no_arg(self, module_configuration, database): def test_hide_implicits_no_arg(self, module_configuration, mutable_database):
module_configuration("exclude_implicits") module_configuration("exclude_implicits")
# mpileaks has been installed explicitly when setting up # mpileaks has been installed explicitly when setting up
# the tests database # the tests database
mpileaks_specs = database.query("mpileaks") mpileaks_specs = mutable_database.query("mpileaks")
for item in mpileaks_specs: for item in mpileaks_specs:
writer = writer_cls(item, "default") writer = writer_cls(item, "default")
assert not writer.conf.excluded assert not writer.conf.excluded
# callpath is a dependency of mpileaks, and has been pulled # callpath is a dependency of mpileaks, and has been pulled
# in implicitly # in implicitly
callpath_specs = database.query("callpath") callpath_specs = mutable_database.query("callpath")
for item in callpath_specs: for item in callpath_specs:
writer = writer_cls(item, "default") writer = writer_cls(item, "default")
assert writer.conf.excluded assert writer.conf.excluded
@ -473,8 +473,7 @@ def test_hide_implicits_with_arg(self, module_configuration):
assert writer.conf.excluded assert writer.conf.excluded
@pytest.mark.regression("9624") @pytest.mark.regression("9624")
@pytest.mark.db def test_autoload_with_constraints(self, modulefile_content, module_configuration):
def test_autoload_with_constraints(self, modulefile_content, module_configuration, database):
"""Tests the automatic loading of direct dependencies.""" """Tests the automatic loading of direct dependencies."""
module_configuration("autoload_with_constraints") module_configuration("autoload_with_constraints")

12
lib/spack/spack/test/packaging.py
View File

@ -506,9 +506,7 @@ def fake_fn(self):
"manual,instr", [(False, False), (False, True), (True, False), (True, True)] "manual,instr", [(False, False), (False, True), (True, False), (True, True)]
) )
@pytest.mark.disable_clean_stage_check @pytest.mark.disable_clean_stage_check
def test_manual_download( def test_manual_download(mock_download, default_mock_concretization, monkeypatch, manual, instr):
install_mockery, mock_download, default_mock_concretization, monkeypatch, manual, instr
):
""" """
Ensure expected fetcher fail message based on manual download and instr. Ensure expected fetcher fail message based on manual download and instr.
""" """
@ -539,18 +537,14 @@ def fetch(self):
monkeypatch.setattr(spack.package_base.PackageBase, "fetcher", FetchingNotAllowed()) monkeypatch.setattr(spack.package_base.PackageBase, "fetcher", FetchingNotAllowed())
def test_fetch_without_code_is_noop( def test_fetch_without_code_is_noop(default_mock_concretization, fetching_not_allowed):
default_mock_concretization, install_mockery, fetching_not_allowed
):
"""do_fetch for packages without code should be a no-op""" """do_fetch for packages without code should be a no-op"""
pkg = default_mock_concretization("a").package pkg = default_mock_concretization("a").package
pkg.has_code = False pkg.has_code = False
pkg.do_fetch() pkg.do_fetch()
def test_fetch_external_package_is_noop( def test_fetch_external_package_is_noop(default_mock_concretization, fetching_not_allowed):
default_mock_concretization, install_mockery, fetching_not_allowed
):
"""do_fetch for packages without code should be a no-op""" """do_fetch for packages without code should be a no-op"""
spec = default_mock_concretization("a") spec = default_mock_concretization("a")
spec.external_path = "/some/where" spec.external_path = "/some/where"

6
lib/spack/spack/test/patch.py
View File

@ -229,7 +229,7 @@ def test_nested_directives(mock_packages):
@pytest.mark.not_on_windows("Test requires Autotools") @pytest.mark.not_on_windows("Test requires Autotools")
def test_patched_dependency(mock_packages, config, install_mockery, mock_fetch): def test_patched_dependency(mock_packages, install_mockery, mock_fetch):
"""Test whether patched dependencies work.""" """Test whether patched dependencies work."""
spec = Spec("patch-a-dependency") spec = Spec("patch-a-dependency")
spec.concretize() spec.concretize()
@ -268,7 +268,7 @@ def trigger_bad_patch(pkg):
def test_patch_failure_develop_spec_exits_gracefully( def test_patch_failure_develop_spec_exits_gracefully(
mock_packages, config, install_mockery, mock_fetch, tmpdir, mock_stage mock_packages, install_mockery, mock_fetch, tmpdir, mock_stage
): ):
"""ensure that a failing patch does not trigger exceptions for develop specs""" """ensure that a failing patch does not trigger exceptions for develop specs"""
@ -284,7 +284,7 @@ def test_patch_failure_develop_spec_exits_gracefully(
# success if no exceptions raised # success if no exceptions raised
def test_patch_failure_restages(mock_packages, config, install_mockery, mock_fetch): def test_patch_failure_restages(mock_packages, install_mockery, mock_fetch):
""" """
ensure that a failing patch does not trigger exceptions ensure that a failing patch does not trigger exceptions
for non-develop specs and the source gets restaged for non-develop specs and the source gets restaged

4
lib/spack/spack/test/spec_syntax.py
View File

@ -851,12 +851,12 @@ def test_multiple_specs_with_hash(database, config):
@pytest.mark.db @pytest.mark.db
def test_ambiguous_hash(mutable_database, default_mock_concretization, config): def test_ambiguous_hash(mutable_database):
"""Test that abstract hash ambiguity is delayed until concretization. """Test that abstract hash ambiguity is delayed until concretization.
In the past this ambiguity error would happen during parse time.""" In the past this ambiguity error would happen during parse time."""
# This is a very sketchy as manually setting hashes easily breaks invariants # This is a very sketchy as manually setting hashes easily breaks invariants
x1 = default_mock_concretization("a") x1 = spack.spec.Spec("a").concretized()
x2 = x1.copy() x2 = x1.copy()
x1._hash = "xyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy" x1._hash = "xyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy"
x1._process_hash = "xyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy" x1._process_hash = "xyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy"