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

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

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

{pybuilder_integration-107 → pybuilder_integration-109}/pybuilder_integration/directory_utility.py

@@ -29,8 +29,7 @@ def prepare_directory(dir_variable, project):
 
 
 def _ensure_directory_exists(path):
-    if not os.path.exists(path):
-        os.makedirs(path)
+    os.makedirs(path, exist_ok=True)
     return path
 
 

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

@@ -20,5 +20,7 @@ CONSOLIDATE_TESTS = "consolidate_tavern"
 SKIP_NON_MATCHING_TAVERN_ARTIFACTS = "skip_non_matching_tavern_artifacts"
 TESTING_SCOPE = "testing_scope"
 PARALLEL_VERIFY_ENVIRONMENT = "parallel_verify_environment"
+PARALLEL_TAVERN_SUITES = "parallel_tavern_suites"
+PARALLEL_TAVERN_SUITES_WORKERS = "parallel_tavern_suites_workers"
 SUBPROCESS_PROPERTIES_FILE_ENV = "PYBUILDER_INTEGRATION_PROPERTIES_FILE"
 CYPRESS_CACHE_FOLDER = "cypress_cache_folder"

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

@@ -1,9 +1,13 @@
+import atexit
+import errno
 import json
 import os
 import re
 import shutil
 import subprocess
 import tempfile
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from defusedxml import ElementTree as ET
 from defusedxml.common import DefusedXmlException
@@ -45,11 +49,16 @@ _VERIFY_ENVIRONMENT_SUBPROCESS_PROPERTIES = [
     CONSOLIDATE_TESTS,
     SKIP_NON_MATCHING_TAVERN_ARTIFACTS,
     TESTING_SCOPE,
+    PARALLEL_TAVERN_SUITES,
+    PARALLEL_TAVERN_SUITES_WORKERS,
     "abort_upload",
     "record_cypress",
     "verbose",
 ]
 
+_TAVERN_INSTALL_LOCK = threading.Lock()
+_DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS = 8
+
 def integration_artifact_push(project: Project, logger: Logger, reactor: Reactor):
     logger.info("Starting upload of integration artifacts")
     manager = get_artifact_manager(project)
@@ -124,15 +133,21 @@ def _run_verify_environment_passes_in_subprocesses(project: Project, logger: Log
             process, log_file = _start_verify_environment_subprocess(project, logger, pass_config, properties_file)
             processes.append((pass_config, process, log_file))
 
-        failures = []
+        results = []
         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}")
-
+            _close_subprocess_log(process)
+            results.append({
+                "name": pass_config["name"],
+                "exit_code": exit_code,
+                "log_file": log_file,
+            })
+
+        _log_parallel_verify_environment_summary(logger, results)
+        failures = [
+            f"{result['name']} exit_code={result['exit_code']} log={result['log_file']}"
+            for result in results if result["exit_code"] != 0
+        ]
         if failures:
             raise BuildFailedException("Parallel verify_environment failed: " + "; ".join(failures))
     finally:
@@ -141,24 +156,422 @@ def _run_verify_environment_passes_in_subprocesses(project: Project, logger: Log
             if callable(poll) and poll() is None:
                 process.terminate()
                 process.wait()
-            log_handle = getattr(process, "_pybuilder_integration_log_handle", None)
-            if log_handle and not log_handle.closed:
-                log_handle.close()
+            _close_subprocess_log(process)
         _merge_parallel_verify_environment_outputs(project, passes)
+        _write_cypress_summary(project, logger)
         if os.path.exists(properties_file):
             os.remove(properties_file)
 
 
+_ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
+_SUITE_RUNNING_LINE = re.compile(
+    r"^\[INFO\]\s+Running (?!tavern tests\b|against target\b|cypress on host\b|args:).+"
+)
+_SECRET_QUOTE = r"(?:['\"]|"|')?"
+_SECRET_VALUE = rf"{_SECRET_QUOTE}[^'\"\s<&>,}}]+"
+_SECRET_LITERAL_VALUE = rf"(?!(?:true|false|yes|no|on|off|null|none)\b){_SECRET_VALUE}"
+_SECRET_KEY_NAME = (
+    r"(?:[A-Za-z][A-Za-z0-9]*[_-])*"
+    r"(?:"
+    r"x-api-key|x-amz-security-token|"
+    r"api[_-]?key|secret[_-]?access[_-]?key|access[_-]?key(?:[_-]?id)?|"
+    r"client[_-]?secret|password|secret|"
+    r"(?:id|access|refresh|session)?[_-]?token"
+    r")"
+)
+_SECRET_HINT_LINE = re.compile(
+    r"("
+    rf"\bauthorization\b{_SECRET_QUOTE}\s*:\s*{_SECRET_QUOTE}(?:(?:bearer|basic)\s+)?{_SECRET_VALUE}"
+    rf"|\b(?:set-cookie|cookie)\b{_SECRET_QUOTE}\s*:\s*{_SECRET_QUOTE}{_SECRET_VALUE}(?:\s*;\s*{_SECRET_VALUE})*"
+    rf"|{_SECRET_KEY_NAME}{_SECRET_QUOTE}\s*[:=]\s*{_SECRET_LITERAL_VALUE}"
+    r"|\bbearer\s+[A-Za-z0-9._\-]+"
+    r"|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}(?:\.[A-Za-z0-9_-]{10,})?"
+    r"|https?://[^/\s]+:[^/\s]+@"
+    r"|\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})"
+    r")",
+    re.IGNORECASE,
+)
+_REDACTED_SECRET = "[redacted]"
+_REDACTED_COPY_EXTENSIONS = {".html", ".json", ".log", ".md", ".out", ".txt", ".xml"}
+_REDACT_STAGING_DIRNAME = ".pybuilder-integration-redact"
+_REDACT_TEMP_FILES = set()
+_SUBPROCESS_LOG_JOIN_SECONDS = 30
+
+
+def _log_parallel_verify_environment_summary(logger: Logger, results):
+    summary = _build_parallel_verify_environment_summary(results)
+    print(summary)
+    github_summary_path = os.environ.get("GITHUB_STEP_SUMMARY")
+    if not github_summary_path:
+        return
+    try:
+        with os.fdopen(
+            os.open(github_summary_path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600),
+            "a",
+            encoding="utf-8",
+        ) as summary_file:
+            summary_file.write(summary)
+            if not summary.endswith("\n"):
+                summary_file.write("\n")
+    except OSError:
+        logger.warn("Could not append parallel verify_environment summary to GITHUB_STEP_SUMMARY")
+
+
+def _build_parallel_verify_environment_summary(results):
+    lines = ["Parallel verify_environment summary"]
+    for result in results:
+        status = "PASSED" if result["exit_code"] == 0 else "FAILED"
+        lines.append(f"  {result['name']}: {status} (exit_code={result['exit_code']})")
+    for result in results:
+        if result["exit_code"] == 0:
+            continue
+        lines.append(f"  {result['name']} log: {result['log_file']}")
+        for hint in _extract_parallel_verify_failure_hints(result["log_file"]):
+            lines.append(f"    {hint}")
+    return "\n".join(lines) + "\n"
+
+
+def _extract_parallel_verify_failure_hints(log_file, max_hints=12):
+    if not log_file or not os.path.exists(log_file):
+        return ["child log was not found"]
+    try:
+        with open(log_file, encoding="utf-8", errors="replace") as log_handle:
+            raw = log_handle.read()
+    except OSError:
+        return ["child log could not be read"]
+    text = _ANSI_ESCAPE.sub("", raw)
+    lines = [line.rstrip() for line in text.splitlines()]
+    last_running = None
+    last_build_failed = None
+    failed_tests = []
+    session_summaries = []
+    extra_failures = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if _SUITE_RUNNING_LINE.match(stripped):
+            last_running = stripped
+        elif stripped.startswith("BUILD FAILED"):
+            last_build_failed = stripped
+        elif stripped.startswith("FAILED ") and "::" in stripped:
+            failed_tests.append(stripped)
+        elif stripped.startswith("===") and "failed" in stripped.lower():
+            session_summaries.append(stripped)
+        elif stripped.startswith("### FAIL") or "Failed to execute cypress" in stripped:
+            extra_failures.append(stripped)
+    hints = []
+    if last_running:
+        hints.append(last_running)
+    if last_build_failed:
+        hints.append(last_build_failed)
+    hints.extend(extra_failures[-3:])
+    hints.extend(failed_tests[-8:])
+    hints.extend(session_summaries[-3:])
+    if hints:
+        return _without_secret_hint_lines(hints)[:max_hints]
+    tail = [line.strip() for line in lines[-20:] if line.strip()]
+    if not tail:
+        return ["child log was empty"]
+    return _without_secret_hint_lines(tail)[-max_hints:]
+
+
+def _start_subprocess_output_tee(process, log_handle, logger: Logger, pass_name):
+    stdout = getattr(process, "stdout", None)
+    if stdout is None or isinstance(stdout, (int, str)):
+        process._pybuilder_integration_log_thread = None
+        return
+
+    def tee():
+        prefix = f"[{pass_name}] "
+        try:
+            for line in stdout:
+                redacted = _redact_secret_log_line(_decode_subprocess_stdout_line(line))
+                try:
+                    log_handle.write(redacted + "\n")
+                    log_handle.flush()
+                except Exception:
+                    pass
+                try:
+                    logger.info(prefix + redacted)
+                except Exception:
+                    pass
+        finally:
+            try:
+                stdout.close()
+            except Exception:
+                pass
+
+    thread = threading.Thread(target=tee, name=f"verify-environment-{pass_name}-log", daemon=True)
+    thread.start()
+    process._pybuilder_integration_log_thread = thread
+
+
+def _close_subprocess_stdout(process):
+    stdout = getattr(process, "stdout", None)
+    if stdout is None or isinstance(stdout, (int, str)):
+        return
+    try:
+        stdout.close()
+    except Exception:
+        pass
+
+
+def _close_subprocess_log(process):
+    thread = getattr(process, "_pybuilder_integration_log_thread", None)
+    if thread is not None:
+        thread.join(timeout=_SUBPROCESS_LOG_JOIN_SECONDS)
+        if thread.is_alive():
+            _close_subprocess_stdout(process)
+            thread.join(timeout=_SUBPROCESS_LOG_JOIN_SECONDS)
+        if thread.is_alive():
+            return
+        process._pybuilder_integration_log_thread = None
+    log_handle = getattr(process, "_pybuilder_integration_log_handle", None)
+    if log_handle and not getattr(log_handle, "closed", True):
+        log_handle.close()
+
+
+def _decode_subprocess_stdout_line(line):
+    if isinstance(line, bytes):
+        line = line.decode("utf-8", "replace")
+    return line.rstrip("\n\r")
+
+
+def _redact_secret_log_line(line):
+    return _SECRET_HINT_LINE.sub(_REDACTED_SECRET, line)
+
+
+def _redact_secret_log_text(text):
+    if not text:
+        return text
+    return "\n".join(_redact_secret_log_line(line) for line in text.splitlines()) + ("\n" if text.endswith("\n") else "")
+
+
+def _without_secret_hint_lines(lines):
+    return [_redact_secret_log_line(line) for line in lines]
+
+
 _CHILD_OUTPUT_SOURCES = (
     ("logs", "logs"),
     ("reports", "reports"),
     ("reports", "test-reports"),
 )
 _SUBPROCESS_WORKDIR_SKIP = {".pybuilder", "target", ".git", ".nudge-ci-venv"}
+_CHILD_TARGET_LINK_SKIP = {"verify_environment", "logs", "reports", "test-reports"}
+
+
+def _child_output_source_roots(stage_target):
+    return (
+        stage_target,
+        os.path.join(stage_target, "project", "target"),
+    )
+
+
+def _first_child_cypress_log(stage_target):
+    for source_root in _child_output_source_roots(stage_target):
+        candidate = os.path.join(source_root, "logs", "integration", "cypress_run.log")
+        if os.path.isfile(candidate):
+            return candidate
+    return None
+
+
+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)
+        return dst
+    return shutil.copy2(src, dst, follow_symlinks=follow_symlinks)
+
+
+def _redact_text_file_inplace(path):
+    if os.path.islink(path) or not os.path.isfile(path):
+        return
+    try:
+        with open(path, encoding="utf-8", errors="replace") as source_file:
+            text = source_file.read()
+    except OSError:
+        return
+    redacted = _redact_secret_log_text(text)
+    if redacted == text:
+        return
+    fd, temporary_copy = tempfile.mkstemp(
+        prefix=f".{os.path.basename(path)}.",
+        suffix=".redact",
+        dir=tempfile.gettempdir(),
+    )
+    _register_redact_temp(temporary_copy)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as dest_file:
+            dest_file.write(redacted)
+            dest_file.flush()
+            os.fchmod(dest_file.fileno(), 0o600)
+        _replace_redacted_tempfile(temporary_copy, path)
+    except OSError:
+        _unlink_redact_temp(temporary_copy)
+
+
+def _register_redact_temp(path):
+    _REDACT_TEMP_FILES.add(path)
+    if not getattr(_register_redact_temp, "_atexit_registered", False):
+        atexit.register(_cleanup_redact_temps)
+        _register_redact_temp._atexit_registered = True
+
+
+def _unlink_redact_temp(path):
+    try:
+        os.unlink(path)
+    except OSError:
+        pass
+    _REDACT_TEMP_FILES.discard(path)
+
+
+def _cleanup_redact_temps():
+    for path in list(_REDACT_TEMP_FILES):
+        _unlink_redact_temp(path)
+
+
+def _same_device_staging_base(path):
+    dest = os.path.abspath(path)
+    dest_dev = os.stat(dest).st_dev
+    current = dest if os.path.isdir(dest) else os.path.dirname(dest)
+    last_same = current
+    outside_target = None
+    while True:
+        try:
+            if os.stat(current).st_dev != dest_dev:
+                break
+        except OSError:
+            break
+        last_same = current
+        if "target" not in os.path.abspath(current).split(os.sep):
+            outside_target = current
+            break
+        parent = os.path.dirname(current)
+        if parent == current:
+            break
+        current = parent
+    return outside_target or last_same
+
+
+def _same_device_staging_dir(path):
+    staging = os.path.join(_same_device_staging_base(path), _REDACT_STAGING_DIRNAME)
+    os.makedirs(staging, mode=0o700, exist_ok=True)
+    try:
+        os.chmod(staging, 0o700)
+    except OSError:
+        pass
+    return staging
+
+
+def _remove_empty_redact_staging_dir(staging):
+    try:
+        os.rmdir(staging)
+    except OSError:
+        pass
+
+
+def _purge_redact_staging_dir(staging):
+    if os.path.basename(os.path.abspath(staging)) != _REDACT_STAGING_DIRNAME:
+        return
+    if os.path.islink(staging) or not os.path.isdir(staging):
+        return
+    for name in os.listdir(staging):
+        path = os.path.join(staging, name)
+        try:
+            if os.path.isdir(path) and not os.path.islink(path):
+                shutil.rmtree(path)
+            else:
+                os.unlink(path)
+        except OSError:
+            pass
+        _REDACT_TEMP_FILES.discard(path)
+    _remove_empty_redact_staging_dir(staging)
+
+
+def _redact_staging_candidates(path):
+    candidates = []
+    try:
+        candidates.append(os.path.join(_same_device_staging_base(path), _REDACT_STAGING_DIRNAME))
+    except OSError:
+        pass
+    abs_path = os.path.abspath(path)
+    if os.path.isdir(abs_path):
+        candidates.append(os.path.join(abs_path, _REDACT_STAGING_DIRNAME))
+    return candidates
+
+
+def _purge_known_redact_staging_dirs(*paths):
+    seen = set()
+    for path in paths:
+        if not path or not os.path.exists(path):
+            continue
+        for staging in _redact_staging_candidates(path):
+            if staging in seen:
+                continue
+            seen.add(staging)
+            _purge_redact_staging_dir(staging)
+
+
+def _replace_redacted_tempfile(temporary_copy, path):
+    try:
+        os.replace(temporary_copy, path)
+        _REDACT_TEMP_FILES.discard(temporary_copy)
+        return
+    except OSError as error:
+        if getattr(error, "errno", None) != errno.EXDEV:
+            raise
+    staging = _same_device_staging_dir(path)
+    fd, local_copy = tempfile.mkstemp(
+        prefix=f".{os.path.basename(path)}.",
+        suffix=".redact",
+        dir=staging,
+    )
+    _register_redact_temp(local_copy)
+    try:
+        with os.fdopen(fd, "wb") as destination, open(temporary_copy, "rb") as source:
+            shutil.copyfileobj(source, destination)
+            destination.flush()
+            os.fchmod(destination.fileno(), 0o600)
+        os.replace(local_copy, path)
+        _REDACT_TEMP_FILES.discard(local_copy)
+    except OSError:
+        _unlink_redact_temp(local_copy)
+        raise
+    finally:
+        _unlink_redact_temp(temporary_copy)
+        _remove_empty_redact_staging_dir(staging)
+
+
+def _redact_directory_text_files(root):
+    if not os.path.isdir(root):
+        return
+    _purge_known_redact_staging_dirs(root)
+    for dirpath, dirnames, filenames in os.walk(root):
+        if _REDACT_STAGING_DIRNAME in dirnames:
+            dirnames.remove(_REDACT_STAGING_DIRNAME)
+        for name in filenames:
+            if os.path.splitext(name)[1].lower() not in _REDACTED_COPY_EXTENSIONS:
+                continue
+            _redact_text_file_inplace(os.path.join(dirpath, name))
+
+
+def _copy_redacted_text_file(src, dst):
+    parent = os.path.dirname(dst)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+    try:
+        with open(src, encoding="utf-8", errors="replace") as source_file:
+            text = _redact_secret_log_text(source_file.read())
+    except OSError:
+        shutil.copy2(src, dst)
+        return
+    with os.fdopen(os.open(dst, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), "w", encoding="utf-8") as dest_file:
+        dest_file.write(text)
 
 
 def _merge_parallel_verify_environment_outputs(project: Project, passes):
     parent_target = project.expand_path("$dir_target")
