pytest-threadpool 0.2.0__tar.gz → 0.3.0__tar.gz

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/ANALYSIS.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-pytest-threadpool runs test bodies in parallel via `ThreadPoolExecutor` while keeping all pytest internals (fixtures, setup/teardown, reporting) sequential. This analysis covers risks, potential bugs, and missing test coverage.
+pytest-threadpool runs test bodies and function-scoped fixture setup in parallel via a thread pool while keeping shared fixtures (module/class/session scope) and teardown sequential. Function-scoped FixtureDefs are cloned per-item so each worker creates independent fixture instances. This analysis covers risks, potential bugs, and missing test coverage.
 
 ---
 

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/CONTRIBUTING.md

@@ -107,7 +107,7 @@ src/pytest_threadpool/
     _constants.py     # ParallelScope and _GroupPrefix enums
     _markers.py       # MarkerResolver: marker introspection
     _grouping.py      # GroupKeyBuilder: parallel batch grouping
-    _fixtures.py      # FixtureManager: finalizer save/restore
+    _fixtures.py      # FixtureManager: fixture cloning, shared cache population, finalizer save/restore
     _runner.py        # ParallelRunner: parallel execution orchestration
     plugin.py         # pytest hook implementations (wiring only)
 

pytest_threadpool-0.2.0/README.md → pytest_threadpool-0.3.0/PKG-INFO

@@ -1,7 +1,25 @@
+Metadata-Version: 2.4
+Name: pytest-threadpool
+Version: 0.3.0
+Summary: Parallel test execution for free-threaded Python builds
+License-Expression: MIT
+License-File: LICENSE
+Keywords: free-threaded,nogil,parallel,pytest,pytest parallel,testing,threadpool
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.13
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: selenium>=4.41.0
+Description-Content-Type: text/markdown
+
 # pytest-threadpool
 
