pytest-asyncio-concurrent-fork 0.5.2__tar.gz

pytest_asyncio_concurrent_fork-0.5.2/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Zane Chen
+
+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_asyncio_concurrent_fork-0.5.2/PKG-INFO

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: pytest-asyncio-concurrent-fork
+Version: 0.5.2
+Summary: Temporary pytest compatibility fork of pytest-asyncio-concurrent.
+Author-email: Zane Chen <czl970721@gmail.com>
+Maintainer-email: Zane Chen <czl970721@gmail.com>
+License: 
+        The MIT License (MIT)
+        
+        Copyright (c) 2024 Zane Chen
+        
+        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.
+        
+Project-URL: Repository, https://github.com/AnswerDotAI/pytest-asyncio-concurrent
+Project-URL: Homepage, https://github.com/AnswerDotAI/pytest-asyncio-concurrent
+Project-URL: Issues, https://github.com/AnswerDotAI/pytest-asyncio-concurrent/issues
+Classifier: Framework :: Pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: pytest>=6.2.0
+Provides-Extra: testing
+Requires-Dist: coverage>=7.6.0; extra == "testing"
+Dynamic: license-file
+
+==============================
+pytest-asyncio-concurrent-fork
+==============================
+
+This is a temporary pytest compatibility fork of `pytest-asyncio-concurrent <https://github.com/czl9707/pytest-asyncio-concurrent>`_. The intent is to return to upstream once the fixes land there.
+
+The fork registers concurrent tests as active during fixture setup and execution, as required by pytest 9.1. Async fixtures and concurrent tests share one session-owned event loop rather than relying on an implicit current loop.
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio-concurrent-fork.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent-fork
+    :alt: PyPI version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio-concurrent-fork.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent-fork
+    :alt: Python versions
+
+.. image:: https://github.com/AnswerDotAI/pytest-asyncio-concurrent/actions/workflows/main.yml/badge.svg
+    :target: https://github.com/AnswerDotAI/pytest-asyncio-concurrent/actions/workflows/main.yml
+    :alt: See Build Status on GitHub Actions
+
+
+System/Integration tests can take a really long time. 
+
+And ``pytest-asyncio-concurrent`` A pytest plugin aiming to solve this by running asynchronous tests in true parallel, enabling faster execution for high I/O or network-bound test suites. 
+
+Unlike ``pytest-asyncio``, which runs async tests **sequentially**, ``pytest-asyncio-concurrent`` takes advantage of Python's asyncio capabilities to execute tests **concurrently** by specifying **async group**.
+
+Note: This plugin would more or less `Break Test Isolation Principle` \(for none function scoped fixture\). Please make sure your tests is ok to run concurrently before you use this plugin.
+
+
+Key Features
+------------
+
+* Giving the capability to run pytest async functions.
+* Providing granular control over Concurrency -- See **Async Group** for details
+  
+  * Specifying Async Group to control tests that can run together. 
+  * Limitation: Only test functions defined under same direct parent can be put into same group.
+
+* ``asyncio_concurrent`` mark accept a ``timeout`` parameter, which would throw error when test reach the given time.
+* Compatible with ``pytest-asyncio``.
+
+Key Concept: Async Group
+------------------------
+
+The plugin control tests concurrency by putting them into different groups.
+
+* Limitation: Each group can **only** contain tests under **same direct parent**. For example, class methods within same class, or functions within same file.
+* Explicitly specify group by providing ``group`` parameter to ``asyncio_concurrent`` mark. 
+
+    * All tests marked with same group name will be executed together.
+    * All tests will be skipped if the ``Same Parent`` rule got violated.
+
+* Use default grouping strategy. The plugin accept ``--default-group-strategy`` cli parameter, or ``default_group_strategy`` in ini or toml file. Possible value: ``self``, ``parent``.
+    
+    * **self**\(default\): Each test will be executed by itself if no group provided.
+    * **parent**: Tests will grouped by their parent node. For example, all method within same class will be grouped together.
+
+Installation
+------------
+
+Replace the upstream distribution with the fork; do not install both, since they provide the same Python package and pytest plugin::
+
+    $ pip uninstall pytest-asyncio-concurrent
+    $ pip install pytest-asyncio-concurrent-fork
+
+The marker and plugin names are unchanged. With pytest 8.4 or later, projects can load only the plugins they use:
+
+.. code-block:: toml
+
+    [tool.pytest.ini_options]
+    addopts = "--disable-plugin-autoload -p asyncio-concurrent"
+
+Use plain ``@pytest.fixture`` for async fixtures owned by this plugin. If also using ``pytest-asyncio``, explicitly load ``-p asyncio`` and use its strict mode so it does not take ownership of concurrent tests.
+
+
+How this work?
+--------------
+
+This plugin extend ``pytest_runtestloop`` hook to handle async tests seperately.
+
+In the 'async loop', tests are grouped by the `group` provided in the mark. and executed one group at a time.
+
+In each group, instead of sequentially calling ``setup``, ``call``, ``teardown`` for individual test, these hooks are called for all tests in the group in batch.
+
+The fixture lifecycle within group is handled by this plugin instead of pytest core, to work around pytest sequential test execution assumption.
+
+
+Usage
+-----
+
+Run test Sequentially
+
+.. code-block:: python
+
+    @pytest.mark.asyncio_concurrent
+    async def async_test_A():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    @pytest.mark.asyncio_concurrent
+    async def async_test_B():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Run tests Concurrently
+
+.. code-block:: python
+
+    # the test below will run by itself
+    @pytest.mark.asyncio_concurrent
+    async def test_by_itself():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # the two tests below will run concurrently
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    async def test_groupA():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # this one will have a 10s timeout
+    @pytest.mark.asyncio_concurrent(group="my_group", timeout=10)
+    async def test_groupB():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Parametrized Tests
+
+.. code-block:: python
+
+    # the parametrized tests below will run sequential
+    @pytest.mark.asyncio_concurrent
+    @pytest.parametrize("p", [0, 1, 2])
+    async def test_parametrize_sequential(p):
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # the parametrized tests below will run concurrently
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    @pytest.parametrize("p", [0, 1, 2])
+    async def test_parametrize_concurrent():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Contributing
+------------
+
+Contributions are very welcome. Tests can be run with ``tox``, please ensure
+the coverage at least stays the same before you submit a pull request.
+
+License
+-------
+
+Distributed under the terms of the ``MIT`` license, "pytest-asyncio-concurrent" is free and open source software

