codecraftai-testplus 1.2.0__py3-none-any.whl

ccai/testplus/cli/cmdtree/testing/run.py

@@ -0,0 +1,371 @@
+"""
+    .. module:: run
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: CLI command used to execute collections of tests via the
+    TestPlus framework.
+
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+from typing import List
+
+import os
+import sys
+
+import click
+
+from ccai.interfaces.itestjob import ITestJob
+from ccai.xmodules.xlogging.levels import LOG_LEVEL_NAMES
+from ccai.xmodules.xlogging.enhancedloggers import getEnhancedLogger
+
+from ccai.testplus.cli.cmdtree.testing.constants import (
+    HELP_ROOT,
+    HELP_EXCLUDES,
+    HELP_INCLUDES,
+    HELP_OUTPUT,
+    HELP_START,
+    HELP_BRANCH,
+    HELP_BUILD,
+    HELP_FLAVOR,
+    HELP_JOB_ID,
+    HELP_JOB_INITIATOR,
+    HELP_JOB_LABEL,
+    HELP_JOB_NAME,
+    HELP_JOB_OWNER,
+    HELP_RUNID,
+    HELP_CONSOLE_LOG_LEVEL,
+    HELP_FILE_LOG_LEVEL,
+    HELP_DEBUGGER,
+    HELP_BREAKPOINT,
+    HELP_PRERUN_DIAGNOSTIC,
+    HELP_POSTRUN_DIAGNOSTIC,
+    HELP_INCLUDE_MARKER_EXP,
+    HELP_EXCLUDE_MARKER_EXP
+)
+
+from ccai.testplus.cli.cmdtree.testing.constants import (
+    HELP_CONFIG_NAME,
+    HELP_CREDENTIAL,
+    HELP_CREDENTIAL_NAMES,
+    HELP_CREDENTIAL_SOURCES,
+    HELP_DEFAULT_CONFIGS,
+    HELP_LANDSCAPE,
+    HELP_LANDSCAPE_NAMES,
+    HELP_LANDSCAPE_SOURCES,
+    HELP_RUNTIME,
+    HELP_RUNTIME_NAMES,
+    HELP_RUNTIME_SOURCES,
+    HELP_TOPOLOGY,
+    HELP_TOPOLOGY_NAMES,
+    HELP_TOPOLOGY_SOURCES,
+    HELP_PRERUN_DIAGNOSTIC,
+    HELP_POSTRUN_DIAGNOSTIC,
+    CONFIGURATION_CHOICES
+)
+
+@click.command("run", help="Command used to run collections of tests.")
+@click.option("--root", default=None,  type=str, required=False, help=HELP_ROOT)
+@click.option("--excludes", "-x", multiple=True, required=False, help=HELP_EXCLUDES)
+@click.option("--includes", "-i", multiple=True, help=HELP_INCLUDES)
+@click.option("--output", "-o", default=None, required=False, help=HELP_OUTPUT)
+@click.option("--start", default=None, required=False, help=HELP_START)
+@click.option("--runid", default=None, required=False, help=HELP_RUNID)
+@click.option("--branch", default=None, required=False, help=HELP_BRANCH)
+@click.option("--build", default=None, required=False, help=HELP_BUILD)
+@click.option("--flavor", default=None, required=False, help=HELP_FLAVOR)
+@click.option("--job-id", default=None, required=False, help=HELP_JOB_ID)
+@click.option("--job-initiator", default=None, required=False, help=HELP_JOB_INITIATOR)
+@click.option("--job-label", default=None, required=False, help=HELP_JOB_LABEL)
+@click.option("--job-name", default=None, required=False, help=HELP_JOB_NAME)
+@click.option("--job-owner", default=None, required=False, help=HELP_JOB_OWNER)
+@click.option("--default-configs", "default_configs", multiple=True, default=None, required=False, type=click.Choice(CONFIGURATION_CHOICES), help=HELP_DEFAULT_CONFIGS)
+@click.option("--config-name", "config_name", multiple=False, default=None, required=False, help=HELP_CONFIG_NAME)
+@click.option("--credential", "credential_files", multiple=True, default=None, required=False, help=HELP_CREDENTIAL)
+@click.option("--credential-name", "credential_names", multiple=True, default=None, required=False, help=HELP_CREDENTIAL_NAMES)
+@click.option("--credential-source", "credential_sources", multiple=True, default=None, required=False, help=HELP_CREDENTIAL_SOURCES)
+@click.option("--landscape", "landscape_files", multiple=True, default=None, required=False, help=HELP_LANDSCAPE)
+@click.option("--landscape-name", "landscape_names", multiple=True, default=None, required=False, help=HELP_LANDSCAPE_NAMES)
+@click.option("--landscape-source", "landscape_sources", multiple=True, default=None, required=False, help=HELP_LANDSCAPE_SOURCES)
+@click.option("--runtime", "runtime_files", multiple=True, default=None, required=False, help=HELP_RUNTIME)
+@click.option("--runtime-name", "runtime_names", multiple=True, default=None, required=False, help=HELP_RUNTIME_NAMES)
+@click.option("--runtime-source", "runtime_sources", multiple=True, default=None, required=False, help=HELP_RUNTIME_SOURCES)
+@click.option("--topology", "topology_files", multiple=True, default=None, required=False, help=HELP_TOPOLOGY)
+@click.option("--topology-name", "topology_names", multiple=True, default=None, required=False, help=HELP_TOPOLOGY_NAMES)
+@click.option("--topology-source", "topology_sources", multiple=True, default=None, required=False, help=HELP_TOPOLOGY_SOURCES)
+@click.option("--console-level", default=None, required=False, type=click.Choice(LOG_LEVEL_NAMES, case_sensitive=False), help=HELP_CONSOLE_LOG_LEVEL)
+@click.option("--logfile-level", default=None, required=False, type=click.Choice(LOG_LEVEL_NAMES, case_sensitive=False), help=HELP_FILE_LOG_LEVEL)
+@click.option("--debugger", default=None, required=False, type=click.Choice(['pdb', 'debugpy']), help=HELP_DEBUGGER)
+@click.option("--breakpoint", "breakpoints", default=None, required=False, multiple=True, type=click.Choice(['test-discovery', 'testrun-start']), help=HELP_BREAKPOINT)
+@click.option("--prerun-diagnostic", is_flag=True, default=False, required=False, help=HELP_PRERUN_DIAGNOSTIC)
+@click.option("--postrun-diagnostic", is_flag=True, default=False, required=False, help=HELP_POSTRUN_DIAGNOSTIC)
+@click.option("--include-marker-exp", required=False, multiple=True, help=HELP_INCLUDE_MARKER_EXP)
+@click.option("--exclude-marker-exp", required=False, multiple=True, help=HELP_EXCLUDE_MARKER_EXP)
+def command_testplus_testing_run(root, includes, excludes, output, start, runid, branch, build, flavor, job_id, job_initiator,
+                        job_label, job_name, job_owner, default_configs, config_name, credential_files, credential_names, credential_sources,
+                        landscape_files, landscape_names, landscape_sources, runtime_files, runtime_names, runtime_sources,
+                        topology_files, topology_names, topology_sources, console_level, logfile_level,
+                        debugger, breakpoints, prerun_diagnostic, postrun_diagnostic, include_marker_exp,
+                        exclude_marker_exp):
+    """
+        Executes a collection of tests using the TestPlus framework.
+
+        :param root: Root directory used when scanning for tests.
+        :param includes: Test inclusion expressions.
+        :param excludes: Test exclusion expressions.
+
+        :returns: ``None``
+    """
+
+    # The click options below are declared multiple=True, so these arrive as
+    # immutable tuples; copy them into lists before appending the config name.
+    landscape_names = list(landscape_names)
+    topology_names = list(topology_names)
+
+    if config_name is not None:
+        if config_name not in landscape_names:
+            landscape_names.append(config_name)
+        if config_name not in topology_names:
+            topology_names.append(config_name)
+
+    # pylint: disable=unused-import,import-outside-toplevel
+
+    # We do the imports of the automation framework code inside the action functions because
+    # we don't want to startup loggin and the processing of inputs and environment variables
+    # until we have entered an action method.  Thats way we know how to setup the environment.
+
+    # IMPORTANT: We need to load the context first because it will trigger the loading
+    # of the default user configuration
+
+    from ccai.thisapp.contextpaths import ContextPaths
+    from ccai.thisapp.wellknown import ThisApplicationSingleton
+
+    from ccai.xmodules.xpython import prepend_python_path
+
+    from ccai.thisapp.runtimevariables import RuntimeVariables, RuntimeVariablesDesc
+
+    from ccai.runtime.optionoverrides import AM_RUNTIME_OPTION_OVERRIDES
+    from ccai.configuration.optionoverrides import ConfigOptionOverrides
+
+    # STEP 1 - Initialize the Runtime (Performed by the root command)
+    
+    # STEP 2 - Resolve the configuration variables (Performed by the root command)
+
+    # STEP 3 - Apply any 'Configuration' related option overrides
+
+    this_app = ThisApplicationSingleton()
+
+    # We need to default these to 'None' so they do not effect the runtime behavior unless
+    # this command explicitly sets them later.
+    use_credentials = None
+    use_landscape = None
+    use_runtime = None
+    use_topology = None
+
+    if "all" in default_configs:
+        use_credentials = True
+        use_landscape = True
+        use_runtime = True
+        use_topology = True
+    else:
+        if "credentials" in default_configs:
+            use_credentials = True
+        if "landscape" in default_configs:
+            use_landscape = True
+        if "runtime" in default_configs:
+            use_runtime = True
+        if "topology" in default_configs:
+            use_topology = True
+
+    from ccai.testbase.markers import MetaFilter, parse_marker_expression
+
+    if len(credential_files) > 0:
+        use_credentials = True
+        ConfigOptionOverrides.override_config_credentials_files(credential_files)
+
+    if len(credential_names) > 0:
+        use_credentials = True
+        ConfigOptionOverrides.override_config_credentials_names(credential_names)
+
+    if len(credential_sources) > 0:
+        use_credentials = True
+        ConfigOptionOverrides.override_config_credentials_sources(credential_sources)
+
+
+    if len(landscape_files) > 0:
+        use_landscape = True
+        ConfigOptionOverrides.override_config_landscape_files(landscape_files)
+
+    if len(landscape_names) > 0:
+        use_landscape = True
+        ConfigOptionOverrides.override_config_landscape_names(landscape_names)
+
+    if len(landscape_sources) > 0:
+        use_landscape = True
+        ConfigOptionOverrides.override_config_landscape_sources(landscape_sources)
+
+
+    if len(runtime_files) > 0:
+        use_runtime = True
+        ConfigOptionOverrides.override_config_runtime_files(runtime_files)
+
+    if len(runtime_names) > 0:
+        use_runtime = True
+        ConfigOptionOverrides.override_config_runtime_names(runtime_names)
+
+    if len(runtime_sources) > 0:
+        use_runtime = True
+        ConfigOptionOverrides.override_config_runtime_sources(runtime_sources)
+
+
+    if len(topology_files) > 0:
+        use_topology = True
+        ConfigOptionOverrides.override_config_topology_files(topology_files)
+
+    if len(topology_names) > 0:
+        use_topology = True
+        ConfigOptionOverrides.override_config_topology_names(topology_names)
+
+    if len(topology_sources) > 0:
+        use_topology = True
+        ConfigOptionOverrides.override_config_topology_sources(topology_sources)
+
+
+    # STEP 4 - Resolve the Configuration Maps
+    from ccai.configuration.configurationmaps import resolve_configuration_maps
+    resolve_configuration_maps(use_credentials=use_credentials, use_landscape=use_landscape,
+                               use_runtime=use_runtime, use_topology=use_topology)
+
+
+    # STEP 5 - The application of the remaining options must happen after we have resolved configuration
+    # maps because some of those settings will get overridden by the options.  So the runtime
+    # needs to be loaded and set first before we apply runtime options 
+
+    if prerun_diagnostic:
+        this_app.override_variable_value(RuntimeVariablesDesc.AM_DIAGNOSTICS_PRERUN, {})
+
+    if postrun_diagnostic:
+        this_app.override_variable_value(RuntimeVariablesDesc.AM_DIAGNOSTICS_POSTRUN, {})
+
+    if branch is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_build_branch(branch)
+
+    if build is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_build_name(build)
+
+    if flavor is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_build_flavor(flavor)
+
+
+    if job_id is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_job_id(job_id)
+
+    if job_initiator is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_job_initiator(job_initiator)
+
+    if job_label is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_job_label(job_label)
+
+    if job_name is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_job_name(job_name)
+
+    if job_owner is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_job_owner(job_owner)
+
+    if console_level is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_loglevel_console(console_level)
+
+    if logfile_level is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_loglevel_file(logfile_level)
+
+    if output is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_output_directory(output)
+
+    if start is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_starttime(start)
+
+    if runid is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_run_id(runid)
+
+    # The '--breakpoint' option is declared multiple=True, so click delivers an
+    # empty tuple rather than None when it is not given.  Only a non-empty
+    # selection is a request to break, so only then override the breakpoints
+    # and fall back to a default debugger.
+    if breakpoints is not None and len(breakpoints) > 0:
+        AM_RUNTIME_OPTION_OVERRIDES.override_debug_breakpoints(breakpoints)
+
+        # If a breakpoint was passed but the debugger was not, fall back to
+        # 'debugpy' as the default debugger.
+        if debugger is None:
+            AM_RUNTIME_OPTION_OVERRIDES.override_debug_debugger('debugpy')
+
+    if debugger is not None:
+        AM_RUNTIME_OPTION_OVERRIDES.override_debug_debugger(debugger)
+
+    # TODO: Handle 'root' parameter better
+    if root is None:
+        if RuntimeVariables.AM_TESTROOT is not None:
+            root = RuntimeVariables.AM_TESTROOT
+        else:
+            root = "."
+
+    test_root = os.path.abspath(os.path.expandvars(os.path.expanduser(root)))
+    if not os.path.isdir(test_root):
+        errmsg = "The specified root folder does not exist. root=%s" % root
+        if test_root != root:
+            errmsg += " expanded=%s" % test_root
+        raise click.BadParameter(errmsg)
+
+    AM_RUNTIME_OPTION_OVERRIDES.override_testroot(root)
+
+    # Make sure we extend PATH to include the test roots parent folder so imports will
+    # work properly.
+    test_root_parent = os.path.dirname(test_root)
+    prepend_python_path(test_root_parent)
+
+    metafilters: List[MetaFilter] = []
+    for imexp in include_marker_exp:
+        imexp = imexp.strip("\"")
+        imexp = imexp.strip("'")
+        mfilter = parse_marker_expression("+" + imexp)
+        metafilters.append(mfilter)
+
+    for exmexp in exclude_marker_exp:
+        exmexp = exmexp.strip("\"")
+        exmexp = exmexp.strip("'")
+        mfilter = parse_marker_expression("-" + exmexp)
+        metafilters.append(mfilter)
+
+
+    # STEP 6 - Initialize the Results Output
+
+    # Initialize testplus results and logging
+    from ccai.testplus.initialize import initialize_testplus_results
+
+    initialize_testplus_results()
+
+    logger = getEnhancedLogger()
+
+
+    # STEP 7 - Create and kick off the job
+
+    from ccai.thisapp.wellknown import ConfiguredSuperFactorySingleton
+    from ccai.testbase.factoryprotocols import TestBaseFactoryProtocol
+
+    # At this point in the code, we either lookup an existing test job or we create a test job
+    # from the includes, excludes or test_module
+    sfactory = ConfiguredSuperFactorySingleton()
+    TestJobType = sfactory.get_override_types_by_order(TestBaseFactoryProtocol.get_testbase_default_job_type)
+
+    tjob: ITestJob
+
+    result_code = 0
+    with TestJobType(logger, test_root, includes=includes, excludes=excludes, metafilters=metafilters) as tjob:
+        result_code = tjob.execute()
+
+    sys.exit(result_code)
+
+    return

ccai/testplus/cli/testplus_command.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""
+    .. module:: testplus_command
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: The script entrypoint for the 'testplus' command.
+
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+
+import click
+
+from ccai.thisapp.wellknown import ThisApplicationSingleton
+
+from ccai.thisapp.runtimevariables import RuntimeVariablesDesc
+
+from ccai.testplus.cli.cmdtree.testing import group_testplus_testing
+
+from ccai.testplus.initialize import initialize_testplus_runtime
+
+@click.group("testplus", help="Run and inspect distributed, multi-host tests.")
+@click.option('-v', '--verbose', count=True, help="Set the verbosity level.")
+def testplus_root_command(verbose):
+    """
+        Entry point for the ``testplus`` command line interface.
+
+        :param int verbose: Verbosity level specified by ``-v`` or ``--verbose``.
+
+        :returns: ``None``
+    """
+
+    initialize_testplus_runtime()
+    
+    interactive_console = False
+    log_level_console = "WARNING"
+
+    if verbose == 0:
+        interactive_console = True
+    else:
+        interactive_console = False
+
+        if verbose == 1:
+            log_level_console = "INFO"
+        elif verbose == 2:
+            log_level_console = "DEBUG"
+        elif verbose > 2:
+            log_level_console = "NOTSET"
+
+    this_app = ThisApplicationSingleton()
+
+    this_app.override_variable_value(RuntimeVariablesDesc.AM_INTERACTIVE_CONSOLE, interactive_console)
+    this_app.override_variable_value(RuntimeVariablesDesc.AM_LOG_LEVEL_CONSOLE, log_level_console)
+
+    return
+
+
+# NOTE: testbase's 'services' and 'utilities' groups are deliberately NOT
+# mounted here.  This root command is still a click group, while testbase's
+# command tree has been migrated to arcli, and click cannot dispatch to an
+# arcli command: click's Group.invoke calls cmd.make_context() and its help
+# formatter reads cmd.hidden, neither of which an arcli GroupingCommand has.
+#
+# Mounting them raised AttributeError on EVERY use -- 'testplus services',
+# 'testplus utilities', any subcommand of either, and 'testplus --help'
+# itself, because formatting the root help walks every registered command.
+# So they contributed no working functionality while breaking root help.
+#
+# Those commands remain available through the 'testbase' entry point, which
+# is installed alongside this one (testplus depends on testbase).  Mount them
+# here again only once this root command is itself migrated to arcli.
+testplus_root_command.add_command(group_testplus_testing)
+
+
+if __name__ == '__main__':
+    testplus_root_command()

ccai/testplus/distributedtestjob.py

@@ -0,0 +1,90 @@
+"""
+    .. module:: distributedtestjob
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: Module containing the :class:`DistributedTestJob` class which is the
+               TestPlus parent container for distributed (multi-host) test runs.
+
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+
+from ccai.landscaping.testing.testjob import LandscapeTestJob
+
+from ccai.testplus.distributedtestsequencer import DistributedTestSequencer
+
+
+class DistributedTestJob(LandscapeTestJob):
+    """
+        TestPlus parent container for a distributed test run.
+
+        Layered inheritance:
+
+        * :class:`ccai.testbase.testjob.TestJob` — single-host base
+          (lifecycle, recorder, sequencer factory, properties, ``execute``);
+          standalone-default seams (stdout recorder).
+        * :class:`ccai.integrationruntime.integratedtestjob.IntegratedTestJob` —
+          integration tier: JSOS/HTML/presence-folder result recording and run
+          metadata sourced from ``RuntimeVariables``.
+        * :class:`ccai.landscaping.testing.testjob.LandscapeTestJob` —
+          the landscaping tier: supplies the landscape singleton and carries
+          the landscape-activation lifecycle on the two attachment hooks
+          (``activate_configuration`` / ``activate_integration`` /
+          ``activate_operations``, ``collect_resources``,
+          ``establish_presence``).
+        * :class:`DistributedTestJob` (this class) — constructs a
+          :class:`DistributedTestSequencer` so the sequencer's
+          ``attach_to_environment`` / ``attach_to_framework`` methods accept
+          the landscape and so distributed-test scheduling primitives become
+          available.
+
+        Single Instance.  Setup Test Landscape.  Jobs have an expected number
+        of tests based on includes / excludes.  Collects and organises results
+        across hosts.  Can be subclassed to customise the sequencing of test
+        packs across distributed infrastructure.
+    """
+
+    # Derived jobs set these to indicate that the test framework must load the
+    # corresponding configuration maps before the run (opt-in; default False).
+    # ``distributed_test_entrypoint`` reads them to call ``resolve_configuration_maps``.
+    requires_credentials = False
+    requires_landscape = False
+    requires_runtime = False
+    requires_topology = False
+
+    def _create_sequencer(self) -> DistributedTestSequencer:
+        """
+            Hook used by :meth:`TestJob.execute` to construct the test
+            sequencer for this job.  Returns a
+            :class:`DistributedTestSequencer` so the sequencer's
+            ``attach_to_environment`` / ``attach_to_framework`` methods
+            accept the landscape supplied by
+            :class:`LandscapeTestJob`.
+
+            :returns: A :class:`DistributedTestSequencer` configured with
+                      this job's title, test root, includes / excludes,
+                      metafilters, and ``job_seed`` for reproducible
+                      property-based testing.
+        """
+        inst = DistributedTestSequencer(
+            self._title,
+            self._testroot,
+            includes=self.includes,
+            excludes=self.excludes,
+            metafilters=self.metafilters,
+            job_seed=self.job_seed,
+            output_context=self._output_context,
+        )
+        return inst
+
+
+class DefaultDistributedTestJob(DistributedTestJob):
+    """
+        The :class:`DefaultDistributedTestJob` is utilized as a job container when a
+        job was not specified.
+    """
+    name = "Test Job"
+    description = "Unspecified test job."

