pytest-threadpool 0.3.5__tar.gz → 0.3.6__tar.gz

{pytest_threadpool-0.3.5 → pytest_threadpool-0.3.6}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.3.6
+
+### Fixes
+
+- Fixed session, module, and class-scoped fixtures being torn down and
+  re-created between parallel groups instead of being resolved once and
+  shared for their entire scope. The same fix applies to xunit-style
+  `setup_module`/`setup_class` hooks.
+
 ## 0.3.5
 
 ### Fixes

{pytest_threadpool-0.3.5 → pytest_threadpool-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-threadpool
-Version: 0.3.5
+Version: 0.3.6
 Summary: Parallel test execution for free-threaded Python builds
 Project-URL: Homepage, https://github.com/pytest-threadpool/pytest-threadpool
 Project-URL: Source, https://github.com/pytest-threadpool/pytest-threadpool

pytest_threadpool-0.3.6/examples/test_event_bus/event_bus.py

@@ -0,0 +1,76 @@
+"""In-memory event bus — thread-safe test double.
+
+A minimal pub/sub bus that records all published events. Tests publish
+events concurrently, then verify delivery, ordering, and deduplication
+against the shared log.
+
+With pytest-xdist this would require an external broker (Redis, RabbitMQ)
+or a socket-based mock server since each worker is a separate process.
+With pytest-threadpool it's a plain Python object protected by a Lock.
+"""
+
+import threading
+
+
+class EventBus:
+    """Thread-safe in-memory event bus for testing.
+
+    Instance-based: each test scope gets its own bus via a fixture,
+    with proper setup/teardown handled by pytest's fixture lifecycle.
+    """
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._events: list[dict] = []
+        self._subscribers: dict[str, list] = {}
+        self._waiters: list[tuple[str | None, int, threading.Event]] = []
+
+    def publish(self, topic: str, payload: dict) -> None:
+        with self._lock:
+            event = {"topic": topic, "payload": payload, "thread": threading.current_thread().name}
+            self._events.append(event)
+            for callback in self._subscribers.get(topic, []):
+                callback(event)
+            self._check_waiters()
+
+    def subscribe(self, topic: str, callback) -> None:
+        with self._lock:
+            self._subscribers.setdefault(topic, []).append(callback)
+
+    def events(self, topic: str | None = None) -> list[dict]:
+        with self._lock:
+            if topic is None:
+                return list(self._events)
+            return [e for e in self._events if e["topic"] == topic]
+
+    def wait_for(self, count: int, topic: str | None = None, timeout: float = 10) -> list[dict]:
+        """Block until at least ``count`` events match, then return them."""
+        ready = threading.Event()
+        with self._lock:
+            matched = self._filter(topic)
+            if len(matched) >= count:
+                return matched
+            self._waiters.append((topic, count, ready))
+        if not ready.wait(timeout=timeout):
+            actual = len(self.events(topic))
+            label = f"topic={topic!r}" if topic else "all topics"
+            raise TimeoutError(
+                f"EventBus.wait_for: expected {count} events on {label}, "
+                f"got {actual} after {timeout}s"
+            )
+        return self.events(topic)
+
+    def _check_waiters(self) -> None:
+        """Signal any waiters whose condition is met. Must hold _lock."""
+        remaining = []
+        for topic, count, event in self._waiters:
+            if len(self._filter(topic)) >= count:
+                event.set()
+            else:
+                remaining.append((topic, count, event))
+        self._waiters[:] = remaining
+
+    def _filter(self, topic: str | None) -> list[dict]:
+        if topic is None:
+            return list(self._events)
+        return [e for e in self._events if e["topic"] == topic]

pytest_threadpool-0.3.6/examples/test_event_bus/test_event_bus.py

@@ -0,0 +1,110 @@
+"""Shared in-memory test double — concurrent access to a shared event bus.
+
+This pattern is impossible with pytest-xdist: each subprocess has its own
+memory space, so a plain Python object can't collect events from multiple
+workers. You'd need Redis, a socket server, or a temp file to coordinate.
+
+With pytest-threadpool, all tests share the same process. A class-scoped
+fixture creates one EventBus instance, shared by all parallel methods —
+proper lifecycle management with no global mutable state.
+
+Patterns demonstrated:
+- Class-scoped fixture providing a shared test double to parallel workers
+- Concurrent access to a shared in-memory object from parallel threads
+- Subscriber callbacks firing synchronously during publish
+- Aggregate cross-test visibility via wait_for
+"""
+
+import threading
+
+import pytest
+
+from examples.test_event_bus.event_bus import EventBus
+
+_N_PUBLISHERS = 4
+
+
+@pytest.fixture(scope="class")
+def bus():
+    return EventBus()
+
+
+@pytest.mark.parallelizable("children")
+class TestEventBus:
+    """All tests run in parallel, sharing one bus via a class-scoped fixture."""
+
+    def _publish_own_events(self, bus: EventBus, name: str) -> None:
+        """Each test publishes its own uniquely-tagged events."""
+        bus.publish("work", {"source": name, "step": "start"})
+        bus.publish("work", {"source": name, "step": "done"})
+
+    def test_publish_and_verify_signup(self, bus):
+        """Publish signup events and verify only own events are correct."""
+        bus.publish("user.created", {"user_id": "u1"})
+        bus.publish("email.queued", {"to": "a@test.com", "template": "welcome"})
+
+        own_emails = [e for e in bus.events("email.queued") if e["payload"]["to"] == "a@test.com"]
+        assert len(own_emails) == 1
+        assert own_emails[0]["payload"]["template"] == "welcome"
+
+    def test_publish_and_verify_purchase(self, bus):
+        """Publish purchase events and verify own events landed."""
+        bus.publish("order.created", {"order_id": "o1", "user_id": "u2"})
+        bus.publish("payment.charged", {"order_id": "o1", "amount": 99})
+
+        own = [e for e in bus.events("payment.charged") if e["payload"]["order_id"] == "o1"]
+        assert len(own) == 1
+        assert own[0]["payload"]["amount"] == 99
+
+    def test_subscriber_callback_fires_on_publish(self):
+        """Subscribe, publish, verify callback fired — all within one test.
+
+        Uses a dedicated EventBus instance so the subscriber doesn't leak
+        into the shared class-scoped bus.
+        """
+        local_bus = EventBus()
+        received: list[dict] = []
+
+        def on_event(event):
+            received.append(event)
+
+        local_bus.subscribe("audit.log", on_event)
+        local_bus.publish("audit.log", {"action": "login", "user": "alice"})
+        local_bus.publish("audit.log", {"action": "logout", "user": "alice"})
+
+        actions = [e["payload"]["action"] for e in received]
+        assert actions == ["login", "logout"]
+
+    def test_wait_for_own_events(self, bus):
+        """Publish from a background thread, wait_for in the test thread."""
+        topic = "async.work"
+
+        def background_publisher():
+            bus.publish(topic, {"step": 1})
+            bus.publish(topic, {"step": 2})
+
+        t = threading.Thread(target=background_publisher)
+        t.start()
+
+        events = bus.wait_for(2, topic=topic)
+        t.join(timeout=10)
+
+        steps = [e["payload"]["step"] for e in events]
+        assert 1 in steps
+        assert 2 in steps
+
+    # -- aggregate visibility: each parametrized worker publishes tagged events,
+    #    then waits for all N_PUBLISHERS to have contributed --
+
+    @pytest.mark.parametrize("worker", range(_N_PUBLISHERS))
+    def test_publish_and_observe_aggregate(self, bus, worker):
+        """Each worker publishes its own events, then waits to see all workers' events.
+
+        This proves cross-test visibility: events from parallel threads
+        are visible to every other thread via the shared bus.
+        """
+        self._publish_own_events(bus, f"worker_{worker}")
+
+        all_events = bus.wait_for(_N_PUBLISHERS * 2, topic="work")
+        sources = {e["payload"]["source"] for e in all_events}
+        assert len(sources) == _N_PUBLISHERS

{pytest_threadpool-0.3.5 → pytest_threadpool-0.3.6}/src/pytest_threadpool/_runner.py

@@ -356,22 +356,34 @@ class ParallelRunner:
         )
 
         needs_sep = False