-[![PyPI](https://img.shields.io/pypi/v/pytest-threadpool.svg)](https://pypi.org/project/pytest-threadpool/)
-[![Python](https://img.shields.io/pypi/pyversions/pytest-threadpool.svg)](https://pypi.org/project/pytest-threadpool/)
+![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)
 [![License](https://img.shields.io/github/license/pytest-threadpool/pytest-threadpool)](https://github.com/pytest-threadpool/pytest-threadpool/blob/main/LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-pytest--threadpool-blue?logo=github)](https://github.com/pytest-threadpool/pytest-threadpool)
 [![CI](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml/badge.svg)](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml)
@@ -9,8 +27,9 @@
 
 **Status: Beta** · Parallel test execution for free-threaded Python builds (3.13t+).
 
-Runs test *bodies* concurrently in a `ThreadPoolExecutor` while keeping
-fixture setup/teardown sequential (pytest internals are not thread-safe).
+Runs test *bodies* and function-scoped fixture setup concurrently in a thread
+pool while keeping shared fixtures (module/class/session scope) and teardown
+sequential.
 
 ## Installation
 
@@ -58,6 +77,24 @@ def test_must_be_sequential(): ...
 | `parameters` | Parametrized variants of the same test run concurrently           |
 | `all`        | Combines `children` + `parameters`                                |
 
+## Fixture handling
+
+Function-scoped fixtures are cloned per-item and set up in parallel alongside
+test calls. Each worker gets independent fixture instances — no shared mutable
+state between concurrent fixture setups.
+
+Shared fixtures (module, class, and session scope) are resolved once
+sequentially before workers launch and served from cache to all items.
+
+| Scope      | Behavior                                        |
+|------------|-------------------------------------------------|
+| `function` | Cloned per-item, set up in parallel workers     |
+| `class`    | Resolved once, cached, shared across items      |
+| `module`   | Resolved once, cached, shared across items      |
+| `session`  | Resolved once, cached, shared across items      |
+
+Teardown for all scopes runs sequentially after the parallel group completes.
+
 ## Marker levels
 
 Markers can be applied at function, class, module (`pytestmark`), or

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/PLAN.md

@@ -46,7 +46,8 @@ This is probably the single highest-value documentation addition.
 You want one section that explicitly says:
 Guarantees
 test call phases may run concurrently
-fixture setup/teardown remains sequential
+function-scoped fixture setup runs in parallel (cloned per-item)
+shared fixture setup/teardown (module/class/session) remains sequential
 unmarked tests remain sequential
 not_parallelizable always wins
 marker precedence rules are stable

pytest_threadpool-0.2.0/PKG-INFO → pytest_threadpool-0.3.0/README.md

@@ -1,24 +1,7 @@
-Metadata-Version: 2.4
-Name: pytest-threadpool
-Version: 0.2.0
-Summary: Parallel test execution for free-threaded Python builds
-License-Expression: MIT
-License-File: LICENSE
-Keywords: free-threaded,nogil,parallel,pytest,testing,threadpool
-Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: Pytest
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.13
-Requires-Dist: pytest>=9.0.2
-Description-Content-Type: text/markdown
-
 # pytest-threadpool
 
-[![PyPI](https://img.shields.io/pypi/v/pytest-threadpool.svg)](https://pypi.org/project/pytest-threadpool/)
-[![Python](https://img.shields.io/pypi/pyversions/pytest-threadpool.svg)](https://pypi.org/project/pytest-threadpool/)
+![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)
 [![License](https://img.shields.io/github/license/pytest-threadpool/pytest-threadpool)](https://github.com/pytest-threadpool/pytest-threadpool/blob/main/LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-pytest--threadpool-blue?logo=github)](https://github.com/pytest-threadpool/pytest-threadpool)
 [![CI](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml/badge.svg)](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml)
@@ -26,8 +9,9 @@ Description-Content-Type: text/markdown
 
 **Status: Beta** · Parallel test execution for free-threaded Python builds (3.13t+).
 
-Runs test *bodies* concurrently in a `ThreadPoolExecutor` while keeping
-fixture setup/teardown sequential (pytest internals are not thread-safe).
+Runs test *bodies* and function-scoped fixture setup concurrently in a thread
+pool while keeping shared fixtures (module/class/session scope) and teardown
+sequential.
 
 ## Installation
 
@@ -75,6 +59,24 @@ def test_must_be_sequential(): ...
 | `parameters` | Parametrized variants of the same test run concurrently           |
 | `all`        | Combines `children` + `parameters`                                |
 
+## Fixture handling
+
+Function-scoped fixtures are cloned per-item and set up in parallel alongside
+test calls. Each worker gets independent fixture instances — no shared mutable
+state between concurrent fixture setups.
+
+Shared fixtures (module, class, and session scope) are resolved once
+sequentially before workers launch and served from cache to all items.
+
+| Scope      | Behavior                                        |
+|------------|-------------------------------------------------|
+| `function` | Cloned per-item, set up in parallel workers     |
+| `class`    | Resolved once, cached, shared across items      |
+| `module`   | Resolved once, cached, shared across items      |
+| `session`  | Resolved once, cached, shared across items      |
+
+Teardown for all scopes runs sequentially after the parallel group completes.
+
 ## Marker levels
 
 Markers can be applied at function, class, module (`pytestmark`), or

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/TODO.md

@@ -1,17 +1,5 @@
 # TODO — Road to Beta and Beyond
 
-## Beta Requirements
-
-### CI/CD
-- [x] Add GitHub Actions running tests on Python 3.13t
-- [x] Validate at least one pytest version in CI
-
-### Documentation
-- [x] Add "Known Limitations" section to README (private API fragility, no plugin compat guarantees, no captured stdout in parallel)
-- [x] Add pytest version upper bound or document tested versions
-
----
-
 ## 1.0 Requirements
 
 ### Phase 1 — Trust (Highest ROI)

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "pytest-threadpool"
-version = "0.2.0"
+version = "0.3.0"
 description = "Parallel test execution for free-threaded Python builds"
 requires-python = ">=3.13"
 license = "MIT"
 readme = "README.md"
-keywords = ["pytest", "parallel", "free-threaded", "nogil", "testing", "threadpool"]
+keywords = ["pytest", "parallel", "free-threaded", "nogil", "testing", "threadpool", "pytest parallel"]
 classifiers = [
     "Framework :: Pytest",
     "Development Status :: 4 - Beta",
@@ -16,6 +16,7 @@ classifiers = [
 ]
 dependencies = [
     "pytest>=9.0.2",
+    "selenium>=4.41.0",
 ]
 
 [project.entry-points.pytest11]

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/src/pytest_threadpool/_fixtures.py

@@ -1,5 +1,6 @@
 """Fixture finalizer save/restore helpers for parallel execution."""
 
+from _pytest.fixtures import FixtureDef
 from _pytest.scope import Scope
 
 
@@ -12,6 +13,40 @@ class FixtureManager:
     runner.py and fixtures.py use.
     """
 
+    @staticmethod
+    def clone_function_fixturedefs(item) -> None:
+        """Clone function-scoped FixtureDefs so this item has its own copies.
+
+        Shared (module/class/session) FixtureDefs are kept as-is — their
+        cached values are read-only after the first item's setup.
+        Function-scoped FixtureDefs get independent copies with fresh
+        cached_result and _finalizers, allowing concurrent fixture setup
+        across items without racing on shared singleton state.
+        """
+        # noinspection PyProtectedMember
+        # request._arg2fixturedefs, fixturedef._scope: no public API;
+        # mirrors pytest's own TopRequest/FixtureDef internals.
+        request = getattr(item, "_request", None)
+        if not request or not hasattr(request, "_arg2fixturedefs"):
+            return
+
+        new_arg2fds = {}
+        for argname, fds in request._arg2fixturedefs.items():  # pyright: ignore[reportPrivateUsage]
+            new_fds = []
+            for fd in fds:
+                if fd._scope is Scope.Function:  # pyright: ignore[reportPrivateUsage]
+                    clone = FixtureDef.__new__(FixtureDef)
+                    clone.__dict__.update(fd.__dict__)
+                    clone.cached_result = None
+                    clone._finalizers = []  # pyright: ignore[reportPrivateUsage, reportAttributeAccessIssue]
+                    new_fds.append(clone)
+                else:
+                    new_fds.append(fd)
+            new_arg2fds[argname] = new_fds
+
+        # _arg2fixturedefs is typed Final but not enforced at runtime
+        object.__setattr__(request, "_arg2fixturedefs", new_arg2fds)
+
     @staticmethod
     def save_and_clear_function_fixtures(item) -> list:
         """After an item's setup, save its function-scoped fixture finalizers
@@ -58,6 +93,39 @@ class FixtureManager:
                 if fixturedef._scope is Scope.Function and fixturedef.cached_result is not None:  # pyright: ignore[reportPrivateUsage]
                     fixturedef.cached_result = None
 
+    @staticmethod
+    def populate_shared_fixtures(item) -> None:
+        """Resolve only non-function-scoped fixtures for the item.
+
+        Populates shared fixture caches (module/class/session scope) by
+        calling getfixturevalue for each non-function-scoped fixture.
+        Function-scoped fixtures are skipped — they will be created later
+        from cloned FixtureDefs in parallel workers.
+
+        Must be called inside a setup hook context (item in setupstate)
+        so that addfinalizer works for the resolved fixtures.
+        """
+        # noinspection PyProtectedMember
+        # request._arg2fixturedefs, fixturedef._scope: no public API;
+        # mirrors pytest's own TopRequest/FixtureDef internals.
+        request = getattr(item, "_request", None)
+        if not request or not hasattr(request, "_arg2fixturedefs"):
+            return
+
+        for argname in item.fixturenames:
+            if argname in item.funcargs:
+                continue
+            fds = request._arg2fixturedefs.get(argname, [])  # pyright: ignore[reportPrivateUsage]
+            if fds and fds[-1]._scope is not Scope.Function:  # pyright: ignore[reportPrivateUsage]
+                value = request.getfixturevalue(argname)
+                item.funcargs[argname] = value
+                # Eagerly initialize lazy state on shared fixture values.
+                # TmpPathFactory.getbasetemp() lazily creates the basetemp
+                # directory; without this, parallel workers would race on
+                # the first tmp_path_factory.mktemp() call.
+                if hasattr(value, "getbasetemp"):
+                    value.getbasetemp()
+
     @staticmethod
     def save_collector_finalizers(session, next_item) -> list:
         """Save finalizers from stack nodes that would be torn down when

{pytest_threadpool-0.2.0 → pytest_threadpool-0.3.0}/src/pytest_threadpool/_runner.py

@@ -339,12 +339,17 @@ class ParallelRunner:
         ihook.pytest_runtest_logfinish(nodeid=item.nodeid, location=item.location)
 
     def _run_parallel(self, items) -> None:
-        """Run a group's tests with parallel call phases.
+        """Run a group's tests with parallel fixture setup and calls.
 
-        1. Sequential: setup every item (no reporting yet).
-        2. Parallel:   item.runtest() in a thread pool.
-        3. Sequential: report setup and call results per item.
-        4. Sequential: teardown.
+        Function-scoped FixtureDefs are cloned per-item so their setup can
+        run concurrently alongside the test call.  Shared fixtures
+        (module/class/session scope) are set up once via the first item,
+        then served from cache to all workers.
+
+        1. Sequential: set up first item (populates shared fixture caches).
+        2. Sequential: prepare remaining items (_initrequest + clone FixtureDefs).
+        3. Parallel:   workers run setup (cloned fixtures) + call per item.
+        4. Sequential: report, teardown.
         """
         session = self._session
         setup_passed = {}
@@ -352,12 +357,12 @@ class ParallelRunner:
         per_item_fixture_fins = {}
         saved_collector_fins = []
 
-        # Phase 1: sequential setup (silent)
         # noinspection PyProtectedMember
         # item._request/_initrequest and session._setupstate: no public API
         # for request lifecycle or setup state management.  Mirrors pytest's
         # own runner.py (_pytest.runner.runtestprotocol / SetupState).
-        for item in items:
+        def _setup_first_item(item):
+            """Full sequential setup for the first item (caches shared fixtures)."""
             if hasattr(item, "_request") and not item._request:  # pyright: ignore[reportPrivateUsage]
                 item._initrequest()  # pyright: ignore[reportPrivateUsage]
 
@@ -381,6 +386,8 @@ class ParallelRunner:
                 session._setupstate.stack.pop(item)  # pyright: ignore[reportPrivateUsage]
 
         if session.config.getoption("setuponly", False):
+            for item in items:
+                _setup_first_item(item)
             for item in items:
                 ihook = item.ihook
                 ihook.pytest_runtest_logstart(nodeid=item.nodeid, location=item.location)
@@ -390,29 +397,123 @@ class ParallelRunner:
             self._teardown_all(items, per_item_fixture_fins, saved_collector_fins)
             return
 
-        # Phase 2: parallel calls with live reporting
-        callable_items = [it for it in items if setup_passed.get(it)]
-        workers = min(self._nthreads, len(callable_items)) if callable_items else 1
+        # Phase 1+2: fire hooks for all items, populate shared fixture caches,
+        # and clone function-scoped FixtureDefs.
+        #
+        # The first item that passes hook evaluation resolves shared fixtures
+        # (module/class/session scope) to populate FixtureDef caches.  All
+        # subsequent items get cache hits for shared fixtures.  Function-scoped
+        # fixtures are NOT created here — they are deferred to parallel workers.
+        #
+        # noinspection PyProtectedMember
+        parallel_items = []
+        shared_populated = False
+
+        for item in items:
+            if hasattr(item, "_request") and not item._request:  # pyright: ignore[reportPrivateUsage]
+                item._initrequest()  # pyright: ignore[reportPrivateUsage]
+
+            # Handle collector transitions (needed for PKG_CHILDREN groups
+            # that span multiple modules).
+            needed = set(item.listchain())
+            if any(node not in needed for node in session._setupstate.stack):  # pyright: ignore[reportPrivateUsage]
+                saved_collector_fins.extend(
+                    FixtureManager.save_collector_finalizers(session, item)
+                )
+                session._setupstate.teardown_exact(nextitem=item)  # pyright: ignore[reportPrivateUsage]
+
+            # Fire setup hooks with a custom setup function:
+            # - First eligible item: resolve shared fixtures only (populates caches)
+            # - Remaining items: no-op (shared caches already populated)
+            # This evaluates skip/xfail markers and initializes capture/logging
+            # without creating function-scoped fixtures.
+            original_setup = item.setup
+            if not shared_populated:
+                item.setup = lambda i=item: FixtureManager.populate_shared_fixtures(i)
+            else:
+                item.setup = lambda: None
+            try:
+                hook_rep = call_and_report(item, "setup", log=False)
+            finally:
+                item.setup = original_setup
+
+            # Pop item from setupstate (pushed by _setupstate.setup inside the
+            # hook) so the next item's hook doesn't fail the stack assertion.
+            if item in session._setupstate.stack:  # pyright: ignore[reportPrivateUsage]
+                session._setupstate.stack.pop(item)  # pyright: ignore[reportPrivateUsage]
 
+            if not hook_rep.passed:
+                # Hooks raised (skip, skipif, xfail NOTRUN, etc.)
+                setup_reports[item] = hook_rep
+                setup_passed[item] = False
+                continue
+
+            if not shared_populated:
+                shared_populated = True
+
+            FixtureManager.clone_function_fixturedefs(item)
+            parallel_items.append(item)
+
+        # Push all parallel items to setupstate stack so addfinalizer
+        # assertions pass during fixture resolution in worker threads.
+        # Done after the hook loop so items don't interfere with each
+        # other's _setupstate.setup() assertions.
+        for item in parallel_items:
+            session._setupstate.stack[item] = ([item.teardown], None)  # pyright: ignore[reportPrivateUsage]
+
+        # Phase 3: parallel setup + call
+        workers = min(self._nthreads, len(parallel_items) or 1)
         call_results = {}
         reported = set()
         live = _LiveReporter(session, items)
         live.pre_print()
 
-        def _do_call(test_item):
+        cancelled = threading.Event()
+
+        def _do_setup_and_call(test_item):
+            """Setup + call worker (for items with cloned FixtureDefs).
+
+            Fixture setup uses cloned function-scoped FixtureDefs so each
+            worker creates independent fixture instances without racing
+            on shared FixtureDef state.  Shared fixtures are already cached
+            from the first item's sequential setup, so their FixtureDef.execute()
+            is a cache-hit read.
+
+            addfinalizer is redirected to a per-item list to avoid the
+            setupstate stack assertion (the item IS in the stack, but
+            list.append on the stack entry is also safe on free-threaded Python;
+            the redirect simply avoids coupling to setupstate internals).
+            """
             if cancelled.is_set():
-                return test_item, CallInfo.from_call(lambda: None, when="call")
-            live.mark_running(test_item)
-            call_info = CallInfo.from_call(lambda: test_item.runtest(), when="call")
-            if not cancelled.is_set():
-                live.mark_call_done(test_item, call_info.excinfo)
-            return test_item, call_info
+                return test_item, None, None, []
+
+            # Redirect node.addfinalizer to per-item list
+            original_addfinalizer = test_item.addfinalizer
+            node_fins = []
+            test_item.addfinalizer = lambda fin: node_fins.append(fin)
+
+            try:
+                setup_info = CallInfo.from_call(lambda: test_item.setup(), when="setup")
+            finally:
+                test_item.addfinalizer = original_addfinalizer
+
+            if setup_info.excinfo is None:
+                fixture_fins = FixtureManager.save_and_clear_function_fixtures(test_item)
+                if not cancelled.is_set():
+                    live.mark_running(test_item)
+                    call_info = CallInfo.from_call(lambda: test_item.runtest(), when="call")
+                    if not cancelled.is_set():
+                        live.mark_call_done(test_item, call_info.excinfo)
+                    return test_item, setup_info, call_info, fixture_fins
+                return test_item, setup_info, None, fixture_fins
+
+            FixtureManager.clear_function_fixture_caches(test_item)
+            return test_item, setup_info, None, []
 
         def _report_item(item):
             """Report a single item — live cursor mode or plain fallback."""
             ihook = item.ihook
 
-            # Build the call report first (needed for a live dot letter)
             call_rep = None
             if setup_passed[item] and item in call_results:
                 call_info = call_results[item]
@@ -420,10 +521,6 @@ class ParallelRunner:
 
             report = call_rep or setup_reports[item]
 
-            # Suppress terminal reporter output, fire hooks for stats only.
-            # try/finally ensures restore() runs even on KeyboardInterrupt,
-            # otherwise the terminal writer stays suppressed and pytest's
-            # interrupt traceback is silently lost.
             live.suppress()
             try:
                 ihook.pytest_runtest_logstart(nodeid=item.nodeid, location=item.location)
@@ -440,8 +537,7 @@ class ParallelRunner:
             reported.add(item)
 
         interrupted = False
-        cancelled = threading.Event()
-        if workers > 1 and len(callable_items) > 1:
+        if workers > 1 and len(parallel_items) > 1:
             work_queue = queue.SimpleQueue()
             result_queue = queue.SimpleQueue()
 
@@ -451,16 +547,21 @@ class ParallelRunner:
                     if work_item is None or cancelled.is_set():
                         return
                     try:
-                        result = _do_call(work_item)
+                        item, setup_info, call_info, fixture_fins = _do_setup_and_call(work_item)
+                        per_item_fixture_fins[item] = fixture_fins
+                        if setup_info is not None:
+                            setup_rep = item.ihook.pytest_runtest_makereport(
+                                item=item, call=setup_info
+                            )
+                            setup_reports[item] = setup_rep
+                            setup_passed[item] = setup_info.excinfo is None
+                        result_queue.put((item, call_info))
                     except BaseException as exc:
-                        # Ensure the result queue always gets an entry so the
-                        # main thread never blocks forever on .get().
                         call_info = CallInfo.from_call(
                             lambda e=exc: (_ for _ in ()).throw(e),
                             when="call",
                         )
-                        result = (work_item, call_info)
-                    result_queue.put(result)
+                        result_queue.put((work_item, call_info))
 
             threads = []
             for _ in range(workers):
@@ -468,36 +569,46 @@ class ParallelRunner:
                 t.start()
                 threads.append(t)
 
-            for ci in callable_items:
-                work_queue.put(ci)
+            # Submit all parallel items (setup + call)
+            for item in parallel_items:
+                work_queue.put(item)
 
             try:
-                remaining = len(callable_items)
-                while remaining > 0:
-                    item, call_info = result_queue.get()
-                    call_results[item] = call_info
-                    _report_item(item)
-                    remaining -= 1
+                collected = 0
+                while collected < len(parallel_items):
+                    finished_item, call_info = result_queue.get()
+                    if call_info is not None:
+                        call_results[finished_item] = call_info
+                    _report_item(finished_item)
+                    collected += 1
             except KeyboardInterrupt:
                 interrupted = True
                 cancelled.set()
 
-            # Signal workers to stop (best-effort; they're daemon threads)
             for _ in range(workers):
                 work_queue.put(None)
             if not interrupted:
                 for t in threads:
                     t.join()
         else:
+            # Single worker fallback: sequential setup + call
             try:
-                for item in callable_items:
-                    _, call_info = _do_call(item)
-                    call_results[item] = call_info
+                for item in parallel_items:
+                    item, setup_info, call_info, fixture_fins = _do_setup_and_call(item)
+                    per_item_fixture_fins[item] = fixture_fins
+                    if setup_info is not None:
+                        setup_rep = item.ihook.pytest_runtest_makereport(
+                            item=item, call=setup_info
+                        )
+                        setup_reports[item] = setup_rep
+                        setup_passed[item] = setup_info.excinfo is None
+                    if call_info is not None:
+                        call_results[item] = call_info
                     _report_item(item)
             except KeyboardInterrupt:
                 interrupted = True
 
-        # Phase 3: report any remaining items (setup failures, stragglers)
+        # Report any remaining items (setup failures, stragglers)
         if not interrupted:
             for item in items:
                 if item not in reported:
@@ -505,7 +616,13 @@ class ParallelRunner:
 
         live.finish()
 
-        # Phase 4: teardown (always runs, even after interrupt)
+        # Pop parallel items from setupstate stack
+        # noinspection PyProtectedMember
+        for item in parallel_items:
+            if item in session._setupstate.stack:  # pyright: ignore[reportPrivateUsage]
+                session._setupstate.stack.pop(item)  # pyright: ignore[reportPrivateUsage]
+
+        # Teardown (always runs, even after interrupt)
         self._teardown_all(items, per_item_fixture_fins, saved_collector_fins)
 
         if interrupted:

pytest_threadpool-0.3.0/tests/integration_tests/cases/fixture_func_addfinalizer.py

@@ -0,0 +1,49 @@
+"""Function-scoped fixture using request.addfinalizer (non-yield style)."""
+
+import threading
+from typing import ClassVar
+
+import pytest
+
+
+class TestState:
+    setup_log: ClassVar[list] = []
+    finalizer_log: ClassVar[list] = []
+    lock: ClassVar[threading.Lock] = threading.Lock()
+
+
+@pytest.fixture
+def managed_resource(request):
+    name = request.node.name
+    with TestState.lock:
+        TestState.setup_log.append(name)
+
+    def cleanup():
+        with TestState.lock:
+            TestState.finalizer_log.append(name)
+
+    request.addfinalizer(cleanup)  # noqa: PT021 — intentionally testing addfinalizer API
+    return f"resource_{name}"
+
+
+@pytest.mark.parallelizable("children")
+class TestAddfinalizer:
+    barrier = threading.Barrier(3, timeout=10)
+
+    def test_a(self, managed_resource):
+        assert managed_resource == "resource_test_a"
+        self.barrier.wait()
+
+    def test_b(self, managed_resource):
+        assert managed_resource == "resource_test_b"
+        self.barrier.wait()
+
+    def test_c(self, managed_resource):
+        assert managed_resource == "resource_test_c"
+        self.barrier.wait()
+
+
+def test_verify():
+    expected = {"test_a", "test_b", "test_c"}
+    assert expected == set(TestState.setup_log), f"setups: {TestState.setup_log}"
+    assert expected == set(TestState.finalizer_log), f"finalizers: {TestState.finalizer_log}"