pytest-isolated 0.1.0__py3-none-any.whl

pytest_isolated/__init__.py

@@ -0,0 +1,3 @@
+"""pytest-isolated: Run pytest tests in isolated subprocesses."""
+
+__version__ = "0.1.0"

pytest_isolated/plugin.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+# Guard to prevent infinite recursion (parent spawns child; child must not spawn again)
+SUBPROC_ENV = "PYTEST_RUNNING_IN_SUBPROCESS"
+
+# Parent tells child where to write JSONL records per test call
+SUBPROC_REPORT_PATH = "PYTEST_SUBPROCESS_REPORT_PATH"
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Add configuration options for subprocess isolation."""
+    group = parser.getgroup("subprocess")
+    group.addoption(
+        "--subprocess-timeout",
+        type=int,
+        default=None,
+        help="Timeout in seconds for subprocess groups (default: 300)",
+    )
+    group.addoption(
+        "--no-subprocess",
+        action="store_true",
+        default=False,
+        help="Disable subprocess isolation (for debugging)",
+    )
+    parser.addini(
+        "subprocess_timeout",
+        type="string",
+        default="300",
+        help="Default timeout in seconds for subprocess groups",
+    )
+    parser.addini(
+        "subprocess_capture_passed",
+        type="bool",
+        default=False,
+        help="Capture output for passed tests (default: False)",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "subprocess(group=None): run this test in a grouped fresh Python subprocess; "
+        "tests with the same group run together in one subprocess.",
+    )
+
+
+# ----------------------------
+# CHILD MODE: record results + captured output per test phase
+# ----------------------------
+def pytest_runtest_logreport(report: pytest.TestReport) -> None:
+    """
+    In the child process, write one JSON line per test phase (setup/call/teardown)
+    containing outcome, captured stdout/stderr, duration, and other metadata.
+    The parent will aggregate and re-emit this info.
+    """
+    path = os.environ.get(SUBPROC_REPORT_PATH)
+    if not path:
+        return
+
+    # Capture ALL phases (setup, call, teardown), not just call
+    rec = {
+        "nodeid": report.nodeid,
+        "when": report.when,  # setup, call, or teardown
+        "outcome": report.outcome,  # passed/failed/skipped
+        "longrepr": str(report.longrepr) if report.longrepr else "",
+        "duration": getattr(report, "duration", 0.0),
+        "stdout": getattr(report, "capstdout", "") or "",
+        "stderr": getattr(report, "capstderr", "") or "",
+        # Preserve test metadata for proper reporting
+        "keywords": list(report.keywords),
+        "sections": getattr(report, "sections", []),  # captured logs, etc.
+        "user_properties": getattr(report, "user_properties", []),
+        "wasxfail": hasattr(report, "wasxfail"),
+    }
+    with Path(path).open("a", encoding="utf-8") as f:
+        f.write(json.dumps(rec) + "\n")
+
+
+# ----------------------------
+# PARENT MODE: group marked tests
+# ----------------------------
+def pytest_collection_modifyitems(
+    config: pytest.Config, items: list[pytest.Item]
+) -> None:
+    """
+    Partition items into subprocess groups + normal items and stash on config.
+    """
+    if os.environ.get(SUBPROC_ENV) == "1":
+        return  # child should not do grouping
+
+    # If --no-subprocess is set, treat all tests as normal (no subprocess isolation)
+    if config.getoption("no_subprocess", False):
+        config._subprocess_groups = OrderedDict()  # type: ignore[attr-defined]
+        config._subprocess_normal_items = items  # type: ignore[attr-defined]
+        return
+
+    groups: OrderedDict[str, list[pytest.Item]] = OrderedDict()
+    normal: list[pytest.Item] = []
+
+    for item in items:
+        m = item.get_closest_marker("subprocess")
+        if not m:
+            normal.append(item)
+            continue
+
+        group = m.kwargs.get("group")
+        # Default grouping to module path (so you don't accidentally group everything)
+        if group is None:
+            group = item.nodeid.split("::")[0]
+        groups.setdefault(str(group), []).append(item)
+
+    config._subprocess_groups = groups  # type: ignore[attr-defined]
+    config._subprocess_normal_items = normal  # type: ignore[attr-defined]
+
+
+def pytest_runtestloop(session: pytest.Session) -> int | None:
+    """
+    Run each subprocess group in its own subprocess once;
+    then run normal tests in-process.
+
+    Enhanced to:
+    - Capture all test phases (setup, call, teardown)
+    - Support configurable timeouts
+    - Properly handle crashes and missing results
+    - Integrate with pytest's reporting system
+    """
+    if os.environ.get(SUBPROC_ENV) == "1":
+        return None  # child runs the normal loop
+
+    config = session.config
+    groups: OrderedDict[str, list[pytest.Item]] = getattr(
+        config, "_subprocess_groups", OrderedDict()
+    )
+    normal_items: list[pytest.Item] = getattr(
+        config, "_subprocess_normal_items", session.items
+    )
+
+    # Get timeout configuration
+    timeout_opt = config.getoption("subprocess_timeout", None)
+    timeout_ini = config.getini("subprocess_timeout")
+    timeout = timeout_opt or (int(timeout_ini) if timeout_ini else 300)
+
+    # Get capture configuration
+    capture_passed = config.getini("subprocess_capture_passed")
+
+    def emit_report(
+        item: pytest.Item,
+        when: str,
+        outcome: str,
+        longrepr: str = "",
+        duration: float = 0.0,
+        stdout: str = "",
+        stderr: str = "",
+        sections: list[tuple[str, str]] | None = None,
+        user_properties: list[tuple[str, Any]] | None = None,
+        wasxfail: bool = False,
+    ) -> None:
+        """
+        Emit a synthetic report for the given item and phase.
+        Attach captured output based on outcome and configuration.
+        """
+        call = pytest.CallInfo.from_call(lambda: None, when=when)
+        rep = pytest.TestReport.from_item_and_call(item, call)
+        rep.outcome = outcome
+        rep.duration = duration
+
+        if user_properties:
+            rep.user_properties = user_properties
+
+        if wasxfail:
+            rep.wasxfail = "reason: xfail"
+
+        # For skipped tests, longrepr needs to be a tuple (path, lineno, reason)
+        if outcome == "skipped" and longrepr:
+            # Parse longrepr or create simple tuple
+            rep.longrepr = (str(item.fspath), item.location[1], longrepr)
+        elif outcome == "failed" and longrepr:
+            rep.longrepr = longrepr
+
+        # Add captured output as sections (capstdout/capstderr are read-only)
+        if outcome == "failed" or (outcome == "passed" and capture_passed):
+            all_sections = list(sections) if sections else []
+            if stdout:
+                all_sections.append(("Captured stdout call", stdout))
+            if stderr:
+                all_sections.append(("Captured stderr call", stderr))
+            if all_sections:
+                rep.sections = all_sections
+
+        item.ihook.pytest_runtest_logreport(report=rep)
+
+    # Run groups
+    for group_name, group_items in groups.items():
+        nodeids = [it.nodeid for it in group_items]
+
+        # file where the child will append JSONL records
+        with tempfile.NamedTemporaryFile(
+            prefix="pytest-subproc-", suffix=".jsonl", delete=False
+        ) as tf:
+            report_path = tf.name
+
+        env = os.environ.copy()
+        env[SUBPROC_ENV] = "1"
+        env[SUBPROC_REPORT_PATH] = report_path
+
+        # Run pytest in subprocess with timeout
+        cmd = [sys.executable, "-m", "pytest", *nodeids]
+
+        try:
+            proc = subprocess.run(
+                cmd, env=env, timeout=timeout, capture_output=False, check=False
+            )
+            returncode = proc.returncode
+            timed_out = False
+        except subprocess.TimeoutExpired:
+            returncode = -1
+            timed_out = True
+
+        # Gather results from JSONL file
+        results: dict[str, dict[str, Any]] = {}
+        report_file = Path(report_path)
+        if report_file.exists():
+            with report_file.open(encoding="utf-8") as f:
+                for line in f:
+                    file_line = line.strip()
+                    if not file_line:
+                        continue
+                    rec = json.loads(file_line)
+                    nodeid = rec["nodeid"]
+                    when = rec["when"]
+
+                    if nodeid not in results:
+                        results[nodeid] = {}
+                    results[nodeid][when] = rec
+            with contextlib.suppress(OSError):
+                report_file.unlink()
+
+        # Handle timeout or crash
+        if timed_out:
+            msg = (
+                f"Subprocess group={group_name!r} timed out after {timeout} "
+                f"seconds. Increase timeout with --subprocess-timeout or "
+                f"subprocess_timeout ini option."
+            )
+            for it in group_items:
+                emit_report(it, "call", "failed", longrepr=msg)
+                session.testsfailed += 1
+            continue
+
+        if not results:
+            msg = (
+                f"Subprocess group={group_name!r} exited with code {returncode} "
+                f"and produced no per-test report. The subprocess may have "
+                f"crashed during collection."
+            )
+            for it in group_items:
+                emit_report(it, "call", "failed", longrepr=msg)
+                session.testsfailed += 1
+            continue
+
+        # Emit per-test results into parent (all phases)
+        for it in group_items:
+            node_results = results.get(it.nodeid, {})
+
+            # Emit setup, call, teardown in order
+            for when in ["setup", "call", "teardown"]:
+                if when not in node_results:
+                    # If missing a phase, synthesize a passing one
+                    if when == "call" and not node_results:
+                        # Test completely missing - mark as failed
+                        emit_report(
+                            it,
+                            "call",
+                            "failed",
+                            longrepr=f"Missing result from subprocess for {it.nodeid}",
+                        )
+                        session.testsfailed += 1
+                    continue
+
+                rec = node_results[when]
+                emit_report(
+                    it,
+                    when=when,
+                    outcome=rec["outcome"],
+                    longrepr=rec.get("longrepr", ""),
+                    duration=rec.get("duration", 0.0),
+                    stdout=rec.get("stdout", ""),
+                    stderr=rec.get("stderr", ""),
+                    sections=rec.get("sections"),
+                    user_properties=rec.get("user_properties"),
+                    wasxfail=rec.get("wasxfail", False),
+                )
+
+                if when == "call" and rec["outcome"] == "failed":
+                    session.testsfailed += 1
+
+    # Run normal tests in-process
+    for idx, item in enumerate(normal_items):
+        nextitem = normal_items[idx + 1] if idx + 1 < len(normal_items) else None
+        item.config.hook.pytest_runtest_protocol(item=item, nextitem=nextitem)
+
+    return 1 if session.testsfailed else 0

pytest_isolated-0.1.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: pytest-isolated
+Version: 0.1.0
+Summary: Run marked pytest tests in grouped subprocesses (cross-platform).
+Author: pytest-isolated contributors
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=7.0
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest-timeout; extra == "test"
+Dynamic: license-file
+
+# pytest-isolated
+
+A pytest plugin that runs marked tests in isolated subprocesses with intelligent grouping.
+
+## Features
+
+- Run tests in fresh Python subprocesses to prevent state pollution
+- Group related tests to run together in the same subprocess
+- Handles crashes, timeouts, and setup/teardown failures
+- Captures stdout/stderr for failed tests
+- Works with pytest reporters (JUnit XML, etc.)
+- Configurable timeouts to prevent hanging subprocesses
+- Cross-platform: Linux, macOS, Windows
+
+## Installation
+
+```bash
+pip install pytest-isolated
+```
+
+## Quick Start
+
+Mark tests to run in isolated subprocesses:
+
+```python
+import pytest
+
+@pytest.mark.subprocess
+def test_isolated():
+    # Runs in a fresh subprocess
+    assert True
+```
+
+Tests with the same group run together in one subprocess:
+
+```python
+@pytest.mark.subprocess(group="mygroup")
+def test_one():
+    shared_state.append(1)
+
+@pytest.mark.subprocess(group="mygroup")
+def test_two():
+    # Sees state from test_one
+    assert len(shared_state) == 2
+```
+
+Tests without an explicit group are automatically grouped by module.
+
+## Configuration
+
+### Command Line
+
+```bash
+# Set subprocess timeout (seconds)
+pytest --subprocess-timeout=60
+
+# Disable subprocess isolation for debugging
+pytest --no-subprocess
+
+# Combine with pytest debugger
+pytest --no-subprocess --pdb
+```
+
+### pytest.ini / pyproject.toml
+
+```ini
+[pytest]
+subprocess_timeout = 300
+subprocess_capture_passed = false
+```
+
+Or in `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+subprocess_timeout = "300"
+subprocess_capture_passed = false
+```
+
+## Use Cases
+
+### Testing Global State
+
+```python
+@pytest.mark.subprocess
+def test_modifies_environ():
+    import os
+    os.environ["MY_VAR"] = "value"
+    # Won't affect other tests
+
+@pytest.mark.subprocess
+def test_clean_environ():
+    import os
+    assert "MY_VAR" not in os.environ
+```
+
+### Testing Singletons
+
+```python
+@pytest.mark.subprocess(group="singleton_tests")
+def test_singleton_init():
+    from myapp import DatabaseConnection
+    db = DatabaseConnection.get_instance()
+    assert db is not None
+
+@pytest.mark.subprocess(group="singleton_tests")
+def test_singleton_reuse():
+    db = DatabaseConnection.get_instance()
+    # Same instance as previous test in group
+```
+
+### Testing Process Resources
+
+```python
+@pytest.mark.subprocess
+def test_signal_handlers():
+    import signal
+    signal.signal(signal.SIGTERM, custom_handler)
+    # Won't interfere with pytest
+```
+
+## Output and Reporting
+
+Failed tests automatically capture and display stdout/stderr:
+
+```python
+@pytest.mark.subprocess
+def test_failing():
+    print("Debug info")
+    assert False
+```
+
+Works with standard pytest reporters:
+
+```bash
+pytest --junitxml=report.xml --durations=10
+```
+
+## Limitations
+
+**Fixtures**: Module/session fixtures run in each subprocess group. Cannot share fixture objects between parent and subprocess.
+
+**Debugging**: Use `--no-subprocess` to run all tests in the main process for easier debugging with `pdb` or IDE debuggers.
+
+**Performance**: Subprocess creation adds ~100-500ms per group. Group related tests to minimize overhead.
+
+## Advanced
+
+### Timeout Handling
+
+```bash
+pytest --subprocess-timeout=30
+```
+
+Timeout errors are clearly reported with the group name and timeout duration.
+
+### Crash Detection
+
+If a subprocess crashes, tests in that group are marked as failed with exit code information.
+
+### Subprocess Detection
+
+```python
+import os
+
+if os.environ.get("PYTEST_RUNNING_IN_SUBPROCESS") == "1":
+    # Running in subprocess
+    pass
+```
+
+## Troubleshooting
+
+**Tests timing out**: Increase timeout with `--subprocess-timeout=600`
+
+**Missing output**: Enable capture for passed tests with `subprocess_capture_passed = true`
+
+**Subprocess crashes**: Check for segfaults, OOM, or signal issues. Run with `-v` for details.
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Changelog
+
+### 0.1.0 (2026-01-12)
+
+- Initial release
+- Process isolation with subprocess marker
+- Smart grouping by module or explicit group names
+- Timeout support
+- Complete test phase capture (setup/call/teardown)
+- JUnit XML and standard reporter integration
+- Comprehensive error handling and reporting

pytest_isolated-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pytest_isolated/__init__.py,sha256=iqPlqv1sT1c10XcWOeYbJyRyIzeQk0Sa-OhOS14IMfg,89
+pytest_isolated/plugin.py,sha256=lLNjY5Jm5SmllySvVPRCF87fpQTnRx_RMtloKeM1m9U,11296
+pytest_isolated-0.1.0.dist-info/licenses/LICENSE,sha256=WECJyowi685PZSnKcA4Tqs7jukfzbnk7iMPLnm_q4JI,1067
+pytest_isolated-0.1.0.dist-info/METADATA,sha256=qfVoG6VGZCb-Dj5Wl12sGQH7WO-U2Gj4KcGV2H_FXzU,5131
+pytest_isolated-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_isolated-0.1.0.dist-info/entry_points.txt,sha256=HgRNPjIGoPBF1pkhma4UtaSwhpOVB8oZRZ0L1FcZXgk,45
+pytest_isolated-0.1.0.dist-info/top_level.txt,sha256=FAtpozhvI-YaiFoZMepi9JAm6e87mW-TM1Ovu5xLOxg,16
+pytest_isolated-0.1.0.dist-info/RECORD,,

pytest_isolated-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytest_isolated-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+isolated = pytest_isolated.plugin

pytest_isolated-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bryn Lloyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_isolated-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_isolated