pytest_asyncio_concurrent_fork-0.5.2/README.rst

@@ -0,0 +1,158 @@
+==============================
+pytest-asyncio-concurrent-fork
+==============================
+
+This is a temporary pytest compatibility fork of `pytest-asyncio-concurrent <https://github.com/czl9707/pytest-asyncio-concurrent>`_. The intent is to return to upstream once the fixes land there.
+
+The fork registers concurrent tests as active during fixture setup and execution, as required by pytest 9.1. Async fixtures and concurrent tests share one session-owned event loop rather than relying on an implicit current loop.
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio-concurrent-fork.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent-fork
+    :alt: PyPI version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio-concurrent-fork.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent-fork
+    :alt: Python versions
+
+.. image:: https://github.com/AnswerDotAI/pytest-asyncio-concurrent/actions/workflows/main.yml/badge.svg
+    :target: https://github.com/AnswerDotAI/pytest-asyncio-concurrent/actions/workflows/main.yml
+    :alt: See Build Status on GitHub Actions
+
+
+System/Integration tests can take a really long time. 
+
+And ``pytest-asyncio-concurrent`` A pytest plugin aiming to solve this by running asynchronous tests in true parallel, enabling faster execution for high I/O or network-bound test suites. 
+
+Unlike ``pytest-asyncio``, which runs async tests **sequentially**, ``pytest-asyncio-concurrent`` takes advantage of Python's asyncio capabilities to execute tests **concurrently** by specifying **async group**.
+
+Note: This plugin would more or less `Break Test Isolation Principle` \(for none function scoped fixture\). Please make sure your tests is ok to run concurrently before you use this plugin.
+
+
+Key Features
+------------
+
+* Giving the capability to run pytest async functions.
+* Providing granular control over Concurrency -- See **Async Group** for details
+  
+  * Specifying Async Group to control tests that can run together. 
+  * Limitation: Only test functions defined under same direct parent can be put into same group.
+
+* ``asyncio_concurrent`` mark accept a ``timeout`` parameter, which would throw error when test reach the given time.
+* Compatible with ``pytest-asyncio``.
+
+Key Concept: Async Group
+------------------------
+
+The plugin control tests concurrency by putting them into different groups.
+
+* Limitation: Each group can **only** contain tests under **same direct parent**. For example, class methods within same class, or functions within same file.
+* Explicitly specify group by providing ``group`` parameter to ``asyncio_concurrent`` mark. 
+
+    * All tests marked with same group name will be executed together.
+    * All tests will be skipped if the ``Same Parent`` rule got violated.
+
+* Use default grouping strategy. The plugin accept ``--default-group-strategy`` cli parameter, or ``default_group_strategy`` in ini or toml file. Possible value: ``self``, ``parent``.
+    
+    * **self**\(default\): Each test will be executed by itself if no group provided.
+    * **parent**: Tests will grouped by their parent node. For example, all method within same class will be grouped together.
+
+Installation
+------------
+
+Replace the upstream distribution with the fork; do not install both, since they provide the same Python package and pytest plugin::
+
+    $ pip uninstall pytest-asyncio-concurrent
+    $ pip install pytest-asyncio-concurrent-fork
+
+The marker and plugin names are unchanged. With pytest 8.4 or later, projects can load only the plugins they use:
+
+.. code-block:: toml
+
+    [tool.pytest.ini_options]
+    addopts = "--disable-plugin-autoload -p asyncio-concurrent"
+
+Use plain ``@pytest.fixture`` for async fixtures owned by this plugin. If also using ``pytest-asyncio``, explicitly load ``-p asyncio`` and use its strict mode so it does not take ownership of concurrent tests.
+
+
+How this work?
+--------------
+
+This plugin extend ``pytest_runtestloop`` hook to handle async tests seperately.
+
+In the 'async loop', tests are grouped by the `group` provided in the mark. and executed one group at a time.
+
+In each group, instead of sequentially calling ``setup``, ``call``, ``teardown`` for individual test, these hooks are called for all tests in the group in batch.
+
+The fixture lifecycle within group is handled by this plugin instead of pytest core, to work around pytest sequential test execution assumption.
+
+
+Usage
+-----
+
+Run test Sequentially
+
+.. code-block:: python
+
+    @pytest.mark.asyncio_concurrent
+    async def async_test_A():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    @pytest.mark.asyncio_concurrent
+    async def async_test_B():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Run tests Concurrently
+
+.. code-block:: python
+
+    # the test below will run by itself
+    @pytest.mark.asyncio_concurrent
+    async def test_by_itself():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # the two tests below will run concurrently
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    async def test_groupA():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # this one will have a 10s timeout
+    @pytest.mark.asyncio_concurrent(group="my_group", timeout=10)
+    async def test_groupB():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Parametrized Tests
+
+.. code-block:: python
+
+    # the parametrized tests below will run sequential
+    @pytest.mark.asyncio_concurrent
+    @pytest.parametrize("p", [0, 1, 2])
+    async def test_parametrize_sequential(p):
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # the parametrized tests below will run concurrently
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    @pytest.parametrize("p", [0, 1, 2])
+    async def test_parametrize_concurrent():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Contributing
+------------
+
+Contributions are very welcome. Tests can be run with ``tox``, please ensure
+the coverage at least stays the same before you submit a pull request.
+
+License
+-------
+
+Distributed under the terms of the ``MIT`` license, "pytest-asyncio-concurrent" is free and open source software