+    _purge_known_redact_staging_dirs(parent_target, project.basedir)
     parent_logs_directory = prepare_logs_directory(project)
     parent_destinations = {
         "logs": parent_logs_directory,
@@ -168,29 +581,36 @@ def _merge_parallel_verify_environment_outputs(project: Project, passes):
     has_parent_cypress_log = False
     for pass_config in passes:
         stage_target = os.path.join(parent_target, "verify_environment", pass_config["name"])
-        for destination_kind, source_dirname in _CHILD_OUTPUT_SOURCES:
-            source = os.path.join(stage_target, source_dirname, "integration")
-            if not os.path.exists(source):
-                continue
-            destination = os.path.join(
-                parent_destinations[destination_kind],
-                "parallel",
-                pass_config["name"],
-            )
-            shutil.copytree(source, destination, dirs_exist_ok=True)
-            if destination_kind == "logs":
-                cypress_log = os.path.join(source, "cypress_run.log")
-                if os.path.exists(cypress_log):
-                    _copy_cypress_log(cypress_log, parent_cypress_log, has_parent_cypress_log)
-                    has_parent_cypress_log = True
+        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")
+                if not os.path.exists(source):
+                    continue
+                _redact_directory_text_files(source)
+                destination = os.path.join(
+                    parent_destinations[destination_kind],
+                    "parallel",
+                    pass_config["name"],
+                )
+                shutil.copytree(source, destination, dirs_exist_ok=True, copy_function=_copy_maybe_redacted_file)
+        cypress_log = _first_child_cypress_log(stage_target)
+        if cypress_log:
+            _copy_cypress_log(cypress_log, parent_cypress_log, has_parent_cypress_log)
+            has_parent_cypress_log = True
 
 
 def _copy_cypress_log(source, destination, append):
+    try:
+        with open(source, encoding="utf-8", errors="replace") as source_file:
+            text = _redact_secret_log_text(source_file.read())
+    except OSError:
+        return
+    if text and not text.endswith("\n"):
+        text += "\n"
     flags = os.O_WRONLY | os.O_CREAT | (os.O_APPEND if append else os.O_TRUNC)
-    mode = "ab" if append else "wb"
-    with open(source, "rb") as source_file:
-        with os.fdopen(os.open(destination, flags, 0o600), mode) as destination_file:
-            shutil.copyfileobj(source_file, destination_file)
+    mode = "a" if append else "w"
+    with os.fdopen(os.open(destination, flags, 0o600), mode, encoding="utf-8") as destination_file:
+        destination_file.write(text)
 
 
 def _verify_environment_subprocess_stage_dir(project: Project, pass_config):
@@ -231,7 +651,7 @@ def _link_parent_target_tree(project: Project, workdir):
     if not os.path.isdir(parent_target):
         return
     for name in os.listdir(parent_target):
-        if name == "verify_environment":
+        if name in _CHILD_TARGET_LINK_SKIP:
             continue
         os.symlink(os.path.join(parent_target, name), os.path.join(child_target, name))
 
@@ -317,21 +737,27 @@ _PYBUILDER_CLI_MAIN = "import sys; from pybuilder.cli import main; raise SystemE
 def _isolated_plugin_python_command(plugin_python, args):
     pyb_script = os.path.join(os.path.dirname(plugin_python), "pyb")
     if os.path.isfile(pyb_script):
-        return [plugin_python, pyb_script] + args
-    return [plugin_python, "-c", _PYBUILDER_CLI_MAIN] + args
+        return [plugin_python, "-u", pyb_script] + args
+    return [plugin_python, "-u", "-c", _PYBUILDER_CLI_MAIN] + args
 
 
 def _uses_isolated_plugin_python(command):
     if len(command) < 2:
         return False
-    if command[1] == "-c":
-        return len(command) >= 3 and command[2] == _PYBUILDER_CLI_MAIN
-    return os.path.basename(command[1]) == "pyb"
+    args = command[1:]
+    if args and args[0] == "-u":
+        args = args[1:]
+    if not args:
+        return False
+    if args[0] == "-c":
+        return len(args) >= 2 and args[1] == _PYBUILDER_CLI_MAIN
+    return os.path.basename(args[0]) == "pyb"
 
 
 def _verify_environment_subprocess_env(workdir, command, properties_file):
     env = os.environ.copy()
     env[SUBPROCESS_PROPERTIES_FILE_ENV] = properties_file
+    env["PYTHONUNBUFFERED"] = "1"
     env.pop("GITHUB_STEP_SUMMARY", None)
     env.pop("PYTHONHOME", None)
     env.pop("VIRTUAL_ENV", None)
@@ -354,15 +780,16 @@ def _start_verify_environment_subprocess(project: Project, logger: Logger, pass_
     )
     try:
         process = subprocess.Popen(command,
-                                   stdout=log_handle,
+                                   stdout=subprocess.PIPE,
                                    stderr=subprocess.STDOUT,
                                    cwd=workdir,
                                    env=env,
                                    shell=False)
+        process._pybuilder_integration_log_handle = log_handle
+        _start_subprocess_output_tee(process, log_handle, logger, pass_config["name"])
     except Exception:
         log_handle.close()
         raise
-    process._pybuilder_integration_log_handle = log_handle
     return process, log_file
 
 
@@ -465,15 +892,17 @@ def _run_tavern_tests_in_dist_dir(dist_directory, latest, logger, project, react
         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,
+            suite_dirs = list(_iter_latest_tavern_suite_dirs(tavern_test_path, project))
+            if _get_bool_property(project, PARALLEL_TAVERN_SUITES, False) and len(suite_dirs) > 1:
+                _run_tavern_suites_parallel(suite_dirs, logger, project, reactor)
+            else:
+                for tavern_test_directory in suite_dirs:
+                    logger.info(f"Running {tavern_test_directory}")
+                    _run_tavern_tests_in_dir(test_dir=tavern_test_directory,
                                              logger=logger,
                                              project=project,
                                              reactor=reactor,
-                                             role=os.path.basename(tavern_dir))
+                                             role=os.path.basename(tavern_test_directory))
         else:
             _run_tavern_tests_in_dir(test_dir=f"{tavern_test_path}",
                                      logger=logger,
@@ -483,6 +912,92 @@ def _run_tavern_tests_in_dist_dir(dist_directory, latest, logger, project, react
     logger.info(f"Ran Tavern tests: {total_time.get_millis()}")
 
 
+def _iter_latest_tavern_suite_dirs(tavern_test_path, project):
+    for tavern_dir in sorted(os.listdir(tavern_test_path)):
+        tavern_test_directory = os.path.join(tavern_test_path, tavern_dir)
+        if os.path.isdir(tavern_test_directory) and _should_run_latest(tavern_dir, project):
+            yield tavern_test_directory
+
+
+def _parallel_tavern_suite_workers(project, suite_count):
+    configured = project.get_property(PARALLEL_TAVERN_SUITES_WORKERS, None)
+    if configured is None or configured == "":
+        return max(1, min(_DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS, suite_count))
+    try:
+        workers = int(configured)
+    except (TypeError, ValueError):
+        workers = _DEFAULT_PARALLEL_TAVERN_SUITE_WORKERS
+    return max(1, min(workers, suite_count))
+
+
+def _run_tavern_suites_parallel(suite_dirs, logger, project, reactor):
+    prepare_reports_directory(project)
+    runnable = []
+    for tavern_test_directory in suite_dirs:
+        _, requested_marker, declared_markers, skip_non_matching = _tavern_marker_context(
+            tavern_test_directory, project
+        )
+        if _should_skip_nonmatching_tavern(requested_marker, declared_markers, skip_non_matching):
+            logger.info(
+                f"Skipping Tavern tests: artifact markers {sorted(declared_markers)} do not match {requested_marker}"
+            )
+            continue
+        runnable.append(tavern_test_directory)
+    if not runnable:
+        return
+    if len(runnable) == 1:
+        tavern_test_directory = runnable[0]
+        logger.info(f"Running {tavern_test_directory}")
+        _run_tavern_tests_in_dir(
+            test_dir=tavern_test_directory,
+            logger=logger,
+            project=project,
+            reactor=reactor,
+            role=os.path.basename(tavern_test_directory),
+        )
+        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})")
+    failures = []
+
+    def run_suite(tavern_test_directory):
+        role = os.path.basename(tavern_test_directory)
+        logger.info(f"Running {tavern_test_directory}")
+        _run_tavern_tests_in_dir(
+            test_dir=tavern_test_directory,
+            logger=logger,
+            project=project,
+            reactor=reactor,
+            role=role,
+            isolated=True,
+            skip_install=True,
+            extra_pythonpath=suite_sites[tavern_test_directory],
+        )
+        return role
+
+    with ThreadPoolExecutor(max_workers=workers) as executor:
+        futures = {executor.submit(run_suite, suite_dir): suite_dir for suite_dir in runnable}
+        for future in as_completed(futures):
+            suite_dir = futures[future]
+            role = os.path.basename(suite_dir)
+            try:
+                future.result()
+            except Exception as error:
+                failures.append(f"{role}: {error}")
+
+    if failures:
+        raise BuildFailedException(
+            "Parallel tavern suites failed: " + "; ".join(sorted(failures))
+        )
+
+
 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}")
