rustest 0.1.0__cp311-cp311-macosx_11_0_arm64.whl

rustest/__init__.py

@@ -0,0 +1,24 @@
+"""Public Python API for rustest."""
+
+from __future__ import annotations
+
+from . import _decorators
+from ._cli import main
+from ._reporting import RunReport, TestResult
+from .core import run
+
+fixture = _decorators.fixture
+mark = _decorators.mark
+parametrize = _decorators.parametrize
+skip = _decorators.skip
+
+__all__ = [
+    "RunReport",
+    "TestResult",
+    "fixture",
+    "main",
+    "mark",
+    "parametrize",
+    "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/_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/_decorators.py

@@ -0,0 +1,194 @@
+"""User facing decorators mirroring the most common pytest helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, TypeVar
+
+F = TypeVar("F", bound=Callable[..., object])
+
+# Valid fixture scopes
+VALID_SCOPES = frozenset(["function", "class", "module", "session"])
+
+
+def fixture(
+    func: F | None = None,
+    *,
+    scope: str = "function",
+) -> F | Callable[[F], F]:
+    """Mark a function as a fixture with a specific scope.
+
+    Args:
+        func: The function to decorate (when used without parentheses)
+        scope: The scope of the fixture. One of:
+            - "function": New instance for each test function (default)
+            - "class": Shared across all test methods in a class
+            - "module": Shared across all tests in a module
+            - "session": Shared across all tests in the session
+
+    Usage:
+        @fixture
+        def my_fixture():
+            return 42
+
+        @fixture(scope="module")
+        def shared_fixture():
+            return expensive_setup()
+    """
+    if scope not in VALID_SCOPES:
+        valid = ", ".join(sorted(VALID_SCOPES))
+        msg = f"Invalid fixture scope '{scope}'. Must be one of: {valid}"
+        raise ValueError(msg)
+
+    def decorator(f: F) -> F:
+        setattr(f, "__rustest_fixture__", True)
+        setattr(f, "__rustest_fixture_scope__", scope)
+        return f
+
+    # Support both @fixture and @fixture(scope="...")
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+def skip(reason: str | None = None) -> Callable[[F], F]:
+    """Skip a test or fixture."""
+
+    def decorator(func: F) -> F:
+        setattr(func, "__rustest_skip__", reason or "skipped via rustest.skip")
+        return func
+
+    return decorator
+
+
+def parametrize(
+    arg_names: str | Sequence[str],
+    values: Sequence[Sequence[object] | Mapping[str, object]],
+    *,
+    ids: Sequence[str] | None = None,
+) -> Callable[[F], F]:
+    """Parametrise a test function."""
+
+    normalized_names = _normalize_arg_names(arg_names)
+
+    def decorator(func: F) -> F:
+        cases = _build_cases(normalized_names, values, ids)
+        setattr(func, "__rustest_parametrization__", cases)
+        return func
+
+    return decorator
+
+
+def _normalize_arg_names(arg_names: str | Sequence[str]) -> tuple[str, ...]:
+    if isinstance(arg_names, str):
+        parts = [part.strip() for part in arg_names.split(",") if part.strip()]
+        if not parts:
+            msg = "parametrize() expected at least one argument name"
+            raise ValueError(msg)
+        return tuple(parts)
+    return tuple(arg_names)
+
+
+def _build_cases(
+    names: tuple[str, ...],
+    values: Sequence[Sequence[object] | Mapping[str, object]],
+    ids: Sequence[str] | None,
+) -> tuple[dict[str, object], ...]:
+    case_payloads: list[dict[str, object]] = []
+    if ids is not None and len(ids) != len(values):
+        msg = "ids must match the number of value sets"
+        raise ValueError(msg)
+
+    for index, case in enumerate(values):
+        # Mappings are only treated as parameter mappings when there are multiple parameters
+        # For single parameters, dicts/mappings are treated as values
+        if isinstance(case, Mapping) and len(names) > 1:
+            data = {name: case[name] for name in names}
+        elif isinstance(case, tuple) and len(case) == len(names):
+            # Tuples are unpacked to match parameter names (pytest convention)
+            # This handles both single and multiple parameters
+            data = {name: case[pos] for pos, name in enumerate(names)}
+        else:
+            # Everything else is treated as a single value
+            # This includes: primitives, lists (even if len==names), dicts (single param), objects
+            if len(names) == 1:
+                data = {names[0]: case}
+            else:
+                raise ValueError("Parametrized value does not match argument names")
+        case_id = ids[index] if ids is not None else f"case_{index}"
+        case_payloads.append({"id": case_id, "values": data})
+    return tuple(case_payloads)
+
+
+class MarkDecorator:
+    """A decorator for applying a mark to a test function."""
+
+    def __init__(self, name: str, args: tuple[Any, ...], kwargs: dict[str, Any]) -> None:
+        super().__init__()
+        self.name = name
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self, func: F) -> F:
+        """Apply this mark to the given function."""
+        # Get existing marks or create a new list
+        existing_marks: list[dict[str, Any]] = getattr(func, "__rustest_marks__", [])
+
+        # Add this mark to the list
+        mark_data = {
+            "name": self.name,
+            "args": self.args,
+            "kwargs": self.kwargs,
+        }
+        existing_marks.append(mark_data)
+
+        # Store the marks list on the function
+        setattr(func, "__rustest_marks__", existing_marks)
+        return func
+
+    def __repr__(self) -> str:
+        return f"Mark({self.name!r}, {self.args!r}, {self.kwargs!r})"
+
+
+class MarkGenerator:
+    """Namespace for dynamically creating marks like pytest.mark.
+
+    Usage:
+        @mark.slow
+        @mark.integration
+        @mark.timeout(seconds=30)
+    """
+
+    def __getattr__(self, name: str) -> Any:
+        """Create a mark decorator for the given name."""
+        # Return a callable that can be used as @mark.name or @mark.name(args)
+        return self._create_mark(name)
+
+    def _create_mark(self, name: str) -> Any:
+        """Create a MarkDecorator that can be called with or without arguments."""
+
+        class _MarkDecoratorFactory:
+            """Factory that allows @mark.name or @mark.name(args)."""
+
+            def __init__(self, mark_name: str) -> None:
+                super().__init__()
+                self.mark_name = mark_name
+
+            def __call__(self, *args: Any, **kwargs: Any) -> Any:
+                # If called with a single argument that's a function, it's @mark.name
+                if (
+                    len(args) == 1
+                    and not kwargs
+                    and callable(args[0])
+                    and hasattr(args[0], "__name__")
+                ):
+                    decorator = MarkDecorator(self.mark_name, (), {})
+                    return decorator(args[0])
+                # Otherwise it's @mark.name(args) - return a decorator
+                return MarkDecorator(self.mark_name, args, kwargs)
+
+        return _MarkDecoratorFactory(name)
+
+
+# Create a singleton instance
+mark = MarkGenerator()

rustest/_reporting.py

@@ -0,0 +1,63 @@
+"""Utilities for converting raw results from the Rust layer."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from . import _rust
+
+
+@dataclass(slots=True)
+class TestResult:
+    """Structured view of a single test outcome."""
+
+    __test__ = False  # Tell pytest this is not a test class
+
+    name: str
+    path: str
+    status: str
+    duration: float
+    message: str | None
+    stdout: str | None
+    stderr: str | None
+
+    @classmethod
+    def from_py(cls, result: _rust.PyTestResult) -> "TestResult":
+        return cls(
+            name=result.name,
+            path=result.path,
+            status=result.status,
+            duration=result.duration,
+            message=result.message,
+            stdout=result.stdout,
+            stderr=result.stderr,
+        )
+
+
+@dataclass(slots=True)
+class RunReport:
+    """Aggregate statistics for an entire test session."""
+
+    total: int
+    passed: int
+    failed: int
+    skipped: int
+    duration: float
+    results: tuple[TestResult, ...]
+
+    @classmethod
+    def from_py(cls, report: _rust.PyRunReport) -> "RunReport":
+        return cls(
+            total=report.total,
+            passed=report.passed,
+            failed=report.failed,
+            skipped=report.skipped,
+            duration=report.duration,
+            results=tuple(TestResult.from_py(result) for result in report.results),
+        )
+
+    def iter_status(self, status: str) -> Iterable[TestResult]:
+        """Yield results with the requested status."""
+
+        return (result for result in self.results if result.status == status)

rustest/_rust.py

@@ -0,0 +1,23 @@
+"""Fallback stub for the compiled rustest extension.
+
+This module is packaged with the Python distribution so unit tests can import the
+package without building the Rust extension. Individual tests are expected to
+monkeypatch the functions they exercise.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+
+def run(
+    _paths: Sequence[str],
+    _pattern: str | None,
+    _workers: int | None,
+    _capture_output: bool,
+) -> Any:
+    """Placeholder implementation that mirrors the extension signature."""
+
+    raise NotImplementedError(
+        "The rustest native extension is unavailable. Tests must patch rustest._rust.run."
+    )

rustest/_rust.pyi

@@ -0,0 +1,35 @@
+"""Type stubs for the Rust extension module."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+class PyTestResult:
+    """Test result from Rust layer."""
+
+    name: str
+    path: str
+    status: str
+    duration: float
+    message: str | None
+    stdout: str | None
+    stderr: str | None
+
+class PyRunReport:
+    """Run report from Rust layer."""
+
+    total: int
+    passed: int
+    failed: int
+    skipped: int
+    duration: float
+    results: Sequence[PyTestResult]
+
+def run(
+    paths: list[str],
+    pattern: str | None,
+    workers: int | None,
+    capture_output: bool,
+) -> PyRunReport:
+    """Run tests and return a report."""
+    ...

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)