pytest_asyncio_concurrent_fork-0.5.2/pyproject.toml

@@ -0,0 +1,119 @@
+[build-system]
+requires = [
+  "setuptools>=61.0",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytest-asyncio-concurrent-fork"
+description = "Temporary pytest compatibility fork of pytest-asyncio-concurrent."
+version = "0.5.2"
+readme = "README.rst"
+requires-python = ">=3.8"
+authors = [
+    { name = "Zane Chen", email = "czl970721@gmail.com" },
+]
+maintainers = [
+    { name = "Zane Chen", email = "czl970721@gmail.com" },
+]
+license = {file = "LICENSE"}
+classifiers = [
+    "Framework :: Pytest",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Testing",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3 :: Only",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "pytest>=6.2.0",
+]
+optional-dependencies.testing = [
+    "coverage>=7.6.0",
+]
+[project.urls]
+Repository = "https://github.com/AnswerDotAI/pytest-asyncio-concurrent"
+Homepage = "https://github.com/AnswerDotAI/pytest-asyncio-concurrent"
+Issues = "https://github.com/AnswerDotAI/pytest-asyncio-concurrent/issues"
+
+[project.entry-points.pytest11]
+asyncio-concurrent = "pytest_asyncio_concurrent.plugin"
+
+[tool.setuptools]
+packages = [
+  "pytest_asyncio_concurrent",
+]
+include-package-data = true
+license-files = [
+  "LICENSE",
+]
+
+[tool.black]
+line-length = 100
+
+[tool.flake8]
+max-line-length = 100
+
+[tool.pytest.ini_options]
+addopts = "--disable-plugin-autoload"
+
+[tool.coverage.run]
+source = [
+  "pytest_asyncio_concurrent",
+]
+branch = true
+data_file = "coverage/coverage"
+omit = [
+  "*/_version.py",
+]
+parallel = true
+concurrency = [ 
+    "multiprocessing"
+]
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.bumpversion]
+current_version = "0.5.2"
+parse = """(?x)
+  (?P<major>0|[1-9]\\d*)\\.
+  (?P<minor>0|[1-9]\\d*)\\.
+  (?P<patch>0|[1-9]\\d*)
+  (?:
+      -prerelease-(?P<pre>0|[1-9]\\d*)
+  )?
+"""
+serialize = [
+  "{major}.{minor}.{patch}-prerelease-{pre}",
+  "{major}.{minor}.{patch}",
+]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = false
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bump version: {current_version} → {new_version}"
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = "version = \"{current_version}\""
+replace = "version = \"{new_version}\""