ccai/testplus/distributedtestsequencer.py

@@ -0,0 +1,111 @@
+"""
+    .. module:: distributedtestsequencer
+    :platform: Darwin, Linux, Unix, Windows
+    :synopsis: Module containing the :class:`DistributedTestSequencer` type which is use to control
+    the flow of the automation environment startup and test execution sequence for a distributed
+    automation environment.
+
+    .. moduleauthor:: Myron Walker <myron.walker@gmail.com>
+"""
+
+__author__ = "Myron Walker"
+__copyright__ = "Copyright 2025, Code Craft AI LLC"
+__credits__ = []
+
+
+from typing import List, Optional, Sequence
+
+import collections
+import json
+import os
+import sys
+
+from ccai.thisapp.paths import get_path_for_output
+
+from ccai.testbase.coupling.integrationcoupling import IntegrationCoupling
+from ccai.testbase.markers import MetaFilter
+
+from ccai.landscaping.landscape import Landscape
+
+from ccai.testbase.output.outputcontext import IOutputContext
+from ccai.testbase.sequencing.testsequencer import TestSequencer
+
+
+class DistributedTestSequencer(TestSequencer):
+    """
+        The :class:`DistributedTestSequencer` is a state machine that helps to orchestrate the flow fo the test run.  It ensures
+        that the steps of the test flow are consistent between runs.
+    """
+
+    def __init__(self, jobtitle: str, root: str, includes: Sequence[str], excludes: Sequence[str], metafilters: List[MetaFilter], job_seed: int = None,
+                 output_context: Optional[IOutputContext] = None):
+        """
+            Creates a 'TestSequencer' object which is used to discover the tests and control the flow of a test run.
+
+            :param jobtitle: The name of the test job.
+            :param root: The path to the root folder that is the base of the tests.
+            :param includes: List of expressions used to determine which tests to include.
+            (scope):(package).(package)@(module)#(testname)
+            :param excludes: List of expressions used to determine which tests to exclued from the included tests.
+            :param metafilters: List of expressions used to filter tests by metadata
+            :param job_seed: Job-level seed forwarded to the parent :class:`TestSequencer` for
+                             reproducible property-based testing.
+            :param output_context: The :class:`IOutputContext` forwarded to the parent
+                                   :class:`TestSequencer` for resolving artefact directories.
+        """
+        super().__init__(jobtitle=jobtitle, root=root, includes=includes, excludes=excludes, metafilters=metafilters, job_seed=job_seed,
+                         output_context=output_context)
+
+        self._landscape = None
+        return
+
+    def attach_to_framework(self, landscape: Landscape):
+        """
+            Goes through all the integrations and provides them with an opportunity to
+            attach to the test environment.
+        """
+
+        self._landscape = landscape
+
+        integ_type: IntegrationCoupling
+
+        for _, integ_type in self._integrations.items():
+            integ_type.attach_to_framework(landscape=landscape)
+
+        return
+
+    def attach_to_environment(self, landscape):
+        """
+            Goes through all the integrations and provides them with an opportunity to
+            attach to the test environment.
+        """
+
+        results_dir = get_path_for_output()
+
+        environment_dict = self.create_password_masked_environment()
+
+        package_dict = collections.OrderedDict()
+
+        package_names = [k for k in sys.modules.keys()]
+        package_names.sort()
+        for pname in package_names:
+            nxtmod = sys.modules[pname]
+            if pname.find(".") == -1 and hasattr(nxtmod, "__file__"):
+                package_dict[pname] = nxtmod.__file__
+
+        startup_dict = collections.OrderedDict([
+            ("command", " ".join(sys.argv)),
+            ("environment", environment_dict),
+            ("packages", package_dict)
+        ])
+
+        startup_full = os.path.join(results_dir, "startup-configuration.json")
+        with open(startup_full, 'w') as suf:
+            json.dump(startup_dict, suf, indent=True)
+
+        integ_type: IntegrationCoupling
+
+        for _, integ_type in self._integrations.items():
+            integ_type.attach_to_environment(landscape=landscape)
+
+        return