rustest 0.1.0__cp311-cp311-macosx_11_0_arm64.whl → 0.5.0__cp311-cp311-macosx_11_0_arm64.whl

rustest-0.5.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: rustest
+Version: 0.5.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'
+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
+- 🔍 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**.
+
+```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
+
+@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
+
+def test_division_by_zero() -> None:
+    with raises(ZeroDivisionError, match="division by zero"):
+        1 / 0
+```
+
+### 2. Run Your Tests
+
+```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
+
+# 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:
+
+```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.5.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rustest-0.5.0.dist-info/METADATA,sha256=t13FMGBrjwTTq6iJ3xqPuJbO7zMriNL3MS87YAopr5Y,8054
+rustest-0.5.0.dist-info/WHEEL,sha256=dewdenAwp3PDth0u4HpQhcjieEs1_hiwRbm3WvCuoaI,104
+rustest-0.5.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.5.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=U7mlUghUnkrRcmjUD_R0leNgdC43fzUrki6XzWmUpRE,9201
+rustest/core.py,sha256=KoifFNU3tvOZgLU_zLvpcyEciOE4rAkQfpXWO2_EQmo,1189
+rustest/decorators.py,sha256=yQD6EV3mM2cAx2yns1YM22LfRw5m1k62yZXUZwm3Vz4,13715
+rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustest/reporting.py,sha256=3-R8aljv2ZbmjOa9Q9KZeCPsMaitm8nZ96LoJS_NnUQ,1623
+rustest/rust.cpython-311-darwin.so,sha256=TX-2ZgwYJA1alIrRHvI2IR6kiTROIupeknFDg9oe-B8,1502880
+rustest/rust.py,sha256=tCIvjYd06VxoT_rKvv2o8CpXW_pFNua5VgcRDjLgU78,659
+rustest/rust.pyi,sha256=-eAPqXfM9KwXHX_-oEuPwIU1x1mDEw_qkbur3mRouT0,762
+rustest-0.5.0.dist-info/RECORD,,

rustest/_decorators.py

@@ -1,194 +0,0 @@
-"""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()