pybuilder-integration 109__tar.gz → 112__tar.gz

{pybuilder_integration-109 → pybuilder_integration-112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybuilder-integration
-Version: 109
+Version: 112
 Summary: A pybuilder plugin that runs integration tests (Tavern & Cypress) against a target.
 Home-page: https://github.com/rspitler/pybuilder-integration
 Author: 

{pybuilder_integration-109 → pybuilder_integration-112}/pybuilder_integration/properties.py

@@ -22,5 +22,7 @@ TESTING_SCOPE = "testing_scope"
 PARALLEL_VERIFY_ENVIRONMENT = "parallel_verify_environment"
 PARALLEL_TAVERN_SUITES = "parallel_tavern_suites"
 PARALLEL_TAVERN_SUITES_WORKERS = "parallel_tavern_suites_workers"
+PARALLEL_CYPRESS_SUITES = "parallel_cypress_suites"
+PARALLEL_CYPRESS_SUITES_WORKERS = "parallel_cypress_suites_workers"
 SUBPROCESS_PROPERTIES_FILE_ENV = "PYBUILDER_INTEGRATION_PROPERTIES_FILE"
 CYPRESS_CACHE_FOLDER = "cypress_cache_folder"

{pybuilder_integration-109 → pybuilder_integration-112}/pybuilder_integration/tasks.py

@@ -1,5 +1,6 @@
 import atexit
 import errno
+import hashlib
 import json
 import os
 import re
@@ -51,13 +52,22 @@ _VERIFY_ENVIRONMENT_SUBPROCESS_PROPERTIES = [
     TESTING_SCOPE,
     PARALLEL_TAVERN_SUITES,
     PARALLEL_TAVERN_SUITES_WORKERS,
+    PARALLEL_CYPRESS_SUITES,
+    PARALLEL_CYPRESS_SUITES_WORKERS,
     "abort_upload",
     "record_cypress",
     "verbose",
 ]
 
 _TAVERN_INSTALL_LOCK = threading.Lock()
+_CYPRESS_TARGET_COPY_LOCK = threading.Lock()
 _DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS = 8
+_DEFAULT_PARALLEL_CYPRESS_SUITE_WORKERS = 4
+_CYPRESS_SPEC_SUFFIXES = (
+    ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".coffee", ".feature",
+)
+_CYPRESS_SPEC_SKIP_DIRS = {"node_modules", "dist", "target", "videos", "screenshots", ".git"}
+_CYPRESS_PARALLEL_FAILURES_FILE = "cypress_parallel_failures.json"
 
 def integration_artifact_push(project: Project, logger: Logger, reactor: Reactor):
     logger.info("Starting upload of integration artifacts")
@@ -157,8 +167,8 @@ def _run_verify_environment_passes_in_subprocesses(project: Project, logger: Log
                 process.terminate()
                 process.wait()
             _close_subprocess_log(process)
-        _merge_parallel_verify_environment_outputs(project, passes)
-        _write_cypress_summary(project, logger)
+        cypress_failures = _merge_parallel_verify_environment_outputs(project, passes) or []
+        _write_cypress_summary(project, logger, extra_failures=cypress_failures)
         if os.path.exists(properties_file):
             os.remove(properties_file)
 
@@ -376,6 +386,27 @@ def _first_child_cypress_log(stage_target):
     return None
 
 
+def _child_parallel_cypress_failures(stage_target, pass_name):
+    for source_root in _child_output_source_roots(stage_target):
+        candidate = os.path.join(
+            source_root, "logs", "integration", _CYPRESS_PARALLEL_FAILURES_FILE
+        )
+        if not os.path.isfile(candidate):
+            continue
+        try:
+            with open(candidate, encoding="utf-8") as failures_file:
+                failures = json.load(failures_file)
+            if not isinstance(failures, list) or not all(isinstance(failure, str) for failure in failures):
+                raise ValueError("expected a list of strings")
+            return [
+                f"{pass_name}: {_redact_secret_log_text(failure).strip()}"
+                for failure in failures
+            ]
+        except (OSError, ValueError, TypeError, json.JSONDecodeError) as error:
+            return [f"{pass_name}: could not read Cypress parallel failure details: {error}"]
+    return []
+
+
 def _copy_maybe_redacted_file(src, dst, *, follow_symlinks=True):
     if os.path.splitext(src)[1].lower() in _REDACTED_COPY_EXTENSIONS:
         _copy_redacted_text_file(src, dst)
@@ -579,8 +610,12 @@ def _merge_parallel_verify_environment_outputs(project: Project, passes):
     }
     parent_cypress_log = os.path.join(parent_logs_directory, "cypress_run.log")
     has_parent_cypress_log = False
+    cypress_failures = []
     for pass_config in passes:
         stage_target = os.path.join(parent_target, "verify_environment", pass_config["name"])
+        cypress_failures.extend(
+            _child_parallel_cypress_failures(stage_target, pass_config["name"])
+        )
         for source_root in _child_output_source_roots(stage_target):
             for destination_kind, source_dirname in _CHILD_OUTPUT_SOURCES:
                 source = os.path.join(source_root, source_dirname, "integration")
@@ -597,6 +632,7 @@ def _merge_parallel_verify_environment_outputs(project: Project, passes):
         if cypress_log:
             _copy_cypress_log(cypress_log, parent_cypress_log, has_parent_cypress_log)
             has_parent_cypress_log = True
+    return cypress_failures
 
 
 def _copy_cypress_log(source, destination, append):
@@ -867,9 +903,11 @@ def _run_cypress_tests_in_dist_dir(dist_directory, latest, logger, project, reac
         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):
+            suite_dirs = list(_iter_latest_cypress_suite_dirs(cypress_test_path, project))
+            if _get_bool_property(project, PARALLEL_CYPRESS_SUITES, False) and suite_dirs:
+                _run_cypress_suites_parallel(suite_dirs, logger, project, reactor)
+            else:
+                for directory_to_test in suite_dirs:
                     logger.info(f"Running {directory_to_test}")
                     _run_cypress_tests_in_directory(work_dir=directory_to_test,
                                                     logger=logger,
@@ -919,17 +957,42 @@ def _iter_latest_tavern_suite_dirs(tavern_test_path, project):
             yield tavern_test_directory
 
 
-def _parallel_tavern_suite_workers(project, suite_count):
-    configured = project.get_property(PARALLEL_TAVERN_SUITES_WORKERS, None)
+def _iter_latest_cypress_suite_dirs(cypress_test_path, project):
+    for test_dir in sorted(os.listdir(cypress_test_path)):
+        directory_to_test = os.path.join(cypress_test_path, test_dir)
+        if os.path.isdir(directory_to_test) and _should_run_latest(test_dir, project):
+            yield directory_to_test
+
+
+def _parallel_suite_workers(project, suite_count, property_name, default_workers):
+    configured = project.get_property(property_name, None)
     if configured is None or configured == "":
-        return max(1, min(_DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS, suite_count))
+        return max(1, min(default_workers, suite_count))
     try:
         workers = int(configured)
     except (TypeError, ValueError):
-        workers = _DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS
+        workers = default_workers
     return max(1, min(workers, suite_count))
 
 
+def _parallel_tavern_suite_workers(project, suite_count):
+    return _parallel_suite_workers(
+        project,
+        suite_count,
+        PARALLEL_TAVERN_SUITES_WORKERS,
+        _DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS,
+    )
+
+
+def _parallel_cypress_suite_workers(project, suite_count):
+    return _parallel_suite_workers(
+        project,
+        suite_count,
+        PARALLEL_CYPRESS_SUITES_WORKERS,
+        _DEFAULT_PARALLEL_CYPRESS_SUITE_WORKERS,
+    )
+
+
 def _run_tavern_suites_parallel(suite_dirs, logger, project, reactor):
     prepare_reports_directory(project)
     runnable = []
@@ -957,19 +1020,33 @@ def _run_tavern_suites_parallel(suite_dirs, logger, project, reactor):
         )
         return
 
-    suite_sites = {}
-    for tavern_test_directory in runnable:
-        suite_sites[tavern_test_directory] = _install_tavern_suite_site(
-            tavern_test_directory, logger, project, reactor
-        )
-
     workers = _parallel_tavern_suite_workers(project, len(runnable))
     logger.info(f"Running {len(runnable)} tavern suites in parallel (workers={workers})")
+    fingerprint_by_dir = {suite_dir: _tavern_requirements_fingerprint(suite_dir) for suite_dir in runnable}
+    plugin_fingerprint = _plugin_venv_requirements_fingerprint(fingerprint_by_dir)
+    installer = _ParallelTavernRequirementInstaller(plugin_fingerprint)
+    if plugin_fingerprint is not None:
+        sample_dir = next(
+            suite_dir for suite_dir, fingerprint in fingerprint_by_dir.items()
+            if fingerprint == plugin_fingerprint
+        )
+        logger.info(
+            f"Installing tavern requirements from {os.path.basename(sample_dir)} "
+            f"into the plugin venv before parallel pytest"
+        )
+        installer.install(sample_dir, plugin_fingerprint, logger, project, reactor)
     failures = []
 
     def run_suite(tavern_test_directory):
         role = os.path.basename(tavern_test_directory)
         logger.info(f"Running {tavern_test_directory}")
+        site = installer.install(
+            tavern_test_directory,
+            fingerprint_by_dir[tavern_test_directory],
+            logger,
+            project,
+            reactor,
+        )
         _run_tavern_tests_in_dir(
             test_dir=tavern_test_directory,
             logger=logger,
@@ -978,7 +1055,7 @@ def _run_tavern_suites_parallel(suite_dirs, logger, project, reactor):
             role=role,
             isolated=True,
             skip_install=True,
-            extra_pythonpath=suite_sites[tavern_test_directory],
+            extra_pythonpath=site,
         )
         return role
 
@@ -998,6 +1075,257 @@ def _run_tavern_suites_parallel(suite_dirs, logger, project, reactor):
         )
 
 