-        for group_key, items in groups:
+        for group_idx, (group_key, items) in enumerate(groups):
             if session.shouldfail:
                 raise session.Failed(session.shouldfail)
             if session.shouldstop:
                 raise session.Interrupted(session.shouldstop)
 
+            # First item of the next group — tells teardown_exact which
+            # session/module/class nodes to keep alive across groups.
+            next_group_first = None
+            for _, future_items in groups[group_idx + 1 :]:
+                if future_items:
+                    next_group_first = future_items[0]
+                    break
+
             if group_key is None or len(items) <= 1 or self._nthreads <= 1:
                 for i, item in enumerate(items):
-                    nextitem = items[i + 1] if i + 1 < len(items) else None
+                    nextitem = items[i + 1] if i + 1 < len(items) else next_group_first
                     if has_parallel:
                         self._run_sequential_nodeid(item, nextitem)
                     else:
                         self._run_sequential(item, nextitem)
                 needs_sep = bool(items)
             else:
-                self._run_parallel(items, after_sequential=needs_sep)
+                self._run_parallel(
+                    items,
+                    after_sequential=needs_sep,
+                    next_group_first=next_group_first,
+                )
                 needs_sep = True
 
         return True
@@ -469,7 +481,7 @@ class ParallelRunner:
             f.write(f"\n{item.nodeid} {color}{word}{reset}")
             f.flush()
 