@@ -540,11 +1055,23 @@ def _run_cypress_tests_in_directory(work_dir, logger, project, reactor: Reactor)
 
 
 def _write_cypress_summary(project, logger):
-    """Parse cypress_run.log and write a portable Markdown summary artifact."""
+    """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.
+    """
     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:
+        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 = _build_cypress_summary(log_path)
+        output = _redact_secret_log_text(_build_cypress_summary(log_path))
         with os.fdopen(
             os.open(summary_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
             "w",
@@ -654,7 +1181,101 @@ def verify_tavern(project: Project, logger: Logger, reactor: 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):
+def _tavern_marker_context(test_dir, project):
+    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 = _get_bool_property(project, SKIP_NON_MATCHING_TAVERN_ARTIFACTS, False)
+    return extra_args, requested_marker, declared_markers, skip_non_matching
+
+
+def _should_skip_nonmatching_tavern(requested_marker, declared_markers, skip_non_matching):
+    return bool(skip_non_matching and requested_marker and declared_markers and requested_marker not in declared_markers)
+
+
+def _install_tavern_requirements(test_dir, logger, project, reactor):
+    requirements_file = os.path.join(test_dir, "requirements.txt")
+    if not os.path.exists(requirements_file):
+        return
+    dependency = RequirementsFile(requirements_file)
+    with _TAVERN_INSTALL_LOCK:
+        install_dependencies(logger, project, dependency, reactor.pybuilder_venv,
+                             f"{prepare_logs_directory(project)}/install_tavern_pip_dependencies.log")
+
+
+def _plugin_venv_executable_path(executable):
+    if executable is None:
+        return None
+    if isinstance(executable, (list, tuple)):
+        if not executable:
+            return None
+        return _plugin_venv_executable_path(executable[0])
+    try:
+        path = os.fspath(executable)
+    except TypeError:
+        return None
+    if isinstance(path, bytes):
+        path = os.fsdecode(path)
+    return path
+
+
+def _plugin_venv_python(reactor):
+    venv = getattr(reactor, "pybuilder_venv", None)
+    path = _plugin_venv_executable_path(getattr(venv, "executable", None))
+    if path and os.path.isfile(path) and os.access(path, os.X_OK):
+        return path
+    raise BuildFailedException("plugin venv python is missing or not executable")
+
+
+def _tavern_suite_site_directory(project, role):
+    root = project.expand_path("$dir_target/integration/tavern-sites")
+    directory_utility._ensure_directory_exists(root)
+    site = os.path.join(root, role)
+    if os.path.islink(site) or os.path.isfile(site):
+        os.unlink(site)
+    elif os.path.isdir(site):
+        shutil.rmtree(site)
+    os.makedirs(site, mode=0o700)
+    return site
+
+
+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)
+    if extra_pythonpath:
+        env["PYTHONPATH"] = extra_pythonpath
+    return env
+
+
+def _install_tavern_suite_site(test_dir, logger, project, reactor):
+    requirements_file = os.path.join(test_dir, "requirements.txt")
+    if not os.path.exists(requirements_file):
+        return None
+    role = os.path.basename(test_dir)
+    site = _tavern_suite_site_directory(project, role)
+    command = [_plugin_venv_python(reactor), "-m", "pip", "install", "-r", requirements_file, "-t", site]
+    logger.info(f"Installing tavern requirements for {role} into {site}")
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        cwd=test_dir,
+        env=_isolated_suite_subprocess_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}"
+        )
+    return site
+
+
+def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, reactor: Reactor, role=None,
+                             isolated=False, skip_install=False, extra_pythonpath=None):
     logger.info("Running tavern tests: {}".format(test_dir))
     if not os.path.exists(test_dir):
         logger.info("Skipping tavern run: no tests")
