rustest 0.3.0__cp311-cp311-win_amd64.whl

rustest/__init__.py

@@ -0,0 +1,28 @@
+"""Public Python API for rustest."""
+
+from __future__ import annotations
+
+from . import decorators
+from .approx import approx
+from .cli import main
+from .reporting import RunReport, TestResult
+from .core import run
+
+fixture = decorators.fixture
+mark = decorators.mark
+parametrize = decorators.parametrize
+raises = decorators.raises
+skip = decorators.skip
+
+__all__ = [
+    "RunReport",
+    "TestResult",
+    "approx",
+    "fixture",
+    "main",
+    "mark",
+    "parametrize",
+    "raises",
+    "run",
+    "skip",
+]

rustest/__main__.py

@@ -0,0 +1,10 @@
+"""Module executed when running ``python -m rustest``."""
+
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

rustest/approx.py

@@ -0,0 +1,160 @@
+"""Approximate comparison for floating-point numbers.
+
+This module provides the `approx` class for comparing floating-point numbers
+with a tolerance, similar to pytest.approx.
+"""
+
+from typing import Any, Mapping, Sequence, Union
+
+# Type alias for values that can be approximated
+ApproxValue = Union[float, int, complex, Sequence[Any], Mapping[str, Any]]
+
+
+class approx:
+    """Assert that two numbers (or collections of numbers) are equal to each other
+    within some tolerance.
+
+    This is similar to pytest.approx and is useful for comparing floating-point
+    numbers that may have small rounding errors.
+
+    Usage:
+        assert 0.1 + 0.2 == approx(0.3)
+        assert 0.1 + 0.2 == approx(0.3, rel=1e-6)
+        assert 0.1 + 0.2 == approx(0.3, abs=1e-9)
+        assert [0.1 + 0.2, 0.3] == approx([0.3, 0.3])
+        assert {"a": 0.1 + 0.2} == approx({"a": 0.3})
+
+    Args:
+        expected: The expected value to compare against
+        rel: The relative tolerance (default: 1e-6)
+        abs: The absolute tolerance (default: 1e-12)
+
+    By default, numbers are considered close if the difference between them is
+    less than or equal to:
+        abs(expected * rel) + abs_tolerance
+    """
+
+    def __init__(
+        self,
+        expected: ApproxValue,
+        rel: float = 1e-6,
+        abs: float = 1e-12,
+    ) -> None:
+        """Initialize approx with expected value and tolerances.
+
+        Args:
+            expected: The expected value to compare against
+            rel: The relative tolerance (default: 1e-6)
+            abs: The absolute tolerance (default: 1e-12)
+        """
+        super().__init__()
+        self.expected = expected
+        self.rel = rel
+        self.abs = abs
+
+    def __repr__(self) -> str:
+        """Return a string representation of the approx object."""
+        return f"approx({self.expected!r}, rel={self.rel}, abs={self.abs})"
+
+    def __eq__(self, actual: Any) -> bool:
+        """Compare actual value with expected value within tolerance.
+
+        Args:
+            actual: The actual value to compare
+
+        Returns:
+            True if the values are approximately equal, False otherwise
+        """
+        return self._approx_compare(actual, self.expected)
+
+    def _approx_compare(self, actual: Any, expected: Any) -> bool:
+        """Recursively compare actual and expected values.
+
+        Args:
+            actual: The actual value
+            expected: The expected value
+
+        Returns:
+            True if values are approximately equal, False otherwise
+        """
+        # Handle None
+        if actual is None or expected is None:
+            return actual == expected
+
+        # Handle dictionaries
+        if isinstance(expected, dict):
+            if not isinstance(actual, dict):
+                return False
+            if set(actual.keys()) != set(expected.keys()):
+                return False
+            return all(self._approx_compare(actual[k], expected[k]) for k in expected.keys())
+
+        # Handle sequences (lists, tuples, etc.) but not strings
+        if isinstance(expected, (list, tuple)) and not isinstance(expected, str):
+            # Check that actual is the same type (list vs tuple matters)
+            if type(actual) is not type(expected):
+                return False
+            if len(actual) != len(expected):
+                return False
+            return all(self._approx_compare(a, e) for a, e in zip(actual, expected))
+
+        # Handle numbers (float, int, complex)
+        if isinstance(expected, (float, int, complex)) and isinstance(
+            actual, (float, int, complex)
+        ):
+            return self._is_close(actual, expected)
+
+        # For other types, use exact equality
+        return actual == expected
+
+    def _is_close(
+        self, actual: Union[float, int, complex], expected: Union[float, int, complex]
+    ) -> bool:
+        """Check if two numbers are close within tolerance.
+
+        Uses the formula: |actual - expected| <= max(rel * max(|actual|, |expected|), abs)
+
+        Args:
+            actual: The actual number
+            expected: The expected number
+
+        Returns:
+            True if numbers are close, False otherwise
+        """
+        # Handle infinities and NaN
+        if isinstance(actual, complex) or isinstance(expected, complex):
+            # For complex numbers, compare real and imaginary parts separately
+            if isinstance(actual, complex) and isinstance(expected, complex):
+                return self._is_close(actual.real, expected.real) and self._is_close(
+                    actual.imag, expected.imag
+                )
+            # One is complex, the other is not
+            if isinstance(actual, complex):
+                return self._is_close(actual.real, expected) and abs(actual.imag) <= self.abs
+            else:  # expected is complex
+                return self._is_close(actual, expected.real) and abs(expected.imag) <= self.abs
+
+        # Convert to float for comparison
+        actual_float = float(actual)
+        expected_float = float(expected)
+
+        # Handle special float values
+        if actual_float == expected_float:
+            # This handles infinities and zeros
+            return True
+
+        # Check for NaN - NaN should never be equal to anything
+        import math
+
+        if math.isnan(actual_float) or math.isnan(expected_float):
+            return False
+
+        # Check for infinities
+        if math.isinf(actual_float) or math.isinf(expected_float):
+            return actual_float == expected_float
+
+        # Calculate tolerance
+        abs_diff = abs(actual_float - expected_float)
+        tolerance = max(self.rel * max(abs(actual_float), abs(expected_float)), self.abs)
+
+        return abs_diff <= tolerance

