pytest-isolated 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

pytest_isolated/__init__.py

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

pytest_isolated/plugin.py

@@ -9,20 +9,111 @@ import tempfile
 import time
 from collections import OrderedDict
 from pathlib import Path
-from typing import Any
+from typing import Any, Final, Literal, TypedDict, cast
 
 import pytest
 
 # Guard to prevent infinite recursion (parent spawns child; child must not spawn again)
-SUBPROC_ENV = "PYTEST_RUNNING_IN_SUBPROCESS"
+SUBPROC_ENV: Final = "PYTEST_RUNNING_IN_SUBPROCESS"
 
 # Parent tells child where to write JSONL records per test call
-SUBPROC_REPORT_PATH = "PYTEST_SUBPROCESS_REPORT_PATH"
+SUBPROC_REPORT_PATH: Final = "PYTEST_SUBPROCESS_REPORT_PATH"
+
+# Options that should be forwarded to subprocess (flags without values)
+_FORWARD_FLAGS: Final = {
+    "-v",
+    "--verbose",
+    "-q",
+    "--quiet",
+    "-s",  # disable output capturing
+    "-l",
+    "--showlocals",
+    "--strict-markers",
+    "--strict-config",
+    "-x",  # exit on first failure
+    "--exitfirst",
+}
+
+# Options that should be forwarded to subprocess (options with values)
+_FORWARD_OPTIONS_WITH_VALUE: Final = {
+    "--tb",  # traceback style
+    "-r",  # show extra test summary info
+    "--capture",  # capture method (fd/sys/no/tee-sys)
+}
+
+
+def _has_isolated_marker(obj: Any) -> bool:
+    """Check if an object has the isolated marker in its pytestmark."""
+    markers = getattr(obj, "pytestmark", [])
+    if not isinstance(markers, list):
+        markers = [markers]
+    return any(getattr(m, "name", None) == "isolated" for m in markers)
+
+
+# ---------------------------------------------------------------------------
+# Cross-platform crash detection helpers
+# ---------------------------------------------------------------------------
+
+
+def _format_crash_reason(returncode: int) -> str:
+    """Format a human-readable crash reason from a return code.
+
+    On Unix, negative return codes indicate signal numbers.
+    On Windows, we report the exit code directly.
+    """
+    if returncode < 0:
+        # Unix: negative return code is -signal_number
+        return f"crashed with signal {-returncode}"
+    # Windows or other: positive exit code
+    return f"crashed with exit code {returncode}"
+
+
+def _format_crash_message(
+    returncode: int,
+    context: str,
+    stderr_text: str = "",
+) -> str:
+    """Build a complete crash error message with optional stderr output.
+
+    Args:
+        returncode: The subprocess return code.
+        context: Description of when the crash occurred (e.g., "during test execution").
+        stderr_text: Optional captured stderr from the subprocess.
+
+    Returns:
+        A formatted error message suitable for test failure reports.
+    """
+    reason = _format_crash_reason(returncode)
+    msg = f"Subprocess {reason} {context}."
+    if stderr_text:
+        msg += f"\n\nSubprocess stderr:\n{stderr_text}"
+    return msg
+
+
+class _TestRecord(TypedDict, total=False):
+    """Structure for test phase results from subprocess."""
+
+    nodeid: str
+    when: Literal["setup", "call", "teardown"]
+    outcome: Literal["passed", "failed", "skipped"]
+    longrepr: str
+    duration: float
+    stdout: str
+    stderr: str
+    keywords: list[str]
+    sections: list[tuple[str, str]]
+    user_properties: list[tuple[str, Any]]
+    wasxfail: bool
 
 
 def pytest_addoption(parser: pytest.Parser) -> None:
-    """Add configuration options for subprocess isolation."""
     group = parser.getgroup("isolated")
