pybuilder-integration 101__tar.gz → 104__tar.gz

{pybuilder-integration-101 → pybuilder_integration-104}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pybuilder-integration
-Version: 101
+Version: 104
 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-101 → pybuilder_integration-104}/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."
@@ -27,12 +39,23 @@ def init_plugin(project):
                   f"\t${INTEGRATION_TARGET_URL} - (required) Full URL target for tests\n"
                   f"\t${INTEGRATION_PUBLIC_TARGET_URL} - (required) Full public URL target for tests\n"
                   f"\t${ENVIRONMENT} - (required) Environment that is being tested (ci/prod)\n"
+                  f"\t${TESTING_SCOPE} - (optional) Will limit scope of tests, default is to the same application - * can be used.\n"
                   f"\t${PROMOTE_ARTIFACT} - Promote integration tests to LATEST-${ENVIRONMENT} (default TRUE)\n"
       )
 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-101 → pybuilder_integration-104}/pybuilder_integration/artifact_manager.py

@@ -174,13 +174,22 @@ def extract_application_role(logger, project):
     return app_group, app_name, role
 
 
+def in_scope(scope, filename):
+    if scope == "*": return True
+    return scope in filename
+
+
 def _unzip_downloaded_artifacts(dir_with_zips: str, destination: str, logger: Logger, project:Project) -> str:
+    scope = project.get_property(TESTING_SCOPE,project.get_property(APPLICATION,'*'))
     for file in os.listdir(dir_with_zips):
         # expect {tool}-{self.project.name}.zip
-        if os.path.basename(file).find("tavern") >= 0:
+        filename = os.path.basename(file)
+        if not in_scope(scope, filename):
+            continue
+        if filename.find("tavern") >= 0:
             shutil.unpack_archive(filename=os.path.join(dir_with_zips, file), extract_dir=f"{destination}/tavern",
                                   format="zip")
-        elif os.path.basename(file).find("cypress") >= 0:
+        elif filename.find("cypress") >= 0:
             shutil.unpack_archive(filename=os.path.join(dir_with_zips, file), extract_dir=f"{destination}/cypress",
                                   format="zip")
         else:
@@ -197,7 +206,7 @@ def _unzip_downloaded_artifacts(dir_with_zips: str, destination: str, logger: Lo
                 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")
     return destination
 
 

{pybuilder-integration-101 → pybuilder_integration-104}/pybuilder_integration/properties.py

@@ -17,3 +17,7 @@ APPLICATION = "application"
 APPLICATION_GROUP = "application_group"
 RUN_PARALLEL = "pytest_parallel"
 CONSOLIDATE_TESTS = "consolidate_tavern"
+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-101 → pybuilder_integration-104}/pybuilder_integration/tasks.py

@@ -1,5 +1,11 @@
+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
@@ -17,6 +23,29 @@ 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,
+    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)
@@ -30,16 +59,153 @@ def integration_artifact_push(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))
+    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)
-    latest_directory = artifact_manager.download_artifacts(project=project, logger=logger, reactor=reactor)
+    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)
-    if project.get_property(PROMOTE_ARTIFACT, 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:
@@ -140,23 +306,108 @@ def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor)
             f"screenshotsFolder={test_report_folder}/screenshots",
             "--reporter-options",
             f"mochaFile={results_file}"]
-    if project.get_property("record_cypress", True):
+    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}")
-    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)
+    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
@@ -211,7 +462,7 @@ def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, re
     if project.get_property("verbose"):
         args.append("-s")
         args.append("-v")
-    if project.get_property(RUN_PARALLEL, False):
+    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)
@@ -223,6 +474,14 @@ def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, re
         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:
+                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)
 
@@ -243,6 +502,23 @@ def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, re
     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 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")

pybuilder_integration-104/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-101 → pybuilder_integration-104}/pybuilder_integration.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pybuilder-integration
-Version: 101
+Version: 104
 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-101 → pybuilder_integration-104}/setup.py

@@ -21,7 +21,7 @@ class install(_install):
 if __name__ == '__main__':
     setup(
         name = 'pybuilder-integration',
-        version = '101',
+        version = '104',
         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-101/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)
-
-