+class _ParallelTavernRequirementInstaller:
+    def __init__(self, plugin_venv_fingerprint):
+        self._plugin_venv_fingerprint = plugin_venv_fingerprint
+        self._lock = threading.Lock()
+        self._events = {}
+        self._results = {}
+        self._errors = {}
+
+    def install(self, test_dir, fingerprint, logger, project, reactor):
+        if fingerprint is None:
+            return None
+        with self._lock:
+            if fingerprint in self._results:
+                return self._results[fingerprint]
+            if fingerprint in self._errors:
+                raise self._errors[fingerprint]
+            event = self._events.get(fingerprint)
+            if event is None:
+                event = threading.Event()
+                self._events[fingerprint] = event
+                leader = True
+            else:
+                leader = False
+        if not leader:
+            event.wait()
+            with self._lock:
+                if fingerprint in self._errors:
+                    raise self._errors[fingerprint]
+                if fingerprint in self._results:
+                    return self._results[fingerprint]
+                raise BuildFailedException(
+                    f"Tavern requirements install for {os.path.basename(test_dir)} finished without a result"
+                )
+        try:
+            if fingerprint == self._plugin_venv_fingerprint:
+                _install_tavern_requirements(test_dir, logger, project, reactor)
+                site = None
+            else:
+                site = _install_tavern_suite_site(test_dir, logger, project, reactor, fingerprint)
+            with self._lock:
+                self._results[fingerprint] = site
+            return site
+        except Exception as error:
+            with self._lock:
+                self._errors[fingerprint] = error
+            raise
+        finally:
+            event.set()
+
+
+def _plugin_venv_requirements_fingerprint(fingerprint_by_dir):
+    counts = {}
+    order = []
+    for fingerprint in fingerprint_by_dir.values():
+        if fingerprint is None:
+            continue
+        if fingerprint not in counts:
+            order.append(fingerprint)
+            counts[fingerprint] = 0
+        counts[fingerprint] += 1
+    if not order:
+        return None
+    return max(order, key=lambda fingerprint: (counts[fingerprint], -order.index(fingerprint)))
+
+
+def _run_cypress_suites_parallel(suite_dirs, logger, project, reactor):
+    if not suite_dirs:
+        return
+    _write_parallel_cypress_failures(project, [])
+    failures = []
+    prepared = []
+    for suite_dir in suite_dirs:
+        role = os.path.basename(suite_dir)
+        try:
+            logger.info(f"Installing cypress dependencies for {role} before parallel run")
+            _install_cypress_suite_dependencies(
+                suite_dir, logger, project, reactor, suite_name=role
+            )
+            prepared.append(suite_dir)
+        except Exception as error:
+            failures.append(f"{role}: {error}")
+
+    work_items = _cypress_parallel_work_items(prepared, project)
+    if not work_items:
+        _merge_parallel_cypress_suite_logs(project, logger, [], extra_failures=failures)
+        if failures:
+            raise BuildFailedException(
+                "Parallel cypress suites failed: " + "; ".join(sorted(failures))
+            )
+        return
+
+    if len(work_items) == 1 and not failures:
+        suite_dir, name, spec_files = work_items[0]
+        logger.info(f"Running {suite_dir}")
+        try:
+            _run_cypress_tests_in_directory(
+                work_dir=suite_dir,
+                logger=logger,
+                project=project,
+                reactor=reactor,
+                write_summary=False,
+                skip_install=True,
+            )
+        except Exception as error:
+            failures.append(f"{name}: {error}")
+            _write_parallel_cypress_failures(project, failures)
+            _write_cypress_summary(project, logger, extra_failures=failures)
+            raise
+        _write_cypress_summary(project, logger)
+        return
+
+    workers = _parallel_cypress_suite_workers(project, len(work_items))
+    logger.info(
+        f"Running {len(work_items)} cypress shards in parallel (workers={workers})"
+    )
+
+    def run_item(work_item):
+        suite_dir, name, spec_files = work_item
+        logger.info(f"Running {suite_dir} [{name}]")
+        try:
+            _run_cypress_tests_in_directory(
+                work_dir=suite_dir,
+                logger=logger,
+                project=project,
+                reactor=reactor,
+                suite_name=name,
+                write_summary=False,
+                spec_files=spec_files,
+                skip_install=True,
+                record=False,
+            )
+            return "ran"
+        except BuildFailedException:
+            if spec_files and _cypress_shard_had_no_matching_specs(project, name):
+                logger.info(
+                    f"Cypress shard {name} had no specs after applying configured filters"
+                )
+                return "empty"
+            raise
+
+    ran_items = 0
+    empty_items = 0
+    try:
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = {executor.submit(run_item, item): item for item in work_items}
+            for future in as_completed(futures):
+                suite_dir, name, _spec_files = futures[future]
+                try:
+                    result = future.result()
+                    if result == "empty":
+                        empty_items += 1
+                    else:
+                        ran_items += 1
+                except Exception as error:
+                    failures.append(f"{name}: {error}")
+    finally:
+        if not failures and empty_items and not ran_items:
+            failures.append(
+                "No Cypress specs matched the configured specPattern and test filters"
+            )
+        shard_names = [name for _suite_dir, name, _spec_files in work_items]
+        _merge_parallel_cypress_suite_logs(
+            project, logger, shard_names, extra_failures=failures
+        )
+
+    if failures:
+        raise BuildFailedException(
+            "Parallel cypress suites failed: " + "; ".join(sorted(failures))
+        )
+
+
+def _cypress_parallel_work_items(suite_dirs, project):
+    items = []
+    for suite_dir in suite_dirs:
+        role = os.path.basename(suite_dir)
+        specs = _iter_cypress_spec_files(suite_dir)
+        if len(specs) > 1:
+            workers = _parallel_cypress_suite_workers(project, len(specs))
+            chunks = _partition_cypress_specs(specs, workers)
+            for index, chunk in enumerate(chunks):
+                name = role if len(chunks) == 1 else f"{role}-{index}"
+                items.append((suite_dir, name, chunk))
+        else:
+            items.append((suite_dir, role, None))
+    return items
+
+
+def _iter_cypress_spec_files(work_dir):
+    specs = []
+    for root, dirs, files in os.walk(work_dir):
+        dirs[:] = [directory for directory in dirs if directory not in _CYPRESS_SPEC_SKIP_DIRS]
+        for filename in files:
+            lower = filename.lower()
+            if any(lower.endswith(suffix) for suffix in _CYPRESS_SPEC_SUFFIXES):
+                relative = os.path.relpath(os.path.join(root, filename), work_dir)
+                specs.append(relative.replace(os.sep, "/"))
+    return sorted(specs)
+
+
+def _cypress_shard_had_no_matching_specs(project, shard_name):
+    log_path = os.path.join(
+        prepare_logs_directory(project), f"cypress_run_{shard_name}.log"
+    )
+    for candidate in (log_path, f"{log_path}.err"):
+        try:
+            with open(candidate, encoding="utf-8", errors="replace") as log_file:
+                output = log_file.read()
+        except OSError:
+            continue
+        if re.search(r"no spec files were found|Specs:\s*0 found", output, re.IGNORECASE):
+            return True
+    return False
+
+
+def _partition_cypress_specs(specs, worker_count):
+    workers = max(1, min(worker_count, len(specs)))
+    chunks = [[] for _ in range(workers)]
+    for index, spec in enumerate(specs):
+        chunks[index % workers].append(spec)
+    return [chunk for chunk in chunks if chunk]
+
+
+def _merge_parallel_cypress_suite_logs(project, logger, shard_names, extra_failures=None):
+    parent_cypress_log = os.path.join(prepare_logs_directory(project), "cypress_run.log")
+    appended = False
+    for name in sorted(shard_names):
+        source = os.path.join(prepare_logs_directory(project), f"cypress_run_{name}.log")
+        if os.path.isfile(source) and os.path.getsize(source) > 0:
+            _copy_cypress_log(source, parent_cypress_log, appended)
+            appended = True
+    _write_parallel_cypress_failures(project, extra_failures or [])
+    _write_cypress_summary(project, logger, extra_failures=extra_failures)
+
+
+def _write_parallel_cypress_failures(project, failures):
+    path = os.path.join(prepare_logs_directory(project), _CYPRESS_PARALLEL_FAILURES_FILE)
+    if not failures:
+        if os.path.isfile(path):
+            os.remove(path)
+        return
+    redacted_failures = [
+        _redact_secret_log_text(str(failure)).strip() for failure in failures
+    ]
+    with os.fdopen(
+        os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+        "w",
+        encoding="utf-8",
+    ) as failures_file:
+        json.dump(redacted_failures, failures_file)
+
+
 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}")
