testing

Classes:

• ArxTestRunner –
• AssertionFailureReport –
• DiscoveredTestCase –
• TestExecutionResult –
• TestRunError –
• TestRunSummary –

ArxTestRunner dataclass

ArxTestRunner(
    paths: tuple[str, ...] = DEFAULT_TEST_PATHS,
    exclude: tuple[str, ...] = (),
    file_pattern: str = DEFAULT_TEST_FILE_PATTERN,
    function_pattern: str = DEFAULT_TEST_FUNCTION_PATTERN,
    name_filter: str = "",
    fail_fast: bool = False,
    keep_artifacts: bool = False,
    list_only: bool = False,
    link_mode: LinkMode = "auto",
)

Methods:

• collect_tests –
• run –

collect_tests

collect_tests() -> tuple[DiscoveredTestCase, ...]

Source code in src/arx/testing.py

def collect_tests(self) -> tuple[DiscoveredTestCase, ...]:
    """
    title: Collect and filter discovered tests across configured paths.
    returns:
      type: tuple[DiscoveredTestCase, Ellipsis]
    """
    files = self._discover_test_files()
    discovered: list[DiscoveredTestCase] = []
    seen_display_names: set[str] = set()

    for file in files:
        module = self._parse_module(file)
        for case in self._discover_tests(module, file):
            if case.name in seen_display_names:
                raise TestRunError(
                    f"duplicate test name '{case.name}' "
                    f"across discovered files"
                )
            seen_display_names.add(case.name)
            discovered.append(case)

    if not discovered:
        raise TestRunError(
            f"no tests matching '{self.function_pattern}' were found "
            f"in paths {list(self.paths)} "
            f"(file pattern: {self.file_pattern!r})"
        )

    if not self.name_filter:
        return tuple(discovered)

    filtered = tuple(
        test for test in discovered if self.name_filter in test.name
    )
    if filtered:
        return filtered

    raise TestRunError(
        f"no tests matched -k {self.name_filter!r} "
        f"in paths {list(self.paths)}"
    )

run

run() -> TestRunSummary

Source code in src/arx/testing.py

def run(self) -> TestRunSummary:
    """
    title: Collect, compile, and execute the configured test selection.
    returns:
      type: TestRunSummary
    """
    try:
        selected_tests = self.collect_tests()
    except TestRunError as err:
        print(f"ERROR: {err}", file=sys.stderr)
        if err.artifact_dir is not None:
            print(
                f"ERROR: artifacts kept in {err.artifact_dir}",
                file=sys.stderr,
            )
        return TestRunSummary(
            selected=0,
            executed=0,
            passed=0,
            failed=0,
            exit_code=2,
            results=(),
        )

    if self.list_only:
        for test_case in selected_tests:
            print(test_case.name)
        return TestRunSummary(
            selected=len(selected_tests),
            executed=0,
            passed=0,
            failed=0,
            exit_code=0,
            results=(),
        )

    results: list[TestExecutionResult] = []
    for test_case in selected_tests:
        try:
            result = self._compile_and_run_test(test_case)
        except TestRunError as err:
            print(f"ERROR: {err}", file=sys.stderr)
            if err.artifact_dir is not None:
                print(
                    f"ERROR: artifacts kept in {err.artifact_dir}",
                    file=sys.stderr,
                )
            return TestRunSummary(
                selected=len(selected_tests),
                executed=len(results),
                passed=sum(item.passed for item in results),
                failed=sum(not item.passed for item in results),
                exit_code=2,
                results=tuple(results),
            )

        results.append(result)
        self._print_test_result(result)
        if self.fail_fast and not result.passed:
            break

    passed_count = sum(item.passed for item in results)
    failed_count = sum(not item.passed for item in results)
    exit_code = 0 if failed_count == 0 else 1
    summary = TestRunSummary(
        selected=len(selected_tests),
        executed=len(results),
        passed=passed_count,
        failed=failed_count,
        exit_code=exit_code,
        results=tuple(results),
    )
    self._print_summary(summary)
    return summary

AssertionFailureReport dataclass

AssertionFailureReport(
    source: str, line: int, col: int, message: str
)

DiscoveredTestCase dataclass

DiscoveredTestCase(
    name: str, function_name: str, file: Path
)

TestExecutionResult dataclass

TestExecutionResult(
    name: str,
    passed: bool,
    returncode: int,
    stdout: str,
    stderr: str,
    assertion_failure: AssertionFailureReport | None,
    artifact_dir: Path | None = None,
)

TestRunError

TestRunError(
    message: str, artifact_dir: Path | None = None
)

Bases: RuntimeError

Source code in src/arx/testing.py

def __init__(
    self,
    message: str,
    artifact_dir: Path | None = None,
) -> None:
    """
    title: Initialize TestRunError.
    parameters:
      message:
        type: str
      artifact_dir:
        type: Path | None
    """
    super().__init__(message)
    self.artifact_dir: Path | None = artifact_dir

TestRunSummary dataclass

TestRunSummary(
    selected: int,
    executed: int,
    passed: int,
    failed: int,
    exit_code: int,
    results: tuple[TestExecutionResult, ...],
)