rustest 0.14.0__cp313-cp313-macosx_11_0_arm64.whl

rustest/fixture_registry.py

@@ -0,0 +1,130 @@
+"""Global fixture registry for runtime fixture resolution.
+
+This module provides a thread-safe global registry that stores fixture information
+and enables dynamic fixture resolution via request.getfixturevalue().
+"""
+
+from __future__ import annotations
+
+import inspect
+import threading
+from typing import Any
+
+_registry_lock = threading.Lock()
+_fixture_registry: dict[str, Any] = {}
+_fixture_cache: dict[str, Any] = {}
+
+
+def register_fixtures(fixtures: dict[str, Any]) -> None:
+    """Register fixtures for the current test context.
+
+    Args:
+        fixtures: Dictionary mapping fixture names to fixture callables
+    """
+    with _registry_lock:
+        _fixture_registry.clear()
+        _fixture_registry.update(fixtures)
+
+
+def clear_registry() -> None:
+    """Clear the fixture registry and cache."""
+    with _registry_lock:
+        _fixture_registry.clear()
+        _fixture_cache.clear()
+
+
+def get_fixture(name: str) -> Any:
+    """Get a fixture callable by name.
+
+    Args:
+        name: Name of the fixture
+
+    Returns:
+        The fixture callable
+
+    Raises:
+        ValueError: If the fixture is not found
+    """
+    with _registry_lock:
+        if name not in _fixture_registry:
+            raise ValueError(f"fixture '{name}' not found")
+        return _fixture_registry[name]
+
+
+def resolve_fixture(name: str, _executed_fixtures: dict[str, Any] | None = None) -> Any:
+    """Resolve and execute a fixture by name.
+
+    This handles fixture dependencies recursively and caches results per test.
+
+    Args:
+        name: Name of the fixture to resolve
+        _executed_fixtures: Internal cache of already-executed fixtures for this test
+
+    Returns:
+        The fixture value
+
+    Raises:
+        ValueError: If the fixture is not found
+        NotImplementedError: If the fixture is async (not yet supported)
+    """
+    if _executed_fixtures is None:
+        _executed_fixtures = {}
+
+    # Check if already executed for this test
+    if name in _executed_fixtures:
+        return _executed_fixtures[name]
+
+    # Get the fixture callable
+    fixture_func = get_fixture(name)
+
+    # Check if it's async (either async function or async generator)
+    if inspect.iscoroutinefunction(fixture_func) or inspect.isasyncgenfunction(fixture_func):
+        # Raise a clear, helpful error explaining the issue and how to fix it
+        raise NotImplementedError(
+            f"\nCannot use async fixture '{name}' with request.getfixturevalue().\n\n"
+            + "Why this fails:\n"
+            + "  • getfixturevalue() is a synchronous function that returns values immediately\n"
+            + "  • Async fixtures must be awaited, but we can't await in a sync context\n"
+            + "  • Calling the async fixture returns a coroutine object, not the actual value\n\n"
+            + "Good news: Async fixtures work perfectly with normal injection!\n\n"
+            + "How to fix:\n"
+            + f"  ❌ Don't use: request.getfixturevalue('{name}')\n"
+            + f"  ✅ Instead use: def test_something({name}):\n\n"
+            + "Example:\n"
+            + "  # This works perfectly:\n"
+            + f"  async def test_my_feature({name}):\n"
+            + f"      assert {name} is not None\n"
+        )
+
+    # Get fixture parameters
+    sig = inspect.signature(fixture_func)
+    params = sig.parameters
+
+    # Resolve dependencies recursively
+    resolved_args = {}
+    for param_name in params:
+        # Use get_fixture() which has lock protection, instead of checking registry directly
+        try:
+            # Try to get the fixture (thread-safe with lock)
+            get_fixture(param_name)
+            # It's a fixture - resolve it recursively
+            resolved_args[param_name] = resolve_fixture(param_name, _executed_fixtures)
+        except ValueError:
+            # Not a fixture - skip it
+            # Special handling for 'request' parameter
+            if param_name == "request":
+                # Skip 'request' parameter - will be handled by caller
+                resolved_args[param_name] = None
+
+    # Execute the fixture
+    result = fixture_func(**resolved_args)
+
+    # Handle generator fixtures
+    if inspect.isgenerator(result):
+        result = next(result)
+        # TODO: Store generator for teardown
+
+    # Cache the result
+    _executed_fixtures[name] = result
+
+    return result

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,43 @@
+"""Type stubs for the rustest Rust extension module."""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+class PyTestResult:
+    """Individual test result from the Rust extension."""
+
+    name: str
+    path: str
+    status: str
+    duration: float
+    message: str | None
+    stdout: str | None
+    stderr: str | None
+
+class PyRunReport:
+    """Test run report from the Rust extension."""
+
+    total: int
+    passed: int
+    failed: int
+    skipped: int
+    duration: float
+    results: list[PyTestResult]
+
+def run(
+    paths: Sequence[str],
+    pattern: str | None,
+    mark_expr: str | None,
+    workers: int | None,
+    capture_output: bool,
+    enable_codeblocks: bool,
+    last_failed_mode: str,
+    fail_fast: bool,
+    pytest_compat: bool,
+    verbose: bool,
+    ascii: bool,
+    no_color: bool,
+) -> PyRunReport:
+    """Execute tests and return a report."""
+    ...

