rustest 0.2.0__cp313-cp313-macosx_10_12_x86_64.whl → 0.7.0__cp313-cp313-macosx_10_12_x86_64.whl

rustest/__init__.py

@@ -2,17 +2,17 @@
 
 from __future__ import annotations
 
-from . import _decorators
-from ._approx import approx
-from ._cli import main
-from ._reporting import RunReport, TestResult
+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
+fixture = decorators.fixture
+mark = decorators.mark
+parametrize = decorators.parametrize
+raises = decorators.raises
+skip = decorators.skip
 
 __all__ = [
     "RunReport",

rustest/__main__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import sys
 
-from ._cli import main
+from .cli import main
 
 if __name__ == "__main__":
     sys.exit(main())

rustest/{_cli.py → cli.py}

@@ -5,7 +5,7 @@ from __future__ import annotations
 import argparse
 from collections.abc import Sequence
 
-from ._reporting import RunReport, TestResult
+from .reporting import RunReport, TestResult
 from .core import run
 
 
@@ -52,6 +52,12 @@ def build_parser() -> argparse.ArgumentParser:
         "--pattern",
         help="Substring to filter tests by (case insensitive).",
     )
+    _ = parser.add_argument(
+        "-m",
+        "--marks",
+        dest="mark_expr",
+        help='Run tests matching the given mark expression (e.g., "slow", "not slow", "slow and integration").',
+    )
     _ = parser.add_argument(
         "-n",
         "--workers",
@@ -81,7 +87,41 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_false",
         help="Disable colored output.",
     )
-    _ = parser.set_defaults(capture_output=True, color=True)
+    _ = parser.add_argument(
+        "--no-codeblocks",
+        dest="enable_codeblocks",
+        action="store_false",
+        help="Disable code block tests from markdown files.",
+    )
+    _ = parser.add_argument(
+        "--lf",
+        "--last-failed",
+        action="store_true",
+        dest="last_failed",
+        help="Rerun only the tests that failed in the last run.",
+    )
+    _ = parser.add_argument(
+        "--ff",
+        "--failed-first",
+        action="store_true",
+        dest="failed_first",
+        help="Run previously failed tests first, then all other tests.",
+    )
+    _ = parser.add_argument(
+        "-x",
+        "--exitfirst",
+        action="store_true",
+        dest="fail_fast",
+        help="Exit instantly on first error or failed test.",
+    )
+    _ = parser.set_defaults(
+        capture_output=True,
+        color=True,
+        enable_codeblocks=True,
+        last_failed=False,
+        failed_first=False,
+        fail_fast=False,
+    )
     return parser
 
 
@@ -93,11 +133,23 @@ def main(argv: Sequence[str] | None = None) -> int:
     if not args.color:
         Colors.disable()
 
+    # Determine last_failed_mode
+    if args.last_failed:
+        last_failed_mode = "only"
+    elif args.failed_first:
+        last_failed_mode = "first"
+    else:
+        last_failed_mode = "none"
+
     report = run(
-        paths=tuple(args.paths),
+        paths=list(args.paths),
         pattern=args.pattern,
+        mark_expr=args.mark_expr,
         workers=args.workers,
         capture_output=args.capture_output,
+        enable_codeblocks=args.enable_codeblocks,
+        last_failed_mode=last_failed_mode,
+        fail_fast=args.fail_fast,
     )
     _print_report(report, verbose=args.verbose, ascii_mode=args.ascii)
     return 0 if report.failed == 0 else 1

rustest/core.py

@@ -4,18 +4,41 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from . import _rust
-from ._reporting import RunReport
+from . import rust
+from .reporting import RunReport
 
 
 def run(
     *,
     paths: Sequence[str],
-    pattern: str | None,
-    workers: int | None,
-    capture_output: bool,
+    pattern: str | None = None,
+    mark_expr: str | None = None,
+    workers: int | None = None,
+    capture_output: bool = True,
+    enable_codeblocks: bool = True,
+    last_failed_mode: str = "none",
+    fail_fast: bool = False,
 ) -> RunReport:
