rustest 0.2.0__cp311-cp311-macosx_10_12_x86_64.whl → 0.4.0__cp311-cp311-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
 
 
@@ -81,7 +81,13 @@ 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.set_defaults(capture_output=True, color=True, enable_codeblocks=True)
     return parser
 
 
@@ -98,6 +104,7 @@ def main(argv: Sequence[str] | None = None) -> int:
         pattern=args.pattern,
         workers=args.workers,
         capture_output=args.capture_output,
+        enable_codeblocks=args.enable_codeblocks,
     )
     _print_report(report, verbose=args.verbose, ascii_mode=args.ascii)
     return 0 if report.failed == 0 else 1

rustest/core.py

@@ -4,18 +4,19 @@ 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,
+    workers: int | None = None,
+    capture_output: bool = True,
+    enable_codeblocks: bool = True,
 ) -> RunReport:
     """Execute tests and return a rich report."""
 
-    raw_report = _rust.run(list(paths), pattern, workers, capture_output)
+    raw_report = rust.run(list(paths), pattern, workers, capture_output, enable_codeblocks)
     return RunReport.from_py(raw_report)

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,21 @@ 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,
     workers: int | None,
     capture_output: bool,
+    enable_codeblocks: bool,
 ) -> PyRunReport:
-    """Run tests and return a report."""
+    """Execute tests and return a report."""
     ...