rustest-0.14.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: rustest
+Version: 0.14.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.15
+Requires-Dist: basedpyright>=1.19 ; extra == 'dev'
+Requires-Dist: maturin>=1.4,<2 ; extra == 'dev'
+Requires-Dist: packaging>=20.0 ; extra == 'dev'
+Requires-Dist: poethepoet>=0.22 ; extra == 'dev'
+Requires-Dist: pre-commit>=3.5 ; extra == 'dev'
+Requires-Dist: py>=1.11 ; extra == 'dev'
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.2.0 ; extra == 'dev'
+Requires-Dist: pytest-codeblocks>=0.17.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.1.9 ; extra == 'dev'
+Requires-Dist: zensical ; extra == 'docs'
+Provides-Extra: dev
+Provides-Extra: docs
+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
+Project-URL: Documentation, https://apex-engineers-inc.github.io/rustest
+
+<div align="center">
+
+![rustest logo](assets/logo.svg)
+
+</div>
+
+Rustest is a Rust-powered pytest-compatible test runner delivering **8.5× average speedup** with familiar pytest syntax and zero setup.
+
+📚 **[Full Documentation](https://apex-engineers-inc.github.io/rustest)** | [Getting Started](https://apex-engineers-inc.github.io/rustest/getting-started/quickstart/) | [Migration Guide](https://apex-engineers-inc.github.io/rustest/from-pytest/migration/)
+
+## 🚀 Try It Now
+
+Run your existing pytest tests with rustest — no code changes required:
+
+<!--pytest.mark.skip-->
+```bash
+pip install rustest
+rustest --pytest-compat tests/
+```
+
+See the speedup immediately, then migrate to native rustest for full features.
+
+## Why Rustest?
+
+- 🚀 **8.5× average speedup** over pytest (up to 19× on large suites)
+- 🧪 **pytest-compatible** — Run existing tests with `--pytest-compat`
+- ✅ **Familiar API** — Same `@fixture`, `@parametrize`, `@mark` decorators
+- 🔄 **Built-in async & mocking** — No pytest-asyncio or pytest-mock plugins needed
+- 🐛 **Clear error messages** — Vitest-style output with Expected/Received diffs
+- 📝 **Markdown testing** — Test code blocks in documentation
+- 🛠️ **Rich fixtures** — `tmp_path`, `monkeypatch`, `mocker`, `capsys`, `caplog`, `cache`, and more
+
+## Performance
+
+Rustest delivers consistent speedups across test suites of all sizes:
+
+| Test Count | pytest | rustest | Speedup |
+|-----------:|-------:|--------:|--------:|
+|         20 | 0.45s  |  0.12s  |  3.8×   |
+|        500 | 1.21s  |  0.15s  |  8.3×   |
+|      5,000 | 7.81s  |  0.40s  | 19.4×   |
+
+**Expected speedups:** 3-4× for small suites, 5-8× for medium suites, 11-19× for large suites.
+
+**[📊 Full Performance Analysis →](https://apex-engineers-inc.github.io/rustest/advanced/performance/)**
+
+## Installation
+
+<!--pytest.mark.skip-->
+```bash
+pip install rustest
+# or
+uv add rustest
+```
+
+**Python 3.10-3.14 supported.** [📖 Installation Guide →](https://apex-engineers-inc.github.io/rustest/getting-started/installation/)
+
+## Quick Start
+
+Write a test in `test_example.py`:
+
+```python
+from rustest import fixture, parametrize, mark, raises
+
+@fixture
+def numbers():
+    return [1, 2, 3, 4, 5]
+
+def test_sum(numbers):
+    assert sum(numbers) == 15
+
+@parametrize("value,expected", [(2, 4), (3, 9)])
+def test_square(value, expected):
+    assert value ** 2 == expected
+
+@mark.asyncio
+async def test_async():
+    result = 42
+    assert result == 42
+
+def test_exception():
+    with raises(ZeroDivisionError):
+        1 / 0
+```
+
+Run your tests:
+
+<!--pytest.mark.skip-->
+```bash
+rustest                      # Run all tests
+rustest tests/               # Run specific directory
+rustest -k "test_sum"        # Filter by name
+rustest -m "slow"            # Filter by mark
+rustest --lf                 # Rerun last failed
+rustest -x                   # Exit on first failure
+```
+
+**[📖 Full Documentation →](https://apex-engineers-inc.github.io/rustest)**
+
+## Learn More
+
+- **[Getting Started](https://apex-engineers-inc.github.io/rustest/getting-started/quickstart/)** — Complete quickstart guide
+- **[Migration from pytest](https://apex-engineers-inc.github.io/rustest/from-pytest/migration/)** — 5-minute migration guide
+- **[User Guide](https://apex-engineers-inc.github.io/rustest/guide/writing-tests/)** — Fixtures, parametrization, marks, assertions
+- **[API Reference](https://apex-engineers-inc.github.io/rustest/api/overview/)** — Complete API documentation
+
+## Contributing
+
+Contributions welcome! See the [Development Guide](https://apex-engineers-inc.github.io/rustest/advanced/development/) for setup instructions.
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.
+

rustest-0.14.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+rustest-0.14.0.dist-info/METADATA,sha256=8xmM0nheAoAgm-JHbIe5mRPVjEmrAGwyZuXcVAfP9KE,5338
+rustest-0.14.0.dist-info/WHEEL,sha256=WjzAfvqut_Q5Xaf14OBgb9ZsnYHdVRd7o0GDAayVL0I,105
+rustest-0.14.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.14.0.dist-info/licenses/LICENSE,sha256=s64ibUGtb6jEDBsYuxUFtMr_c4PaqYP-vj3YY6QtTGw,1075
+rustest/__init__.py,sha256=eg_pai6AXfe-F-GVaSPcbBVfW0yyJ7NKBLK1Sy5yTLQ,841
+rustest/__main__.py,sha256=bBvo5gsSluUzlDTDvn5bP_gZZEXMwJQZMqVA5W1M1v8,178
+rustest/approx.py,sha256=tHDkWqNQAj94eXsBclFcOukc169qiWuZTSh2-rCjz9c,6455
+rustest/builtin_fixtures.py,sha256=3wNdhSV_LjlroCgMV0VKDN6ZpbWiUlDFh6M6umqUcuU,36322
+rustest/cli.py,sha256=ZYBxpimBZEaBhmL-PI1XFz50FWPvqxaYslbhETrQpns,3870
+rustest/compat/__init__.py,sha256=seRdlvStizCfkarfll8aIS_eikEK2V9kjlnJY6iiWA4,70
+rustest/compat/pytest.py,sha256=UgNNEDj9Amhl-M8J74XSth6k6es8kKyC3uUMA8QobzM,37214
+rustest/core.py,sha256=IJHo-z60MPnJtCZS1ha1yjRN0XJ9IPvnGlnKC5Ai50Y,1953
+rustest/decorators.py,sha256=mxZAYHsBeZfpsDVCd65sPrYzjurvf32eFBKjPMy9De4,34416
+rustest/fixture_registry.py,sha256=Rs7_wxBSox5XUWW5Mpb84Lcy3tjZuGxzsOJkYOxPmHI,4339
+rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustest/reporting.py,sha256=3-R8aljv2ZbmjOa9Q9KZeCPsMaitm8nZ96LoJS_NnUQ,1623
+rustest/rust.cpython-313-darwin.so,sha256=8PhJ2VJlQyljyXOPQzefgBL3oYA9mUdEHsyI22mz6FA,2413712
+rustest/rust.py,sha256=tCIvjYd06VxoT_rKvv2o8CpXW_pFNua5VgcRDjLgU78,659
+rustest/rust.pyi,sha256=QCEy3Qc8pZqOSUR7cgsWnTQThgQVcsKrM1skpGVMCgc,891
+rustest-0.14.0.dist-info/RECORD,,

rustest-0.14.0.dist-info/WHEEL

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

rustest-0.14.0.dist-info/entry_points.txt

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

rustest-0.14.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.