summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rwxr-xr-xlib/spack/spack/installer.py51
-rw-r--r--lib/spack/spack/test/install.py69
-rw-r--r--lib/spack/spack/test/installer.py269
3 files changed, 280 insertions, 109 deletions
diff --git a/lib/spack/spack/installer.py b/lib/spack/spack/installer.py
index 4559fd70ba..4e8ec39733 100755
--- a/lib/spack/spack/installer.py
+++ b/lib/spack/spack/installer.py
@@ -36,6 +36,7 @@ import six
import sys
import time
+import llnl.util.filesystem as fs
import llnl.util.lock as lk
import llnl.util.tty as tty
import spack.binary_distribution as binary_distribution
@@ -43,14 +44,12 @@ import spack.compilers
import spack.error
import spack.hooks
import spack.package
+import spack.package_prefs as prefs
import spack.repo
import spack.store
-from llnl.util.filesystem import \
- chgrp, install, install_tree, mkdirp, touch, working_dir
from llnl.util.tty.color import colorize, cwrite
from llnl.util.tty.log import log_output
-from spack.package_prefs import get_package_dir_permissions, get_package_group
from spack.util.environment import dump_environment
from spack.util.executable import which
@@ -133,21 +132,21 @@ def _do_fake_install(pkg):
chmod = which('chmod')
# Install fake command
- mkdirp(pkg.prefix.bin)
- touch(os.path.join(pkg.prefix.bin, command))
+ fs.mkdirp(pkg.prefix.bin)
+ fs.touch(os.path.join(pkg.prefix.bin, command))
chmod('+x', os.path.join(pkg.prefix.bin, command))
# Install fake header file
- mkdirp(pkg.prefix.include)
- touch(os.path.join(pkg.prefix.include, header + '.h'))
+ fs.mkdirp(pkg.prefix.include)
+ fs.touch(os.path.join(pkg.prefix.include, header + '.h'))
# Install fake shared and static libraries
- mkdirp(pkg.prefix.lib)
+ fs.mkdirp(pkg.prefix.lib)
for suffix in [dso_suffix, '.a']:
- touch(os.path.join(pkg.prefix.lib, library + suffix))
+ fs.touch(os.path.join(pkg.prefix.lib, library + suffix))
# Install fake man page
- mkdirp(pkg.prefix.man.man1)
+ fs.mkdirp(pkg.prefix.man.man1)
packages_dir = spack.store.layout.build_packages_path(pkg.spec)
dump_packages(pkg.spec, packages_dir)
@@ -377,14 +376,14 @@ def dump_packages(spec, path):
Dump all package information for a spec and its dependencies.
This creates a package repository within path for every namespace in the
- spec DAG, and fills the repos wtih package files and patch files for every
+ spec DAG, and fills the repos with package files and patch files for every
node in the DAG.
Args:
spec (Spec): the Spack spec whose package information is to be dumped
path (str): the path to the build packages directory
"""
- mkdirp(path)
+ fs.mkdirp(path)
# Copy in package.py files from any dependencies.
# Note that we copy them in as they are in the *install* directory
@@ -425,7 +424,7 @@ def dump_packages(spec, path):
if node is spec:
spack.repo.path.dump_provenance(node, dest_pkg_dir)
elif source_pkg_dir:
- install_tree(source_pkg_dir, dest_pkg_dir)
+ fs.install_tree(source_pkg_dir, dest_pkg_dir)
def install_msg(name, pid):
@@ -461,17 +460,17 @@ def log(pkg):
tty.debug(e)
# Archive the whole stdout + stderr for the package
- install(pkg.log_path, pkg.install_log_path)
+ fs.install(pkg.log_path, pkg.install_log_path)
# Archive the environment used for the build
- install(pkg.env_path, pkg.install_env_path)
+ fs.install(pkg.env_path, pkg.install_env_path)
if os.path.exists(pkg.configure_args_path):
# Archive the args used for the build
- install(pkg.configure_args_path, pkg.install_configure_args_path)
+ fs.install(pkg.configure_args_path, pkg.install_configure_args_path)
# Finally, archive files that are specific to each package
- with working_dir(pkg.stage.path):
+ with fs.working_dir(pkg.stage.path):
errors = six.StringIO()
target_dir = os.path.join(
spack.store.layout.metadata_path(pkg.spec), 'archived-files')
@@ -493,8 +492,8 @@ def log(pkg):
target = os.path.join(target_dir, f)
# We must ensure that the directory exists before
# copying a file in
- mkdirp(os.path.dirname(target))
- install(f, target)
+ fs.mkdirp(os.path.dirname(target))
+ fs.install(f, target)
except Exception as e:
tty.debug(e)
@@ -505,7 +504,7 @@ def log(pkg):
if errors.getvalue():
error_file = os.path.join(target_dir, 'errors.txt')
- mkdirp(target_dir)
+ fs.mkdirp(target_dir)
with open(error_file, 'w') as err:
err.write(errors.getvalue())
tty.warn('Errors occurred when archiving files.\n\t'
@@ -1071,10 +1070,10 @@ class PackageInstaller(object):
pkg.name, 'src')
tty.msg('{0} Copying source to {1}'
.format(pre, src_target))
- install_tree(pkg.stage.source_path, src_target)
+ fs.install_tree(pkg.stage.source_path, src_target)
# Do the real install in the source directory.
- with working_dir(pkg.stage.source_path):
+ with fs.working_dir(pkg.stage.source_path):
# Save the build environment in a file before building.
dump_environment(pkg.env_path)
@@ -1286,20 +1285,20 @@ class PackageInstaller(object):
spack.store.layout.create_install_directory(pkg.spec)
else:
# Set the proper group for the prefix
- group = get_package_group(pkg.spec)
+ group = prefs.get_package_group(pkg.spec)
if group:
- chgrp(pkg.spec.prefix, group)
+ fs.chgrp(pkg.spec.prefix, group)
# Set the proper permissions.
# This has to be done after group because changing groups blows
# away the sticky group bit on the directory
mode = os.stat(pkg.spec.prefix).st_mode
- perms = get_package_dir_permissions(pkg.spec)
+ perms = prefs.get_package_dir_permissions(pkg.spec)
if mode != perms:
os.chmod(pkg.spec.prefix, perms)
# Ensure the metadata path exists as well
- mkdirp(spack.store.layout.metadata_path(pkg.spec), mode=perms)
+ fs.mkdirp(spack.store.layout.metadata_path(pkg.spec), mode=perms)
def _update_failed(self, task, mark=False, exc=None):
"""
diff --git a/lib/spack/spack/test/install.py b/lib/spack/spack/test/install.py
index ff7f5a3355..2f779c6a5f 100644
--- a/lib/spack/spack/test/install.py
+++ b/lib/spack/spack/test/install.py
@@ -7,7 +7,7 @@ import os
import pytest
import shutil
-from llnl.util.filesystem import mkdirp, touch, working_dir
+import llnl.util.filesystem as fs
from spack.package import InstallError, PackageBase, PackageStillNeededError
import spack.error
@@ -380,11 +380,11 @@ def test_pkg_build_paths(install_mockery):
# Backward compatibility checks
log_dir = os.path.dirname(log_path)
- mkdirp(log_dir)
- with working_dir(log_dir):
+ fs.mkdirp(log_dir)
+ with fs.working_dir(log_dir):
# Start with the older of the previous log filenames
older_log = 'spack-build.out'
- touch(older_log)
+ fs.touch(older_log)
assert spec.package.log_path.endswith(older_log)
# Now check the newer log filename
@@ -416,11 +416,11 @@ def test_pkg_install_paths(install_mockery):
# Backward compatibility checks
log_dir = os.path.dirname(log_path)
- mkdirp(log_dir)
- with working_dir(log_dir):
+ fs.mkdirp(log_dir)
+ with fs.working_dir(log_dir):
# Start with the older of the previous install log filenames
older_log = 'build.out'
- touch(older_log)
+ fs.touch(older_log)
assert spec.package.install_log_path.endswith(older_log)
# Now check the newer install log filename
@@ -437,7 +437,8 @@ def test_pkg_install_paths(install_mockery):
shutil.rmtree(log_dir)
-def test_pkg_install_log(install_mockery):
+def test_log_install_without_build_files(install_mockery):
+ """Test the installer log function when no build files are present."""
# Get a basic concrete spec for the trivial install package.
spec = Spec('trivial-install-test-package').concretized()
@@ -445,17 +446,40 @@ def test_pkg_install_log(install_mockery):
with pytest.raises(IOError, match="No such file or directory"):
spack.installer.log(spec.package)
- # Set up mock build files and try again
+
+def test_log_install_with_build_files(install_mockery, monkeypatch):
+ """Test the installer's log function when have build files."""
+ config_log = 'config.log'
+
+ # Retain the original function for use in the monkey patch that is used
+ # to raise an exception under the desired condition for test coverage.
+ orig_install_fn = fs.install
+
+ def _install(src, dest):
+ orig_install_fn(src, dest)
+ if src.endswith(config_log):
+ raise Exception('Mock log install error')
+
+ monkeypatch.setattr(fs, 'install', _install)
+
+ spec = Spec('trivial-install-test-package').concretized()
+
+ # Set up mock build files and try again to include archive failure
log_path = spec.package.log_path
log_dir = os.path.dirname(log_path)
- mkdirp(log_dir)
- with working_dir(log_dir):
- touch(log_path)
- touch(spec.package.env_path)
- touch(spec.package.configure_args_path)
+ fs.mkdirp(log_dir)
+ with fs.working_dir(log_dir):
+ fs.touch(log_path)
+ fs.touch(spec.package.env_path)
+ fs.touch(spec.package.configure_args_path)
install_path = os.path.dirname(spec.package.install_log_path)
- mkdirp(install_path)
+ fs.mkdirp(install_path)
+
+ source = spec.package.stage.source_path
+ config = os.path.join(source, 'config.log')
+ fs.touchp(config)
+ spec.package.archive_files = ['missing', '..', config]
spack.installer.log(spec.package)
@@ -463,6 +487,21 @@ def test_pkg_install_log(install_mockery):
assert os.path.exists(spec.package.install_env_path)
assert os.path.exists(spec.package.install_configure_args_path)
+ archive_dir = os.path.join(install_path, 'archived-files')
+ source_dir = os.path.dirname(source)
+ rel_config = os.path.relpath(config, source_dir)
+
+ assert os.path.exists(os.path.join(archive_dir, rel_config))
+ assert not os.path.exists(os.path.join(archive_dir, 'missing'))
+
+ expected_errs = [
+ 'OUTSIDE SOURCE PATH', # for '..'
+ 'FAILED TO ARCHIVE' # for rel_config
+ ]
+ with open(os.path.join(archive_dir, 'errors.txt'), 'r') as fd:
+ for ln, expected in zip(fd, expected_errs):
+ assert expected in ln
+
# Cleanup
shutil.rmtree(log_dir)
diff --git a/lib/spack/spack/test/installer.py b/lib/spack/spack/test/installer.py
index b9730c3165..0be4bc78c0 100644
--- a/lib/spack/spack/test/installer.py
+++ b/lib/spack/spack/test/installer.py
@@ -7,15 +7,19 @@ import os
import py
import pytest
+import llnl.util.filesystem as fs
import llnl.util.tty as tty
+import llnl.util.lock as ulk
import spack.binary_distribution
import spack.compilers
import spack.directory_layout as dl
import spack.installer as inst
-import spack.util.lock as lk
+import spack.package_prefs as prefs
import spack.repo
import spack.spec
+import spack.store
+import spack.util.lock as lk
def _mock_repo(root, namespace):
@@ -152,7 +156,7 @@ def test_process_external_package_module(install_mockery, monkeypatch, capfd):
def test_process_binary_cache_tarball_none(install_mockery, monkeypatch,
capfd):
- """Tests to cover _process_binary_cache_tarball when no tarball."""
+ """Tests of _process_binary_cache_tarball when no tarball."""
monkeypatch.setattr(spack.binary_distribution, 'download_tarball', _none)
pkg = spack.repo.get('trivial-install-test-package')
@@ -162,7 +166,7 @@ def test_process_binary_cache_tarball_none(install_mockery, monkeypatch,
def test_process_binary_cache_tarball_tar(install_mockery, monkeypatch, capfd):
- """Tests to cover _process_binary_cache_tarball with a tar file."""
+ """Tests of _process_binary_cache_tarball with a tar file."""
def _spec(spec):
return spec
@@ -179,6 +183,25 @@ def test_process_binary_cache_tarball_tar(install_mockery, monkeypatch, capfd):
assert 'Installing a from binary cache' in capfd.readouterr()[0]
+def test_try_install_from_binary_cache(install_mockery, mock_packages,
+ monkeypatch, capsys):
+ """Tests SystemExit path for_try_install_from_binary_cache."""
+ def _spec(spec, force):
+ spec = spack.spec.Spec('mpi').concretized()
+ return {spec: None}
+
+ spec = spack.spec.Spec('mpich')
+ spec.concretize()
+
+ monkeypatch.setattr(spack.binary_distribution, 'get_spec', _spec)
+
+ with pytest.raises(SystemExit):
+ inst._try_install_from_binary_cache(spec.package, False, False)
+
+ captured = capsys.readouterr()
+ assert 'add a spack mirror to allow download' in str(captured)
+
+
def test_installer_init_errors(install_mockery):
"""Test to ensure cover installer constructor errors."""
with pytest.raises(ValueError, match='must be a package'):
@@ -189,17 +212,18 @@ def test_installer_init_errors(install_mockery):
inst.PackageInstaller(pkg)
-def test_installer_strings(install_mockery):
- """Tests of installer repr and str for coverage purposes."""
+def test_installer_repr(install_mockery):
spec, installer = create_installer('trivial-install-test-package')
- # Cover __repr__
irep = installer.__repr__()
assert irep.startswith(installer.__class__.__name__)
assert "installed=" in irep
assert "failed=" in irep
- # Cover __str__
+
+def test_installer_str(install_mockery):
+ spec, installer = create_installer('trivial-install-test-package')
+
istr = str(installer)
assert "#tasks=0" in istr
assert "installed (0)" in istr
@@ -207,7 +231,6 @@ def test_installer_strings(install_mockery):
def test_installer_last_phase_error(install_mockery, capsys):
- """Test to cover last phase error."""
spec = spack.spec.Spec('trivial-install-test-package')
spec.concretize()
assert spec.concrete
@@ -220,7 +243,6 @@ def test_installer_last_phase_error(install_mockery, capsys):
def test_installer_ensure_ready_errors(install_mockery):
- """Test to cover _ensure_ready errors."""
spec, installer = create_installer('trivial-install-test-package')
fmt = r'cannot be installed locally.*{0}'
@@ -247,24 +269,102 @@ def test_installer_ensure_ready_errors(install_mockery):
installer._ensure_install_ready(spec.package)
-def test_ensure_locked_have(install_mockery, tmpdir):
- """Test to cover _ensure_locked when already have lock."""
+def test_ensure_locked_err(install_mockery, monkeypatch, tmpdir, capsys):
+ """Test _ensure_locked when a non-lock exception is raised."""
+ mock_err_msg = 'Mock exception error'
+
+ def _raise(lock, timeout):
+ raise RuntimeError(mock_err_msg)
+
spec, installer = create_installer('trivial-install-test-package')
+ monkeypatch.setattr(ulk.Lock, 'acquire_read', _raise)
with tmpdir.as_cwd():
+ with pytest.raises(RuntimeError):
+ installer._ensure_locked('read', spec.package)
+
+ out = str(capsys.readouterr()[1])
+ assert 'Failed to acquire a read lock' in out
+ assert mock_err_msg in out
+
+
+def test_ensure_locked_have(install_mockery, tmpdir, capsys):
+ """Test _ensure_locked when already have lock."""
+ spec, installer = create_installer('trivial-install-test-package')
+
+ with tmpdir.as_cwd():
+ # Test "downgrade" of a read lock (to a read lock)
lock = lk.Lock('./test', default_timeout=1e-9, desc='test')
lock_type = 'read'
tpl = (lock_type, lock)
installer.locks[installer.pkg_id] = tpl
assert installer._ensure_locked(lock_type, spec.package) == tpl
+ # Test "upgrade" of a read lock without read count to a write
+ lock_type = 'write'
+ err = 'Cannot upgrade lock'
+ with pytest.raises(ulk.LockUpgradeError, match=err):
+ installer._ensure_locked(lock_type, spec.package)
+
+ out = str(capsys.readouterr()[1])
+ assert 'Failed to upgrade to a write lock' in out
+ assert 'exception when releasing read lock' in out
+
+ # Test "upgrade" of the read lock *with* read count to a write
+ lock._reads = 1
+ tpl = (lock_type, lock)
+ assert installer._ensure_locked(lock_type, spec.package) == tpl
+
+ # Test "downgrade" of the write lock to a read lock
+ lock_type = 'read'
+ tpl = (lock_type, lock)
+ assert installer._ensure_locked(lock_type, spec.package) == tpl
+
+
+@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'
+ spec, installer = create_installer(pkg_id)
+ with tmpdir.as_cwd():
+ ltype, lock = installer._ensure_locked(lock_type, spec.package)
+ assert ltype == lock_type
+ assert lock is not None
+ assert lock._reads == reads
+ assert lock._writes == writes
+
+
+def test_ensure_locked_new_warn(install_mockery, monkeypatch, tmpdir, capsys):
+ orig_pl = spack.database.Database.prefix_lock
+
+ def _pl(db, spec, timeout):
+ lock = orig_pl(db, spec, timeout)
+ lock.default_timeout = 1e-9 if timeout is None else None
+ return lock
+
+ pkg_id = 'a'
+ spec, installer = create_installer(pkg_id)
+
+ monkeypatch.setattr(spack.database.Database, 'prefix_lock', _pl)
-def test_package_id(install_mockery):
- """Test to cover package_id functionality."""
+ lock_type = 'read'
+ ltype, lock = installer._ensure_locked(lock_type, spec.package)
+ assert ltype == lock_type
+ assert lock is not None
+
+ out = str(capsys.readouterr()[1])
+ assert 'Expected prefix lock timeout' in out
+
+
+def test_package_id_err(install_mockery):
pkg = spack.repo.get('trivial-install-test-package')
with pytest.raises(ValueError, match='spec is not concretized'):
inst.package_id(pkg)
+
+def test_package_id_ok(install_mockery):
spec = spack.spec.Spec('trivial-install-test-package')
spec.concretize()
assert spec.concrete
@@ -273,36 +373,44 @@ def test_package_id(install_mockery):
def test_fake_install(install_mockery):
- """Test to cover fake install basics."""
spec = spack.spec.Spec('trivial-install-test-package')
spec.concretize()
assert spec.concrete
+
pkg = spec.package
inst._do_fake_install(pkg)
assert os.path.isdir(pkg.prefix.lib)
-def test_packages_needed_to_bootstrap_compiler(install_mockery, monkeypatch):
- """Test to cover most of _packages_needed_to_boostrap_compiler."""
- # TODO: More work is needed to go beyond the dependency check
- def _no_compilers(pkg, arch_spec):
- return []
-
- # Test path where no compiler packages returned
+def test_packages_needed_to_bootstrap_compiler_none(install_mockery):
spec = spack.spec.Spec('trivial-install-test-package')
spec.concretize()
assert spec.concrete
+
packages = inst._packages_needed_to_bootstrap_compiler(spec.package)
assert not packages
- # Test up to the dependency check
- monkeypatch.setattr(spack.compilers, 'compilers_for_spec', _no_compilers)
- with pytest.raises(spack.repo.UnknownPackageError, match='not found'):
- inst._packages_needed_to_bootstrap_compiler(spec.package)
+
+def test_packages_needed_to_bootstrap_compiler_packages(install_mockery,
+ monkeypatch):
+ spec = spack.spec.Spec('trivial-install-test-package')
+ spec.concretize()
+
+ def _conc_spec(compiler):
+ return spack.spec.Spec('a').concretized()
+
+ # Ensure we can get past functions that are precluding obtaining
+ # packages.
+ monkeypatch.setattr(spack.compilers, 'compilers_for_spec', _none)
+ monkeypatch.setattr(spack.compilers, 'pkg_spec_for_compiler', _conc_spec)
+ monkeypatch.setattr(spack.spec.Spec, 'concretize', _noop)
+
+ packages = inst._packages_needed_to_bootstrap_compiler(spec.package)
+ assert packages
def test_dump_packages_deps_ok(install_mockery, tmpdir, mock_repo_path):
- """Test to add coverage to dump_packages with dependencies happy path."""
+ """Test happy path for dump_packages with dependencies."""
spec_name = 'simple-inheritance'
spec = spack.spec.Spec(spec_name).concretized()
@@ -314,7 +422,7 @@ def test_dump_packages_deps_ok(install_mockery, tmpdir, mock_repo_path):
def test_dump_packages_deps_errs(install_mockery, tmpdir, monkeypatch, capsys):
- """Test to add coverage to dump_packages with dependencies."""
+ """Test error paths for dump_packages with dependencies."""
orig_bpp = spack.store.layout.build_packages_path
orig_dirname = spack.repo.Repo.dirname_for_package_name
repo_err_msg = "Mock dirname_for_package_name"
@@ -354,59 +462,45 @@ def test_dump_packages_deps_errs(install_mockery, tmpdir, monkeypatch, capsys):
assert "Couldn't copy in provenance for cmake" in out
-@pytest.mark.tld
-def test_check_deps_status_errs(install_mockery, monkeypatch):
- """Test to cover _check_deps_status failures."""
+def test_check_deps_status_install_failure(install_mockery, monkeypatch):
spec, installer = create_installer('a')
# Make sure the package is identified as failed
- orig_fn = spack.database.Database.prefix_failed
monkeypatch.setattr(spack.database.Database, 'prefix_failed', _true)
with pytest.raises(inst.InstallError, match='install failure'):
installer._check_deps_status()
- monkeypatch.setattr(spack.database.Database, 'prefix_failed', orig_fn)
- # Ensure do not acquire the lock
+def test_check_deps_status_write_locked(install_mockery, monkeypatch):
+ spec, installer = create_installer('a')
+
+ # Ensure the lock is not acquired
monkeypatch.setattr(inst.PackageInstaller, '_ensure_locked', _not_locked)
with pytest.raises(inst.InstallError, match='write locked by another'):
installer._check_deps_status()
-@pytest.mark.tld
def test_check_deps_status_external(install_mockery, monkeypatch):
- """Test to cover _check_deps_status for external."""
spec, installer = create_installer('a')
- deps = spec.dependencies()
- assert len(deps) > 0
- dep_id = 'b'
-
- # Ensure the known dependent is installed if flagged as external
+ # Mock the known dependent, b, as external so assumed to be installed
monkeypatch.setattr(spack.spec.Spec, 'external', True)
installer._check_deps_status()
- assert dep_id in installer.installed
+ assert 'b' in installer.installed
-@pytest.mark.tld
def test_check_deps_status_upstream(install_mockery, monkeypatch):
- """Test to cover _check_deps_status for upstream."""
spec, installer = create_installer('a')
- deps = spec.dependencies()
- assert len(deps) > 0
- dep_id = 'b'
-
- # Ensure the known dependent, b, is installed if flagged as upstream
+ # Mock the known dependent, b, as installed upstream
monkeypatch.setattr(spack.package.PackageBase, 'installed_upstream', True)
installer._check_deps_status()
- assert dep_id in installer.installed
+ assert 'b' in installer.installed
def test_add_bootstrap_compilers(install_mockery, monkeypatch):
- """Test to cover _add_bootstrap_compilers."""
def _pkgs(pkg):
spec = spack.spec.Spec('mpi').concretized()
return [(spec.package, True)]
@@ -445,7 +539,6 @@ def test_installer_init_queue(install_mockery):
def test_install_task_use_cache(install_mockery, monkeypatch):
- """Test _install_task to cover use_cache path."""
spec, installer = create_installer('trivial-install-test-package')
task = create_build_task(spec.package)
@@ -454,25 +547,27 @@ def test_install_task_use_cache(install_mockery, monkeypatch):
assert spec.package.name in installer.installed
-def test_install_task_stop_iter(install_mockery, monkeypatch, capfd):
- """Test _install_task to cover the StopIteration exception."""
- mock_err_msg = 'mock stop iteration'
+def test_install_task_add_compiler(install_mockery, monkeypatch, capfd):
+ config_msg = 'mock add_compilers_to_config'
- def _raise(installer, pkg):
- raise StopIteration(mock_err_msg)
+ def _add(_compilers):
+ tty.msg(config_msg)
spec, installer = create_installer('a')
task = create_build_task(spec.package)
+ task.compiler = True
+ # Preclude any meaningful side-effects
monkeypatch.setattr(spack.package.PackageBase, 'unit_test_check', _true)
- monkeypatch.setattr(inst.PackageInstaller, '_setup_install_dir', _raise)
+ monkeypatch.setattr(inst.PackageInstaller, '_setup_install_dir', _noop)
+ monkeypatch.setattr(spack.build_environment, 'fork', _noop)
+ monkeypatch.setattr(spack.database.Database, 'add', _noop)
+ monkeypatch.setattr(spack.compilers, 'add_compilers_to_config', _add)
installer._install_task(task)
- out = capfd.readouterr()[0]
- assert mock_err_msg in out
- assert 'Package stage directory' in out
- assert spec.package.stage.source_path in out
+ out = capfd.readouterr()[0]
+ assert config_msg in out
def test_release_lock_write_n_exception(install_mockery, tmpdir, capsys):
@@ -529,8 +624,36 @@ def test_cleanup_all_tasks(install_mockery, monkeypatch):
assert len(installer.build_tasks) == 1
-def test_cleanup_failed(install_mockery, tmpdir, monkeypatch, capsys):
- """Test to increase coverage of _cleanup_failed."""
+def test_setup_install_dir_grp(install_mockery, monkeypatch, capfd):
+ """Test _setup_install_dir's group change."""
+ mock_group = 'mockgroup'
+ mock_chgrp_msg = 'Changing group for {0} to {1}'
+
+ def _get_group(spec):
+ return mock_group
+
+ def _chgrp(path, group):
+ tty.msg(mock_chgrp_msg.format(path, group))
+
+ monkeypatch.setattr(prefs, 'get_package_group', _get_group)
+ monkeypatch.setattr(fs, 'chgrp', _chgrp)
+
+ spec, installer = create_installer('trivial-install-test-package')
+
+ fs.touchp(spec.prefix)
+ metadatadir = spack.store.layout.metadata_path(spec)
+ # Should fail with a "not a directory" error
+ with pytest.raises(OSError, match=metadatadir):
+ installer._setup_install_dir(spec.package)
+
+ out = str(capfd.readouterr()[0])
+
+ expected_msg = mock_chgrp_msg.format(spec.prefix, mock_group)
+ assert expected_msg in out
+
+
+def test_cleanup_failed_err(install_mockery, tmpdir, monkeypatch, capsys):
+ """Test _cleanup_failed exception path."""
msg = 'Fake release_write exception'
def _raise_except(lock):
@@ -550,13 +673,14 @@ def test_cleanup_failed(install_mockery, tmpdir, monkeypatch, capsys):
assert msg in out
-def test_update_failed_no_mark(install_mockery):
- """Test of _update_failed sans mark and dependent build tasks."""
+def test_update_failed_no_dependent_task(install_mockery):
+ """Test _update_failed with missing dependent build tasks."""
spec, installer = create_installer('dependent-install')
- task = create_build_task(spec.package)
- installer._update_failed(task)
- assert installer.failed['dependent-install'] is None
+ for dep in spec.traverse(root=False):
+ task = create_build_task(dep.package)
+ installer._update_failed(task, mark=False)
+ assert installer.failed[task.pkg_id] is None
def test_install_uninstalled_deps(install_mockery, monkeypatch, capsys):
@@ -710,3 +834,12 @@ def test_install_dir_exists(install_mockery, monkeypatch, capfd):
installer.install()
assert 'b' in installer.installed
+
+
+def test_install_skip_patch(install_mockery, mock_fetch):
+ """Test the path skip_patch install path."""
+ spec, installer = create_installer('b')
+
+ installer.install(fake=False, skip_patch=True)
+
+ assert 'b' in installer.installed