@@ -1005,7 +1333,23 @@ def verify_cypress(project: Project, logger: Logger, reactor: Reactor):
         package_artifacts(project, work_dir, "cypress", project.get_property(ROLE))
 
 
-def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor):
+def _install_cypress_suite_dependencies(work_dir, logger, project, reactor, suite_name=None):
+    npm_log_file = f"package_json_npm_install_{suite_name}.log" if suite_name else "package_json_npm_install.log"
+    cypress_npm_log_file = f"cypress_npm_install_{suite_name}.log" if suite_name else "cypress_npm_install.log"
+    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, log_file_name=npm_log_file
+        )
+    else:
+        install_cypress(
+            logger=logger, project=project, reactor=reactor, work_dir=work_dir, log_file_name=cypress_npm_log_file
+        )
+
+
+def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor, suite_name=None, write_summary=True,
+                                    spec_files=None, skip_install=False, record=None):
     total_time = Timer.start()
     target_url = project.get_mandatory_property(INTEGRATION_TARGET_URL)
     environment = project.get_mandatory_property(ENVIRONMENT)
@@ -1014,64 +1358,77 @@ def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor)
         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)
+    if not skip_install:
+        _install_cypress_suite_dependencies(work_dir, logger, project, reactor, suite_name=suite_name)
     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")