rustest/cli.py

@@ -0,0 +1,259 @@
+"""Command line interface helpers."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+
+from .reporting import RunReport, TestResult
+from .core import run
+
+
+# ANSI color codes
+class _ColorsNamespace:
+    """Namespace for ANSI color codes."""
+
+    def __init__(self) -> None:  # pyright: ignore[reportMissingSuperCall]
+        self.green = "\033[92m"
+        self.red = "\033[91m"
+        self.yellow = "\033[93m"
+        self.cyan = "\033[96m"
+        self.bold = "\033[1m"
+        self.dim = "\033[2m"
+        self.reset = "\033[0m"
+
+    def disable(self) -> None:
+        """Disable all colors."""
+        self.green = ""
+        self.red = ""
+        self.yellow = ""
+        self.cyan = ""
+        self.bold = ""
+        self.dim = ""
+        self.reset = ""
+
+
+Colors = _ColorsNamespace()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rustest",
+        description="Run Python tests at blazing speed with a Rust powered core.",
+    )
+    _ = parser.add_argument(
+        "paths",
+        nargs="*",
+        default=(".",),
+        help="Files or directories to collect tests from.",
+    )
+    _ = parser.add_argument(
+        "-k",
+        "--pattern",
+        help="Substring to filter tests by (case insensitive).",
+    )
+    _ = parser.add_argument(
+        "-n",
+        "--workers",
+        type=int,
+        help="Number of worker slots to use (experimental).",
+    )
+    _ = parser.add_argument(
+        "--no-capture",
+        dest="capture_output",
+        action="store_false",
+        help="Do not capture stdout/stderr during test execution.",
+    )
+    _ = parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Show verbose output with hierarchical test structure.",
+    )
+    _ = parser.add_argument(
+        "--ascii",
+        action="store_true",
+        help="Use ASCII characters instead of Unicode symbols for output.",
+    )
+    _ = parser.add_argument(
+        "--no-color",
+        dest="color",
+        action="store_false",
+        help="Disable colored output.",
+    )
+    _ = parser.set_defaults(capture_output=True, color=True)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # Disable colors if requested
+    if not args.color:
+        Colors.disable()
+
+    report = run(
+        paths=tuple(args.paths),
+        pattern=args.pattern,
+        workers=args.workers,
+        capture_output=args.capture_output,
+    )
+    _print_report(report, verbose=args.verbose, ascii_mode=args.ascii)
+    return 0 if report.failed == 0 else 1
+
+
+def _print_report(report: RunReport, verbose: bool = False, ascii_mode: bool = False) -> None:
+    """Print test report with configurable output format.
+
+    Args:
+        report: The test run report
+        verbose: If True, show hierarchical verbose output (vitest-style)
+        ascii_mode: If True, use ASCII characters instead of Unicode symbols
+    """
+    if verbose:
+        _print_verbose_report(report, ascii_mode)
+    else:
+        _print_default_report(report, ascii_mode)
+
+    # Print summary line with colors
+    passed_str = (
+        f"{Colors.green}{report.passed} passed{Colors.reset}"
+        if report.passed > 0
+        else f"{report.passed} passed"
+    )
+    failed_str = (
+        f"{Colors.red}{report.failed} failed{Colors.reset}"
+        if report.failed > 0
+        else f"{report.failed} failed"
+    )
+    skipped_str = (
+        f"{Colors.yellow}{report.skipped} skipped{Colors.reset}"
+        if report.skipped > 0
+        else f"{report.skipped} skipped"
+    )
+
+    summary = (
+        f"\n{Colors.bold}{report.total} tests:{Colors.reset} "
+        f"{passed_str}, "
+        f"{failed_str}, "
+        f"{skipped_str} in {Colors.dim}{report.duration:.3f}s{Colors.reset}"
+    )
+    print(summary)
+
+
+def _print_default_report(report: RunReport, ascii_mode: bool) -> None:
+    """Print pytest-style progress indicators followed by failure details."""
+    # Define symbols
+    if ascii_mode:
+        # pytest-style: . (pass), F (fail), s (skip)
+        pass_symbol = "."
+        fail_symbol = "F"
+        skip_symbol = "s"
+    else:
+        # Unicode symbols (no spaces, with colors)
+        pass_symbol = f"{Colors.green}✓{Colors.reset}"
+        fail_symbol = f"{Colors.red}✗{Colors.reset}"
+        skip_symbol = f"{Colors.yellow}⊘{Colors.reset}"
+
+    # Print progress indicators
+    for result in report.results:
+        if result.status == "passed":
+            print(pass_symbol, end="")
+        elif result.status == "failed":
+            print(fail_symbol, end="")
+        elif result.status == "skipped":
+            print(skip_symbol, end="")
+    print()  # Newline after progress indicators
+
+    # Print failure details
+    failures = [r for r in report.results if r.status == "failed"]
+    if failures:
+        print(f"\n{Colors.red}{'=' * 70}")
+        print(f"{Colors.bold}FAILURES{Colors.reset}")
+        print(f"{Colors.red}{'=' * 70}{Colors.reset}")
+        for result in failures:
+            print(
+                f"\n{Colors.bold}{result.name}{Colors.reset} ({Colors.cyan}{result.path}{Colors.reset})"
+            )
+            print(f"{Colors.red}{'-' * 70}{Colors.reset}")
+            if result.message:
+                print(result.message.rstrip())
+
+
+def _print_verbose_report(report: RunReport, ascii_mode: bool) -> None:
+    """Print vitest-style hierarchical output with nesting and timing."""
+    # Define symbols
+    if ascii_mode:
+        pass_symbol = "PASS"
+        fail_symbol = "FAIL"
+        skip_symbol = "SKIP"
+    else:
+        pass_symbol = f"{Colors.green}✓{Colors.reset}"
+        fail_symbol = f"{Colors.red}✗{Colors.reset}"
+        skip_symbol = f"{Colors.yellow}⊘{Colors.reset}"
+
+    # Group tests by file path and organize hierarchically
+    from collections import defaultdict
+
+    tests_by_file: dict[str, list[TestResult]] = defaultdict(list)
+    for result in report.results:
+        tests_by_file[result.path].append(result)
+
+    # Print hierarchical structure
+    for file_path in sorted(tests_by_file.keys()):
+        print(f"\n{Colors.bold}{file_path}{Colors.reset}")
+
+        # Group tests by class within this file
+        tests_by_class: dict[str | None, list[tuple[TestResult, str | None]]] = defaultdict(list)
+        for result in tests_by_file[file_path]:
+            # Parse test name to extract class if present
+            # Format can be: "test_name" or "ClassName.test_name" or "module::Class::test"
+            class_name: str | None
+            if "::" in result.name:
+                parts = result.name.split("::")
+                class_name = "::".join(parts[:-1]) if len(parts) > 1 else None
+            elif "." in result.name:
+                parts = result.name.split(".")
+                class_name = parts[0] if len(parts) > 1 else None
+            else:
+                class_name = None
+            tests_by_class[class_name].append((result, class_name))
+
+        # Print tests organized by class
+        for class_name in sorted(tests_by_class.keys(), key=lambda x: (x is None, x)):
+            # Print class name if present
+            if class_name:
+                print(f"  {Colors.cyan}{class_name}{Colors.reset}")
+
+            for result, _ in tests_by_class[class_name]:
+                # Get symbol based on status
+                if result.status == "passed":
+                    symbol = pass_symbol
+                elif result.status == "failed":
+                    symbol = fail_symbol
+                elif result.status == "skipped":
+                    symbol = skip_symbol
+                else:
+                    symbol = "?"
+
+                # Extract just the test method name
+                if "::" in result.name:
+                    display_name = result.name.split("::")[-1]
+                elif "." in result.name:
+                    display_name = result.name.split(".")[-1]
+                else:
+                    display_name = result.name
+
+                # Indent based on whether it's in a class
+                indent = "    " if class_name else "  "
+
+                # Print with symbol, name, and timing
+                duration_str = f"{Colors.dim}{result.duration * 1000:.0f}ms{Colors.reset}"
+                print(f"{indent}{symbol} {display_name} {duration_str}")
+
+                # Show error message for failures
+                if result.status == "failed" and result.message:
+                    error_lines = result.message.rstrip().split("\n")
+                    for line in error_lines:
+                        print(f"{indent}  {line}")

rustest/core.py

@@ -0,0 +1,21 @@
+"""High level Python API wrapping the Rust extension."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from . import rust
+from .reporting import RunReport
+
+
+def run(
+    *,
+    paths: Sequence[str],
+    pattern: str | None,
+    workers: int | None,
+    capture_output: bool,
+) -> RunReport:
+    """Execute tests and return a rich report."""
+
+    raw_report = rust.run(list(paths), pattern, workers, capture_output)
+    return RunReport.from_py(raw_report)