rustest-0.1.0.dist-info/METADATA

@@ -0,0 +1,487 @@
+Metadata-Version: 2.4
+Name: rustest
+Version: 0.1.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Testing
+Requires-Dist: typing-extensions>=4.8
+Requires-Dist: basedpyright>=1.19 ; extra == 'dev'
+Requires-Dist: maturin>=1.4,<2 ; extra == 'dev'
+Requires-Dist: poethepoet>=0.22 ; extra == 'dev'
+Requires-Dist: pre-commit>=3.5 ; extra == 'dev'
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.1.9 ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Summary: Rust powered pytest-compatible runner
+Author: rustest contributors
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Apex-Engineers-Inc/rustest
+Project-URL: Repository, https://github.com/Apex-Engineers-Inc/rustest
+
+# rustest
+
+Rustest (pronounced like Russ-Test) is a Rust-powered test runner that aims to provide the most common pytest ergonomics with a focus on raw performance. Get **78x faster** test execution with familiar syntax and minimal setup.
+
+## Why rustest?
+
+- 🚀 **78x faster** than pytest (measured on real-world integration tests)
+- ✅ Familiar `@fixture`, `@parametrize`, `@skip`, and `@mark` decorators
+- 🔍 Automatic test discovery (`test_*.py` and `*_test.py` files)
+- 🎯 Simple, clean API—if you know pytest, you already know rustest
+- 📦 Easy installation with pip or uv
+- ⚡ Sub-10ms execution for small test suites—tests feel instant
+
+## Performance
+
+Rustest is designed for speed. Our benchmarks show **78x faster** execution compared to pytest on the rustest integration test suite (~199 tests):
+
+| Test Runner | Time | Tests/Second | Speedup |
+|-------------|------|--------------|---------|
+| pytest      | 0.39s | 502 | 1.0x (baseline) |
+| rustest     | 0.005s | 39,800 | **78x faster** |
+
+**Actual CI measurements:**
+- **pytest**: 196 passed, 5 skipped in 0.39s
+- **rustest**: 194 passed, 5 skipped in 0.005s
+
+**Why so fast?**
+- **Near-zero startup time**: Native Rust binary vs Python interpreter startup
+- **Rust-native test discovery**: Minimal imports until test execution
+- **Optimized fixture resolution**: Efficient dependency graph in Rust
+- **Efficient orchestration**: ~50-100μs per-test overhead vs ~1-2ms in pytest
+
+**Real-world impact:**
+- **200 tests**: 0.39s → 0.005s (instant feedback)
+- **1,000 tests**: ~2s → ~0.025s (tests complete before you can switch tabs)
+- **10,000 tests**: ~20s → ~0.25s (dramatically faster feedback loops)
+
+See [BENCHMARKS.md](BENCHMARKS.md) for detailed performance analysis and methodology.
+
+## Installation
+
+Rustest supports Python **3.10 through 3.14**.
+
+### Using pip
+```bash
+pip install rustest
+```
+
+### Using uv
+```bash
+uv add rustest
+```
+
+### For Development
+If you want to contribute to rustest, see [DEVELOPMENT.md](DEVELOPMENT.md) for setup instructions.
+
+## Quick Start
+
+### 1. Write Your Tests
+
+Create a file `test_math.py`:
+
+```python
+from rustest import fixture, parametrize, mark
+
+@fixture
+def numbers() -> list[int]:
+    return [1, 2, 3, 4, 5]
+
+def test_sum(numbers: list[int]) -> None:
+    assert sum(numbers) == 15
+
+@parametrize("value,expected", [(2, 4), (3, 9), (4, 16)])
+def test_square(value: int, expected: int) -> None:
+    assert value ** 2 == expected
+
+@mark.slow
+def test_expensive_operation() -> None:
+    # This test is marked as slow for filtering
+    result = sum(range(1000000))
+    assert result > 0
+```
+
+### 2. Run Your Tests
+
+```bash
+# Run all tests in the current directory
+rustest
+
+# Run tests in a specific directory
+rustest tests/
+
+# Run tests matching a pattern
+rustest -k "test_sum"
+
+# Show output during test execution
+rustest --no-capture
+```
+
+## Usage Examples
+
+### CLI Usage
+
+```bash
+# Run all tests in current directory
+rustest
+
+# Run tests in specific paths
+rustest tests/ integration/
+
+# Filter tests by name pattern
+rustest -k "user"           # Runs test_user_login, test_user_signup, etc.
+rustest -k "auth"           # Runs all tests with "auth" in the name
+
+# Control output capture
+rustest --no-capture        # See print statements during test execution
+```
+
+### Python API Usage
+
+You can also run rustest programmatically from Python:
+
+```python
+from rustest import run
+
+# Basic usage
+report = run(paths=["tests"])
+print(f"Passed: {report.passed}, Failed: {report.failed}")
+
+# With pattern filtering
+report = run(paths=["tests"], pattern="user")
+
+# Without output capture (see print statements)
+report = run(paths=["tests"], capture_output=False)
+
+# Access individual test results
+for result in report.results:
+    print(f"{result.name}: {result.status} ({result.duration:.3f}s)")
+    if result.status == "failed":
+        print(f"  Error: {result.message}")
+```
+
+### Writing Tests
+
+#### Basic Test Functions
+
+```python
+def test_simple_assertion() -> None:
+    assert 1 + 1 == 2
+
+def test_string_operations() -> None:
+    text = "hello world"
+    assert text.startswith("hello")
+    assert "world" in text
+```
+
+#### Using Fixtures
+
+Fixtures provide reusable test data and setup:
+
+```python
+from rustest import fixture
+
+@fixture
+def database_connection() -> dict:
+    # Setup: create a connection
+    conn = {"host": "localhost", "port": 5432}
+    return conn
+    # Teardown happens automatically
+
+@fixture
+def sample_user() -> dict:
+    return {"id": 1, "name": "Alice", "email": "alice@example.com"}
+
+def test_database_query(database_connection: dict) -> None:
+    assert database_connection["host"] == "localhost"
+
+def test_user_email(sample_user: dict) -> None:
+    assert "@" in sample_user["email"]
+```
+
+#### Fixtures with Dependencies
+
+Fixtures can depend on other fixtures:
+
+```python
+from rustest import fixture
+
+@fixture
+def api_url() -> str:
+    return "https://api.example.com"
+
+@fixture
+def api_client(api_url: str) -> dict:
+    return {"base_url": api_url, "timeout": 30}
+
+def test_api_configuration(api_client: dict) -> None:
+    assert api_client["base_url"].startswith("https://")
+    assert api_client["timeout"] == 30
+```
+
+#### Yield Fixtures with Setup/Teardown
+
+Fixtures can use `yield` to perform cleanup after tests:
+
+```python
+from rustest import fixture
+
+@fixture
+def database_connection():
+    # Setup: create connection
+    conn = create_db_connection()
+    print("Database connected")
+
+    yield conn
+
+    # Teardown: close connection
+    conn.close()
+    print("Database connection closed")
+
+@fixture
+def temp_file():
+    # Setup
+    file = open("temp.txt", "w")
+    file.write("test data")
+
+    yield file
+
+    # Teardown
+    file.close()
+    os.remove("temp.txt")
+
+def test_database_query(database_connection):
+    result = database_connection.query("SELECT 1")
+    assert result is not None
+```
+
+#### Fixture Scopes
+
+Fixtures support different scopes to control when they are created and destroyed:
+
+```python
+from rustest import fixture
+
+@fixture  # Default: function scope - new instance per test
+def function_fixture() -> dict:
+    return {"value": "reset each test"}
+
+@fixture(scope="class")  # Shared across all tests in a class
+def class_database() -> dict:
+    return {"connection": "db://test", "shared": True}
+
+@fixture(scope="module")  # Shared across all tests in a module
+def module_config() -> dict:
+    return {"env": "test", "timeout": 30}
+
+@fixture(scope="session")  # Shared across entire test session
+def session_cache() -> dict:
+    return {"global_cache": {}}
+
+# Fixtures can depend on fixtures with different scopes
+@fixture(scope="function")
+def request_handler(module_config: dict, session_cache: dict) -> dict:
+    return {
+        "config": module_config,  # module-scoped
+        "cache": session_cache,   # session-scoped
+        "request_id": id(object())  # unique per test
+    }
+```
+
+**Scope Behavior:**
+- `function` (default): New instance for each test function
+- `class`: Shared across all test methods in a test class
+- `module`: Shared across all tests in a Python module
+- `session`: Shared across the entire test session
+
+Scoped fixtures are especially useful for expensive setup operations like database connections, API clients, or configuration loading.
+
+**Using conftest.py for Shared Fixtures:**
+
+You can define fixtures in a `conftest.py` file to share them across multiple test files:
+
+```python
+# conftest.py
+from rustest import fixture
+
+@fixture(scope="session")
+def database():
+    """Shared database connection for all tests."""
+    db = setup_database()
+    yield db
+    db.cleanup()
+
+@fixture(scope="module")
+def api_client():
+    """API client shared across a module."""
+    return create_api_client()
+```
+
+All test files in the same directory (and subdirectories) can use these fixtures automatically.
+
+#### Parametrized Tests
+
+Run the same test with different inputs:
+
+```python
+from rustest import parametrize
+
+@parametrize("input,expected", [
+    (1, 2),
+    (2, 4),
+    (3, 6),
+])
+def test_double(input: int, expected: int) -> None:
+    assert input * 2 == expected
+
+# With custom test IDs for better output
+@parametrize("value,expected", [
+    (2, 4),
+    (3, 9),
+    (4, 16),
+], ids=["two", "three", "four"])
+def test_square(value: int, expected: int) -> None:
+    assert value ** 2 == expected
+```
+
+#### Combining Fixtures and Parameters
+
+```python
+from rustest import fixture, parametrize
+
+@fixture
+def multiplier() -> int:
+    return 10
+
+@parametrize("value,expected", [
+    (1, 10),
+    (2, 20),
+    (3, 30),
+])
+def test_multiply(multiplier: int, value: int, expected: int) -> None:
+    assert multiplier * value == expected
+```
+
+#### Skipping Tests
+
+```python
+from rustest import skip, mark
+
+@skip("Not implemented yet")
+def test_future_feature() -> None:
+    assert False
+
+@mark.skip(reason="Waiting for API update")
+def test_deprecated_api() -> None:
+    assert False
+```
+
+#### Using Marks to Organize Tests
+
+```python
+from rustest import mark
+
+@mark.unit
+def test_calculation() -> None:
+    assert 2 + 2 == 4
+
+@mark.integration
+def test_database_integration() -> None:
+    # Integration test
+    pass
+
+@mark.slow
+@mark.integration
+def test_full_workflow() -> None:
+    # This test has multiple marks
+    pass
+```
+
+### Test Output
+
+When you run rustest, you'll see clean, informative output:
+
+```
+  PASSED   0.001s test_simple_assertion
+  PASSED   0.002s test_string_operations
+  PASSED   0.001s test_database_query
+  PASSED   0.003s test_square[two]
+  PASSED   0.001s test_square[three]
+  PASSED   0.002s test_square[four]
+ SKIPPED   0.000s test_future_feature
+  FAILED   0.005s test_broken_feature
+----------------------------------------
+AssertionError: Expected 5, got 4
+  at test_example.py:42
+
+8 tests: 6 passed, 1 failed, 1 skipped in 0.015s
+```
+
+## Feature Comparison with pytest
+
+Rustest aims to provide the most commonly-used pytest features with dramatically better performance. Here's how the two compare:
+
+| Feature | pytest | rustest | Notes |
+|---------|--------|---------|-------|
+| **Core Test Discovery** |
+| `test_*.py` / `*_test.py` files | ✅ | ✅ | Rustest uses Rust for dramatically faster discovery |
+| Test function detection (`test_*`) | ✅ | ✅ | |
+| Test class detection (`Test*`) | ✅ | ✅ | via `unittest.TestCase` support |
+| Pattern-based filtering | ✅ | ✅ | `-k` pattern matching |
+| **Fixtures** |
+| `@fixture` decorator | ✅ | ✅ | Rust-based dependency resolution |
+| Fixture dependency injection | ✅ | ✅ | Much faster in rustest |
+| Fixture scopes (function/class/module/session) | ✅ | ✅ | Full support for all scopes |
+| Yield fixtures (setup/teardown) | ✅ | ✅ | Full support with cleanup |
+| Fixture parametrization | ✅ | 🚧 | Planned |
+| **Parametrization** |
+| `@parametrize` decorator | ✅ | ✅ | Full support with custom IDs |
+| Multiple parameter sets | ✅ | ✅ | |
+| Parametrize with fixtures | ✅ | ✅ | |
+| **Marks** |
+| `@mark.skip` / `@skip` | ✅ | ✅ | Skip tests with reasons |
+| Custom marks (`@mark.slow`, etc.) | ✅ | ✅ | Just added! |
+| Mark with arguments | ✅ | ✅ | `@mark.timeout(30)` |
+| Selecting tests by mark (`-m`) | ✅ | 🚧 | Mark metadata collected, filtering planned |
+| **Test Execution** |
+| Detailed assertion introspection | ✅ | ❌ | Uses standard Python assertions |
+| Parallel execution | ✅ (`pytest-xdist`) | 🚧 | Planned (Rust makes this easier) |
+| Test isolation | ✅ | ✅ | |
+| Stdout/stderr capture | ✅ | ✅ | |
+| **Reporting** |
+| Pass/fail/skip summary | ✅ | ✅ | |
+| Failure tracebacks | ✅ | ✅ | Full Python traceback support |
+| Duration reporting | ✅ | ✅ | Per-test timing |
+| JUnit XML output | ✅ | 🚧 | Planned |
+| HTML reports | ✅ (`pytest-html`) | 🚧 | Planned |
+| **Advanced Features** |
+| Plugins | ✅ | ❌ | Not planned (keeps rustest simple) |
+| Hooks | ✅ | ❌ | Not planned |
+| Custom collectors | ✅ | ❌ | Not planned |
+| `conftest.py` | ✅ | ✅ | Shared fixtures across test files |
+| **Developer Experience** |
+| Fully typed Python API | ⚠️ | ✅ | rustest uses `basedpyright` strict mode |
+| Fast CI/CD runs | ⚠️ | ✅ | 78x faster = dramatically shorter feedback loops |
+
+**Legend:**
+- ✅ Fully supported
+- 🚧 Planned or in progress
+- ⚠️ Partial support
+- ❌ Not planned
+
+**Philosophy:** Rustest implements the 20% of pytest features that cover 80% of use cases, with a focus on raw speed and simplicity. If you need advanced pytest features like plugins or custom hooks, stick with pytest. If you want fast, straightforward testing with familiar syntax, rustest is for you.
+
+## License
+
+rustest is distributed under the terms of the MIT license. See [LICENSE](LICENSE).
+

