rustest 0.5.0__cp312-cp312-win_amd64.whl → 0.7.0__cp312-cp312-win_amd64.whl

rustest/cli.py

@@ -93,7 +93,35 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_false",
         help="Disable code block tests from markdown files.",
     )
-    _ = parser.set_defaults(capture_output=True, color=True, enable_codeblocks=True)
+    _ = 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
 
 
@@ -105,6 +133,14 @@ 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=list(args.paths),
         pattern=args.pattern,
@@ -112,6 +148,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         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

@@ -16,6 +16,8 @@ def run(
     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.
 
@@ -26,6 +28,8 @@ def run(
         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),
@@ -34,5 +38,7 @@ def run(
         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

@@ -162,8 +162,122 @@ class MarkGenerator:
         @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,

rustest/rust.pyi

@@ -32,6 +32,8 @@ def run(
     workers: int | None,
     capture_output: bool,
     enable_codeblocks: bool,
+    last_failed_mode: str,
+    fail_fast: bool,
 ) -> PyRunReport:
     """Execute tests and return a report."""
     ...

{rustest-0.5.0.dist-info → rustest-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustest
-Version: 0.5.0
+Version: 0.7.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -18,6 +18,8 @@ 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'
@@ -44,6 +46,7 @@ Rustest (pronounced like Russ-Test) is a Rust-powered test runner that aims to p
 
 - 🚀 **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
@@ -76,6 +79,7 @@ With **10,000 parametrized invocations**:
 
 Rustest supports Python **3.10 through 3.14**.
 
+<!--pytest.mark.skip-->
 ```bash
 # Using pip
 pip install rustest
@@ -94,6 +98,7 @@ Create a file `test_math.py`:
 
 ```python
 from rustest import fixture, parametrize, mark, approx, raises
+import asyncio
 
 @fixture
 def numbers() -> list[int]:
@@ -111,6 +116,13 @@ 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
@@ -118,6 +130,7 @@ def test_division_by_zero() -> None:
 
 ### 2. Run Your Tests
 
+<!--pytest.mark.skip-->
 ```bash
 # Run all tests
 rustest
@@ -133,6 +146,16 @@ 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
 ```
@@ -186,6 +209,7 @@ We welcome contributions! See the [Development Guide](https://apex-engineers-inc
 
 Quick reference:
 
+<!--pytest.mark.skip-->
 ```bash
 # Setup
 git clone https://github.com/Apex-Engineers-Inc/rustest.git

rustest-0.7.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rustest-0.7.0.dist-info/METADATA,sha256=t6zLLc3Y-0qY2KKh3xCdVK50GM1B1ZNugDVGt4AChzI,9011
+rustest-0.7.0.dist-info/WHEEL,sha256=M1DN_cdEL9MiMVOnA_mgpqWn-huMwVTFfEx_RmZww1E,97
+rustest-0.7.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.7.0.dist-info/licenses/LICENSE,sha256=Ci0bB0T1ZGkqIV237Zp_Bv8LIJJ0Vxwc-AhLhgDgAoQ,1096
+rustest/__init__.py,sha256=LL9UloOClzeNO6A-iMkEFtHDrBTAhRLko3sXy55H0QA,542
+rustest/__main__.py,sha256=yMhaWvxGAV46BYY8fB6GoRy9oh8Z8YrS9wlZI3LmoyY,188
+rustest/approx.py,sha256=sGaH15n3vSSv84dmR_QAIDV-xwaUrX-MqwpWIp5ihjk,5904
+rustest/cli.py,sha256=6etivUqjdnHgYShXobtrEFFhjW2PuetWuj8hwM4gRuI,10496
+rustest/core.py,sha256=ORTAlkeuu6nC2Q43hg-VJY6PN1HUiaMoP1vu_WH-8cs,1505
+rustest/decorators.py,sha256=mUrnY09mn7x0--3OAB47WQRR2f8NtexVSUWAUGcHvyc,19240
+rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustest/reporting.py,sha256=g4jdlwjFoKF_fWA_sKfeDwmhDeHxPJQUqypa_E2XQlc,1686
+rustest/rust.cp312-win_amd64.pyd,sha256=PUQBX9EY49xlHJ6zyxKz6yDayGOLDA5Gc8OBdeA2xow,1411584
+rustest/rust.py,sha256=N_1C-uXRiC2qkV7ecKVcb51-XXyfhYNepd5zs-RIYOo,682
+rustest/rust.pyi,sha256=ltvSC9_ZUpuRgq9cShN93YLxaxt9c1B2AqBswpk1nfY,849
+rustest-0.7.0.dist-info/RECORD,,

{rustest-0.5.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: cp312-cp312-win_amd64

rustest-0.5.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-rustest-0.5.0.dist-info/METADATA,sha256=SkRHcV4Pv7s5Hfo9ywd77-b3wuJtgbPvtrYY6LQoaYk,8225
-rustest-0.5.0.dist-info/WHEEL,sha256=n8ZdhGDUio-M1d1jdBhS3kD6MKEN1SRxo8BOjWwZdsg,96
-rustest-0.5.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
-rustest-0.5.0.dist-info/licenses/LICENSE,sha256=Ci0bB0T1ZGkqIV237Zp_Bv8LIJJ0Vxwc-AhLhgDgAoQ,1096
-rustest/__init__.py,sha256=LL9UloOClzeNO6A-iMkEFtHDrBTAhRLko3sXy55H0QA,542
-rustest/__main__.py,sha256=yMhaWvxGAV46BYY8fB6GoRy9oh8Z8YrS9wlZI3LmoyY,188
-rustest/approx.py,sha256=sGaH15n3vSSv84dmR_QAIDV-xwaUrX-MqwpWIp5ihjk,5904
-rustest/cli.py,sha256=Y7I3sLMA7icsHFLdcGJMy0LElEcoqzrVrTkedE_vGTs,9474
-rustest/core.py,sha256=2_kav-3XPhrtXnayQBDSc_tCaaaEj07rFHq5ln4Em8Q,1227
-rustest/decorators.py,sha256=mCiqNJXYpbQMCMaVEdeiebN9KWLvgtRmqZ6nbUXpm6E,14138
-rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rustest/reporting.py,sha256=g4jdlwjFoKF_fWA_sKfeDwmhDeHxPJQUqypa_E2XQlc,1686
-rustest/rust.cp312-win_amd64.pyd,sha256=RFiwEJBXWgLvajST9qNaP7RV5QbL7L6BWIMPAPgOAYQ,1341440
-rustest/rust.py,sha256=N_1C-uXRiC2qkV7ecKVcb51-XXyfhYNepd5zs-RIYOo,682
-rustest/rust.pyi,sha256=D2PL2GamLpcwdBDZxFeWC1ZgJ01CkvWycU62LnVTMD0,799
-rustest-0.5.0.dist-info/RECORD,,