+    report_name = suite_name or os.path.basename(work_dir)
+    results_file = os.path.join(prepare_reports_directory(project), f"cypress-{report_name}.out.xml")
     # Run the actual tests against the baseURL provided by ${integration_target}
     test_report_folder = directory_utility.prepare_reports_directory(project)
+    videos_folder = f"{test_report_folder}/videos"
+    screenshots_folder = f"{test_report_folder}/screenshots"
+    if suite_name:
+        videos_folder = f"{videos_folder}/{suite_name}"
+        screenshots_folder = f"{screenshots_folder}/{suite_name}"
     args = ["run", "--config",
             f"baseUrl={target_url},"
-            f"videosFolder={test_report_folder}/videos,"
-            f"screenshotsFolder={test_report_folder}/screenshots",
+            f"videosFolder={videos_folder},"
+            f"screenshotsFolder={screenshots_folder}",
             "--reporter-options",
             f"mochaFile={results_file}"]
-    if _get_bool_property(project, "record_cypress", True):
+    should_record = _get_bool_property(project, "record_cypress", True) if record is None else bool(record)
+    if should_record:
         args.append('--record')
+    if spec_files:
+        args.extend(["--spec", ",".join(spec_files)])
     _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}")
+    log_file_name = f"cypress_run_{suite_name}.log" if suite_name else "cypress_run.log"
     try:
         exec_utility.exec_command(command_name=executable, args=args,
-                                  failure_message="Failed to execute cypress tests", log_file_name='cypress_run.log',
+                                  failure_message="Failed to execute cypress tests", log_file_name=log_file_name,
                                   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)