rustest-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+rustest-0.1.0.dist-info/METADATA,sha256=MxCLrEAs8gtwnesn3cpHVwnD-lzCdw7A03a2aTmxrvI,13963
+rustest-0.1.0.dist-info/WHEEL,sha256=dewdenAwp3PDth0u4HpQhcjieEs1_hiwRbm3WvCuoaI,104
+rustest-0.1.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.1.0.dist-info/licenses/LICENSE,sha256=s64ibUGtb6jEDBsYuxUFtMr_c4PaqYP-vj3YY6QtTGw,1075
+rustest/__init__.py,sha256=K7MyGPARnn97RSjk-E_x_1KjqD49RK4fII_sZ_0rdcc,439
+rustest/__main__.py,sha256=nqdz6DhrDze715SXxtzAYV2sie3CPoy7IvWCdcyHJEM,179
+rustest/_cli.py,sha256=kq9LAwHaJmZ-gnAlTsz7Ov8r1fiDvNoLf4hEI3sxhng,8700
+rustest/_decorators.py,sha256=EFcAmZfThiyj_J5l6fEx7Ix9LroXIBrOwa8QuxltNLI,6561
+rustest/_reporting.py,sha256=6nVcccX1dgEBW72wCOeOIl5I-OE-ukjJD0VQs56pwjo,1626
+rustest/_rust.cpython-311-darwin.so,sha256=RK7ZC1Z3ZNxKvXKNv6ub_mHbJ0mYb2mAGdlcRCgw34s,1466544
+rustest/_rust.py,sha256=k3nXhGiehOVY_S6w28rIdrc0CEc3gFLgwWVOEMcPOZo,660
+rustest/_rust.pyi,sha256=fDFLX0qj4G_bV1sHmTtRPI26grTDG_LFzPFEqp5vFGk,671
+rustest/core.py,sha256=xmBUpuPs0r0HQthc9J5dCQYkZnXqfxqIfSGkHeoqQS4,488
+rustest-0.1.0.dist-info/RECORD,,

rustest-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.6)
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_11_0_arm64

rustest-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rustest=rustest.__main__:main

rustest-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Apex Engineers Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.