tenzir-test 0.12.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

tenzir_test/cli.py

@@ -51,6 +51,15 @@ def _normalize_exit_code(value: object) -> int:
     type=click.Path(path_type=Path, dir_okay=False, writable=False, resolve_path=False),
     help="Path to the tenzir-node executable.",
 )
+@click.option(
+    "package_dirs",
+    "--package-dirs",
+    multiple=True,
+    help=(
+        "Comma-separated list of package directories to load (repeatable). "
+        "These only control package visibility; test selection still follows the usual --root/args."
+    ),
+)
 @click.argument(
     "tests",
     nargs=-1,
@@ -124,6 +133,12 @@ def _normalize_exit_code(value: object) -> int:
     is_flag=True,
     help="Stream raw test output directly to the terminal.",
 )
+@click.option(
+    "-v",
+    "--verbose",
+    is_flag=True,
+    help="Print individual test results as they complete. By default, only failures are shown. Automatically enabled in passthrough mode.",
+)
 @click.option(
     "-a",
     "--all-projects",
@@ -137,6 +152,7 @@ def cli(
     root: Path | None,
     tenzir_binary: Path | None,
     tenzir_node_binary: Path | None,
+    package_dirs: tuple[str, ...],
     tests: tuple[Path, ...],
     update: bool,
     debug: bool,
@@ -151,10 +167,19 @@ def cli(
     keep_tmp_dirs: bool,
     jobs: int,
     passthrough: bool,
+    verbose: bool,
     all_projects: bool,
 ) -> int:
     """Execute tenzir-test scenarios."""
 
+    package_paths: list[Path] = []
+    for entry in package_dirs:
+        for piece in entry.split(","):
+            piece = piece.strip()
+            if not piece:
+                continue
+            package_paths.append(Path(piece))
+
     jobs_source = ctx.get_parameter_source("jobs")
     jobs_overridden = jobs_source is not click.core.ParameterSource.DEFAULT
 
@@ -163,6 +188,7 @@ def cli(
             root=root,
             tenzir_binary=tenzir_binary,
             tenzir_node_binary=tenzir_node_binary,
+            package_dirs=package_paths,
             tests=list(tests),
             update=update,
             debug=debug,
@@ -177,6 +203,7 @@ def cli(
             keep_tmp_dirs=keep_tmp_dirs,
             jobs=jobs,
             passthrough=passthrough,
+            verbose=verbose,
             jobs_overridden=jobs_overridden,
             all_projects=all_projects,
         )

tenzir_test/config.py

@@ -41,7 +41,7 @@ def discover_settings(
 ) -> Settings:
     """Produce harness settings by combining CLI overrides with environment defaults."""
 
-    environment = dict(env or os.environ)
+    environment = dict(os.environ if env is None else env)
 
     chosen_root = root or environment.get("TENZIR_TEST_ROOT") or Path.cwd()
     root_path = Path(chosen_root).resolve()

tenzir_test/fixtures/node.py

@@ -6,6 +6,7 @@ import atexit
 import functools
 import logging
 import os
+import select
 import shlex
 import subprocess
 import tempfile
@@ -26,6 +27,37 @@ from . import (
 if TYPE_CHECKING:
     from . import FixtureContext
 
+_STDERR_READ_TIMEOUT = 0.5  # seconds to wait for stderr data
+
+
+def _read_available_stderr(process: subprocess.Popen[str]) -> str:
+    """Read any available stderr output without blocking.
+
+    Uses select() to check if data is available before reading. This allows
+    capturing diagnostic output even when the process is still running but
+    has written error messages to stderr.
+    """
+    if not process.stderr:
+        return ""
+    try:
+        fd = process.stderr.fileno()
+        readable, _, _ = select.select([fd], [], [], _STDERR_READ_TIMEOUT)
+        if not readable:
+            return ""
+        # Read available data in chunks to avoid blocking on partial reads.
+        chunks: list[str] = []
+        while True:
+            ready, _, _ = select.select([fd], [], [], 0)
+            if not ready:
+                break
+            chunk = os.read(fd, 4096).decode("utf-8", errors="replace")
+            if not chunk:
+                break
+            chunks.append(chunk)
+        return "".join(chunks).strip()
+    except Exception:
+        return ""
+
 
 def _terminate_process(process: subprocess.Popen[str]) -> None:
     """Terminate the spawned node process and ensure its group is gone."""
@@ -138,16 +170,47 @@ def node() -> Iterator[dict[str, str]]:
         raise RuntimeError("TENZIR_NODE_BINARY must be configured for the node fixture")
 
     env = context.env.copy()
-    config_args = [arg for arg in context.config_args if not arg.startswith("--config=")]
+    # Extract and filter config arguments: we handle --config and --package-dirs separately.
+    config_args: list[str] = []
+    config_package_dirs: list[str] = []
+    for arg in context.config_args:
+        if arg.startswith("--config="):
+            continue
+        if arg.startswith("--package-dirs="):
+            value = arg.split("=", 1)[1]
+            config_package_dirs.extend(entry.strip() for entry in value.split(",") if entry.strip())
+            continue
+        config_args.append(arg)
     node_config = env.get("TENZIR_NODE_CONFIG")
     if node_config:
         config_args.append(f"--config={node_config}")
-    package_root = env.get("TENZIR_PACKAGE_ROOT")
     package_args: list[str] = []
+    package_root = env.get("TENZIR_PACKAGE_ROOT")
+    package_dirs: list[str] = []
     if package_root:
-        package_arg = f"--package-dirs={package_root}"
-        if package_arg not in config_args:
-            package_args.append(package_arg)
+        package_dirs.append(package_root)
+
+    extra_package_dirs = env.get("TENZIR_PACKAGE_DIRS")
+    if extra_package_dirs:
+        package_dirs.extend(
+            [entry.strip() for entry in extra_package_dirs.split(",") if entry.strip()]
+        )
+
+    # Include package directories from config_args as well.
+    package_dirs.extend(config_package_dirs)
+
+    # Deduplicate while preserving order by using resolved paths as keys.
+    seen: set[str] = set()
+    unique_dirs: list[str] = []
+    for entry in package_dirs:
+        resolved = str(Path(entry).expanduser().resolve(strict=False))
+        if resolved not in seen:
+            seen.add(resolved)
+            unique_dirs.append(entry)
+    package_dirs = unique_dirs
+
+    if package_dirs:
+        package_args.append(f"--package-dirs={','.join(package_dirs)}")
     temp_dir = _ensure_temp_dir(context)
     key = id(context)
 
@@ -213,7 +276,21 @@ def node() -> Iterator[dict[str, str]]:
             endpoint = process.stdout.readline().strip()
 
         if not endpoint:
-            raise RuntimeError("failed to obtain endpoint from tenzir-node")
+            # Collect diagnostic information to help debug startup failures.
+            diagnostics: list[str] = []
+            returncode = process.poll()
+            if returncode is not None:
+                diagnostics.append(f"exit code {returncode}")
+            # Try to read stderr output using non-blocking I/O. This captures
+            # diagnostics even when the process is still running (e.g., when it
+            # hangs after writing an error message but before exiting).
+            stderr_output = _read_available_stderr(process)
+            if stderr_output:
+                diagnostics.append(f"stderr:\n{stderr_output}")
+            detail = (
+                "; ".join(diagnostics) if diagnostics else "no additional diagnostics available"
+            )
+            raise RuntimeError(f"failed to obtain endpoint from tenzir-node ({detail})")
 
         fixture_env = {
             "TENZIR_NODE_CLIENT_ENDPOINT": endpoint,

tenzir_test/run.py

@@ -128,6 +128,7 @@ class ExecutionMode(enum.Enum):
 
     PROJECT = "project"
     PACKAGE = "package"
+    LIBRARY = "library"
 
 
 class HarnessMode(enum.Enum):
@@ -146,6 +147,18 @@ class ColorMode(enum.Enum):
     NEVER = "never"
 
 
+def _is_library_root(path: Path) -> bool:
+    """Return True when the directory looks like a library of packages."""
+
+    if packages.is_package_dir(path):
+        return False
+    try:
+        entries = list(packages.iter_package_dirs(path))
+    except OSError:
+        return False
+    return bool(entries)
+
+
 def detect_execution_mode(root: Path) -> tuple[ExecutionMode, Path | None]:
     """Return the execution mode and detected package root for `root`."""
 
@@ -156,6 +169,9 @@ def detect_execution_mode(root: Path) -> tuple[ExecutionMode, Path | None]:
     if parent is not None and packages.is_package_dir(parent):
         return ExecutionMode.PACKAGE, parent
 
+    if _is_library_root(root):
+        return ExecutionMode.LIBRARY, None
+
     return ExecutionMode.PROJECT, None
 
 
@@ -467,6 +483,7 @@ KEEP_TMP_DIRS = bool(os.environ.get(_TMP_KEEP_ENV_VAR))
 
 SHOW_DIFF_OUTPUT = True
 SHOW_DIFF_STAT = True
+VERBOSE_OUTPUT = False
 _BLOCK_INDENT = ""
 _PLUS_SYMBOLS = {1: "□", 10: "▣", 100: "■"}
 _MINUS_SYMBOLS = {1: "□", 10: "▣", 100: "■"}
@@ -490,6 +507,21 @@ def should_show_diff_stat() -> bool:
     return SHOW_DIFF_STAT
 
 
+def set_verbose_output(enabled: bool) -> None:
+    """Enable or disable verbose output for individual test results.
+
+    When enabled, both success and skip messages are printed as tests complete.
+    When disabled (default), only failures are printed.
+    """
+    global VERBOSE_OUTPUT
+    VERBOSE_OUTPUT = enabled
+
+
+def is_verbose_output() -> bool:
+    """Return whether verbose output is enabled."""
+    return VERBOSE_OUTPUT
+
+
 def set_harness_mode(mode: HarnessMode) -> None:
     """Set the global harness execution mode."""
 
@@ -746,6 +778,23 @@ _CLI_LOGGER.setLevel(logging.DEBUG if _debug_logging else logging.WARNING)
 _DIRECTORY_CONFIG_CACHE: dict[Path, "_DirectoryConfig"] = {}
 
 _DISCOVERY_ENABLED = False
+_CLI_PACKAGES: list[Path] = []
+
+
+def _expand_package_dirs(path: Path) -> list[str]:
+    """Normalize a package dir hint; if it contains packages, return those."""
+
+    resolved = path.expanduser().resolve()
+    if packages.is_package_dir(resolved):
+        return [str(resolved)]
+    expanded: list[str] = []
+    try:
+        for pkg in packages.iter_package_dirs(resolved):
+            expanded.append(str(pkg.resolve()))
+    except OSError as exc:
+        _CLI_LOGGER.debug("failed to expand package dir %s: %s", path, exc)
+        return [str(resolved)]
+    return expanded or [str(resolved)]
 
 
 def _set_discovery_logging(enabled: bool) -> None:
@@ -753,6 +802,29 @@ def _set_discovery_logging(enabled: bool) -> None:
     _DISCOVERY_ENABLED = enabled
 
 
+def _set_cli_packages(package_paths: list[Path]) -> None:
+    global _CLI_PACKAGES
+    _CLI_PACKAGES = [path.resolve() for path in package_paths]
+
+
+def _get_cli_packages() -> list[Path]:
+    return list(_CLI_PACKAGES)
+
+
+def _deduplicate_package_dirs(candidates: list[str]) -> list[str]:
+    """Remove duplicate package directories while preserving order."""
+
+    seen: set[str] = set()
+    result: list[str] = []
+    for candidate in candidates:
+        normalized = str(Path(candidate).expanduser().resolve(strict=False))
+        if normalized in seen:
+            continue
+        seen.add(normalized)
+        result.append(candidate)
+    return result
+
+
 def _print_discovery_message(message: str) -> None:
     if _CLI_LOGGER.isEnabledFor(logging.DEBUG):
         _CLI_LOGGER.debug(message)
@@ -768,6 +840,7 @@ class ProjectMarker(enum.Enum):
     TESTS_DIRECTORY = "tests_directory"
     TEST_CONFIG = "test_config"
     TEST_SUITE_DIRECTORY = "test_suite_directory"
+    LIBRARY_ROOT = "library_root"
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
@@ -790,6 +863,7 @@ _PRIMARY_PROJECT_MARKERS = {
     ProjectMarker.TESTS_DIRECTORY,
     ProjectMarker.TEST_CONFIG,
     ProjectMarker.TEST_SUITE_DIRECTORY,
+    ProjectMarker.LIBRARY_ROOT,
 }
 
 
@@ -819,6 +893,12 @@ def _describe_project_root(path: Path) -> ProjectSignature | None:
     if resolved.name == "tests" and resolved.is_dir():
         markers.add(ProjectMarker.TEST_SUITE_DIRECTORY)
 
+    try:
+        if _is_library_root(resolved):
+            markers.add(ProjectMarker.LIBRARY_ROOT)
+    except OSError:
+        pass
+
     if not markers:
         return None
 
@@ -1117,12 +1197,15 @@ def _default_test_config() -> TestConfig:
         "inputs": None,
         "retry": 1,
         "suite": None,
+        "package_dirs": tuple(),
     }
 
 
 def _canonical_config_key(key: str) -> str:
     if key == "fixture":
         return "fixtures"
+    if key in {"package_dirs", "package-dirs"}:
+        return "package_dirs"
     return key
 
 
@@ -1224,6 +1307,50 @@ def _normalize_inputs_value(
     return None
 
 
+def _normalize_package_dirs_value(
+    value: typing.Any,
+    *,
+    location: Path | str,
+    line_number: int | None = None,
+) -> tuple[str, ...]:
+    if value is None:
+        return tuple()
+    if not isinstance(value, (list, tuple)):
+        _raise_config_error(
+            location,
+            f"Invalid value for 'package-dirs', expected list of strings, got '{value}'",
+            line_number,
+        )
+        return tuple()
+    base_dir = _extract_location_path(location).parent
+    normalized: list[str] = []
+    for entry in value:
+        if not isinstance(entry, (str, os.PathLike)):
+            _raise_config_error(
+                location,
+                f"Invalid package-dirs entry '{entry}', expected string",
+                line_number,
+            )
+            continue
+        raw = os.fspath(entry).strip()
+        if not raw:
+            _raise_config_error(
+                location,
+                "Invalid package-dirs entry: must be non-empty string",
+                line_number,
+            )
+            continue
+        path = Path(raw)
+        if not path.is_absolute():
+            path = base_dir / path
+        try:
+            path = path.resolve()
+        except OSError:
+            path = path
+        normalized.append(str(path))
+    return tuple(normalized)
+
+
 def _assign_config_option(
     config: TestConfig,
     key: str,
@@ -1234,7 +1361,16 @@ def _assign_config_option(
     origin: ConfigOrigin,
 ) -> None:
     canonical = _canonical_config_key(key)
-    valid_keys: set[str] = {"error", "timeout", "runner", "skip", "fixtures", "inputs", "retry"}
+    valid_keys: set[str] = {
+        "error",
+        "timeout",
+        "runner",
+        "skip",
+        "fixtures",
+        "inputs",
+        "retry",
+        "package_dirs",
+    }
     if origin == "directory":
         valid_keys.add("suite")
     if canonical not in valid_keys:
@@ -1321,6 +1457,17 @@ def _assign_config_option(
             value, location=location, line_number=line_number
         )
         return
+    if canonical == "package_dirs":
+        if origin != "directory":
+            _raise_config_error(
+                location,
+                "'package-dirs' can only be specified in directory-level test.yaml files",
+                line_number,
+            )
+        config[canonical] = _normalize_package_dirs_value(
+            value, location=location, line_number=line_number
+        )
+        return
     if canonical == "retry":
         if origin == "frontmatter" and isinstance(config.get("suite"), str):
             _raise_config_error(
@@ -1510,20 +1657,12 @@ def _iter_project_test_directories(root: Path) -> Iterator[Path]:
 
 
 def _is_inputs_path(path: Path) -> bool:
-    """Return True when the path lives under an inputs directory."""
+    """Return True when the path lives under any inputs directory."""
     try:
         parts = path.relative_to(ROOT).parts
     except ValueError:
         parts = path.parts
-
-    for index, part in enumerate(parts):
-        if part != "inputs":
-            continue
-        if index == 0:
-            return True
-        if index > 0 and parts[index - 1] == "tests":
-            return True
-    return False
+    return "inputs" in parts
 
 
 def _refresh_registry() -> None:
@@ -1556,6 +1695,25 @@ def _resolve_inputs_dir(root: Path) -> Path:
     return direct
 
 
+def _find_nearest_inputs_dir(test: Path, root: Path) -> Path | None:
+    """Walk up from test directory to find nearest inputs/ directory.
+
+    Returns the nearest inputs/ directory between the test and root,
+    or None if no inputs/ directory exists in that range.
+    """
+    current = test.parent
+    root_resolved = root.resolve()
+    while True:
+        candidate = current / "inputs"
+        if candidate.is_dir():
+            return candidate
+        # Stop when we reach or pass the root
+        if current.resolve() == root_resolved or current == current.parent:
+            break
+        current = current.parent
+    return None
+
+
 def _looks_like_project_root(path: Path) -> bool:
     """Return True when the path or one of its parents resembles a project root."""
 
@@ -1687,13 +1845,22 @@ def get_test_env_and_config_args(
     config_args = [f"--config={config_file}"] if config_file.exists() else []
     env = os.environ.copy()
     if inputs is None:
-        inputs_path = str(_resolve_inputs_dir(ROOT).resolve())
+        # Try nearest inputs/ directory first, fall back to project-level
+        nearest = _find_nearest_inputs_dir(test, ROOT)
+        if nearest is not None:
+            inputs_path = str(nearest.resolve())
+        else:
+            inputs_path = str(_resolve_inputs_dir(ROOT).resolve())
     else:
         candidate = Path(os.fspath(inputs))
         if not candidate.is_absolute():
             candidate = test.parent / candidate
         inputs_path = str(candidate.resolve())
     env["TENZIR_INPUTS"] = inputs_path
+    # Check for inline input file (.input extension)
+    inline_input = test.with_suffix(".input")
+    if inline_input.is_file():
+        env["TENZIR_INPUT"] = str(inline_input.resolve())
     if config_file.exists():
         env.setdefault("TENZIR_CONFIG", str(config_file))
     if node_config_file.exists():
@@ -2556,6 +2723,8 @@ def get_version() -> str:
 
 
 def success(test: Path) -> None:
+    if not is_verbose_output():
+        return
     with stdout_lock:
         rel_test = _relativize_path(test)
         suite_suffix = _format_suite_suffix()
@@ -2563,6 +2732,10 @@ def success(test: Path) -> None:
         print(f"{CHECKMARK} {rel_test}{suite_suffix}{attempt_suffix}")
 
 
+# Failures always print regardless of verbose mode because failures are critical
+# information that users need to see immediately. In contrast, success() and
+# handle_skip() respect the verbose setting since passed/skipped tests are
+# expected outcomes that can be summarized at the end.
 def fail(test: Path) -> None:
     with stdout_lock:
         rel_test = _relativize_path(test)
@@ -2710,14 +2883,32 @@ def run_simple_test(
     expect_error = bool(test_config.get("error", False))
     passthrough_mode = is_passthrough_enabled()
 
+    config_package_dirs = cast(tuple[str, ...], test_config.get("package_dirs", tuple()))
+    additional_package_dirs: list[str] = []
+    for entry in config_package_dirs:
+        additional_package_dirs.extend(_expand_package_dirs(Path(entry)))
+
     package_root = packages.find_package_root(test)
     package_args: list[str] = []
+    package_dir_candidates: list[str] = []
     if package_root is not None:
         env["TENZIR_PACKAGE_ROOT"] = str(package_root)
         package_tests_root = package_root / "tests"
         if inputs_override is None:
-            env["TENZIR_INPUTS"] = str(package_tests_root / "inputs")
-        package_args.append(f"--package-dirs={package_root}")
+            # Try nearest inputs/ directory, fall back to package-level
+            nearest = _find_nearest_inputs_dir(test, package_root)
+            if nearest is not None:
+                env["TENZIR_INPUTS"] = str(nearest.resolve())
+            else:
+                env["TENZIR_INPUTS"] = str(package_tests_root / "inputs")
+        package_dir_candidates.append(str(package_root))
+    package_dir_candidates.extend(additional_package_dirs)
+    for cli_path in _get_cli_packages():
+        package_dir_candidates.extend(_expand_package_dirs(cli_path))
+    if package_dir_candidates:
+        merged_dirs = _deduplicate_package_dirs(package_dir_candidates)
+        env["TENZIR_PACKAGE_DIRS"] = ",".join(merged_dirs)
+        package_args.append(f"--package-dirs={','.join(merged_dirs)}")
 
     context_token = fixtures_impl.push_context(
         fixtures_impl.FixtureContext(
@@ -2859,9 +3050,10 @@ def run_simple_test(
 
 
 def handle_skip(reason: str, test: Path, update: bool, output_ext: str) -> bool | str:
-    rel_path = _relativize_path(test)
-    suite_suffix = _format_suite_suffix()
-    print(f"{SKIP} skipped {rel_path}{suite_suffix}: {reason}")
+    if is_verbose_output():
+        rel_path = _relativize_path(test)
+        suite_suffix = _format_suite_suffix()
+        print(f"{SKIP} skipped {rel_path}{suite_suffix}: {reason}")
     ref_path = test.with_suffix(f".{output_ext}")
     if update:
         with ref_path.open("wb") as f:
@@ -2975,12 +3167,29 @@ class Worker:
             raise RuntimeError(f"failed to parse suite config for {primary_test}: {exc}") from exc
         inputs_override = typing.cast(str | None, primary_config.get("inputs"))
         env, config_args = get_test_env_and_config_args(primary_test, inputs=inputs_override)
+        config_package_dirs = cast(tuple[str, ...], primary_config.get("package_dirs", tuple()))
+        additional_package_dirs: list[str] = []
+        for entry in config_package_dirs:
+            additional_package_dirs.extend(_expand_package_dirs(Path(entry)))
         package_root = packages.find_package_root(primary_test)
+        package_dir_candidates: list[str] = []
         if package_root is not None:
             env["TENZIR_PACKAGE_ROOT"] = str(package_root)
             if inputs_override is None:
-                env["TENZIR_INPUTS"] = str((package_root / "tests" / "inputs"))
-        _apply_fixture_env(env, suite_item.fixtures)
+                # Try nearest inputs/ directory, fall back to package-level
+                nearest = _find_nearest_inputs_dir(primary_test, package_root)
+                if nearest is not None:
+                    env["TENZIR_INPUTS"] = str(nearest.resolve())
+                else:
+                    env["TENZIR_INPUTS"] = str((package_root / "tests" / "inputs"))
+            package_dir_candidates.append(str(package_root))
+        package_dir_candidates.extend(additional_package_dirs)
+        for cli_path in _get_cli_packages():
+            package_dir_candidates.extend(_expand_package_dirs(cli_path))
+        if package_dir_candidates:
+            merged_dirs = _deduplicate_package_dirs(package_dir_candidates)
+            env["TENZIR_PACKAGE_DIRS"] = ",".join(merged_dirs)
+            config_args = list(config_args) + [f"--package-dirs={','.join(merged_dirs)}"]
         context_token = fixtures_impl.push_context(
             fixtures_impl.FixtureContext(
                 test=primary_test,
@@ -3152,6 +3361,7 @@ def run_cli(
     root: Path | None,
     tenzir_binary: Path | None,
     tenzir_node_binary: Path | None,
+    package_dirs: Sequence[Path] | None = None,
     tests: Sequence[Path],
     update: bool,
     debug: bool,
@@ -3166,10 +3376,16 @@ def run_cli(
     jobs: int,
     keep_tmp_dirs: bool,
     passthrough: bool,
+    verbose: bool = False,
     jobs_overridden: bool = False,
     all_projects: bool = False,
 ) -> ExecutionResult:
-    """Execute the harness and return a structured result for library consumers."""
+    """Execute the harness and return a structured result for library consumers.
+
+    Args:
+        verbose: Print individual test results (pass/skip) as they complete.
+            When False (default), only failures are printed during execution.
+    """
     from tenzir_test.engine import state as engine_state
 
     try:
@@ -3222,6 +3438,8 @@ def run_cli(
             harness_mode = HarnessMode.COMPARE
         set_harness_mode(harness_mode)
         passthrough_mode = harness_mode is HarnessMode.PASSTHROUGH
+        # Passthrough mode requires verbose output to show real-time test results
+        set_verbose_output(verbose or passthrough_mode)
         if passthrough_mode and jobs > 1:
             if jobs_overridden:
                 print(f"{INFO} forcing --jobs=1 in passthrough mode to preserve output ordering")
@@ -3236,6 +3454,7 @@ def run_cli(
             tenzir_node_binary=tenzir_node_binary,
         )
         apply_settings(settings)
+        _set_cli_packages(list(package_dirs or []))
         selected_tests = list(tests)
 
         plan: ExecutionPlan | None = None
@@ -3494,7 +3713,8 @@ def run_cli(
                 _print_compact_summary(project_summary)
                 summary_enabled = show_summary or runner_summary or fixture_summary
                 if summary_enabled:
-                    _print_detailed_summary(project_summary)
+                    if is_verbose_output():
+                        _print_detailed_summary(project_summary)
                     _print_ascii_summary(
                         project_summary,
                         include_runner=runner_summary,
@@ -3592,11 +3812,16 @@ def execute(
     jobs: int | None = None,
     keep_tmp_dirs: bool = False,
     passthrough: bool = False,
+    verbose: bool = False,
     jobs_overridden: bool = False,
     all_projects: bool = False,
 ) -> ExecutionResult:
-    """Library-oriented wrapper around `run_cli` with defaulted parameters."""
+    """Library-oriented wrapper around `run_cli` with defaulted parameters.
 
+    Args:
+        verbose: Print individual test results (pass/skip) as they complete.
+            When False (default), only failures are printed during execution.
+    """
     resolved_jobs = jobs if jobs is not None else get_default_jobs()
     return run_cli(
         root=root,
@@ -3616,6 +3841,7 @@ def execute(
         jobs=resolved_jobs,
         keep_tmp_dirs=keep_tmp_dirs,
         passthrough=passthrough,
+        verbose=verbose,
         jobs_overridden=jobs_overridden,
         all_projects=all_projects,
     )

tenzir_test/runners/diff_runner.py

@@ -106,11 +106,16 @@ class DiffRunner(TqlRunner):
             fixture_api.pop_context(context_token)
             run_mod.cleanup_test_tmp_dir(env.get(run_mod.TEST_TMP_ENV_VAR))
 
+        # Strip the ROOT prefix from paths in output to make them relative,
+        # consistent with run_simple_test behavior.
+        root_bytes = str(run_mod.ROOT).encode() + b"/"
+        unoptimized_stdout = unoptimized.stdout.replace(root_bytes, b"")
+        optimized_stdout = optimized.stdout.replace(root_bytes, b"")
         diff_chunks = list(
             difflib.diff_bytes(
                 difflib.unified_diff,
-                unoptimized.stdout.splitlines(keepends=True),
-                optimized.stdout.splitlines(keepends=True),
+                unoptimized_stdout.splitlines(keepends=True),
+                optimized_stdout.splitlines(keepends=True),
                 n=2**31 - 1,
             )
         )[3:]
@@ -118,7 +123,7 @@ class DiffRunner(TqlRunner):
             diff_bytes = b"".join(diff_chunks)
         else:
             diff_bytes = b"".join(
-                b" " + line for line in unoptimized.stdout.splitlines(keepends=True)
+                b" " + line for line in unoptimized_stdout.splitlines(keepends=True)
             )
         ref_path = test.with_suffix(".diff")
         if update:

{tenzir_test-0.12.0.dist-info → tenzir_test-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tenzir-test
-Version: 0.12.0
+Version: 0.15.0
 Summary: Reusable test execution framework extracted from the Tenzir repository.
 Project-URL: Homepage, https://github.com/tenzir/test
 Project-URL: Repository, https://github.com/tenzir/test
@@ -63,18 +63,18 @@ for an end-to-end walkthrough of writing tests.
 We also provide a dense [reference](https://docs.tenzir.com/reference/test) that
 explains concepts, configuration, multi-project execution, and CLI details.
 
-## 🧑‍💻 Development
-
-Contributor workflows, quality gates, and release procedures live in
-[`DEVELOPMENT.md`](DEVELOPMENT.md). Follow that guide when you work on the
-project locally.
-
 ## 🗞️ Releases
 
 New versions are published to PyPI through trusted publishing when a GitHub
 release is created. Review the latest release notes on GitHub for details about
 what's new.
 
+## 🤝 Contributing
+
+Want to contribute? We're all-in on agentic coding with [Claude
+Code](https://claude.ai/code)! The repo comes pre-configured with our [custom
+plugins](https://github.com/tenzir/claude-plugins)—just clone and start hacking.
+
 ## 📜 License
 
 `tenzir-test` is available under the Apache License, Version 2.0. See

{tenzir_test-0.12.0.dist-info → tenzir_test-0.15.0.dist-info}/RECORD

@@ -1,29 +1,28 @@
 tenzir_test/__init__.py,sha256=k7V6Pbjaa8SAy6t4KnaauHTyfnyVEwc1VGtH823MANU,1181
 tenzir_test/_python_runner.py,sha256=LmghMIolsNEC2wUyJdv1h_cefOxTxET1IACrw-_hHuY,2900
-tenzir_test/checks.py,sha256=VhZjU1TExqWzA1KcaW1xOGICpqb_G43AezrJIzw09eM,653
-tenzir_test/cli.py,sha256=kDatxC4drfjAKnYIYFQmjhPJX45KYbm03pX44iqFgOk,5967
-tenzir_test/config.py,sha256=q1_VEXuxL-xsGlnooeGvXxx9cMw652UEB9a1mPzZIQs,1680
+tenzir_test/cli.py,sha256=e93O5dyp6oeiuW3Im11wWyuOc6duKTwUJmcmFuoVnoE,6803
+tenzir_test/config.py,sha256=bVuMJlEvevZxCmvzTJ4bs4SkYLNGZtxcCDYhtC-0sp8,1697
 tenzir_test/packages.py,sha256=cTCQdGjCS1XmuKyiwh0ew-z9tHn6J-xZ6nvBP-hU8bc,948
 tenzir_test/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tenzir_test/run.py,sha256=LE23W07n6O8TnUnkXJArvfwvLI1HYcIu8WCV4lPW70o,125110
+tenzir_test/run.py,sha256=OmW-qaWK6Y9vCAWZmnMczz-ycaleMa9jmiPcATpCoL8,133280
 tenzir_test/engine/__init__.py,sha256=5APwy90YDm7rmL_qCZfToAcfbQthcZ8yV2_ExXKqaqE,110
 tenzir_test/engine/operations.py,sha256=OCYjuMHyMAaay4s08u2Sl7oE-PmgeXumylp7R8GYIH4,950
 tenzir_test/engine/registry.py,sha256=LXCr6TGlv1sR1m1eboTk7SrbS2IVErc3PqUuHxGA2xk,594
 tenzir_test/engine/state.py,sha256=Ez-Q27dL5oNqiJE0A4P2OP0p6i7aYKzH4ZyVWNgEezs,889
 tenzir_test/engine/worker.py,sha256=WwIkx1m_ANNveQjNisy5-qpbUZl_DfDXxVIfdxABKjc,140
 tenzir_test/fixtures/__init__.py,sha256=PdkN334btlqagY-4wAwsCyfhHE8kd_RLNoVM_ULii_I,18384
-tenzir_test/fixtures/node.py,sha256=rLEzNff78r048KZmOanzGBCNg-OuJu9lQoKgGCArths,8197
+tenzir_test/fixtures/node.py,sha256=Y3YqWeqYz-mg3B5V0wIthk55zVOd4JS37zlTdHzlA6c,11193
 tenzir_test/runners/__init__.py,sha256=M3p-TsDp231Dy58miDb467bA1kLYzgpa0pqVr_KP1ro,4616
 tenzir_test/runners/_utils.py,sha256=BWv7UEPGa01l4tGTCg5i_22NblIyRw8vjk_5NIf1x_c,467
 tenzir_test/runners/custom_python_fixture_runner.py,sha256=uXbSf18xTttf51k2EbjWf8AqN2R7TfpfSCkLyU5HJx4,7284
-tenzir_test/runners/diff_runner.py,sha256=ah1hr1vvD6BON2PZz61mxwioRFIzHFuaAbJ0DjDSqG4,5151
+tenzir_test/runners/diff_runner.py,sha256=WIEry_-4R4VIlA9HON5kl2ipyy1TKzS4jRc2wPl6r5c,5476
 tenzir_test/runners/ext_runner.py,sha256=sKL9Mw_ksVVBWnrdIJR2WS5ueVnLKuNYYWZ22FTZIPo,730
 tenzir_test/runners/runner.py,sha256=LtlD8huQOSmD7RyYDnKeCuI4Y6vhxGXMKsHA2qgfWN0,989
 tenzir_test/runners/shell_runner.py,sha256=OuofgHeZN2FaO6xRI3uyqstLBymc6rmWC4HAnSn91AE,6068
 tenzir_test/runners/tenzir_runner.py,sha256=464FFYS_mh6l-ehccc-S8cIUO1MxdapwQL5X3PmMkMI,1006
 tenzir_test/runners/tql_runner.py,sha256=2ZLMf3TIKwcOvaOFrVvvhzK-EcWmGOUZxKkbSoByyQA,248
-tenzir_test-0.12.0.dist-info/METADATA,sha256=VjTW82AKGkRswsZB-0w5wsCWY7MPIrIzZEREINlgZrI,3008
-tenzir_test-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tenzir_test-0.12.0.dist-info/entry_points.txt,sha256=q0eD9RQ_9eMPYvFNpBElo55HQYeaPgLfe9YhLsNwl10,93
-tenzir_test-0.12.0.dist-info/licenses/LICENSE,sha256=ajMbpcBiSTXI8Rr4t17pvowV-On8DktghfZKxY_A22Q,10750
-tenzir_test-0.12.0.dist-info/RECORD,,
+tenzir_test-0.15.0.dist-info/METADATA,sha256=MWDDBuFmf5BU8h1kBsj591GmYUPgv58-IZ357_iu0n8,3066
+tenzir_test-0.15.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tenzir_test-0.15.0.dist-info/entry_points.txt,sha256=l8DJgiEVrjScdTTo613cZ3PKodOmqrUVIbz-3awfV8w,53
+tenzir_test-0.15.0.dist-info/licenses/LICENSE,sha256=ajMbpcBiSTXI8Rr4t17pvowV-On8DktghfZKxY_A22Q,10750
+tenzir_test-0.15.0.dist-info/RECORD,,

{tenzir_test-0.12.0.dist-info → tenzir_test-0.15.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

{tenzir_test-0.12.0.dist-info → tenzir_test-0.15.0.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
-check-release = tenzir_test.checks:main
 tenzir-test = tenzir_test.cli:main

tenzir_test/checks.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import shlex
-import subprocess
-from typing import Sequence
-
-_COMMANDS: Sequence[Sequence[str]] = (
-    ("ruff", "check"),
-    ("ruff", "format", "--check"),
-    ("mypy",),
-    ("pytest",),
-    ("uv", "build"),
-)
-
-
-def _run(command: Sequence[str]) -> None:
-    printable = " ".join(shlex.quote(part) for part in command)
-    print(f"> {printable}")
-    result = subprocess.run(command, check=False)
-    if result.returncode != 0:
-        raise SystemExit(result.returncode)
-
-
-def main() -> int:
-    for command in _COMMANDS:
-        _run(command)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())