@@ -662,51 +1283,51 @@ def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, re
     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:
+    extra_args, requested_marker, declared_markers, skip_non_matching = _tavern_marker_context(test_dir, project)
+    if _should_skip_nonmatching_tavern(requested_marker, declared_markers, skip_non_matching):
         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")
+    if not isolated:
+        from sys import path as syspath
+        syspath.insert(0, test_dir)
+    if not skip_install:
+        _install_tavern_requirements(test_dir, logger, project, reactor)
     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):
+    if not isolated and _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)
+    target_url = project.get_property(INTEGRATION_TARGET_URL)
+    public_target_url = project.get_property(INTEGRATION_PUBLIC_TARGET_URL)
+    environment = project.get_property(ENVIRONMENT)
+    pytest_env = _isolated_suite_subprocess_env(extra_pythonpath) if isolated else os.environ.copy()
+    pytest_env['TARGET'] = target_url
+    pytest_env['PUBLIC_TARGET'] = public_target_url
+    pytest_env[ENVIRONMENT] = environment
+    if not isolated:
+        os.environ['TARGET'] = target_url
+        os.environ['PUBLIC_TARGET'] = public_target_url
+        os.environ[ENVIRONMENT] = environment
+    logger.info(f"Running against target: {target_url} and "
+                f"public target: {public_target_url}")
+    logger.debug(f"Running args: {args} ")
+    label = role or os.path.basename(test_dir)
+    ret = _invoke_pytest(args, test_dir, pytest_env, logger, label, isolated, reactor)
+    if _is_pytest_no_tests_collected(ret):
+        fallback_args = _without_tavern_marker_filter(args)
+        if fallback_args != args and (not skip_non_matching 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 = _invoke_pytest(
+                fallback_args, test_dir, pytest_env, logger, label, isolated, reactor
+            )
 
-    if ret != 0:
+    if _is_pytest_failure(ret):
         if role:
             roles = []
             if project.get_property(CONSOLIDATE_TESTS, False):
@@ -723,6 +1344,54 @@ def _run_tavern_tests_in_dir(test_dir: str, logger: Logger, project: Project, re
     return True
 
 
+def _is_pytest_no_tests_collected(ret):
+    if ret is None:
+        return False
+    return int(ret) == int(pytest.ExitCode.NO_TESTS_COLLECTED)
+
+
+def _is_pytest_failure(ret):
+    if ret is None:
+        return True
+    return int(ret) != 0
+
+
+def _invoke_pytest(args, test_dir, env, logger, label, isolated, reactor=None):
+    if not isolated:
+        cache_wd = os.getcwd()
+        try:
+            os.chdir(test_dir)
+            return pytest.main(args)
+        finally:
+            os.chdir(cache_wd)
+    command = [_plugin_venv_python(reactor), "-u", "-m", "pytest"] + args
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        cwd=test_dir,
+        env=env,
+        shell=False,
+    )
+    return _stream_subprocess_output(process, logger, label)
+
+
+def _stream_subprocess_output(process, logger, label):
+    stdout = process.stdout
+    if stdout is None:
+        return process.wait()
+    try:
+        while True:
+            chunk = stdout.readline()
+            if not chunk:
+                break
+            redacted = _redact_secret_log_line(_decode_subprocess_stdout_line(chunk))
+            logger.info(f"[{label}] {redacted}")
+    finally:
+        stdout.close()
+    return process.wait()
+
+
 def _without_tavern_marker_filter(args):
     marker_options = {"-m", "--markexpr"}
     fallback_args = []

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

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

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

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