{rustest-0.2.0.dist-info → rustest-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustest
-Version: 0.2.0
+Version: 0.4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,6 +37,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
 - 🔍 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 across scalars, collections, and complex numbers
 - 🪤 `raises()` context manager for precise exception assertions with optional message matching
@@ -99,6 +100,51 @@ uv add rustest
 ### For Development
 If you want to contribute to rustest, see [DEVELOPMENT.md](DEVELOPMENT.md) for setup instructions.
 
+## Testing Markdown Code Blocks
+
+Rustest can automatically discover and test Python code blocks in your markdown files, similar to pytest-codeblocks. This is perfect for ensuring your documentation examples stay up-to-date and functional.
+
+### Enabling Code Block Tests
+
+By default, rustest will automatically discover and test Python code blocks in markdown files (`.md`). Each Python code block is treated as a separate test case.
+
+```bash
+# Run tests including markdown code blocks
+rustest
+
+# Disable code block tests
+rustest --no-codeblocks
+```
+
+### Example Markdown File
+
+```markdown
+# Example Documentation
+
+## Basic Addition
+
+\```python
+x = 1 + 1
+assert x == 2
+\```
+
+## String Operations
+
+\```python
+text = "hello world"
+assert text.startswith("hello")
+\```
+```
+
+Each Python code block will be executed as a test. Code blocks with other language tags (like `javascript`, `bash`, etc.) are ignored.
+
+### Features
+
+- **Automatic Discovery**: All `.md` files are scanned for Python code blocks
+- **Simple Testing**: Each `\```python` code block is executed as a test
+- **CLI Control**: Use `--no-codeblocks` to disable code block testing
+- **Fast Execution**: Rust-powered parsing and execution keeps tests fast
+
 ## Quick Start
 
 ### 1. Write Your Tests
@@ -151,7 +197,7 @@ rustest --no-capture
 ### CLI Usage
 
 ```bash
-# Run all tests in current directory
+# Run all tests in current directory (including markdown code blocks)
 rustest
 
 # Run tests in specific paths
@@ -163,6 +209,9 @@ rustest -k "auth"           # Runs all tests with "auth" in the name
 
 # Control output capture
 rustest --no-capture        # See print statements during test execution
+
+# Disable markdown code block tests
+rustest --no-codeblocks     # Only run Python test files, skip .md files
 ```
 
 ### Python API Usage
@@ -171,22 +220,27 @@ You can also run rustest programmatically from Python:
 
 ```python
 from rustest import run
+import os
 
-# Basic usage
-report = run(paths=["tests"])
-print(f"Passed: {report.passed}, Failed: {report.failed}")
+# Basic usage (specify your test directory)
+if os.path.exists("tests"):
+    report = run(paths=["tests"])
+    print(f"Passed: {report.passed}, Failed: {report.failed}")
 
-# With pattern filtering
-report = run(paths=["tests"], pattern="user")
+    # With pattern filtering
+    report = run(paths=["tests"], pattern="user")
 
-# Without output capture (see print statements)
-report = run(paths=["tests"], capture_output=False)
+    # 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}")
+    # Disable markdown code block tests
+    report = run(paths=["tests"], enable_codeblocks=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
@@ -441,6 +495,142 @@ def test_full_workflow() -> None:
     pass
 ```
 
+#### Test Classes
+
+Rustest supports pytest-style test classes, allowing you to organize related tests together:
+
+```python
+from rustest import fixture, parametrize, mark
+
+class TestBasicMath:
+    """Group related tests in a class."""
+
+    def test_addition(self):
+        assert 1 + 1 == 2
+
+    def test_subtraction(self):
+        assert 5 - 3 == 2
+
+    def test_multiplication(self):
+        assert 3 * 4 == 12
+```
+
+**Using Fixtures in Test Classes:**
+
+Test methods can inject fixtures just like standalone test functions:
+
+```python
+from rustest import fixture
+
+@fixture
+def calculator():
+    return {"add": lambda x, y: x + y, "multiply": lambda x, y: x * y}
+
+class TestCalculator:
+    """Test class using fixtures."""
+
+    def test_addition(self, calculator):
+        assert calculator["add"](2, 3) == 5
+
+    def test_multiplication(self, calculator):
+        assert calculator["multiply"](4, 5) == 20
+```
+
+**Class-Scoped Fixtures:**
+
+Class-scoped fixtures are shared across all test methods in the same class, perfect for expensive setup operations:
+
+```python
+from rustest import fixture
+
+@fixture(scope="class")
+def database():
+    """Expensive setup shared across all tests in a class."""
+    db = {"connection": "db://test", "data": []}
+    return db
+
+class TestDatabase:
+    """All tests share the same database fixture instance."""
+
+    def test_connection(self, database):
+        assert database["connection"] == "db://test"
+
+    def test_add_data(self, database):
+        database["data"].append("item1")
+        assert len(database["data"]) >= 1
+
+    def test_data_persists(self, database):
+        # Same database instance, so previous test's data is still there
+        assert len(database["data"]) >= 1
+```
+
+**Fixture Methods Within Test Classes:**
+
+You can define fixtures as methods inside test classes, providing class-specific setup:
+
+```python
+from rustest import fixture
+
+class TestWithFixtureMethod:
+    """Test class with its own fixture methods."""
+
+    @fixture(scope="class")
+    def class_resource(self):
+        """Fixture method shared across tests in this class."""
+        resource = {"value": 42, "name": "test_resource"}
+        yield resource
+        # Teardown happens after all tests in class
+        resource["closed"] = True
+
+    @fixture
+    def per_test_data(self, class_resource):
+        """Fixture method that depends on another fixture."""
+        return {"id": id(self), "resource": class_resource}
+
+    def test_uses_class_resource(self, class_resource):
+        assert class_resource["value"] == 42
+
+    def test_uses_per_test_data(self, per_test_data):
+        assert "resource" in per_test_data
+        assert per_test_data["resource"]["value"] == 42
+```
+
+**Class Variables and Instance Variables:**
+
+Test classes can use class variables for shared state and instance variables for per-test isolation:
+
+```python
+class TestWithVariables:
+    """Test class with class and instance variables."""
+
+    class_variable = "shared_data"  # Shared across all tests
+
+    def test_class_variable(self):
+        # Access class variable
+        assert self.class_variable == "shared_data"
+        assert TestWithVariables.class_variable == "shared_data"
+
+    def test_instance_variable(self):
+        # Each test gets a fresh instance
+        self.instance_var = "test_specific"
+        assert self.instance_var == "test_specific"
+```
+
+**Parametrized Test Methods:**
+
+Use `@parametrize` on class methods just like regular test functions:
+
+```python
+from rustest import parametrize
+
+class TestParametrized:
+    """Test class with parametrized methods."""
+
+    @parametrize("value,expected", [(2, 4), (3, 9), (4, 16)])
+    def test_square(self, value, expected):
+        assert value ** 2 == expected
+```
+
 ### Test Output
 
 When you run rustest, you'll see clean, informative output:
@@ -470,13 +660,15 @@ Rustest aims to provide the most commonly-used pytest features with dramatically
 | **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 |
+| Test class detection (`Test*`) | ✅ | ✅ | Full pytest-style class support with fixture methods |
 | Pattern-based filtering | ✅ | ✅ | `-k` pattern matching |
+| Markdown code block testing | ✅ (`pytest-codeblocks`) | ✅ | Built-in support for testing Python blocks in `.md` files |
 | **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 methods within test classes | ✅ | ✅ | Define fixtures as class methods |
 | Fixture parametrization | ✅ | 🚧 | Planned |
 | **Parametrization** |
 | `@parametrize` decorator | ✅ | ✅ | Full support with custom IDs |

rustest-0.4.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rustest-0.4.0.dist-info/METADATA,sha256=RUECmwFvTEGVbU8UXiT5aPgHXGSGBANBM39Tr-C1ITE,22132
+rustest-0.4.0.dist-info/WHEEL,sha256=p_Yquq5Pk0aa0if4rX4yfMDTA_PSQbCXzFftM7T46yU,106
+rustest-0.4.0.dist-info/entry_points.txt,sha256=7fUa3LO8vudQ4dKG1sTRaDnxcMdBSZsWs9EyuxFQ7Lk,48
+rustest-0.4.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=VeV12EREHrBXva7hvUooEuePKVW6UgJuuaEowkwobgk,8961
+rustest/core.py,sha256=IsRdEfnCuTj41uEsy3WF4g9xI_-pGJ7FLu1s5C-PeKA,561
+rustest/decorators.py,sha256=nijzNG8NQXZd8kEfMjhSB-85gLoIjaIMxwZQNUNWgrE,11373
+rustest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rustest/reporting.py,sha256=3-R8aljv2ZbmjOa9Q9KZeCPsMaitm8nZ96LoJS_NnUQ,1623
+rustest/rust.cpython-311-darwin.so,sha256=RqScRyC5hDwjQUSWYFZ1w2xKMCv6w4Fe8ErhSJVWBwo,1591348
+rustest/rust.py,sha256=tCIvjYd06VxoT_rKvv2o8CpXW_pFNua5VgcRDjLgU78,659
+rustest/rust.pyi,sha256=bUx3229uh62MYJbBDGg1Vfnr1y_oyJnv_zK0g7vKe2s,735
+rustest-0.4.0.dist-info/RECORD,,

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=p_Yquq5Pk0aa0if4rX4yfMDTA_PSQbCXzFftM7T46yU,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-311-darwin.so,sha256=RKKbnOTFQHX1Xb4TcBjGFNgQbAvCvSHI48hLBGcdUdw,1540188
-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,,