-    def _run_parallel(self, items, after_sequential: bool = False) -> None:
+    def _run_parallel(self, items, after_sequential: bool = False, next_group_first=None) -> None:
         """Run a group's tests with parallel fixture setup and calls.
 
         Function-scoped FixtureDefs are cloned per-item so their setup can
@@ -525,7 +537,9 @@ class ParallelRunner:
                 ihook.pytest_runtest_logreport(report=setup_reports[item])
                 if setup_passed[item] and session.config.getoption("setupshow", False):
                     show_test_item(item)
-            self._teardown_all(items, per_item_fixture_fins, {}, saved_collector_fins)
+            self._teardown_all(
+                items, per_item_fixture_fins, {}, saved_collector_fins, next_group_first
+            )
             return
 
         # Phase 1+2: fire hooks for all items, populate shared fixture caches,
@@ -832,13 +846,20 @@ class ParallelRunner:
                 session._setupstate.stack.pop(item)  # pyright: ignore[reportPrivateUsage]
 
         # Teardown reporting + collector teardown (always runs, even after interrupt)
-        self._teardown_all(items, per_item_fixture_fins, teardown_infos, saved_collector_fins)
+        self._teardown_all(
+            items, per_item_fixture_fins, teardown_infos, saved_collector_fins, next_group_first
+        )
 
         if interrupted:
             raise KeyboardInterrupt
 
     def _teardown_all(
-        self, items, per_item_fixture_fins, teardown_infos, saved_collector_fins
+        self,
+        items,
+        per_item_fixture_fins,
+        teardown_infos,
+        saved_collector_fins,
+        next_group_first=None,
     ) -> None:
         """Report teardown results, run any remaining finalizers, and tear down
         collectors.
@@ -846,6 +867,10 @@ class ParallelRunner:
         For items with pre-computed teardown_infos (from parallel workers),
         only reporting happens here.  For items without (setuponly mode),
         finalizers from per_item_fixture_fins are executed sequentially.