+            with _CYPRESS_TARGET_COPY_LOCK:
+                shutil.copytree(f"{work_dir}/target", project.expand_path("$dir_target"), dirs_exist_ok=True)
     finally:
-        _write_cypress_summary(project, logger)
+        if write_summary:
+            _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):
+def _write_cypress_summary(project, logger, extra_failures=None):
     """Parse cypress_run.log and write a portable Markdown summary artifact.
 
-    No-op when Cypress did not run (missing or empty cypress_run.log), so
-    verify_environment jobs without Cypress do not emit a false warning.
-    Parallel child subprocesses also skip it; the parent writes one summary
-    after merging child Cypress logs.
+    No-op when Cypress did not run (missing or empty cypress_run.log) and
+    there are no extra_failures, so verify_environment jobs without Cypress
+    do not emit a false warning. Parallel child subprocesses also skip it;
+    the parent writes one summary after merging child Cypress logs.
+    extra_failures keeps the summary from reporting PASS when a parallel
+    shard failed before producing JUnit.
     """
+    extra_failures = extra_failures or []
     log_path = os.path.join(prepare_logs_directory(project), "cypress_run.log")
     if os.environ.get(SUBPROCESS_PROPERTIES_FILE_ENV):
         logger.debug("Skipping Cypress summary in verify_environment subprocess")
         return None
