def test_process()

in lib/ramble/spack/package.py [0:0]

• 56 lines of code
• 28 McCabe index (conditional complexity)

def test_process(pkg, kwargs):
    verbose = kwargs.get('verbose', False)
    externals = kwargs.get('externals', False)

    with pkg._setup_test(verbose, externals) as logger:
        if pkg.spec.external and not externals:
            print_test_message(
                logger, 'Skipped tests for external package', verbose)
            return

        # run test methods from the package and all virtuals it
        # provides virtuals have to be deduped by name
        v_names = list(set([vspec.name
                            for vspec in pkg.virtuals_provided]))

        # hack for compilers that are not dependencies (yet)
        # TODO: this all eventually goes away
        c_names = ('gcc', 'intel', 'intel-parallel-studio', 'pgi')
        if pkg.name in c_names:
            v_names.extend(['c', 'cxx', 'fortran'])
        if pkg.spec.satisfies('llvm+clang'):
            v_names.extend(['c', 'cxx'])

        test_specs = [pkg.spec] + [spack.spec.Spec(v_name)
                                   for v_name in sorted(v_names)]

        ran_actual_test_function = False
        try:
            with fsys.working_dir(pkg.test_suite.test_dir_for_spec(pkg.spec)):
                for spec in test_specs:
                    pkg.test_suite.current_test_spec = spec
                    # Fail gracefully if a virtual has no package/tests
                    try:
                        spec_pkg = spec.package
                    except spack.repo.UnknownPackageError:
                        continue

                    # copy installed test sources cache into test cache dir
                    if spec.concrete:
                        cache_source = spec_pkg.install_test_root
                        cache_dir = pkg.test_suite.current_test_cache_dir
                        if (os.path.isdir(cache_source) and
                                not os.path.exists(cache_dir)):
                            fsys.install_tree(cache_source, cache_dir)

                    # copy test data into test data dir
                    data_source = Prefix(spec_pkg.package_dir).test
                    data_dir = pkg.test_suite.current_test_data_dir
                    if (os.path.isdir(data_source) and
                            not os.path.exists(data_dir)):
                        # We assume data dir is used read-only
                        # maybe enforce this later
                        shutil.copytree(data_source, data_dir)

                    # grab the function for each method so we can call
                    # it with the package
                    test_fn = spec_pkg.__class__.test
                    if not isinstance(test_fn, types.FunctionType):
                        test_fn = test_fn.__func__

                    # Skip any test methods consisting solely of 'pass'
                    # since they do not contribute to package testing.
                    source = (inspect.getsource(test_fn)).splitlines()[1:]
                    lines = (ln.strip() for ln in source)
                    statements = [ln for ln in lines if not ln.startswith('#')]
                    if len(statements) > 0 and statements[0] == 'pass':
                        continue

                    # Run the tests
                    ran_actual_test_function = True
                    context = logger.force_echo if verbose else nullcontext
                    with context():
                        test_fn(pkg)

            # If fail-fast was on, we error out above
            # If we collect errors, raise them in batch here
            if pkg.test_failures:
                raise TestFailure(pkg.test_failures)

        finally:
            # flag the package as having been tested (i.e., ran one or more
            # non-pass-only methods
            if ran_actual_test_function:
                fsys.touch(pkg.tested_file)
            else:
                print_test_message(logger, 'No tests to run', verbose)