pytest_asyncio_concurrent_fork-0.5.2/pytest_asyncio_concurrent/__init__.py

@@ -0,0 +1,7 @@
+"""The main point for importing pytest-asyncio-concurrent items."""
+
+from .plugin import AsyncioConcurrentGroup
+
+__all__ = [
+    AsyncioConcurrentGroup.__name__,
+]

pytest_asyncio_concurrent_fork-0.5.2/pytest_asyncio_concurrent/fixture_async.py

@@ -0,0 +1,139 @@
+import copy
+import inspect
+import asyncio
+import functools
+
+from typing import Any, Dict, Optional, Sequence
+import warnings
+
+import pytest
+from _pytest import fixtures
+from _pytest import nodes
+
+event_loop_key = pytest.StashKey[asyncio.AbstractEventLoop]()
+
+
+@pytest.hookimpl(specname="pytest_fixture_setup", tryfirst=True)
+def pytest_fixture_setup_wrap_async(
+    fixturedef: pytest.FixtureDef, request: pytest.FixtureRequest
+) -> None:
+    """Wraps the fixture function of an async fixture in a synchronous function."""
+    event_loop = request.config.stash[event_loop_key]
+    if inspect.isasyncgenfunction(fixturedef.func):
+        _wrap_asyncgen_fixture(fixturedef, event_loop)
+    elif inspect.iscoroutinefunction(fixturedef.func):
+        _wrap_asyncfunc_fixture(fixturedef, event_loop)
+
+
+def _wrap_asyncgen_fixture(fixturedef: pytest.FixtureDef, event_loop) -> None:
+    fixtureFunc = fixturedef.func
+
+    @functools.wraps(fixtureFunc)
+    def _asyncgen_fixture_wrapper(**kwargs: Any):
+        gen_obj = fixtureFunc(**kwargs)
+
+        async def setup():
+            res = await gen_obj.__anext__()  # type: ignore[union-attr]
+            return res
+
+        async def teardown() -> None:
+            try:
+                await gen_obj.__anext__()  # type: ignore[union-attr]
+            except StopAsyncIteration:
+                pass
+            else:
+                msg = "Async generator fixture didn't stop."
+                msg += "Yield only once."
+                raise ValueError(msg)
+
+        result = event_loop.run_until_complete(setup())
+        yield result
+        event_loop.run_until_complete(teardown())
+
+    fixturedef.func = _asyncgen_fixture_wrapper  # type: ignore[misc]
+
+
+def _wrap_asyncfunc_fixture(fixturedef: pytest.FixtureDef, event_loop) -> None:
+    fixtureFunc = fixturedef.func
+
+    @functools.wraps(fixtureFunc)
+    def _async_fixture_wrapper(**kwargs: Dict[str, Any]):
+        async def setup():
+            res = await fixtureFunc(**kwargs)
+            return res
+
+        return event_loop.run_until_complete(setup())
+
+    fixturedef.func = _async_fixture_wrapper  # type: ignore[misc]
+
+
+fixture_cache_key = pytest.StashKey[Dict[str, Optional[Sequence[pytest.FixtureDef[Any]]]]]()
+
+
+@pytest.hookimpl(specname="pytest_sessionstart", trylast=True)
+def pytest_sessionstart_cache_fixture(session: pytest.Session):
+    event_loop = session.config.stash[event_loop_key] = asyncio.new_event_loop()
+    session.config.add_cleanup(event_loop.close)
+    # This function in general utilized some private properties.
+
+    # This is to solve two problem:
+    # 1. Funtion scoped fixture result value got shared in different tests in same group.
+    # 2. And fixture teardown got registered under right test using it.
+
+    # FixtureDef for each fixture is unique and held in FixtureManger and got injected into
+    # pytest.Item when the Item is constructed, and FixtureDef class is also in charge of
+    # holding finalizers and cache value.
+
+    # Fixture value caching is highly coupled with pytest entire lifecycle, implementing a
+    # thirdparty fixture cache manager will be hard.
+    # The first problem can be solved by shallow copy the fixtureDef, to split the cache_value.
+    # The finalizers are stored in a private list property in fixtureDef, which need to touch
+    # private API anyway.
+
+    # If the private API change, finalizer errors from this fixture but in different
+    # tests in same group will be reported in one function.
+
+    fixManager: fixtures.FixtureManager = session.config.pluginmanager.get_plugin(
+        "funcmanage"
+    )  # type: ignore
+    getfixturedefs_original = fixManager.getfixturedefs
+
+    @functools.wraps(getfixturedefs_original)
+    def getfixturedefs_wrapper(
+        argname: str,
+        node: nodes.Node,
+    ) -> Optional[Sequence[pytest.FixtureDef[Any]]]:
+        if fixture_cache_key not in node.stash:
+            node.stash[fixture_cache_key] = {}
+
+        cache = node.stash[fixture_cache_key]
+        if argname not in cache:
+            fixtureDefs = getfixturedefs_original(argname, node)
+
+            if fixtureDefs:
+                fixtureDefs = tuple(_clone_function_fixture(fixDef) for fixDef in fixtureDefs)
+
+            cache[argname] = fixtureDefs
+
+        return cache[argname]
+
+    fixManager.getfixturedefs = getfixturedefs_wrapper  # type: ignore
+
+
+def _clone_function_fixture(fixtureDef: pytest.FixtureDef) -> pytest.FixtureDef:
+    if fixtureDef.scope != "function":
+        return fixtureDef
+
+    new_fixdef = copy.copy(fixtureDef)
+    if hasattr(fixtureDef, "_finalizers"):
+        new_fixdef._finalizers = []  # type: ignore
+    else:
+        warnings.warn(
+            f"""
+            pytest {pytest.__version__} changed internal property which this plugin relies on.
+            The teardown error in fixture {fixtureDef.argname} might be reported in wrong place.
+            Please raise an issue.
+            """
+        )
+
+    return new_fixdef