-    if not os.path.isfile(log_path) or os.path.getsize(log_path) == 0:
+    has_log = os.path.isfile(log_path) and os.path.getsize(log_path) > 0
+    if not has_log and not extra_failures:
         logger.debug("Skipping Cypress summary: cypress_run.log not found")
         return None
     summary_path = os.path.join(prepare_reports_directory(project), "cypress-summary.md")
     try:
-        output = _redact_secret_log_text(_build_cypress_summary(log_path))
+        output = _redact_secret_log_text(
+            _build_cypress_summary(log_path if has_log else None, extra_failures)
+        )
         with os.fdopen(
             os.open(summary_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
             "w",
@@ -1092,33 +1449,40 @@ def _write_cypress_summary(project, logger):
         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)
-
+def _build_cypress_summary(log_path, extra_failures=None):
+    extra_failures = extra_failures or []
     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, DefusedXmlException):
-            pass
+    if log_path and os.path.exists(log_path):
+        raw = open(log_path, errors="replace").read()
+        clean = re.sub(r"\x1b\[[0-9;]*m", "", raw)
+
+        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, DefusedXmlException):
+                pass
+    elif not extra_failures:
+        return "## Cypress Test Results\n\n> warning `cypress_run.log` not found\n"
 
     passed = total - failed - skipped
-    if total == 0:
+    if extra_failures:
+        icon = "FAIL"
+        if failed:
+            label = f"{failed} test(s) failed; {len(extra_failures)} suite(s) failed"
+        else:
+            label = f"{len(extra_failures)} parallel suite(s) failed"
+    elif total == 0:
         icon = "WARN"
         label = "No tests ran - check if Cypress found any spec files"
     elif failed == 0:
@@ -1145,6 +1509,13 @@ def _build_cypress_summary(log_path):
         if len(failures) > 20:
             lines.append(f"\n_...and {len(failures) - 20} more_")
 
+    if extra_failures:
+        lines.append("\n### Parallel Suite Failures\n")
+        for extra in extra_failures[:20]:
+            lines.append(f"- **{extra}**")
+        if len(extra_failures) > 20:
+            lines.append(f"\n_...and {len(extra_failures) - 20} more_")
+
     return "\n".join(lines) + "\n"
 
 