+    group.addoption(
+        "--isolated",
+        action="store_true",
+        default=False,
+        help="Run all tests in isolated subprocesses",
+    )
     group.addoption(
         "--isolated-timeout",
         type=int,
@@ -62,17 +153,13 @@ def pytest_configure(config: pytest.Config) -> None:
 # 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.
-    """
+    """Write test phase results to a JSONL file when running in subprocess mode."""
     path = os.environ.get(SUBPROC_REPORT_PATH)
     if not path:
         return
 
     # Capture ALL phases (setup, call, teardown), not just call
-    rec = {
+    rec: _TestRecord = {
         "nodeid": report.nodeid,
         "when": report.when,  # setup, call, or teardown
         "outcome": report.outcome,  # passed/failed/skipped
@@ -96,9 +183,6 @@ def pytest_runtest_logreport(report: pytest.TestReport) -> None:
 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
 
@@ -108,25 +192,58 @@ def pytest_collection_modifyitems(
         config._subprocess_normal_items = items  # type: ignore[attr-defined]
         return
 
+    # If --isolated is set, run all tests in isolation
+    run_all_isolated = config.getoption("isolated", False)
+
     groups: OrderedDict[str, list[pytest.Item]] = OrderedDict()
     group_timeouts: dict[str, int | None] = {}  # Track timeout per group
     normal: list[pytest.Item] = []
 
     for item in items:
         m = item.get_closest_marker("isolated")
-        if not m:
+
+        # Skip non-isolated tests unless --isolated flag is set
+        if not m and not run_all_isolated:
             normal.append(item)
             continue
 
-        group = m.kwargs.get("group")
-        # Default grouping to module path (so you don't accidentally group everything)
+        # Get group from marker (positional arg, keyword arg, or default)
+        group = None
+        if m:
+            # Support @pytest.mark.isolated("groupname") - positional arg
+            if m.args:
+                group = m.args[0]
+            # Support @pytest.mark.isolated(group="groupname") - keyword arg
+            elif "group" in m.kwargs:
+                group = m.kwargs["group"]
+
+        # Default grouping logic
         if group is None:
-            group = item.nodeid.split("::")[0]
+            # If --isolated flag is used (no explicit marker), use unique nodeid
+            if not m:
+                group = item.nodeid
+            # Check if marker was applied to a class or module
+            elif isinstance(item, pytest.Function):
+                if item.cls is not None and _has_isolated_marker(item.cls):
+                    # Group by class name (module::class)
+                    parts = item.nodeid.split("::")
+                    group = "::".join(parts[:2]) if len(parts) >= 3 else item.nodeid
+                elif _has_isolated_marker(item.module):
+                    # Group by module name (first part of nodeid)
+                    parts = item.nodeid.split("::")
+                    group = parts[0]
+                else:
+                    # Explicit marker on function uses unique nodeid
+                    group = item.nodeid
+            else:
+                # Non-Function items use unique nodeid
+                group = item.nodeid
 
         # Store group-specific timeout (first marker wins)
         group_key = str(group)
         if group_key not in group_timeouts:
-            group_timeouts[group_key] = m.kwargs.get("timeout")
+            timeout = m.kwargs.get("timeout") if m else None
+            group_timeouts[group_key] = timeout
 
         groups.setdefault(group_key, []).append(item)
 
@@ -135,24 +252,109 @@ def pytest_collection_modifyitems(
     config._subprocess_normal_items = normal  # type: ignore[attr-defined]
 
 
-def pytest_runtestloop(session: pytest.Session) -> int | None:
+def _emit_report(
+    item: pytest.Item,
+    *,
+    when: Literal["setup", "call", "teardown"],
+    outcome: Literal["passed", "failed", "skipped"],
+    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,
+    capture_passed: bool = False,
+) -> None:
+    """Emit a test report for a specific test phase."""
+    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
+        lineno = item.location[1] if item.location[1] is not None else -1
+        rep.longrepr = (str(item.fspath), lineno, longrepr)  # type: ignore[assignment]
+    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)
+
+
+def _emit_failure_for_items(
+    items: list[pytest.Item],
+    error_message: str,
+    session: pytest.Session,
+    capture_passed: bool = False,
+) -> None:
+    """Emit synthetic failure reports when subprocess execution fails.
+
+    When a subprocess crashes, times out, or fails during collection, we emit
+    synthetic test phase reports to mark affected tests as failed. We report
+    setup="passed" and teardown="passed" (even though these phases never ran)
+    to ensure pytest categorizes the test as FAILED rather than ERROR. The actual
+    failure is reported in the call phase with the error message.
+
+    For xfail tests, call is reported as skipped with wasxfail=True to maintain
+    proper xfail semantics.
     """
-    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
+    for it in items:
+        xfail_marker = it.get_closest_marker("xfail")
+        _emit_report(it, when="setup", outcome="passed", capture_passed=capture_passed)
+        if xfail_marker:
+            _emit_report(
+                it,
+                when="call",
+                outcome="skipped",
+                longrepr=error_message,
+                wasxfail=True,
+                capture_passed=capture_passed,
+            )
+        else:
+            _emit_report(
+                it,
+                when="call",
+                outcome="failed",
+                longrepr=error_message,
+                capture_passed=capture_passed,
+            )
+            session.testsfailed += 1
+        _emit_report(
+            it, when="teardown", outcome="passed", capture_passed=capture_passed
+        )
+
+
+def pytest_runtestloop(session: pytest.Session) -> int | None:
+    """Execute isolated test groups in subprocesses and remaining tests in-process.
+
+    Any subprocess timeouts are caught and reported as test failures; the
+    subprocess.TimeoutExpired exception is not propagated to the caller.
     """
     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()
-    )
+    groups = getattr(config, "_subprocess_groups", OrderedDict())
+    if not isinstance(groups, OrderedDict):
+        groups = OrderedDict()
     group_timeouts: dict[str, int | None] = getattr(
         config, "_subprocess_group_timeouts", {}
     )
@@ -168,52 +370,6 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
     # Get capture configuration
     capture_passed = config.getini("isolated_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]
@@ -231,24 +387,78 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
         env[SUBPROC_ENV] = "1"
         env[SUBPROC_REPORT_PATH] = report_path
 
-        # Run pytest in subprocess with timeout, tracking execution time
-        cmd = [sys.executable, "-m", "pytest", *nodeids]
+        # Forward relevant pytest options to subprocess for consistency
+        # Only forward specific options that affect test execution behavior
+        forwarded_args = []
+        if hasattr(config, "invocation_params") and hasattr(
+            config.invocation_params, "args"
+        ):
+            skip_next = False
+
+            for arg in config.invocation_params.args:
+                if skip_next:
+                    skip_next = False
+                    continue
+
+                # Forward only explicitly allowed options
+                if arg in _FORWARD_FLAGS:
+                    forwarded_args.append(arg)
+                elif arg in _FORWARD_OPTIONS_WITH_VALUE:
+                    forwarded_args.append(arg)
+                    skip_next = True  # Next arg is the value
+                elif arg.startswith(
+                    tuple(f"{opt}=" for opt in _FORWARD_OPTIONS_WITH_VALUE)
+                ):
+                    forwarded_args.append(arg)
+
+                # Skip everything else (positional args, test paths, unknown options)
+
+        # Build pytest command for subprocess
+        cmd = [sys.executable, "-m", "pytest"]
+        cmd.extend(forwarded_args)
+
+        # Pass rootdir to subprocess to ensure it uses the same project root
+        if config.rootpath:
+            cmd.extend(["--rootdir", str(config.rootpath)])
+
+        # Add the test nodeids
+        cmd.extend(nodeids)
+
         start_time = time.time()
 
+        # Determine the working directory for the subprocess
+        # Use rootpath if set, otherwise use invocation directory
+        # This ensures nodeids (which are relative to rootpath) can be resolved
+        subprocess_cwd = None
+        if config.rootpath:
+            subprocess_cwd = str(config.rootpath)
+        elif hasattr(config, "invocation_params") and hasattr(
+            config.invocation_params, "dir"
+        ):
+            subprocess_cwd = str(config.invocation_params.dir)
+
+        proc_stderr = b""
         try:
             proc = subprocess.run(
-                cmd, env=env, timeout=group_timeout, capture_output=False, check=False
+                cmd,
+                env=env,
+                timeout=group_timeout,
+                capture_output=True,
+                check=False,
+                cwd=subprocess_cwd,
             )
             returncode = proc.returncode
+            proc_stderr = proc.stderr or b""
             timed_out = False
-        except subprocess.TimeoutExpired:
+        except subprocess.TimeoutExpired as exc:
             returncode = -1
+            proc_stderr = exc.stderr or b""
             timed_out = True
 
         execution_time = time.time() - start_time
 
         # Gather results from JSONL file
-        results: dict[str, dict[str, Any]] = {}
+        results: dict[str, dict[str, _TestRecord]] = {}
         report_file = Path(report_path)
         if report_file.exists():
             with report_file.open(encoding="utf-8") as f:
@@ -256,7 +466,7 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
                     file_line = line.strip()
                     if not file_line:
                         continue
-                    rec = json.loads(file_line)
+                    rec = cast(_TestRecord, json.loads(file_line))
                     nodeid = rec["nodeid"]
                     when = rec["when"]
 
@@ -266,7 +476,20 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
             with contextlib.suppress(OSError):
                 report_file.unlink()
 
-        # Handle timeout or crash
+        # For crashes (negative returncode), check if we should treat as xfail
+        if returncode < 0 and results:
+            # Check if all tests in this group are marked xfail
+            all_xfail = all(it.get_closest_marker("xfail") for it in group_items)
+            if all_xfail:
+                # Override any results from subprocess - crash is the expected outcome
+                msg = (
+                    f"Subprocess crashed with signal {-returncode} "
+                    f"(expected for xfail test)"
+                )
+                _emit_failure_for_items(group_items, msg, session, capture_passed)
+                continue
+
+        # Handle timeout
         if timed_out:
             msg = (
                 f"Subprocess group={group_name!r} timed out after {group_timeout} "
@@ -274,50 +497,163 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
                 f"Increase timeout with --isolated-timeout, isolated_timeout ini, "
                 f"or @pytest.mark.isolated(timeout=N)."
             )
-            for it in group_items:
-                emit_report(it, "call", "failed", longrepr=msg)
-                session.testsfailed += 1
+            _emit_failure_for_items(group_items, msg, session, capture_passed)
             continue
 
+        # Handle crash during collection (no results produced)
         if not results:
+            stderr_text = proc_stderr.decode("utf-8", errors="replace").strip()
             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
+            if stderr_text:
+                msg += f"\n\nSubprocess stderr:\n{stderr_text}"
+            _emit_failure_for_items(group_items, msg, session, capture_passed)
             continue
 
+        # Handle mid-test crash: detect tests with incomplete phases
+        # (e.g., setup recorded but call missing indicates crash during test)
+        crashed_items: list[pytest.Item] = []
+
+        for it in group_items:
+            node_results = results.get(it.nodeid, {})
+            # Test started (setup passed) but crashed before call completed.
+            # If setup was skipped or failed, no call phase is expected.
+            if node_results and "call" not in node_results:
+                setup_result = node_results.get("setup", {})
+                setup_outcome = setup_result.get("outcome", "")
+                if setup_outcome == "passed":
+                    crashed_items.append(it)
+
+        # If we detected crashed tests, also find tests that never ran
+        # (they come after the crashing test in the same group)
+        not_run_items: list[pytest.Item] = []
+        if crashed_items:
+            for it in group_items:
+                node_results = results.get(it.nodeid, {})
+                # Test never started (no results at all)
+                if not node_results:
+                    not_run_items.append(it)
+
+        if crashed_items or not_run_items:
+            stderr_text = proc_stderr.decode("utf-8", errors="replace").strip()
+
+            # Emit failures for crashed tests
+            if crashed_items:
+                crash_msg = _format_crash_message(
+                    returncode, "during test execution", stderr_text
+                )
+
+                for it in crashed_items:
+                    node_results = results.get(it.nodeid, {})
+                    # Emit setup phase if it was recorded
+                    if "setup" in node_results:
+                        rec = node_results["setup"]
+                        _emit_report(
+                            it,
+                            when="setup",
+                            outcome=rec["outcome"],
+                            longrepr=rec.get("longrepr", ""),
+                            duration=rec.get("duration", 0.0),
+                            capture_passed=capture_passed,
+                        )
+                    else:
+                        _emit_report(
+                            it,
+                            when="setup",
+                            outcome="passed",
+                            capture_passed=capture_passed,
+                        )
+
+                    # Emit call phase as failed with crash info
+                    xfail_marker = it.get_closest_marker("xfail")
+                    if xfail_marker:
+                        _emit_report(
+                            it,
+                            when="call",
+                            outcome="skipped",
+                            longrepr=crash_msg,
+                            wasxfail=True,
+                            capture_passed=capture_passed,
+                        )
+                    else:
+                        _emit_report(
+                            it,
+                            when="call",
+                            outcome="failed",
+                            longrepr=crash_msg,
+                            capture_passed=capture_passed,
+                        )
+                        session.testsfailed += 1
+
+                    _emit_report(
+                        it,
+                        when="teardown",
+                        outcome="passed",
+                        capture_passed=capture_passed,
+                    )
+                    # Remove from results so they're not processed again
+                    results.pop(it.nodeid, None)
+
+            # Emit failures for tests that never ran due to earlier crash
+            if not_run_items:
+                not_run_msg = _format_crash_message(
+                    returncode, "during earlier test execution", stderr_text
+                )
+                not_run_msg = f"Test did not run - {not_run_msg}"
+                _emit_failure_for_items(
+                    not_run_items, not_run_msg, session, capture_passed
+                )
+                for it in not_run_items:
+                    results.pop(it.nodeid, None)
+
         # Emit per-test results into parent (all phases)
         for it in group_items:
             node_results = results.get(it.nodeid, {})
 
+            # Skip tests that were already handled by crash detection above
+            if it.nodeid not in results:
+                continue
+
+            # Check if setup passed (to determine if missing call is expected)
+            setup_passed = (
+                "setup" in node_results and node_results["setup"]["outcome"] == "passed"
+            )
+
             # Emit setup, call, teardown in order
-            for when in ["setup", "call", "teardown"]:
+            for when in ["setup", "call", "teardown"]:  # type: ignore[assignment]
                 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(
+                    # If missing call phase AND setup passed, emit a failure
+                    # (crash detection above should handle most cases, but this
+                    # is a safety net for unexpected situations)
+                    # If setup failed, missing call is expected (pytest skips call)
+                    if when == "call" and setup_passed:
+                        msg = (
+                            "Missing 'call' phase result"
+                            f" from subprocess for {it.nodeid}"
+                        )
+                        _emit_report(
                             it,
-                            "call",
-                            "failed",
-                            longrepr=f"Missing result from subprocess for {it.nodeid}",
+                            when="call",
+                            outcome="failed",
+                            longrepr=msg,
+                            capture_passed=capture_passed,
                         )
                         session.testsfailed += 1
                     continue
 
                 rec = node_results[when]
-                emit_report(
+                _emit_report(
                     it,
-                    when=when,
-                    outcome=rec["outcome"],
+                    when=when,  # type: ignore[arg-type]
+                    outcome=rec.get("outcome", "failed"),  # type: ignore[arg-type]
                     longrepr=rec.get("longrepr", ""),
                     duration=rec.get("duration", 0.0),
                     stdout=rec.get("stdout", ""),
                     stderr=rec.get("stderr", ""),
+                    capture_passed=capture_passed,
                     sections=rec.get("sections"),
                     user_properties=rec.get("user_properties"),
                     wasxfail=rec.get("wasxfail", False),
@@ -326,6 +662,14 @@ def pytest_runtestloop(session: pytest.Session) -> int | None:
                 if when == "call" and rec["outcome"] == "failed":
                     session.testsfailed += 1
 
+        # Check if we should exit early due to maxfail/exitfirst
+        if (
+            session.testsfailed
+            and session.config.option.maxfail
+            and session.testsfailed >= session.config.option.maxfail
+        ):
+            return 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

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

@@ -1,9 +1,12 @@
 Metadata-Version: 2.4
 Name: pytest-isolated
-Version: 0.2.0
+Version: 0.4.0
 Summary: Run marked pytest tests in grouped subprocesses (cross-platform).
 Author: pytest-isolated contributors
 License-Expression: MIT
+Project-URL: Homepage, https://github.com/dyollb/pytest-isolated
+Project-URL: Repository, https://github.com/dyollb/pytest-isolated
+Project-URL: Issues, https://github.com/dyollb/pytest-isolated/issues
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
@@ -29,7 +32,7 @@ Dynamic: license-file
 [![Tests](https://github.com/dyollb/pytest-isolated/actions/workflows/test.yml/badge.svg)](https://github.com/dyollb/pytest-isolated/actions/workflows/test.yml)
 [![PyPI](https://img.shields.io/pypi/v/pytest-isolated.svg)](https://pypi.org/project/pytest-isolated/)
 
-A pytest plugin that runs marked tests in isolated subprocesses with intelligent grouping.
+A cross-platform pytest plugin that runs marked tests in isolated subprocesses with intelligent grouping.
 
 ## Features
 
@@ -41,6 +44,10 @@ A pytest plugin that runs marked tests in isolated subprocesses with intelligent
 - Configurable timeouts to prevent hanging subprocesses
 - Cross-platform: Linux, macOS, Windows
 
+## Cheatsheet for pytest-forked users
+
+This plugin is inspired by [pytest-forked](https://github.com/pytest-dev/pytest-forked). See [pytest-forked migration guide](docs/pytest-forked-migration.md) for a quick reference comparing features.
+
 ## Installation
 
 ```bash
@@ -63,6 +70,7 @@ def test_isolated():
 Tests with the same group run together in one subprocess:
 
 ```python
+# Using keyword argument
 @pytest.mark.isolated(group="mygroup")
 def test_one():
     shared_state.append(1)
@@ -71,6 +79,11 @@ def test_one():
 def test_two():
     # Sees state from test_one
     assert len(shared_state) == 2
+
+# Or using positional argument
+@pytest.mark.isolated("mygroup")
+def test_three():
+    shared_state.append(3)
 ```
 
 Set timeout per test group:
@@ -82,13 +95,48 @@ def test_with_timeout():
     expensive_operation()
 ```
 
-Tests without an explicit group are automatically grouped by module.
+**Note:** Tests without an explicit `group` parameter each run in their own unique subprocess for maximum isolation.
+
+### Class and Module Markers
+
+Apply to entire classes to share state between methods:
+
+```python
+@pytest.mark.isolated
+class TestDatabase:
+    def test_setup(self):
+        self.db = create_database()
+
+    def test_query(self):
+        # Shares state with test_setup
+        result = self.db.query("SELECT 1")
+        assert result
+```
+
+Apply to entire modules using `pytestmark`:
+
+```python
+import pytest
+
+pytestmark = pytest.mark.isolated
+
+def test_one():
+    # Runs in isolated subprocess
+    pass
+
+def test_two():
+    # Shares subprocess with test_one
+    pass
+```
 
 ## Configuration
 
 ### Command Line
 
 ```bash
+# Run all tests in isolation (even without @pytest.mark.isolated)
+pytest --isolated
+
 # Set isolated test timeout (seconds)
 pytest --isolated-timeout=60
 

pytest_isolated-0.4.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytest_isolated/__init__.py,sha256=sBrN76YMZ6pbqIZzb-Yz5SyDPluz0TCQcNJJ3kYSSc0,89
+pytest_isolated/plugin.py,sha256=33KIXSKlaC6Usq8ZrJmy2fjSTyVYj7q85777y7jWAGU,25698
+pytest_isolated/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_isolated-0.4.0.dist-info/licenses/LICENSE,sha256=WECJyowi685PZSnKcA4Tqs7jukfzbnk7iMPLnm_q4JI,1067
+pytest_isolated-0.4.0.dist-info/METADATA,sha256=wQ548E9j84pUfBNIYzDtbdcAh0CaGLXCiq7XGkXFI28,6679
+pytest_isolated-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pytest_isolated-0.4.0.dist-info/entry_points.txt,sha256=HgRNPjIGoPBF1pkhma4UtaSwhpOVB8oZRZ0L1FcZXgk,45
+pytest_isolated-0.4.0.dist-info/top_level.txt,sha256=FAtpozhvI-YaiFoZMepi9JAm6e87mW-TM1Ovu5xLOxg,16
+pytest_isolated-0.4.0.dist-info/RECORD,,

{pytest_isolated-0.2.0.dist-info → pytest_isolated-0.4.0.dist-info}/WHEEL

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

pytest_isolated-0.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-pytest_isolated/__init__.py,sha256=PN_IEdfxCUz6vL1vf0Ka9CGmCq9ppFk33fVGirSVtMc,89
-pytest_isolated/plugin.py,sha256=0AKRTWmdLaiwZdwRicRd3TMLrIeisGBMlFqCDOnJRX0,12206
-pytest_isolated/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytest_isolated-0.2.0.dist-info/licenses/LICENSE,sha256=WECJyowi685PZSnKcA4Tqs7jukfzbnk7iMPLnm_q4JI,1067
-pytest_isolated-0.2.0.dist-info/METADATA,sha256=q_E02kvtbnt1QgQc-ATrghLcJka7Y_2Zx50tmatVGCM,5384
-pytest_isolated-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_isolated-0.2.0.dist-info/entry_points.txt,sha256=HgRNPjIGoPBF1pkhma4UtaSwhpOVB8oZRZ0L1FcZXgk,45
-pytest_isolated-0.2.0.dist-info/top_level.txt,sha256=FAtpozhvI-YaiFoZMepi9JAm6e87mW-TM1Ovu5xLOxg,16
-pytest_isolated-0.2.0.dist-info/RECORD,,