pybuilder-integration 102__tar.gz → 105__tar.gz

{pybuilder_integration-102 → pybuilder_integration-105}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pybuilder-integration
-Version: 102
+Version: 105
 Summary: A pybuilder plugin that runs integration tests (Tavern & Cypress) against a target.
 Home-page: https://github.com/rspitler/pybuilder-integration
 Author: 
@@ -13,5 +13,11 @@ Classifier: Programming Language :: Python
 Requires-Dist: pytest
 Requires-Dist: tavern==1.25.2
 Requires-Dist: boto3
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 A pybuilder plugin that runs integration tests against a target.  This is intended to be a broader scope than unit-tests encompassing dependant functionality.

{pybuilder_integration-102 → pybuilder_integration-105}/pybuilder_integration/__init__.py

@@ -1,9 +1,10 @@
+import json
 import os
 
 from pybuilder.core import task, Project, Logger, depends, after, init
 from pybuilder.reactor import Reactor
 
-import pybuilder_integration.tasks
+import pybuilder_integration.tasks as tasks
 from pybuilder_integration.properties import *
 
 
@@ -18,6 +19,17 @@ def init_plugin(project):
     project.plugin_depends_on("pytest")
     project.build_depends_on('pytest-xdist')
     project.plugin_depends_on("tavern")