@@ -1227,10 +1598,18 @@ def _plugin_venv_python(reactor):
     raise BuildFailedException("plugin venv python is missing or not executable")
 
 
-def _tavern_suite_site_directory(project, role):
+def _tavern_requirements_fingerprint(test_dir):
+    requirements_file = os.path.join(test_dir, "requirements.txt")
+    if not os.path.isfile(requirements_file):
+        return None
+    with open(requirements_file, "rb") as requirements:
+        return hashlib.sha256(requirements.read()).hexdigest()
+
+
+def _tavern_suite_site_directory(project, fingerprint):
     root = project.expand_path("$dir_target/integration/tavern-sites")
     directory_utility._ensure_directory_exists(root)
-    site = os.path.join(root, role)
+    site = os.path.join(root, fingerprint)
     if os.path.islink(site) or os.path.isfile(site):
         os.unlink(site)
     elif os.path.isdir(site):
@@ -1239,37 +1618,45 @@ def _tavern_suite_site_directory(project, role):
     return site
 
 
+def _tavern_pip_cache_directory(project, fingerprint):
+    cache = os.path.join(project.expand_path("$dir_target/integration/tavern-pip-cache"), fingerprint)
+    return directory_utility._ensure_directory_exists(cache)
+
+
 def _isolated_suite_subprocess_env(extra_pythonpath=None):
     env = os.environ.copy()
     env.pop("GITHUB_STEP_SUMMARY", None)
     env.pop("PYTHONHOME", None)
     env.pop("VIRTUAL_ENV", None)
     env.pop("PYTHONPATH", None)
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
     if extra_pythonpath:
         env["PYTHONPATH"] = extra_pythonpath
     return env
 
 
-def _install_tavern_suite_site(test_dir, logger, project, reactor):
+def _install_tavern_suite_site(test_dir, logger, project, reactor, fingerprint):
     requirements_file = os.path.join(test_dir, "requirements.txt")
-    if not os.path.exists(requirements_file):
+    if not os.path.isfile(requirements_file):
         return None
     role = os.path.basename(test_dir)
-    site = _tavern_suite_site_directory(project, role)
+    site = _tavern_suite_site_directory(project, fingerprint)
+    env = _isolated_suite_subprocess_env()
+    env["PIP_CACHE_DIR"] = _tavern_pip_cache_directory(project, fingerprint)
     command = [_plugin_venv_python(reactor), "-m", "pip", "install", "-r", requirements_file, "-t", site]
-    logger.info(f"Installing tavern requirements for {role} into {site}")
+    logger.info(f"Installing tavern requirements from {role} into isolated site {site}")
     process = subprocess.Popen(
         command,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         cwd=test_dir,
-        env=_isolated_suite_subprocess_env(),
+        env=env,
         shell=False,
     )
     returncode = _stream_subprocess_output(process, logger, role)
     if returncode != 0:
         raise BuildFailedException(
-            f"Failed to install tavern requirements for {role} into isolated site {site}"
+            f"Failed to install tavern requirements from {role} into isolated site {site}"
         )
     return site
 

{pybuilder_integration-109 → pybuilder_integration-112}/pybuilder_integration/tool_utility.py

@@ -5,12 +5,12 @@ 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):
+def install_cypress(logger: Logger, project: Project, reactor: Reactor, work_dir, log_file_name=None):
     _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))
+                 log_file_name or 'cypress_npm_install.log', project, reactor, logger, report=False,
+                 working_dir=work_dir, env_vars=_get_npm_env(project))
 
 
 def _verify_npm(reactor):
@@ -18,12 +18,12 @@ def _verify_npm(reactor):
         command_and_arguments=["npm", "--version"], prerequisite="npm", caller="integration_tests")
 
 
-def install_npm_dependencies(work_dir, project, logger, reactor):
+def install_npm_dependencies(work_dir, project, logger, reactor, log_file_name=None):
     _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))
+             log_file_name or '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):

{pybuilder_integration-109 → pybuilder_integration-112}/pybuilder_integration.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybuilder-integration
-Version: 109
+Version: 112
 Summary: A pybuilder plugin that runs integration tests (Tavern & Cypress) against a target.
 Home-page: https://github.com/rspitler/pybuilder-integration
 Author: 

{pybuilder_integration-109 → pybuilder_integration-112}/setup.py

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