-    """Execute tests and return a rich report."""
+    """Execute tests and return a rich report.
 
-    raw_report = _rust.run(list(paths), pattern, workers, capture_output)
+    Args:
+        paths: Files or directories to collect tests from
+        pattern: Substring to filter tests by (case insensitive)
+        mark_expr: Mark expression to filter tests (e.g., "slow", "not slow", "slow and integration")
+        workers: Number of worker slots to use (experimental)
+        capture_output: Whether to capture stdout/stderr during test execution
+        enable_codeblocks: Whether to enable code block tests from markdown files
+        last_failed_mode: Last failed mode: "none", "only", or "first"
+        fail_fast: Exit instantly on first error or failed test
+    """
+    raw_report = rust.run(
+        paths=list(paths),
+        pattern=pattern,
+        mark_expr=mark_expr,
+        workers=workers,
+        capture_output=capture_output,
+        enable_codeblocks=enable_codeblocks,
+        last_failed_mode=last_failed_mode,
+        fail_fast=fail_fast,
+    )
     return RunReport.from_py(raw_report)

rustest/{_decorators.py → decorators.py}

@@ -157,8 +157,195 @@ class MarkGenerator:
         @mark.slow
         @mark.integration
         @mark.timeout(seconds=30)
+
+    Standard marks:
+        @mark.skipif(condition, *, reason="...")
+        @mark.xfail(condition=None, *, reason=None, raises=None, run=True, strict=False)
+        @mark.usefixtures("fixture1", "fixture2")
+        @mark.asyncio(loop_scope="function")
     """
 
+    def asyncio(
+        self,
+        func: Callable[..., Any] | None = None,
+        *,
+        loop_scope: str = "function",
+    ) -> Callable[..., Any]:
+        """Mark an async test function to be executed with asyncio.
+
+        This decorator allows you to write async test functions that will be
+        automatically executed in an asyncio event loop. The loop_scope parameter
+        controls the scope of the event loop used for execution.
+
+        Args:
+            func: The function to decorate (when used without parentheses)
+            loop_scope: The scope of the event loop. One of:
+                - "function": New loop for each test function (default)
+                - "class": Shared loop across all test methods in a class
+                - "module": Shared loop across all tests in a module
+                - "session": Shared loop across all tests in the session
+
+        Usage:
+            @mark.asyncio
+            async def test_async_function():
+                result = await some_async_operation()
+                assert result == expected
+
+            @mark.asyncio(loop_scope="module")
+            async def test_with_module_loop():
+                await another_async_operation()
+
+        Note:
+            This decorator should only be applied to async functions (coroutines).
+            Applying it to regular functions will raise a TypeError.
+        """
+        import asyncio
+        import inspect
+        from functools import wraps
+
+        valid_scopes = {"function", "class", "module", "session"}
+        if loop_scope not in valid_scopes:
+            valid = ", ".join(sorted(valid_scopes))
+            msg = f"Invalid loop_scope '{loop_scope}'. Must be one of: {valid}"
+            raise ValueError(msg)
+
+        def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
+            # Handle class decoration - apply mark to all async methods
+            if inspect.isclass(f):
+                # Apply the mark to the class itself
+                mark_decorator = MarkDecorator("asyncio", (), {"loop_scope": loop_scope})
+                marked_class = mark_decorator(f)
+
+                # Wrap all async methods in the class
+                for name, method in inspect.getmembers(
+                    marked_class, predicate=inspect.iscoroutinefunction
+                ):
+                    wrapped_method = _wrap_async_function(method, loop_scope)
+                    setattr(marked_class, name, wrapped_method)
+                return marked_class
+
+            # Validate that the function is a coroutine
+            if not inspect.iscoroutinefunction(f):
+                msg = f"@mark.asyncio can only be applied to async functions or test classes, but '{f.__name__}' is not async"
+                raise TypeError(msg)
+
+            # Store the asyncio mark
+            mark_decorator = MarkDecorator("asyncio", (), {"loop_scope": loop_scope})
+            marked_f = mark_decorator(f)
+
+            # Wrap the async function to run it synchronously
+            return _wrap_async_function(marked_f, loop_scope)
+
+        def _wrap_async_function(f: Callable[..., Any], loop_scope: str) -> Callable[..., Any]:
+            """Wrap an async function to run it synchronously in an event loop."""
+
+            @wraps(f)
+            def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+                # Get or create event loop based on scope
+                # For now, we'll always create a new loop - scope handling will be
+                # implemented in a future enhancement via fixtures
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    # Run the coroutine in the event loop
+                    # Get the original async function
+                    original_func = getattr(f, "__wrapped__", f)
+                    coro = original_func(*args, **kwargs)
+                    return loop.run_until_complete(coro)
+                finally:
+                    # Clean up the loop
+                    try:
+                        # Cancel any pending tasks
+                        pending = asyncio.all_tasks(loop)
+                        for task in pending:
+                            task.cancel()
+                        # Run the loop one more time to let tasks finish cancellation
+                        if pending:
+                            loop.run_until_complete(
+                                asyncio.gather(*pending, return_exceptions=True)
+                            )
+                    except Exception:
+                        pass
+                    finally:
+                        loop.close()
+
+            # Store reference to original async function
+            sync_wrapper.__wrapped__ = f
+            return sync_wrapper
+
+        # Support both @mark.asyncio and @mark.asyncio(loop_scope="...")
+        if func is not None:
+            return decorator(func)
+        return decorator
+
+    def skipif(
+        self,
+        condition: bool | str,
+        *,
+        reason: str | None = None,
+    ) -> MarkDecorator:
+        """Skip test if condition is true.
+
+        Args:
+            condition: Boolean or string condition to evaluate
+            reason: Explanation for why the test is skipped
+
+        Usage:
+            @mark.skipif(sys.platform == "win32", reason="Not supported on Windows")
+            def test_unix_only():
+                pass
+        """
+        return MarkDecorator("skipif", (condition,), {"reason": reason})
+
+    def xfail(
+        self,
+        condition: bool | str | None = None,
+        *,
+        reason: str | None = None,
+        raises: type[BaseException] | tuple[type[BaseException], ...] | None = None,
+        run: bool = True,
+        strict: bool = False,
+    ) -> MarkDecorator:
+        """Mark test as expected to fail.
+
+        Args:
+            condition: Optional condition - if False, mark is ignored
+            reason: Explanation for why the test is expected to fail
+            raises: Expected exception type(s)
+            run: Whether to run the test (False means skip it)
+            strict: If True, passing test will fail the suite
+
+        Usage:
+            @mark.xfail(reason="Known bug in backend")
+            def test_known_bug():
+                assert False
+
+            @mark.xfail(sys.platform == "win32", reason="Not implemented on Windows")
+            def test_feature():
+                pass
+        """
+        kwargs = {
+            "reason": reason,
+            "raises": raises,
+            "run": run,
+            "strict": strict,
+        }
+        args = () if condition is None else (condition,)
+        return MarkDecorator("xfail", args, kwargs)
+
+    def usefixtures(self, *names: str) -> MarkDecorator:
+        """Use fixtures without explicitly requesting them as parameters.
+
+        Args:
+            *names: Names of fixtures to use
+
+        Usage:
+            @mark.usefixtures("setup_db", "cleanup")
+            def test_with_fixtures():
+                pass
+        """
+        return MarkDecorator("usefixtures", names, {})
+
     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)

rustest/{_reporting.py → reporting.py}

@@ -5,7 +5,7 @@ from __future__ import annotations
 from collections.abc import Iterable
 from dataclasses import dataclass
 
-from . import _rust
+from . import rust
 
 
 @dataclass(slots=True)
@@ -23,7 +23,7 @@ class TestResult:
     stderr: str | None
 
     @classmethod
-    def from_py(cls, result: _rust.PyTestResult) -> "TestResult":
+    def from_py(cls, result: rust.PyTestResult) -> "TestResult":
         return cls(
             name=result.name,
             path=result.path,
@@ -47,7 +47,7 @@ class RunReport:
     results: tuple[TestResult, ...]
 
     @classmethod
-    def from_py(cls, report: _rust.PyRunReport) -> "RunReport":
+    def from_py(cls, report: rust.PyRunReport) -> "RunReport":
         return cls(
             total=report.total,
             passed=report.passed,

rustest/{_rust.py → rust.py}

@@ -19,5 +19,5 @@ def run(
     """Placeholder implementation that mirrors the extension signature."""
 
     raise NotImplementedError(
-        "The rustest native extension is unavailable. Tests must patch rustest._rust.run."
+        "The rustest native extension is unavailable. Tests must patch rustest.rust.run."
     )

rustest/{_rust.pyi → rust.pyi}

@@ -1,11 +1,11 @@
-"""Type stubs for the Rust extension module."""
+"""Type stubs for the rustest Rust extension module."""
 
 from __future__ import annotations
 
-from collections.abc import Sequence
+from typing import Sequence
 
 class PyTestResult:
-    """Test result from Rust layer."""
+    """Individual test result from the Rust extension."""
 
     name: str
     path: str
@@ -16,20 +16,24 @@ class PyTestResult:
     stderr: str | None
 
 class PyRunReport:
-    """Run report from Rust layer."""
+    """Test run report from the Rust extension."""
 
     total: int
     passed: int
     failed: int
     skipped: int
     duration: float
-    results: Sequence[PyTestResult]
+    results: list[PyTestResult]
 
 def run(
-    paths: list[str],
+    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,
 ) -> PyRunReport:
-    """Run tests and return a report."""
+    """Execute tests and return a report."""
     ...

rustest-0.7.0.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: rustest
+Version: 0.7.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: poethepoet>=0.22 ; extra == 'dev'
+Requires-Dist: pre-commit>=3.5 ; 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: mkdocs>=1.5.0 ; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.5.0 ; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24.0 ; extra == 'docs'
+Requires-Dist: mkdocs-autorefs>=0.5.0 ; 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
+
+# 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 **~2x faster** test execution with familiar syntax and minimal setup.
+
+📚 **[Full Documentation](https://apex-engineers-inc.github.io/rustest)** | [Getting Started](https://apex-engineers-inc.github.io/rustest/getting-started/quickstart/) | [User Guide](https://apex-engineers-inc.github.io/rustest/guide/writing-tests/) | [API Reference](https://apex-engineers-inc.github.io/rustest/api/overview/)
+
+## Why rustest?
+
+- 🚀 **About 2x faster** than pytest on the rustest integration test suite
+- ✅ Familiar `@fixture`, `@parametrize`, `@skip`, and `@mark` decorators
+- 🔄 **Built-in async support** with `@mark.asyncio` (like pytest-asyncio)
+- 🔍 Automatic test discovery (`test_*.py` and `*_test.py` files)
+- 📝 **Built-in markdown code block testing** (like pytest-codeblocks, but faster)
+- 🎯 Simple, clean API—if you know pytest, you already know rustest
+- 🧮 Built-in `approx()` helper for tolerant numeric comparisons
+- 🪤 `raises()` context manager for precise exception assertions
+- 📦 Easy installation with pip or uv
+- ⚡ Low-overhead execution keeps small suites feeling instant
+
+## Performance
+
+Rustest is designed for speed. Our latest benchmarks on the rustest integration suite (~200 tests) show a consistent **2.1x wall-clock speedup** over pytest:
+
+| Test Runner | Wall Clock | Speedup | Command |
+|-------------|------------|---------|---------|
+| pytest      | 1.33–1.59s | 1.0x (baseline) | `pytest tests/ examples/tests/ -q` |
+| rustest     | 0.69–0.70s | **~2.1x faster** | `python -m rustest tests/ examples/tests/` |
+
+### Large Parametrized Stress Test
+
+With **10,000 parametrized invocations**:
+
+| Test Runner | Avg. Wall Clock | Speedup | Command |
+|-------------|-----------------|---------|---------|
+| pytest      | 9.72s           | 1.0x    | `pytest benchmarks/test_large_parametrize.py -q` |
+| rustest     | 0.41s           | **~24x faster** | `python -m rustest benchmarks/test_large_parametrize.py` |
+
+**[📊 View Detailed Performance Analysis →](https://apex-engineers-inc.github.io/rustest/advanced/performance/)**
+
+## Installation
+
+Rustest supports Python **3.10 through 3.14**.
+
+<!--pytest.mark.skip-->
+```bash
+# Using pip
+pip install rustest
+
+# Using uv
+uv add rustest
+```
+
+**[📖 Installation Guide →](https://apex-engineers-inc.github.io/rustest/getting-started/installation/)**
+
+## Quick Start
+
+### 1. Write Your Tests
+
+Create a file `test_math.py`:
+
+```python
+from rustest import fixture, parametrize, mark, approx, raises
+import asyncio
+
+@fixture
+def numbers() -> list[int]:
+    return [1, 2, 3, 4, 5]
+
+def test_sum(numbers: list[int]) -> None:
+    assert sum(numbers) == approx(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:
+    result = sum(range(1000000))
+    assert result > 0
+
+@mark.asyncio
+async def test_async_operation() -> None:
+    # Example async operation
+    await asyncio.sleep(0.001)
+    result = 42
+    assert result == 42
+
+def test_division_by_zero() -> None:
+    with raises(ZeroDivisionError, match="division by zero"):
+        1 / 0
+```
+
+### 2. Run Your Tests
+
+<!--pytest.mark.skip-->
+```bash
+# Run all tests
+rustest
+
+# Run specific tests
+rustest tests/
+
+# Filter by test name pattern
+rustest -k "test_sum"
+
+# Filter by marks
+rustest -m "slow"                    # Run only slow tests
+rustest -m "not slow"                # Skip slow tests
+rustest -m "slow and integration"    # Run tests with both marks
+
+# Rerun only failed tests
+rustest --lf                         # Last failed only
+rustest --ff                         # Failed first, then all others
+
+# Exit on first failure
+rustest -x                           # Fail fast
+
+# Combine options
+rustest --ff -x                      # Run failed tests first, stop on first failure
+
+# Show output during execution
+rustest --no-capture
+```
+
+**[📖 Full Quick Start Guide →](https://apex-engineers-inc.github.io/rustest/getting-started/quickstart/)**
+
+## Documentation
+
+**[📚 Full Documentation](https://apex-engineers-inc.github.io/rustest)**
+
+### Getting Started
+- [Installation](https://apex-engineers-inc.github.io/rustest/getting-started/installation/)
+- [Quick Start](https://apex-engineers-inc.github.io/rustest/getting-started/quickstart/)
+
+### User Guide
+- [Writing Tests](https://apex-engineers-inc.github.io/rustest/guide/writing-tests/)
+- [Fixtures](https://apex-engineers-inc.github.io/rustest/guide/fixtures/)
+- [Parametrization](https://apex-engineers-inc.github.io/rustest/guide/parametrization/)
+- [Marks & Skipping](https://apex-engineers-inc.github.io/rustest/guide/marks/)
+- [Test Classes](https://apex-engineers-inc.github.io/rustest/guide/test-classes/)
+- [Assertion Helpers](https://apex-engineers-inc.github.io/rustest/guide/assertions/)
+- [Markdown Testing](https://apex-engineers-inc.github.io/rustest/guide/markdown-testing/)
+- [CLI Usage](https://apex-engineers-inc.github.io/rustest/guide/cli/)
+- [Python API](https://apex-engineers-inc.github.io/rustest/guide/python-api/)
+
+### API Reference
+- [API Overview](https://apex-engineers-inc.github.io/rustest/api/overview/)
+- [Decorators](https://apex-engineers-inc.github.io/rustest/api/decorators/)
+- [Test Execution](https://apex-engineers-inc.github.io/rustest/api/core/)
+- [Reporting](https://apex-engineers-inc.github.io/rustest/api/reporting/)
+- [Assertion Utilities](https://apex-engineers-inc.github.io/rustest/api/approx/)
+
+### Advanced Topics
+- [Performance](https://apex-engineers-inc.github.io/rustest/advanced/performance/)
+- [Comparison with pytest](https://apex-engineers-inc.github.io/rustest/advanced/comparison/)
+- [Development Guide](https://apex-engineers-inc.github.io/rustest/advanced/development/)
+
+## Feature Comparison with pytest
+
+Rustest implements the 20% of pytest features that cover 80% of use cases, with a focus on raw speed and simplicity.
+
+**[📋 View Full Feature Comparison →](https://apex-engineers-inc.github.io/rustest/advanced/comparison/)**
+
+✅ **Supported:** Fixtures, parametrization, marks, test classes, conftest.py, markdown testing
+🚧 **Planned:** Parallel execution, mark filtering, JUnit XML output
+❌ **Not Planned:** Plugins, hooks, custom collectors (keeps rustest simple)
+
+## Contributing
+
+We welcome contributions! See the [Development Guide](https://apex-engineers-inc.github.io/rustest/advanced/development/) for setup instructions.
+
+Quick reference:
+
+<!--pytest.mark.skip-->
+```bash
+# Setup
+git clone https://github.com/Apex-Engineers-Inc/rustest.git
+cd rustest
+uv sync --all-extras
+uv run maturin develop
+
+# Run tests
+uv run poe pytests  # Python tests
+cargo test          # Rust tests
+
+# Format and lint
+uv run pre-commit install  # One-time setup
+git commit -m "message"    # Pre-commit hooks run automatically
+```
+
+## License
+
+rustest is distributed under the terms of the MIT license. See [LICENSE](LICENSE).
+

rustest-0.7.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rustest-0.7.0.dist-info/METADATA,sha256=4oreZ3cw8nBFQuC5UMDhGkci1x-9p5KT6sz0YXkuhoA,8818
+rustest-0.7.0.dist-info/WHEEL,sha256=Vw5ZLWgt_2Ah16i4JL1BF7IIc3gqArKE4ITLavudIhM,107
+rustest-0.7.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.7.0.dist-info/licenses/LICENSE,sha256=s64ibUGtb6jEDBsYuxUFtMr_c4PaqYP-vj3YY6QtTGw,1075
+rustest/__init__.py,sha256=0CkHfrmIjpGw6DMu2VcZLOUpBVtdwsN-aitn-RzOglo,514
+rustest/__main__.py,sha256=bBvo5gsSluUzlDTDvn5bP_gZZEXMwJQZMqVA5W1M1v8,178
+rustest/approx.py,sha256=MKmuorBBHqpH0h0QaIMVjbm3-mXJ0E90limEgSHHVfw,5744
+rustest/cli.py,sha256=26zaX635WqW0q8B-alb0Kk0wzIDZVkF-y9ZqzKtHDbI,10185
+rustest/core.py,sha256=FBnr3yzHQequ83R-pRlwlCdbcYlkjjucwtHpp0gnqdQ,1461
+rustest/decorators.py,sha256=mZDieFSaUx5FIeDqsWO07H6E0urk70cOYtQIuCIjKzY,18703
+rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustest/reporting.py,sha256=3-R8aljv2ZbmjOa9Q9KZeCPsMaitm8nZ96LoJS_NnUQ,1623
+rustest/rust.cpython-313-darwin.so,sha256=6khWVzzAZDRmo6b8c2vlFC0T9JunQjVMLnZ8HnGE7pU,1668920
+rustest/rust.py,sha256=tCIvjYd06VxoT_rKvv2o8CpXW_pFNua5VgcRDjLgU78,659
+rustest/rust.pyi,sha256=bJDdaokbRZWPtTZ1bwsXWb43L9jwOm2gLkk7LzNlQcw,810
+rustest-0.7.0.dist-info/RECORD,,

{rustest-0.2.0.dist-info → rustest-0.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.6)
+Generator: maturin (1.10.0)
 Root-Is-Purelib: false
 Tag: cp313-cp313-macosx_10_12_x86_64

rustest-0.2.0.dist-info/METADATA

@@ -1,521 +0,0 @@
-Metadata-Version: 2.4
-Name: rustest
-Version: 0.2.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: 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 **~2x faster** test execution with familiar syntax and minimal setup.
-
-## Why rustest?
-
-- 🚀 **About 2x faster** than pytest on the rustest integration test suite
-- ✅ 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
-- 🧮 Built-in `approx()` helper for tolerant numeric comparisons across scalars, collections, and complex numbers
-- 🪤 `raises()` context manager for precise exception assertions with optional message matching
-- 📦 Easy installation with pip or uv
-- ⚡ Low-overhead execution keeps small suites feeling instant
-
-## Performance
-
-Rustest is designed for speed. Our latest benchmarks on the rustest integration suite (~200 tests) show a consistent **2.1x wall-clock speedup** over pytest:
-
-| Test Runner | Reported Runtime† | Wall Clock‡ | Speedup (wall) | Command |
-|-------------|------------------|-------------|----------------|---------|
-| pytest      | 0.43–0.59s       | 1.33–1.59s  | 1.0x (baseline) | `pytest tests/ examples/tests/ -q`
-| rustest     | 0.003s           | 0.69–0.70s  | **~2.1x faster** | `python -m rustest tests/ examples/tests/`§
-
-### Large parametrized stress test
-
-We also profiled an extreme case with **10,000 parametrized invocations** to ensure rustest scales on synthetic but heavy workloads. The test lives in [`benchmarks/test_large_parametrize.py`](benchmarks/test_large_parametrize.py) and simply asserts `value + value == 2 * value` across every case. Running the module on its own shows a dramatic gap:
-
-| Test Runner | Avg. Wall Clock (3 runs) | Speedup | Command |
-|-------------|--------------------------|---------|---------|
-| pytest      | 9.72s                    | 1.0x    | `pytest benchmarks/test_large_parametrize.py -q`§
-| rustest     | 0.41s                    | **~24x** | `python -m rustest benchmarks/test_large_parametrize.py`§
-
-† pytest and rustest both report only active test execution time; rustest's figure omits Python interpreter start-up overhead.
-
-‡ Integration-suite wall-clock timing measured with the shell `time` builtin across two consecutive runs in the same environment.
-
-§ Commands executed with `PYTHONPATH=python` in this repository checkout to exercise the local sources. Pytest relies on a small compatibility shim in [`benchmarks/conftest.py`](benchmarks/conftest.py) so it understands the rustest-style decorators. Large-parametrization timings come from averaging three `time.perf_counter()` measurements with output suppressed via `subprocess.DEVNULL`.
-
-Rustest counts parametrized cases slightly differently than pytest, so you will see 199 executed cases vs. pytest's 201 discoveries on the same suite—the reported pass/skip counts still align.
-
-**Why is rustest faster?**
-- **Near-zero startup time**: Native Rust binary minimizes overhead before Python code starts running.
-- **Rust-native test discovery**: Minimal imports until test execution keeps collection quick.
-- **Optimized fixture resolution**: Efficient dependency graph resolution reduces per-test work.
-- **Lean orchestration**: Rust handles scheduling and reporting so the Python interpreter focuses on running test bodies.
-
-**Real-world impact:**
-- **200 tests** (this repository): 1.46s → 0.70s (average wall-clock, ~0.76s saved per run)
-- **1,000 tests** (projected): ~7.3s → ~3.4s assuming similar scaling
-- **10,000 tests** (projected): ~73s → ~34s—minutes saved across CI runs
-
-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, approx, raises
-
-@fixture
-def numbers() -> list[int]:
-    return [1, 2, 3, 4, 5]
-
-def test_sum(numbers: list[int]) -> None:
-    assert sum(numbers) == approx(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
-
-def test_division_by_zero_is_reported() -> None:
-    with raises(ZeroDivisionError, match="division by zero"):
-        1 / 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
-```
-
-#### Assertion Helpers
-
-Rustest ships helpers for expressive assertions:
-
-```python
-from rustest import approx, raises
-
-def test_nearly_equal() -> None:
-    assert 0.1 + 0.2 == approx(0.3, rel=1e-9)
-
-def test_raises_with_message() -> None:
-    with raises(ValueError, match="invalid configuration"):
-        raise ValueError("invalid configuration")
-```
-
-#### 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.2.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-rustest-0.2.0.dist-info/METADATA,sha256=zNdhsqtUfKsGrhvlI7csbjpmT6FFsb3T3kaE2a5Yx5c,16497
-rustest-0.2.0.dist-info/WHEEL,sha256=73R9gF1Kx45mnq358tC7C3GKhsVvyIHwOBt6LvI35MM,106
-rustest-0.2.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
-rustest-0.2.0.dist-info/licenses/LICENSE,sha256=s64ibUGtb6jEDBsYuxUFtMr_c4PaqYP-vj3YY6QtTGw,1075
-rustest/__init__.py,sha256=lXDAo5Ygm_sk-1Qu0M8kZnx3BR5AgSVDJWeb8IX2vYM,523
-rustest/__main__.py,sha256=nqdz6DhrDze715SXxtzAYV2sie3CPoy7IvWCdcyHJEM,179
-rustest/_approx.py,sha256=MKmuorBBHqpH0h0QaIMVjbm3-mXJ0E90limEgSHHVfw,5744
-rustest/_cli.py,sha256=kq9LAwHaJmZ-gnAlTsz7Ov8r1fiDvNoLf4hEI3sxhng,8700
-rustest/_decorators.py,sha256=nijzNG8NQXZd8kEfMjhSB-85gLoIjaIMxwZQNUNWgrE,11373
-rustest/_reporting.py,sha256=6nVcccX1dgEBW72wCOeOIl5I-OE-ukjJD0VQs56pwjo,1626
-rustest/_rust.cpython-313-darwin.so,sha256=htKOwWu0GWLOq_YHMlcMp32Qh2FQ9d_boi9Nm579y7Q,1540452
-rustest/_rust.py,sha256=k3nXhGiehOVY_S6w28rIdrc0CEc3gFLgwWVOEMcPOZo,660
-rustest/_rust.pyi,sha256=fDFLX0qj4G_bV1sHmTtRPI26grTDG_LFzPFEqp5vFGk,671
-rustest/core.py,sha256=xmBUpuPs0r0HQthc9J5dCQYkZnXqfxqIfSGkHeoqQS4,488
-rustest-0.2.0.dist-info/RECORD,,