+    _apply_integration_properties_file(project)
+
+
+def _apply_integration_properties_file(project):
+    properties_file = os.environ.get(SUBPROCESS_PROPERTIES_FILE_ENV)
+    if not properties_file or not os.path.exists(properties_file):
+        return
+    with open(properties_file) as fp:
+        properties = json.load(fp)
+    for key, value in properties.items():
+        project.set_property(key, value)
 
 
 @task(description="Runs integration tests against a CI/Prod environment."
@@ -34,6 +46,16 @@ def verify_environment(project: Project, logger: Logger, reactor: Reactor):
     tasks.verify_environment(project, logger, reactor)
 
 
+@task(description="Run current build integration tests only. Intended for verify_environment subprocesses.")
+def verify_environment_current(project: Project, logger: Logger, reactor: Reactor):
+    tasks._verify_environment_current(project, logger, reactor)
+
+
+@task(description="Run downloaded LATEST integration tests only. Intended for verify_environment subprocesses.")
+def verify_environment_latest(project: Project, logger: Logger, reactor: Reactor):
+    tasks._verify_environment_latest(project, logger, reactor)
+
+
 @task(description="Run integration tests using a cypress spec. Requires NPM installed.\n"
                   f"\t{INTEGRATION_TARGET_URL} - (required) Full URL target for cypress tests\n"
                   f"\t{INTEGRATION_PUBLIC_TARGET_URL} - (required) Full public URL target for cypress tests\n"

{pybuilder_integration-102 → pybuilder_integration-105}/pybuilder_integration/artifact_manager.py

@@ -8,7 +8,7 @@ from pybuilder.reactor import Reactor
 
 from pybuilder_integration import exec_utility
 from pybuilder_integration.directory_utility import get_latest_distribution_directory, \
-    get_latest_zipped_distribution_directory
+    get_latest_zipped_distribution_directory, read_tavern_service_markers, write_tavern_manifest
 from pybuilder_integration.properties import *
 
 
@@ -200,13 +200,21 @@ def _unzip_downloaded_artifacts(dir_with_zips: str, destination: str, logger: Lo
         os.makedirs(consolidated_folder, exist_ok=True)
         logger.debug(f"Creating role file for log retrieval {consolidated_folder}/roles")
         open(f"{consolidated_folder}/roles", 'w').close()
+        consolidated_markers = set()
+        has_tavern_manifest = False
         for dirn in os.listdir(f"{destination}/tavern"):
             if "consolidated" != dirn:
                 logger.debug(f"Consolidating directory: {dirn}")
+                markers = read_tavern_service_markers(f"{destination}/tavern/{dirn}")
+                if markers is not None:
+                    has_tavern_manifest = True
+                    consolidated_markers.update(markers)
                 shutil.copytree(f"{destination}/tavern/{dirn}", consolidated_folder, dirs_exist_ok=True)
                 shutil.rmtree(f"{destination}/tavern/{dirn}")
                 with open(f"{consolidated_folder}/roles", "a") as fp:
-                    fp.writelines(dirn)
+                    fp.write(f"{dirn}\n")
+        if has_tavern_manifest:
+            write_tavern_manifest(consolidated_folder, consolidated_markers)
     return destination
 
 

pybuilder_integration-105/pybuilder_integration/directory_utility.py

@@ -0,0 +1,168 @@
+import json
+import os
+import re
+import shutil
+import tempfile
+
+
+TAVERN_MANIFEST_DIRECTORY = ".pybuilder-integration"
+TAVERN_MANIFEST_FILENAME = "tavern-manifest.json"
+_TAVERN_MARKER_EXCLUSIONS = {"parametrize", "skip", "skipif", "usefixtures", "xfail"}
+
+
+def prepare_reports_directory(project):
+    return prepare_directory("$dir_reports", project)
+
+
+def prepare_logs_directory(project):
+    return prepare_directory("$dir_logs", project)
+
+
+def prepare_dist_directory(project):
+    return prepare_directory("$dir_dist", project)
+
+
+def prepare_directory(dir_variable, project):
+    package__format = f"{dir_variable}/integration"
+    reports_dir = project.expand_path(package__format)
+    return _ensure_directory_exists(reports_dir)
+
+
+def _ensure_directory_exists(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+    return path
+
+
+def get_working_distribution_directory(project):
+    dist_directory = prepare_dist_directory(project)
+    return _ensure_directory_exists(f"{dist_directory}/working")
+
+
+def get_latest_distribution_directory(project):
+    dist_directory = prepare_dist_directory(project)
+    from pybuilder_integration import ENVIRONMENT
+    environment = project.get_mandatory_property(ENVIRONMENT)
+    return _ensure_directory_exists(f"{dist_directory}/LATEST-{environment}")
+
+
+def get_latest_zipped_distribution_directory(project):
+    dist_directory = prepare_dist_directory(project)
+    from pybuilder_integration import ENVIRONMENT
+    environment = project.get_mandatory_property(ENVIRONMENT)
+    return _ensure_directory_exists(f"{dist_directory}/LATEST-{environment}/zipped")
+
+
+def get_local_zip_artifact_path(tool, project, include_ending=False):
+    artifact = f"{prepare_dist_directory(project)}/{tool}-{project.name}"
+    if include_ending:
+        return f"{artifact}.zip"
+    return artifact
+
+
+def get_tavern_manifest_path(test_dir):
+    return os.path.join(test_dir, TAVERN_MANIFEST_DIRECTORY, TAVERN_MANIFEST_FILENAME)
+
+
+def collect_tavern_service_markers(test_dir):
+    markers = set()
+    for root, _, files in os.walk(test_dir):
+        for filename in files:
+            if filename.endswith(".tavern.yaml"):
+                markers.update(_collect_markers_from_tavern_file(os.path.join(root, filename)))
+    return sorted(markers)
+
+
+def write_tavern_manifest(test_dir, service_markers=None):
+    manifest_path = get_tavern_manifest_path(test_dir)
+    manifest_directory = os.path.dirname(manifest_path)
+    os.makedirs(manifest_directory, exist_ok=True)
+    if service_markers is None:
+        service_markers = collect_tavern_service_markers(test_dir)
+    manifest_content = json.dumps({"service_markers": sorted(service_markers)}).encode("utf-8")
+    descriptor, temporary_path = tempfile.mkstemp(prefix=".tavern-manifest-", dir=manifest_directory)
+    try:
+        bytes_written = 0
+        while bytes_written < len(manifest_content):
+            written = os.write(descriptor, manifest_content[bytes_written:])
+            if written == 0:
+                raise OSError("Could not write Tavern marker manifest")
+            bytes_written += written
+        os.close(descriptor)
+        descriptor = None
+        os.replace(temporary_path, manifest_path)
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+        if os.path.exists(temporary_path):
+            os.unlink(temporary_path)
+
+
+def read_tavern_service_markers(test_dir):
+    manifest_path = get_tavern_manifest_path(test_dir)
+    if not os.path.exists(manifest_path):
+        return None
+    try:
+        with open(manifest_path) as manifest_file:
+            manifest = json.load(manifest_file)
+    except (OSError, ValueError):
+        return None
+    markers = manifest.get("service_markers", [])
+    if not isinstance(markers, list) or not all(isinstance(marker, str) for marker in markers):
+        return None
+    return set(markers)
+
+
+def _collect_markers_from_tavern_file(path):
+    markers = set()
+    in_marks = False
+    marks_indent = 0
+    with open(path) as tavern_file:
+        for line in tavern_file:
+            match = re.match(r"^(\s*)marks:\s*(.*)$", line)
+            if match:
+                in_marks = True
+                marks_indent = len(match.group(1))
+                inline_markers = match.group(2).strip()
+                if inline_markers.startswith("[") and inline_markers.endswith("]"):
+                    for marker in inline_markers[1:-1].split(","):
+                        _add_tavern_marker(markers, marker)
+                continue
+            if not in_marks:
+                continue
+            if not line.strip() or line.lstrip().startswith("#"):
+                continue
+            indent = len(line) - len(line.lstrip())
+            if indent <= marks_indent:
+                in_marks = False
+                continue
+            marker = re.match(r"^\s*-\s*(.+?)\s*(?:#.*)?$", line)
+            if marker:
+                _add_tavern_marker(markers, marker.group(1))
+    return markers
+
+
+def _add_tavern_marker(markers, value):
+    marker = value.strip().strip("'\"")
+    if re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", marker) and marker not in _TAVERN_MARKER_EXCLUSIONS:
+        markers.add(marker)
+
+
+def package_artifacts(project, test_dir, tool, role):
+    # Make a copy for easy access in environment validation
+    working_dir = get_working_distribution_directory(project)
+    shutil.copytree(test_dir, f"{working_dir}/{tool}",dirs_exist_ok=True)
+    if tool == "tavern":
+        write_tavern_manifest(f"{working_dir}/{tool}")
+    with tempfile.TemporaryDirectory() as tempdir:
+        shutil.copytree(test_dir, f"{tempdir}/{role}",dirs_exist_ok=True)
+        if tool == "tavern":
+            write_tavern_manifest(f"{tempdir}/{role}")
+        # package a copy for distribution
+        # zip up the test and add them to the integration test dist directory
+        base_name = get_local_zip_artifact_path(tool=tool, project=project)
+        shutil.make_archive(base_name=base_name,
+                            base_dir=role,
+                            format="zip",
+                            root_dir=tempdir)
+

{pybuilder_integration-102 → pybuilder_integration-105}/pybuilder_integration/properties.py

@@ -17,4 +17,8 @@ APPLICATION = "application"
 APPLICATION_GROUP = "application_group"
 RUN_PARALLEL = "pytest_parallel"
 CONSOLIDATE_TESTS = "consolidate_tavern"
+SKIP_NON_MATCHING_TAVERN_ARTIFACTS = "skip_non_matching_tavern_artifacts"
 TESTING_SCOPE = "testing_scope"
+PARALLEL_VERIFY_ENVIRONMENT = "parallel_verify_environment"
+SUBPROCESS_PROPERTIES_FILE_ENV = "PYBUILDER_INTEGRATION_PROPERTIES_FILE"
+CYPRESS_CACHE_FOLDER = "cypress_cache_folder"

pybuilder_integration-105/pybuilder_integration/tasks.py

@@ -0,0 +1,548 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import xml.etree.ElementTree as ET
+
+import pytest
+from pybuilder.core import Project, Logger, RequirementsFile
+from pybuilder.errors import BuildFailedException
+from pybuilder.install_utils import install_dependencies
+from pybuilder.reactor import Reactor
+from pybuilder.utils import Timer
+
+from pybuilder_integration import exec_utility, tool_utility, directory_utility
+from pybuilder_integration.artifact_manager import get_artifact_manager
+from pybuilder_integration.cloudwatchlogs_utility import CloudwatchLogs
+from pybuilder_integration.directory_utility import get_working_distribution_directory, \
+    package_artifacts, prepare_reports_directory, get_local_zip_artifact_path, prepare_logs_directory, \
+    read_tavern_service_markers
+from pybuilder_integration.properties import *
+from pybuilder_integration.tool_utility import install_cypress
+
+
+_VERIFY_ENVIRONMENT_SUBPROCESS_PROPERTIES = [
+    INTEGRATION_ARTIFACT_BUCKET,
+    ENVIRONMENT,
+    ARTIFACT_MANAGER,
+    CYPRESS_TEST_DIR,
+    CYPRESS_CONFIG_FILE,
+    INTEGRATION_TARGET_URL,
+    INTEGRATION_PUBLIC_TARGET_URL,
+    TAVERN_ADDITIONAL_ARGS,
+    TAVERN_TEST_DIR,
+    PROMOTE_ARTIFACT,
+    ROLE,
+    SHOULD_SKIP_LATEST,
+    APPLICATION,
+    APPLICATION_GROUP,
+    RUN_PARALLEL,
+    CONSOLIDATE_TESTS,
+    SKIP_NON_MATCHING_TAVERN_ARTIFACTS,
+    TESTING_SCOPE,
+    "abort_upload",
+    "record_cypress",
+    "verbose",
+]
+
+def integration_artifact_push(project: Project, logger: Logger, reactor: Reactor):
+    logger.info("Starting upload of integration artifacts")
+    manager = get_artifact_manager(project)
+    for tool in ["tavern", "cypress"]:
+        artifact_file = get_local_zip_artifact_path(tool=tool, project=project, include_ending=True)
+        if os.path.exists(artifact_file):
+            logger.info(
+              f"Starting upload of integration artifact: {os.path.basename(artifact_file)} to: {manager.friendly_name}"
+            )
+            manager.upload(file=artifact_file, project=project, logger=logger, reactor=reactor)
+
+
+def verify_environment(project: Project, logger: Logger, reactor: Reactor):
+    if _get_bool_property(project, PARALLEL_VERIFY_ENVIRONMENT, False):
+        _verify_environment_parallel(project, logger, reactor)
+        return
+    _verify_environment_current(project, logger, reactor)
+    latest_directory = _download_latest_environment_artifacts(project, logger, reactor)
+    _verify_environment_latest(project, logger, reactor, latest_directory)
+    if _get_bool_property(project, PROMOTE_ARTIFACT, True):
+        integration_artifact_push(project=project, logger=logger, reactor=reactor)
+
+
+def _verify_environment_current(project: Project, logger: Logger, reactor: Reactor, dist_directory=None):
+    if dist_directory is None:
+        dist_directory = project.get_property(WORKING_TEST_DIR, get_working_distribution_directory(project))
+    logger.info(f"Preparing to run tests found in: {dist_directory}")
+    _run_tests_in_directory(dist_directory, logger, project, reactor)
+
+
+def _download_latest_environment_artifacts(project: Project, logger: Logger, reactor: Reactor):
+    artifact_manager = get_artifact_manager(project=project)
+    return artifact_manager.download_artifacts(project=project, logger=logger, reactor=reactor)
+
+
+def _verify_environment_latest(project: Project, logger: Logger, reactor: Reactor, latest_directory=None):
+    if latest_directory is None:
+        latest_directory = project.get_property(WORKING_TEST_DIR, None)
+    if latest_directory is None:
+        latest_directory = get_artifact_manager(project=project).download_artifacts(project=project,
+                                                                                    logger=logger,
+                                                                                    reactor=reactor)
+    _run_tests_in_directory(latest_directory, logger, project, reactor, latest=True)
+
+
+def _verify_environment_parallel(project: Project, logger: Logger, reactor: Reactor):
+    dist_directory = project.get_property(WORKING_TEST_DIR, get_working_distribution_directory(project))
+    logger.info(f"Preparing to run tests found in: {dist_directory}")
+    latest_directory = _download_latest_environment_artifacts(project, logger, reactor)
+    passes = [
+        {
+            "name": "current",
+            "task": "verify_environment_current",
+            "test_dir": dist_directory,
+        },
+        {
+            "name": "latest",
+            "task": "verify_environment_latest",
+            "test_dir": latest_directory,
+        },
+    ]
+    _run_verify_environment_passes_in_subprocesses(project, logger, passes)
+    if _get_bool_property(project, PROMOTE_ARTIFACT, True):
+        integration_artifact_push(project=project, logger=logger, reactor=reactor)
+
+
+def _run_verify_environment_passes_in_subprocesses(project: Project, logger: Logger, passes):
+    properties_file = _write_subprocess_properties_file(project)
+    processes = []
+    try:
+        for pass_config in passes:
+            process, log_file = _start_verify_environment_subprocess(project, logger, pass_config, properties_file)
+            processes.append((pass_config, process, log_file))
+
+        failures = []
+        for pass_config, process, log_file in processes:
+            exit_code = process.wait()
+            log_handle = getattr(process, "_pybuilder_integration_log_handle", None)
+            if log_handle:
+                log_handle.close()
+            if exit_code != 0:
+                failures.append(f"{pass_config['name']} exit_code={exit_code} log={log_file}")
+
+        if failures:
+            raise BuildFailedException("Parallel verify_environment failed: " + "; ".join(failures))
+    finally:
+        if os.path.exists(properties_file):
+            os.remove(properties_file)
+
+
+def _start_verify_environment_subprocess(project: Project, logger: Logger, pass_config, properties_file):
+    log_file = os.path.join(prepare_logs_directory(project), f"verify_environment_{pass_config['name']}.log")
+    command = _build_verify_environment_subprocess_command(project, pass_config)
+    env = os.environ.copy()
+    env[SUBPROCESS_PROPERTIES_FILE_ENV] = properties_file
+    logger.info(f"Starting {pass_config['name']} verify_environment subprocess: {' '.join(command)}")
+    log_handle = os.fdopen(
+        os.open(log_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+        "w",
+        encoding="utf-8",
+    )
+    try:
+        process = subprocess.Popen(command,
+                                   stdout=log_handle,
+                                   stderr=subprocess.STDOUT,
+                                   cwd=project.basedir,
+                                   env=env,
+                                   shell=False)
+    except Exception:
+        log_handle.close()
+        raise
+    process._pybuilder_integration_log_handle = log_handle
+    return process, log_file
+
+
+def _build_verify_environment_subprocess_command(project: Project, pass_config):
+    stage_target = os.path.join(project.expand_path("$dir_target"), "verify_environment", pass_config["name"])
+    return [
+        sys.executable,
+        "-c",
+        "from pybuilder.cli import main; main()",
+        pass_config["task"],
+        "-P", f"{WORKING_TEST_DIR}={pass_config['test_dir']}",
+        "-P", f"{PARALLEL_VERIFY_ENVIRONMENT}=False",
+        "-P", f"{PROMOTE_ARTIFACT}=False",
+        "-P", f"dir_target={stage_target}",
+        "-P", f"dir_logs={os.path.join(stage_target, 'logs')}",
+        "-P", f"dir_reports={os.path.join(stage_target, 'reports')}",
+    ]
+
+
+def _write_subprocess_properties_file(project: Project):
+    properties = _collect_json_safe_project_properties(project)
+    fd, path = tempfile.mkstemp(prefix="verify_environment_", suffix=".json", dir=prepare_logs_directory(project))
+    with os.fdopen(fd, "w") as fp:
+        json.dump(properties, fp)
+    return path
+
+
+def _collect_json_safe_project_properties(project: Project):
+    safe_properties = {}
+    for name in _VERIFY_ENVIRONMENT_SUBPROCESS_PROPERTIES:
+        value = project.get_property(name, None)
+        if value is None:
+            continue
+        try:
+            json.dumps(value)
+        except (TypeError, ValueError):
+            continue
+        safe_properties[name] = value
+    return safe_properties
+
+
+def _get_bool_property(project: Project, property_name, default=False):
+    value = project.get_property(property_name, default)
+    if isinstance(value, str):
+        return value.lower() in ["1", "true", "yes", "on"]
+    return bool(value)
+
+
+def _should_run_latest(test_dir, project):
+    if project.get_property(SHOULD_SKIP_LATEST, False):
+        if project.get_property(ROLE) == test_dir:
+            return False
+    return True
+
+
+def _run_tests_in_directory(dist_directory, logger, project, reactor, latest=False):
+    logger.debug(f"Run tests in directory: {os.listdir(dist_directory)} ")
+    _run_tavern_tests_in_dist_dir(dist_directory, latest, logger, project, reactor)
+    _run_cypress_tests_in_dist_dir(dist_directory, latest, logger, project, reactor)
+
+
+def _run_cypress_tests_in_dist_dir(dist_directory, latest, logger, project, reactor):
+    total_time = Timer.start()
+    cypress_test_path = f"{dist_directory}/cypress"
+    if os.path.exists(cypress_test_path):
+        logger.debug(f"Run cypress tests in directory: {cypress_test_path} ")
+        logger.debug(f"Run cypress tests in directory files: {os.listdir(cypress_test_path)} ")
+        logger.info(f"Found cypress tests - starting run latest: {latest}")
+        if latest:
+            for test_dir in os.listdir(cypress_test_path):
+                directory_to_test = f"{cypress_test_path}/{test_dir}"
+                if os.path.isdir(directory_to_test) and _should_run_latest(test_dir, project):
+                    logger.info(f"Running {directory_to_test}")
+                    _run_cypress_tests_in_directory(work_dir=directory_to_test,
+                                                    logger=logger,
+                                                    project=project,
+                                                    reactor=reactor)
+        else:
+            _run_cypress_tests_in_directory(work_dir=cypress_test_path,
+                                            logger=logger,
+                                            project=project,
+                                            reactor=reactor)
+    total_time.stop()
+    logger.info(f"Ran Cypress tests: {total_time.get_millis()}")
+
+
+def _run_tavern_tests_in_dist_dir(dist_directory, latest, logger, project, reactor):
+    total_time = Timer.start()
+    tavern_test_path = f"{dist_directory}/tavern"
+    if os.path.exists(tavern_test_path):
+        logger.info(f"Found tavern tests - starting run latest: {latest}")
+        logger.debug(f"Run tavern tests in directory: {tavern_test_path} ")
+        logger.debug(f"Run tavern tests in directory files: {os.listdir(tavern_test_path)} ")
+        if latest:
+            for tavern_dir in os.listdir(tavern_test_path):
+                tavern_test_direcotry = f"{tavern_test_path}/{tavern_dir}"
+                if os.path.isdir(tavern_test_direcotry) and _should_run_latest(tavern_dir, project):
+                    logger.info(f"Running {tavern_test_direcotry}")
+                    _run_tavern_tests_in_dir(test_dir=tavern_test_direcotry,
+                                             logger=logger,
+                                             project=project,
+                                             reactor=reactor,
+                                             role=os.path.basename(tavern_dir))
+        else:
+            _run_tavern_tests_in_dir(test_dir=f"{tavern_test_path}",
+                                     logger=logger,
+                                     project=project,
+                                     reactor=reactor)
+    total_time.stop()
+    logger.info(f"Ran Tavern tests: {total_time.get_millis()}")
+
+
+def verify_cypress(project: Project, logger: Logger, reactor: Reactor):
+    # Get directories with test and cypress executable
+    work_dir = project.expand_path(f"${CYPRESS_TEST_DIR}")
+    if _run_cypress_tests_in_directory(work_dir=work_dir, logger=logger, project=project, reactor=reactor):
+        package_artifacts(project, work_dir, "cypress", project.get_property(ROLE))
+
+
+def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor):
+    total_time = Timer.start()
+    target_url = project.get_mandatory_property(INTEGRATION_TARGET_URL)
+    environment = project.get_mandatory_property(ENVIRONMENT)
+    if not os.path.exists(work_dir):
+        logger.info("Skipping cypress run: no tests")
+        return False
+    logger.info(f"Found {len(os.listdir(work_dir))} files in cypress test directory")
+    logger.debug(f"Files: {os.listdir(work_dir)} ")
+    # Validate NPM install and Install cypress
+    package_json = os.path.join(work_dir, "package.json")
+    if os.path.exists(package_json):
+        logger.info("Found package.json installing dependencies")
+        tool_utility.install_npm_dependencies(work_dir, project=project, logger=logger, reactor=reactor)
+    else:
+        install_cypress(logger=logger, project=project, reactor=reactor, work_dir=work_dir)
+    total_time.stop()
+    logger.info(f"Configured Cypress Environment: {total_time.get_millis()}")
+    total_time = Timer.start()
+    executable = os.path.join(work_dir, "node_modules/cypress/bin/cypress")
+    results_file, run_name = get_test_report_file(project=project, test_dir=work_dir, tool="cypress")
+    # Run the actual tests against the baseURL provided by ${integration_target}
+    test_report_folder = directory_utility.prepare_reports_directory(project)
+    args = ["run", "--config",
+            f"baseUrl={target_url},"
+            f"videosFolder={test_report_folder}/videos,"
+            f"screenshotsFolder={test_report_folder}/screenshots",
+            "--reporter-options",
+            f"mochaFile={results_file}"]
+    if _get_bool_property(project, "record_cypress", True):
+        args.append('--record')
+    _add_config_file(logger, project, args, environment, work_dir)
+    environment_variables = project.get_property(ENVIRONMENT_VARIABLES, {})
+    logger.info(f"Running cypress on host: {target_url}")
+    try:
+        exec_utility.exec_command(command_name=executable, args=args,
+                                  failure_message="Failed to execute cypress tests", log_file_name='cypress_run.log',
+                                  project=project, reactor=reactor, logger=logger, working_dir=work_dir, report=False,
+                                  env_vars=environment_variables)
+        # workaround but cypress output are relative to location of cypress.json, so we need to collapse
+        if os.path.exists(f"{work_dir}/target"):
+            shutil.copytree(f"{work_dir}/target", project.expand_path("$dir_target"), dirs_exist_ok=True)
+    finally:
+        _write_cypress_summary(project, logger)
+    total_time.stop()
+    logger.info(f"Ran Cypress Tests: {total_time.get_millis()}")
+    return True
+
+
+def _write_cypress_summary(project, logger):
+    """Parse cypress_run.log and write a portable Markdown summary artifact."""
+    log_path = os.path.join(prepare_logs_directory(project), "cypress_run.log")
+    summary_path = os.path.join(prepare_reports_directory(project), "cypress-summary.md")
+    try:
+        output = _build_cypress_summary(log_path)
+        with os.fdopen(
+            os.open(summary_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+            "w",
+            encoding="utf-8",
+        ) as summary_file:
+            summary_file.write(output)
+        github_summary_path = os.environ.get("GITHUB_STEP_SUMMARY")
+        if github_summary_path:
+            with os.fdopen(
+                os.open(github_summary_path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600),
+                "a",
+                encoding="utf-8",
+            ) as f:
+                f.write(output)
+        print(output)
+        return summary_path
+    except Exception as e:
+        logger.warn(f"[cypress_summary] failed to generate summary: {e}")
+
+
+def _build_cypress_summary(log_path):
+    if not os.path.exists(log_path):
+        return "## Cypress Test Results\n\n> warning `cypress_run.log` not found\n"
+
+    raw = open(log_path, errors="replace").read()
+    clean = re.sub(r"\x1b\[[0-9;]*m", "", raw)
+
+    total = failed = skipped = 0
+    failures = []
+    for xml_block in re.findall(r"<testsuites[\s\S]*?</testsuites>", clean):
+        try:
+            root = ET.fromstring(xml_block)
+            total += int(root.get("tests", 0))
+            failed += int(root.get("failures", 0))
+            skipped += int(root.get("skipped", 0) or 0)
+            for tc in root.iter("testcase"):
+                failure = tc.find("failure")
+                if failure is not None:
+                    suite = tc.get("classname", "").split(".")[-1]
+                    name = tc.get("name", "")
+                    msg = (failure.get("message") or failure.text or "").split("\n")[0][:120]
+                    failures.append((f"{suite} > {name}", msg))
+        except ET.ParseError:
+            pass
+
+    passed = total - failed - skipped
+    if total == 0:
+        icon = "WARN"
+        label = "No tests ran - check if Cypress found any spec files"
+    elif failed == 0:
+        icon = "PASS"
+        label = "All tests passed"
+    else:
+        icon = "FAIL"
+        label = f"{failed} test(s) failed"
+
+    lines = [
+        "## Cypress Test Results\n",
+        f"### {icon} {label}\n",
+        "| Total | Passed | Failed | Skipped |",
+        "|-------|--------|--------|---------|",
+        f"| {total} | {passed} | {failed} | {skipped} |",
+    ]
+
+    if failures:
+        lines.append("\n### Failed Tests\n")
+        for title, msg in failures[:20]:
+            lines.append(f"- **{title}**")
+            if msg:
+                lines.append(f"  - _{msg}_")
+        if len(failures) > 20:
+            lines.append(f"\n_...and {len(failures) - 20} more_")
+
+    return "\n".join(lines) + "\n"
+
+
+def _add_config_file(logger, project, args, environment, work_dir):
+
+    # Environment variable override
+    cypress_config_file_override = os.environ.get('CYPRESS_CONFIG_FILE')
+    if cypress_config_file_override:
+        logger.info(f"Found CYPRESS_CONFIG_FILE environment variable: {cypress_config_file_override}")
+        project.set_property(CYPRESS_CONFIG_FILE, cypress_config_file_override)
+
+    # Check project for config file else test file system for environment named file
+    cypress_config_file = project.get_property(CYPRESS_CONFIG_FILE)
+    if cypress_config_file and os.path.exists(os.path.join(work_dir, cypress_config_file)):
+        logger.info(f"Setting --config-file parameter from project to {cypress_config_file}")
+        args.append("--config-file")
+        args.append(cypress_config_file)
+    else:
+        logger.info(f"Attempting to discover cypress config file from environment: {environment}")
+        for ending in ['ts', 'json']:
+            config_file_path = f'{environment}-config.{ending}'
+            if os.path.exists(os.path.join(work_dir, config_file_path)):
+                logger.info(f"Setting --config-file parameter from env to {config_file_path}")
+                args.append("--config-file")
+                args.append(config_file_path)
+                return
+
+
+def verify_tavern(project: Project, logger: Logger, reactor: Reactor):
+    # Expand the directory to get full path
+    test_dir = project.expand_path(f"${TAVERN_TEST_DIR}")
+    # Run the tests in the directory
+    if _run_tavern_tests_in_dir(test_dir, logger, project, reactor):
+        package_artifacts(project, test_dir, "tavern", project.get_property(ROLE))
+
+
+def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, reactor: Reactor, role=None):
+    logger.info("Running tavern tests: {}".format(test_dir))
+    if not os.path.exists(test_dir):
+        logger.info("Skipping tavern run: no tests")
+        return False
+    logger.info(f"Found {len(os.listdir(test_dir))} files in tavern test directory")
+    # todo is this unique enough for each run?
+    output_file, run_name = get_test_report_file(project, test_dir)
+    extra_args = [project.expand(prop) for prop in project.get_property(TAVERN_ADDITIONAL_ARGS, [])]
+    requested_marker = _extract_tavern_marker_filter(extra_args)
+    declared_markers = read_tavern_service_markers(test_dir)
+    skip_non_matching_artifacts = _get_bool_property(project, SKIP_NON_MATCHING_TAVERN_ARTIFACTS, False)
+    if skip_non_matching_artifacts and requested_marker and declared_markers and requested_marker not in declared_markers:
+        logger.info(
+            f"Skipping Tavern tests: artifact markers {sorted(declared_markers)} do not match {requested_marker}"
+        )
+        return True
+    from sys import path as syspath
+    syspath.insert(0, test_dir)
+    # install any requirements that my exist
+    requirements_file = os.path.join(test_dir, "requirements.txt")
+    if os.path.exists(requirements_file):
+        dependency = RequirementsFile(requirements_file)
+        install_dependencies(logger, project, dependency, reactor.pybuilder_venv,
+                             f"{prepare_logs_directory(project)}/install_tavern_pip_dependencies.log")
+    args = ["--junit-xml", f"{output_file}", test_dir] + extra_args
+    if project.get_property("verbose"):
+        args.append("-s")
+        args.append("-v")
+    if _get_bool_property(project, RUN_PARALLEL, False):
+        args.extend(['-n', 'auto'])
+    os.environ['TARGET'] = project.get_property(INTEGRATION_TARGET_URL)
+    os.environ['PUBLIC_TARGET'] = project.get_property(INTEGRATION_PUBLIC_TARGET_URL)
+    os.environ[ENVIRONMENT] = project.get_property(ENVIRONMENT)
+    logger.info(f"Running against target: {project.get_property(INTEGRATION_TARGET_URL)} and "
+                f"public target: {project.get_property(INTEGRATION_PUBLIC_TARGET_URL)}")
+    cache_wd = os.getcwd()
+    try:
+        os.chdir(test_dir)
+        logger.debug(f"Running args: {args} ")
+        ret = pytest.main(args)
+        if ret == pytest.ExitCode.NO_TESTS_COLLECTED:
+            fallback_args = _without_tavern_marker_filter(args)
+            if fallback_args != args and (not skip_non_matching_artifacts or not declared_markers):
+                logger.warn(
+                    "No Tavern tests matched the marker filter; rerunning the full suite"
+                )
+                logger.debug(f"Running fallback args: {fallback_args} ")
+                ret = pytest.main(fallback_args)
+    finally:
+        os.chdir(cache_wd)
+
+    if ret != 0:
+        if role:
+            roles = []
+            if project.get_property(CONSOLIDATE_TESTS, False):
+                with open(f"{test_dir}/roles") as fp:
+                    for line in fp:
+                        roles.append(line.strip())
+            else:
+                roles.append(role)
+
+            for service in roles:
+                CloudwatchLogs(project.get_property(ENVIRONMENT), project.get_property(APPLICATION), service,
+                               logger).print_latest()
+        raise BuildFailedException(f"Tavern tests failed see complete output here - {output_file}")
+    return True
+
+
+def _without_tavern_marker_filter(args):
+    marker_options = {"-m", "--markexpr"}
+    fallback_args = []
+    skip_next = False
+    for arg in args:
+        if skip_next:
+            skip_next = False
+            continue
+        if arg in marker_options:
+            skip_next = True
+            continue
+        if arg.startswith("--markexpr="):
+            continue
+        fallback_args.append(arg)
+    return fallback_args
+
+
+def _extract_tavern_marker_filter(args):
+    for index, arg in enumerate(args):
+        if arg in {"-m", "--markexpr"} and index + 1 < len(args):
+            marker = args[index + 1]
+        elif arg.startswith("--markexpr="):
+            marker = arg.split("=", 1)[1]
+        else:
+            continue
+        if marker.replace("_", "").isalnum() and marker:
+            return marker
+    return None
+
+
+def get_test_report_file(project, test_dir, tool="tavern"):
+    run_name = os.path.basename(test_dir)
+    output_file = os.path.join(prepare_reports_directory(project), f"{tool}-{run_name}.out.xml")
+    return output_file, run_name

pybuilder_integration-105/pybuilder_integration/tool_utility.py

@@ -0,0 +1,53 @@
+from pybuilder.core import Logger, Project
+from pybuilder.reactor import Reactor
+
+from pybuilder_integration.exec_utility import exec_command
+from pybuilder_integration.properties import CYPRESS_CACHE_FOLDER
+
+
+def install_cypress(logger: Logger, project: Project, reactor: Reactor, work_dir):
+    _verify_npm(reactor)
+    logger.info(f"Ensuring cypress is installed")
+    exec_command('npm', ['install', "cypress"], f'Failed to install cypress - required for integration tests',
+                 f'{"cypress"}_npm_install.log', project, reactor, logger, report=False, working_dir=work_dir,
+                 env_vars=_get_npm_env(project))
+
+
+def _verify_npm(reactor):
+    reactor.pybuilder_venv.verify_can_execute(
+        command_and_arguments=["npm", "--version"], prerequisite="npm", caller="integration_tests")
+
+
+def install_npm_dependencies(work_dir, project, logger, reactor):
+    _verify_npm(reactor)
+    install_command = 'ci' if _has_package_lock(work_dir) else 'install'
+    exec_command('npm', [install_command], f'Failed to install package.json - required for integration tests',
+             f'package_json_npm_install.log', project, reactor, logger, report=False, working_dir=work_dir,
+             env_vars=_get_npm_env(project))
+
+
+def _has_package_lock(work_dir):
+    return any(
+        [
+            _path_exists(work_dir, "package-lock.json"),
+            _path_exists(work_dir, "npm-shrinkwrap.json"),
+        ]
+    )
+
+
+def _path_exists(work_dir, filename):
+    import os
+    return os.path.exists(os.path.join(work_dir, filename))
+
+
+def _get_npm_env(project):
+    import os
+    cache_folder = project.get_property(CYPRESS_CACHE_FOLDER, None)
+    if cache_folder:
+        return {"CYPRESS_CACHE_FOLDER": project.expand_path(cache_folder)}
+    cache_folder = os.environ.get("CYPRESS_CACHE_FOLDER")
+    if not cache_folder:
+        return {}
+    return {"CYPRESS_CACHE_FOLDER": cache_folder}
+
+

{pybuilder_integration-102 → pybuilder_integration-105}/pybuilder_integration.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pybuilder-integration
-Version: 102
+Version: 105
 Summary: A pybuilder plugin that runs integration tests (Tavern & Cypress) against a target.
 Home-page: https://github.com/rspitler/pybuilder-integration
 Author: 
@@ -13,5 +13,11 @@ Classifier: Programming Language :: Python
 Requires-Dist: pytest
 Requires-Dist: tavern==1.25.2
 Requires-Dist: boto3
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 A pybuilder plugin that runs integration tests against a target.  This is intended to be a broader scope than unit-tests encompassing dependant functionality.

{pybuilder_integration-102 → pybuilder_integration-105}/setup.py

@@ -21,7 +21,7 @@ class install(_install):
 if __name__ == '__main__':
     setup(
         name = 'pybuilder-integration',
-        version = '102',
+        version = '105',
         description = 'A pybuilder plugin that runs integration tests (Tavern & Cypress) against a target.',
         long_description = 'A pybuilder plugin that runs integration tests against a target.  This is intended to be a broader scope than unit-tests encompassing dependant functionality.',
         long_description_content_type = None,
@@ -53,6 +53,7 @@ if __name__ == '__main__':
             'tavern==1.25.2',
             'boto3'
         ],
+        extras_require = {},
         dependency_links = [],
         zip_safe = True,
         cmdclass = {'install': install},

pybuilder_integration-102/pybuilder_integration/directory_utility.py

@@ -1,70 +0,0 @@
-import os
-import shutil
-import tempfile
-
-
-
-def prepare_reports_directory(project):
-    return prepare_directory("$dir_reports", project)
-
-
-def prepare_logs_directory(project):
-    return prepare_directory("$dir_logs", project)
-
-
-def prepare_dist_directory(project):
-    return prepare_directory("$dir_dist", project)
-
-
-def prepare_directory(dir_variable, project):
-    package__format = f"{dir_variable}/integration"
-    reports_dir = project.expand_path(package__format)
-    return _ensure_directory_exists(reports_dir)
-
-
-def _ensure_directory_exists(path):
-    if not os.path.exists(path):
-        os.makedirs(path)
-    return path
-
-
-def get_working_distribution_directory(project):
-    dist_directory = prepare_dist_directory(project)
-    return _ensure_directory_exists(f"{dist_directory}/working")
-
-
-def get_latest_distribution_directory(project):
-    dist_directory = prepare_dist_directory(project)
-    from pybuilder_integration import ENVIRONMENT
-    environment = project.get_mandatory_property(ENVIRONMENT)
-    return _ensure_directory_exists(f"{dist_directory}/LATEST-{environment}")
-
-
-def get_latest_zipped_distribution_directory(project):
-    dist_directory = prepare_dist_directory(project)
-    from pybuilder_integration import ENVIRONMENT
-    environment = project.get_mandatory_property(ENVIRONMENT)
-    return _ensure_directory_exists(f"{dist_directory}/LATEST-{environment}/zipped")
-
-
-def get_local_zip_artifact_path(tool, project, include_ending=False):
-    artifact = f"{prepare_dist_directory(project)}/{tool}-{project.name}"
-    if include_ending:
-        return f"{artifact}.zip"
-    return artifact
-
-
-def package_artifacts(project, test_dir, tool, role):
-    # Make a copy for easy access in environment validation
-    working_dir = get_working_distribution_directory(project)
-    shutil.copytree(test_dir, f"{working_dir}/{tool}",dirs_exist_ok=True)
-    with tempfile.TemporaryDirectory() as tempdir:
-        shutil.copytree(test_dir, f"{tempdir}/{role}",dirs_exist_ok=True)
-        # package a copy for distribution
-        # zip up the test and add them to the integration test dist directory
-        base_name = get_local_zip_artifact_path(tool=tool, project=project)
-        shutil.make_archive(base_name=base_name,
-                            base_dir=role,
-                            format="zip",
-                            root_dir=tempdir)
-

pybuilder_integration-102/pybuilder_integration/tasks.py

@@ -1,249 +0,0 @@
-import os
-import shutil
-
-import pytest
-from pybuilder.core import Project, Logger, RequirementsFile
-from pybuilder.errors import BuildFailedException
-from pybuilder.install_utils import install_dependencies
-from pybuilder.reactor import Reactor
-from pybuilder.utils import Timer
-
-from pybuilder_integration import exec_utility, tool_utility, directory_utility
-from pybuilder_integration.artifact_manager import get_artifact_manager
-from pybuilder_integration.cloudwatchlogs_utility import CloudwatchLogs
-from pybuilder_integration.directory_utility import get_working_distribution_directory, \
-    package_artifacts, prepare_reports_directory, get_local_zip_artifact_path, prepare_logs_directory
-from pybuilder_integration.properties import *
-from pybuilder_integration.tool_utility import install_cypress
-
-
-def integration_artifact_push(project: Project, logger: Logger, reactor: Reactor):
-    logger.info("Starting upload of integration artifacts")
-    manager = get_artifact_manager(project)
-    for tool in ["tavern", "cypress"]:
-        artifact_file = get_local_zip_artifact_path(tool=tool, project=project, include_ending=True)
-        if os.path.exists(artifact_file):
-            logger.info(
-              f"Starting upload of integration artifact: {os.path.basename(artifact_file)} to: {manager.friendly_name}"
-            )
-            manager.upload(file=artifact_file, project=project, logger=logger, reactor=reactor)
-
-
-def verify_environment(project: Project, logger: Logger, reactor: Reactor):
-    dist_directory = project.get_property(WORKING_TEST_DIR, get_working_distribution_directory(project))
-    logger.info(f"Preparing to run tests found in: {dist_directory}")
-    _run_tests_in_directory(dist_directory, logger, project, reactor)
-    artifact_manager = get_artifact_manager(project=project)
-    latest_directory = artifact_manager.download_artifacts(project=project, logger=logger, reactor=reactor)
-    _run_tests_in_directory(latest_directory, logger, project, reactor, latest=True)
-    if project.get_property(PROMOTE_ARTIFACT, True):
-        integration_artifact_push(project=project, logger=logger, reactor=reactor)
-
-
-def _should_run_latest(test_dir, project):
-    if project.get_property(SHOULD_SKIP_LATEST, False):
-        if project.get_property(ROLE) == test_dir:
-            return False
-    return True
-
-
-def _run_tests_in_directory(dist_directory, logger, project, reactor, latest=False):
-    logger.debug(f"Run tests in directory: {os.listdir(dist_directory)} ")
-    _run_tavern_tests_in_dist_dir(dist_directory, latest, logger, project, reactor)
-    _run_cypress_tests_in_dist_dir(dist_directory, latest, logger, project, reactor)
-
-
-def _run_cypress_tests_in_dist_dir(dist_directory, latest, logger, project, reactor):
-    total_time = Timer.start()
-    cypress_test_path = f"{dist_directory}/cypress"
-    if os.path.exists(cypress_test_path):
-        logger.debug(f"Run cypress tests in directory: {cypress_test_path} ")
-        logger.debug(f"Run cypress tests in directory files: {os.listdir(cypress_test_path)} ")
-        logger.info(f"Found cypress tests - starting run latest: {latest}")
-        if latest:
-            for test_dir in os.listdir(cypress_test_path):
-                directory_to_test = f"{cypress_test_path}/{test_dir}"
-                if os.path.isdir(directory_to_test) and _should_run_latest(test_dir, project):
-                    logger.info(f"Running {directory_to_test}")
-                    _run_cypress_tests_in_directory(work_dir=directory_to_test,
-                                                    logger=logger,
-                                                    project=project,
-                                                    reactor=reactor)
-        else:
-            _run_cypress_tests_in_directory(work_dir=cypress_test_path,
-                                            logger=logger,
-                                            project=project,
-                                            reactor=reactor)
-    total_time.stop()
-    logger.info(f"Ran Cypress tests: {total_time.get_millis()}")
-
-
-def _run_tavern_tests_in_dist_dir(dist_directory, latest, logger, project, reactor):
-    total_time = Timer.start()
-    tavern_test_path = f"{dist_directory}/tavern"
-    if os.path.exists(tavern_test_path):
-        logger.info(f"Found tavern tests - starting run latest: {latest}")
-        logger.debug(f"Run tavern tests in directory: {tavern_test_path} ")
-        logger.debug(f"Run tavern tests in directory files: {os.listdir(tavern_test_path)} ")
-        if latest:
-            for tavern_dir in os.listdir(tavern_test_path):
-                tavern_test_direcotry = f"{tavern_test_path}/{tavern_dir}"
-                if os.path.isdir(tavern_test_direcotry) and _should_run_latest(tavern_dir, project):
-                    logger.info(f"Running {tavern_test_direcotry}")
-                    _run_tavern_tests_in_dir(test_dir=tavern_test_direcotry,
-                                             logger=logger,
-                                             project=project,
-                                             reactor=reactor,
-                                             role=os.path.basename(tavern_dir))
-        else:
-            _run_tavern_tests_in_dir(test_dir=f"{tavern_test_path}",
-                                     logger=logger,
-                                     project=project,
-                                     reactor=reactor)
-    total_time.stop()
-    logger.info(f"Ran Tavern tests: {total_time.get_millis()}")
-
-
-def verify_cypress(project: Project, logger: Logger, reactor: Reactor):
-    # Get directories with test and cypress executable
-    work_dir = project.expand_path(f"${CYPRESS_TEST_DIR}")
-    if _run_cypress_tests_in_directory(work_dir=work_dir, logger=logger, project=project, reactor=reactor):
-        package_artifacts(project, work_dir, "cypress", project.get_property(ROLE))
-
-
-def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor):
-    total_time = Timer.start()
-    target_url = project.get_mandatory_property(INTEGRATION_TARGET_URL)
-    environment = project.get_mandatory_property(ENVIRONMENT)
-    if not os.path.exists(work_dir):
-        logger.info("Skipping cypress run: no tests")
-        return False
-    logger.info(f"Found {len(os.listdir(work_dir))} files in cypress test directory")
-    logger.debug(f"Files: {os.listdir(work_dir)} ")
-    # Validate NPM install and Install cypress
-    package_json = os.path.join(work_dir, "package.json")
-    if os.path.exists(package_json):
-        logger.info("Found package.json installing dependencies")
-        tool_utility.install_npm_dependencies(work_dir, project=project, logger=logger, reactor=reactor)
-    else:
-        install_cypress(logger=logger, project=project, reactor=reactor, work_dir=work_dir)
-    total_time.stop()
-    logger.info(f"Configured Cypress Environment: {total_time.get_millis()}")
-    total_time = Timer.start()
-    executable = os.path.join(work_dir, "node_modules/cypress/bin/cypress")
-    results_file, run_name = get_test_report_file(project=project, test_dir=work_dir, tool="cypress")
-    # Run the actual tests against the baseURL provided by ${integration_target}
-    test_report_folder = directory_utility.prepare_reports_directory(project)
-    args = ["run", "--config",
-            f"baseUrl={target_url},"
-            f"videosFolder={test_report_folder}/videos,"
-            f"screenshotsFolder={test_report_folder}/screenshots",
-            "--reporter-options",
-            f"mochaFile={results_file}"]
-    if project.get_property("record_cypress", True):
-        args.append('--record')
-    _add_config_file(logger, project, args, environment, work_dir)
-    environment_variables = project.get_property(ENVIRONMENT_VARIABLES, {})
-    logger.info(f"Running cypress on host: {target_url}")
-    exec_utility.exec_command(command_name=executable, args=args,
-                              failure_message="Failed to execute cypress tests", log_file_name='cypress_run.log',
-                              project=project, reactor=reactor, logger=logger, working_dir=work_dir, report=False,
-                              env_vars=environment_variables)
-    # workaround but cypress output are relative to location of cypress.json, so we need to collapse
-    if os.path.exists(f"{work_dir}/target"):
-        shutil.copytree(f"{work_dir}/target", "./target", dirs_exist_ok=True)
-    total_time.stop()
-    logger.info(f"Ran Cypress Tests: {total_time.get_millis()}")
-    return True
-
-
-def _add_config_file(logger, project, args, environment, work_dir):
-
-    # Environment variable override
-    cypress_config_file_override = os.environ.get('CYPRESS_CONFIG_FILE')
-    if cypress_config_file_override:
-        logger.info(f"Found CYPRESS_CONFIG_FILE environment variable: {cypress_config_file_override}")
-        project.set_property(CYPRESS_CONFIG_FILE, cypress_config_file_override)
-
-    # Check project for config file else test file system for environment named file
-    cypress_config_file = project.get_property(CYPRESS_CONFIG_FILE)
-    if cypress_config_file and os.path.exists(os.path.join(work_dir, cypress_config_file)):
-        logger.info(f"Setting --config-file parameter from project to {cypress_config_file}")
-        args.append("--config-file")
-        args.append(cypress_config_file)
-    else:
-        logger.info(f"Attempting to discover cypress config file from environment: {environment}")
-        for ending in ['ts', 'json']:
-            config_file_path = f'{environment}-config.{ending}'
-            if os.path.exists(os.path.join(work_dir, config_file_path)):
-                logger.info(f"Setting --config-file parameter from env to {config_file_path}")
-                args.append("--config-file")
-                args.append(config_file_path)
-                return
-
-
-def verify_tavern(project: Project, logger: Logger, reactor: Reactor):
-    # Expand the directory to get full path
-    test_dir = project.expand_path(f"${TAVERN_TEST_DIR}")
-    # Run the tests in the directory
-    if _run_tavern_tests_in_dir(test_dir, logger, project, reactor):
-        package_artifacts(project, test_dir, "tavern", project.get_property(ROLE))
-
-
-def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, reactor: Reactor, role=None):
-    logger.info("Running tavern tests: {}".format(test_dir))
-    if not os.path.exists(test_dir):
-        logger.info("Skipping tavern run: no tests")
-        return False
-    logger.info(f"Found {len(os.listdir(test_dir))} files in tavern test directory")
-    # todo is this unique enough for each run?
-    output_file, run_name = get_test_report_file(project, test_dir)
-    from sys import path as syspath
-    syspath.insert(0, test_dir)
-    # install any requirements that my exist
-    requirements_file = os.path.join(test_dir, "requirements.txt")
-    if os.path.exists(requirements_file):
-        dependency = RequirementsFile(requirements_file)
-        install_dependencies(logger, project, dependency, reactor.pybuilder_venv,
-                             f"{prepare_logs_directory(project)}/install_tavern_pip_dependencies.log")
-    extra_args = [project.expand(prop) for prop in project.get_property(TAVERN_ADDITIONAL_ARGS, [])]
-    args = ["--junit-xml", f"{output_file}", test_dir] + extra_args
-    if project.get_property("verbose"):
-        args.append("-s")
-        args.append("-v")
-    if project.get_property(RUN_PARALLEL, False):
-        args.extend(['-n', 'auto'])
-    os.environ['TARGET'] = project.get_property(INTEGRATION_TARGET_URL)
-    os.environ['PUBLIC_TARGET'] = project.get_property(INTEGRATION_PUBLIC_TARGET_URL)
-    os.environ[ENVIRONMENT] = project.get_property(ENVIRONMENT)
-    logger.info(f"Running against target: {project.get_property(INTEGRATION_TARGET_URL)} and "
-                f"public target: {project.get_property(INTEGRATION_PUBLIC_TARGET_URL)}")
-    cache_wd = os.getcwd()
-    try:
-        os.chdir(test_dir)
-        logger.debug(f"Running args: {args} ")
-        ret = pytest.main(args)
-    finally:
-        os.chdir(cache_wd)
-
-    if ret != 0:
-        if role:
-            roles = []
-            if project.get_property(CONSOLIDATE_TESTS, False):
-                with open(f"{test_dir}/roles") as fp:
-                    for line in fp:
-                        roles.append(line.strip())
-            else:
-                roles.append(role)
-
-            for service in roles:
-                CloudwatchLogs(project.get_property(ENVIRONMENT), project.get_property(APPLICATION), service,
-                               logger).print_latest()
-        raise BuildFailedException(f"Tavern tests failed see complete output here - {output_file}")
-    return True
-
-
-def get_test_report_file(project, test_dir, tool="tavern"):
-    run_name = os.path.basename(test_dir)
-    output_file = os.path.join(prepare_reports_directory(project), f"{tool}-{run_name}.out.xml")
-    return output_file, run_name

pybuilder_integration-102/pybuilder_integration/tool_utility.py

@@ -1,24 +0,0 @@
-from pybuilder.core import Logger, Project
-from pybuilder.reactor import Reactor
-
-from pybuilder_integration.exec_utility import exec_command
-
-
-def install_cypress(logger: Logger, project: Project, reactor: Reactor, work_dir):
-    _verify_npm(reactor)
-    logger.info(f"Ensuring cypress is installed")
-    exec_command('npm', ['install', "cypress"], f'Failed to install cypress - required for integration tests',
-                 f'{"cypress"}_npm_install.log', project, reactor, logger, report=False, working_dir=work_dir)
-
-
-def _verify_npm(reactor):
-    reactor.pybuilder_venv.verify_can_execute(
-        command_and_arguments=["npm", "--version"], prerequisite="npm", caller="integration_tests")
-
-
-def install_npm_dependencies(work_dir, project, logger, reactor):
-    _verify_npm(reactor)
-    exec_command('npm', ['install'], f'Failed to install package.json - required for integration tests',
-             f'package_json_npm_install.log', project, reactor, logger, report=False, working_dir=work_dir)
-
-