+
+        next_group_first: first item of the next group (or None if last group).
+        Passed to teardown_exact so session/module/class-scoped fixtures that
+        are still needed by the next group are preserved rather than torn down.
         """
         session = self._session
 
@@ -882,7 +907,9 @@ class ParallelRunner:
             item.ihook.pytest_runtest_logfinish(nodeid=item.nodeid, location=item.location)
 
         # noinspection PyProtectedMember
-        session._setupstate.teardown_exact(nextitem=None)  # pyright: ignore[reportPrivateUsage]
+        # Pass next_group_first so session/module/class nodes needed by the
+        # next group stay in the stack with their cached fixtures intact.
+        session._setupstate.teardown_exact(nextitem=next_group_first)  # pyright: ignore[reportPrivateUsage]
 
         exceptions = []
         for _node, fins in reversed(saved_collector_fins):

{pytest_threadpool-0.3.5 → pytest_threadpool-0.3.6}/src/pytest_threadpool/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.5'
-__version_tuple__ = version_tuple = (0, 3, 5)
+__version__ = version = '0.3.6'
+__version_tuple__ = version_tuple = (0, 3, 6)
 
 __commit_id__ = commit_id = None

pytest_threadpool-0.3.6/tests/integration_tests/cases/fixture_class_across_groups.py

@@ -0,0 +1,48 @@
+"""Class-scoped fixture: same object within a class, different across classes."""
+
+import threading
+
+import pytest
+
+_ids_a = []
+_ids_b = []
+lock = threading.Lock()
+
+
+class Resource:
+    """Mutable object whose identity can be checked via id()."""
+
+
+@pytest.fixture(scope="class")
+def class_resource():
+    return Resource()
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupA:
+    def test_a1(self, class_resource):
+        with lock:
+            _ids_a.append(id(class_resource))
+
+    def test_a2(self, class_resource):
+        with lock:
+            _ids_a.append(id(class_resource))
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupB:
+    def test_b1(self, class_resource):
+        with lock:
+            _ids_b.append(id(class_resource))
+
+    def test_b2(self, class_resource):
+        with lock:
+            _ids_b.append(id(class_resource))
+
+
+def test_verify():
+    # Within each class, all tests see the same object
+    assert len(set(_ids_a)) == 1, f"class A fixture not shared: {set(_ids_a)}"
+    assert len(set(_ids_b)) == 1, f"class B fixture not shared: {set(_ids_b)}"
+    # Across classes, fixtures are different objects
+    assert _ids_a[0] != _ids_b[0], "class-scoped fixture leaked across classes"

pytest_threadpool-0.3.6/tests/integration_tests/cases/fixture_module_across_groups.py

@@ -0,0 +1,50 @@
+"""Module-scoped fixture must be the same object across parallel groups and sequential tests."""
+
+import threading
+
+import pytest
+
+_ids = []
+lock = threading.Lock()
+
+
+class Resource:
+    """Mutable object whose identity can be checked via id()."""
+
+
+@pytest.fixture(scope="module")
+def module_resource():
+    return Resource()
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupA:
+    def test_a1(self, module_resource):
+        with lock:
+            _ids.append(id(module_resource))
+
+    def test_a2(self, module_resource):
+        with lock:
+            _ids.append(id(module_resource))
+
+
+@pytest.mark.not_parallelizable
+def test_sequential_between(module_resource):
+    with lock:
+        _ids.append(id(module_resource))
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupB:
+    def test_b1(self, module_resource):
+        with lock:
+            _ids.append(id(module_resource))
+
+    def test_b2(self, module_resource):
+        with lock:
+            _ids.append(id(module_resource))
+
+
+def test_verify():
+    assert len(_ids) == 5, f"expected 5 recorded ids, got {len(_ids)}"
+    assert len(set(_ids)) == 1, f"module fixture created multiple objects: {set(_ids)}"

pytest_threadpool-0.3.6/tests/integration_tests/cases/fixture_package_across_groups.py

@@ -0,0 +1,70 @@
+"""Package-scoped fixture shared across parallel groups in the same package.
+
+This case provides source strings used by the integration test to
+build a temporary package directory.
+"""
+
+CONFTEST_SRC = """\
+import pytest
+
+
+class Resource:
+    pass
+
+
+@pytest.fixture(scope="package")
+def pkg_resource():
+    return Resource()
+"""
+
+INIT_SRC = """\
+import pytest
+
+pytestmark = pytest.mark.parallelizable("children")
+"""
+
+MOD_A_SRC = """\
+import threading
+
+lock = threading.Lock()
+ids = []
+
+
+def test_a1(pkg_resource):
+    with lock:
+        ids.append(id(pkg_resource))
+
+
+def test_a2(pkg_resource):
+    with lock:
+        ids.append(id(pkg_resource))
+"""
+
+MOD_B_SRC = """\
+import threading
+
+lock = threading.Lock()
+ids = []
+
+
+def test_b1(pkg_resource):
+    with lock:
+        ids.append(id(pkg_resource))
+
+
+def test_b2(pkg_resource):
+    with lock:
+        ids.append(id(pkg_resource))
+"""
+
+VERIFY_SRC = """\
+from mypkg import test_mod_a, test_mod_b
+
+
+def test_verify():
+    all_ids = test_mod_a.ids + test_mod_b.ids
+    assert len(all_ids) == 4, f"expected 4 recorded ids, got {len(all_ids)}"
+    assert len(set(all_ids)) == 1, (
+        f"package fixture created multiple objects: {set(all_ids)}"
+    )
+"""

pytest_threadpool-0.3.6/tests/integration_tests/cases/fixture_session_across_groups.py

@@ -0,0 +1,50 @@
+"""Session-scoped fixture must be the same object across parallel groups and sequential tests."""
+
+import threading
+
+import pytest
+
+_ids = []
+lock = threading.Lock()
+
+
+class Resource:
+    """Mutable object whose identity can be checked via id()."""
+
+
+@pytest.fixture(scope="session")
+def session_resource():
+    return Resource()
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupA:
+    def test_a1(self, session_resource):
+        with lock:
+            _ids.append(id(session_resource))
+
+    def test_a2(self, session_resource):
+        with lock:
+            _ids.append(id(session_resource))
+
+
+@pytest.mark.not_parallelizable
+def test_sequential_between(session_resource):
+    with lock:
+        _ids.append(id(session_resource))
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupB:
+    def test_b1(self, session_resource):
+        with lock:
+            _ids.append(id(session_resource))
+
+    def test_b2(self, session_resource):
+        with lock:
+            _ids.append(id(session_resource))
+
+
+def test_verify():
+    assert len(_ids) == 5, f"expected 5 recorded ids, got {len(_ids)}"
+    assert len(set(_ids)) == 1, f"session fixture created multiple objects: {set(_ids)}"

pytest_threadpool-0.3.6/tests/integration_tests/cases/xunit_setup_class_across_groups.py

@@ -0,0 +1,61 @@
+"""setup_class/teardown_class: once per class, independent across parallel groups."""
+
+import threading
+from typing import ClassVar
+
+import pytest
+
+lock = threading.Lock()
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupA:
+    setup_ids: ClassVar[list] = []
+
+    @classmethod
+    def setup_class(cls):
+        with lock:
+            cls.setup_ids.append(threading.current_thread().name)
+
+    @classmethod
+    def teardown_class(cls):
+        with lock:
+            cls.setup_ids.append("teardown_a")
+
+    def test_a1(self):
+        assert len([x for x in self.setup_ids if x != "teardown_a"]) == 1
+
+    def test_a2(self):
+        assert len([x for x in self.setup_ids if x != "teardown_a"]) == 1
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupB:
+    setup_ids: ClassVar[list] = []
+
+    @classmethod
+    def setup_class(cls):
+        with lock:
+            cls.setup_ids.append(threading.current_thread().name)
+
+    @classmethod
+    def teardown_class(cls):
+        with lock:
+            cls.setup_ids.append("teardown_b")
+
+    def test_b1(self):
+        assert len([x for x in self.setup_ids if x != "teardown_b"]) == 1
+
+    def test_b2(self):
+        assert len([x for x in self.setup_ids if x != "teardown_b"]) == 1
+
+
+def test_verify():
+    # Each class had exactly one setup_class call
+    a_setups = [x for x in TestGroupA.setup_ids if x != "teardown_a"]
+    b_setups = [x for x in TestGroupB.setup_ids if x != "teardown_b"]
+    assert len(a_setups) == 1, f"setup_class ran {len(a_setups)} times for A"
+    assert len(b_setups) == 1, f"setup_class ran {len(b_setups)} times for B"
+    # Both teardowns ran
+    assert "teardown_a" in TestGroupA.setup_ids
+    assert "teardown_b" in TestGroupB.setup_ids

pytest_threadpool-0.3.6/tests/integration_tests/cases/xunit_setup_method_across_groups.py

@@ -0,0 +1,53 @@
+"""setup_method/teardown_method fire for every method across separate parallel classes."""
+
+import threading
+
+import pytest
+
+lock = threading.Lock()
+all_setups: list = []
+all_teardowns: list = []
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupA:
+    barrier = threading.Barrier(2, timeout=10)
+
+    def setup_method(self, method):
+        with lock:
+            all_setups.append(f"A.{method.__name__}")
+
+    def teardown_method(self, method):
+        with lock:
+            all_teardowns.append(f"A.{method.__name__}")
+
+    def test_a1(self):
+        self.barrier.wait()
+
+    def test_a2(self):
+        self.barrier.wait()
+
+
+@pytest.mark.parallelizable("children")
+class TestGroupB:
+    barrier = threading.Barrier(2, timeout=10)
+
+    def setup_method(self, method):
+        with lock:
+            all_setups.append(f"B.{method.__name__}")
+
+    def teardown_method(self, method):
+        with lock:
+            all_teardowns.append(f"B.{method.__name__}")
+
+    def test_b1(self):
+        self.barrier.wait()
+
+    def test_b2(self):
+        self.barrier.wait()
+
+
+def test_verify():
+    expected_setups = {"A.test_a1", "A.test_a2", "B.test_b1", "B.test_b2"}
+    assert expected_setups == set(all_setups), f"setup_method: {all_setups}"
+    assert expected_setups == set(all_teardowns), f"teardown_method: {all_teardowns}"