pytest-asyncio-concurrent 0.1.1__tar.gz

pytest_asyncio_concurrent-0.1.1/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-0.1.1/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: pytest-asyncio-concurrent
+Version: 0.1.1
+Summary: Pytest plugin to execute python async tests concurrently.
+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/czl9707/pytest-asyncio-concurrent
+Project-URL: Homepage, https://github.com/czl9707/pytest-asyncio-concurrent
+Project-URL: Issues, https://github.com/czl9707/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"
+
+=========================
+pytest-asyncio-concurrent
+=========================
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio-concurrent.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent
+    :alt: PyPI version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio-concurrent.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent
+    :alt: Python versions
+
+.. image:: https://codecov.io/github/czl9707/pytest-asyncio-concurrent/graph/badge.svg?token=ENWHQBWQML 
+    :target: https://codecov.io/gh/czl9707/pytest-asyncio-concurrent
+    :alt: Testing Coverage
+
+.. image:: https://github.com/czl9707/pytest-asyncio-concurrent/actions/workflows/main.yml/badge.svg
+    :target: https://github.com/czl9707/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 is a solution for 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
+  - Specifying Async Group to control tests that can run together. 
+  - Specifying Timeout to avoid async tests taking forever. (Under Construction)
+- Compatible with ``pytest-asyncio``.
+
+Installation
+------------
+
+You can install "pytest-asyncio-concurrent" via `pip` from `PyPI`::
+
+    $ pip install pytest-asyncio-concurrent
+
+
+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()
+
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    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-0.1.1/README.rst

@@ -0,0 +1,117 @@
+=========================
+pytest-asyncio-concurrent
+=========================
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio-concurrent.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent
+    :alt: PyPI version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio-concurrent.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent
+    :alt: Python versions
+
+.. image:: https://codecov.io/github/czl9707/pytest-asyncio-concurrent/graph/badge.svg?token=ENWHQBWQML 
+    :target: https://codecov.io/gh/czl9707/pytest-asyncio-concurrent
+    :alt: Testing Coverage
+
+.. image:: https://github.com/czl9707/pytest-asyncio-concurrent/actions/workflows/main.yml/badge.svg
+    :target: https://github.com/czl9707/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 is a solution for 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
+  - Specifying Async Group to control tests that can run together. 
+  - Specifying Timeout to avoid async tests taking forever. (Under Construction)
+- Compatible with ``pytest-asyncio``.
+
+Installation
+------------
+
+You can install "pytest-asyncio-concurrent" via `pip` from `PyPI`::
+
+    $ pip install pytest-asyncio-concurrent
+
+
+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()
+
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    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-0.1.1/pyproject.toml

@@ -0,0 +1,116 @@
+[build-system]
+requires = [
+  "setuptools>=61.0",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytest-asyncio-concurrent"
+description = "Pytest plugin to execute python async tests concurrently."
+version = "0.1.1"
+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/czl9707/pytest-asyncio-concurrent"
+Homepage = "https://github.com/czl9707/pytest-asyncio-concurrent"
+Issues = "https://github.com/czl9707/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.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.1.1"
+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 = true
+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-0.1.1/pytest_asyncio_concurrent/__init__.py

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

pytest_asyncio_concurrent-0.1.1/pytest_asyncio_concurrent/plugin.py

@@ -0,0 +1,270 @@
+import asyncio
+from typing import Any, Callable, Generator, List, Optional, Coroutine, Dict, cast
+import uuid
+
+import pytest
+from _pytest import scope, timing, outcomes, runner
+from pytest import (
+    CallInfo,
+    ExceptionInfo,
+    FixtureDef,
+    Item,
+    Session,
+    Config,
+    Function,
+    Mark,
+    TestReport,
+)
+
+
+# =========================== # Config & Collection # =========================== #
+def pytest_configure(config: Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "asyncio_concurrent(group, timeout): " "mark the tests to run concurrently",
+    )
+
+
+@pytest.hookimpl(specname="pytest_runtestloop", wrapper=True)
+def pytest_runtestloop_wrap_items_by_group(session: Session) -> Generator[None, Any, Any]:
+    """
+    Group items with same asyncio concurrent group together,
+    so they can be executed together in outer loop.
+    """
+    asycio_concurrent_groups: Dict[str, List[Function]] = {}
+    items = session.items
+
+    for item in items:
+        if _get_asyncio_concurrent_mark(item) is None:
+            continue
+
+        concurrent_group_name = _get_asyncio_concurrent_group(item)
+        if concurrent_group_name not in asycio_concurrent_groups:
+            asycio_concurrent_groups[concurrent_group_name] = []
+        asycio_concurrent_groups[concurrent_group_name].append(cast(Function, item))
+
+    for asyncio_items in asycio_concurrent_groups.values():
+        for item in asyncio_items:
+            items.remove(item)
+
+    for group_name, asyncio_items in asycio_concurrent_groups.items():
+        items.append(group_asyncio_concurrent_function(group_name, asyncio_items))
+
+    result = yield
+
+    groups = [item for item in items if isinstance(item, AsyncioConcurrentGroup)]
+    for group in groups:
+        items.remove(group)
+        for item in group._pytest_asyncio_concurrent_children:
+            items.append(item)
+
+    return result
+
+
+class AsyncioConcurrentGroup(Function):
+    _pytest_asyncio_concurrent_children: List[Function] = []
+
+
+def group_asyncio_concurrent_function(
+    group_name: str, children: List[Function]
+) -> AsyncioConcurrentGroup:
+    parent = None
+    for childFunc in children:
+        p_it = childFunc.iter_parents()
+        next(p_it)
+        func_parent = next(p_it)
+
+        if not parent:
+            parent = func_parent
+        elif parent is not func_parent:
+            raise Exception("test case within same group should have same parent.")
+
+        _rewrite_function_scoped_fixture(childFunc)
+
+    g_function = AsyncioConcurrentGroup.from_parent(
+        parent,
+        name=f"ayncio_concurrent_test_group[{group_name}]",
+        callobj=lambda: None,
+    )
+
+    g_function._pytest_asyncio_concurrent_children = children
+    return g_function
+
+
+def _rewrite_function_scoped_fixture(item: Function):
+    for name, fixturedefs in item._request._arg2fixturedefs.items():
+        if hasattr(item, "callspec") and name in item.callspec.params.keys():
+            continue
+
+        if fixturedefs[-1]._scope != scope.Scope.Function:
+            continue
+
+        new_fixdef = FixtureDef(
+            config=item.config,
+            baseid=fixturedefs[-1].baseid,
+            argname=fixturedefs[-1].argname,
+            func=fixturedefs[-1].func,
+            scope=fixturedefs[-1]._scope,
+            params=fixturedefs[-1].params,
+            ids=fixturedefs[-1].ids,
+            _ispytest=True,
+        )
+        fixturedefs = list(fixturedefs[0:-1]) + [new_fixdef]
+        item._request._arg2fixturedefs[name] = fixturedefs
+
+
+# =========================== # function call & setup & teardown #===========================#
+
+
+@pytest.hookimpl(specname="pytest_runtest_setup", wrapper=True)
+def pytest_runtest_setup_group_children(item: Item) -> Generator[None, None, None]:
+    result = yield
+
+    if not isinstance(item, AsyncioConcurrentGroup):
+        return result
+
+    for childFunc in item._pytest_asyncio_concurrent_children:
+        call = CallInfo.from_call(_pytest_simple_setup(childFunc), "setup")
+        report: TestReport = childFunc.ihook.pytest_runtest_makereport(item=childFunc, call=call)
+        childFunc.ihook.pytest_runtest_logreport(report=report)
+
+    return result
+
+
+def _pytest_simple_setup(item: Item) -> Callable[[], None]:
+    def inner() -> None:
+        item.session._setupstate.stack[item] = ([item.teardown], None)
+        item.setup()
+
+    return inner
+
+
+@pytest.hookimpl(specname="pytest_pyfunc_call", wrapper=True)
+def pytest_pyfunc_call_handle_group(pyfuncitem: Function) -> Generator[None, Any, Any]:
+    result = yield
+    if not isinstance(pyfuncitem, AsyncioConcurrentGroup):
+        return result
+
+    coros: List[Coroutine] = []
+    loop = asyncio.get_event_loop()
+
+    for childFunc in pyfuncitem._pytest_asyncio_concurrent_children:
+        coros.append(_async_callinfo_from_call(_pytest_function_call_async(childFunc)))
+
+    call_result = loop.run_until_complete(asyncio.gather(*coros))
+
+    for childFunc, call in zip(pyfuncitem._pytest_asyncio_concurrent_children, call_result):
+        report: TestReport = childFunc.ihook.pytest_runtest_makereport(item=childFunc, call=call)
+        childFunc.ihook.pytest_runtest_logreport(report=report)
+
+    return result
+
+
+def _pytest_function_call_async(item: Function) -> Callable[[], Coroutine]:
+    async def inner() -> Any:
+        testfunction = item.obj
+        testargs = {arg: item.funcargs[arg] for arg in item._fixtureinfo.argnames}
+        return await testfunction(**testargs)
+
+    return inner
+
+
+# referencing CallInfo.from_call
+async def _async_callinfo_from_call(func: Callable[[], Coroutine]) -> CallInfo:
+    excinfo = None
+    start = timing.time()
+    precise_start = timing.perf_counter()
+    try:
+        result = await func()
+    except BaseException:
+        excinfo = ExceptionInfo.from_current()
+        if isinstance(excinfo.value, outcomes.Exit):
+            raise
+        result = None
+
+    precise_stop = timing.perf_counter()
+    duration = precise_stop - precise_start
+    stop = timing.time()
+
+    callInfo: CallInfo = CallInfo(
+        start=start,
+        stop=stop,
+        duration=duration,
+        when="call",
+        result=result,
+        excinfo=excinfo,
+        _ispytest=True,
+    )
+
+    return callInfo
+
+
+@pytest.hookimpl(specname="pytest_runtest_teardown", wrapper=True)
+def pytest_runtest_teardown_group_children(
+    item: Item, nextitem: Optional[Item]
+) -> Generator[None, None, None]:
+    if not isinstance(item, AsyncioConcurrentGroup):
+        return (yield)
+
+    for childFunc in item._pytest_asyncio_concurrent_children:
+        call = CallInfo.from_call(_pytest_simple_teardown(childFunc), "teardown")
+        report: TestReport = childFunc.ihook.pytest_runtest_makereport(item=childFunc, call=call)
+        childFunc.ihook.pytest_runtest_logreport(report=report)
+
+    return (yield)
+
+
+def _pytest_simple_teardown(item: Item) -> Callable[[], None]:
+    def inner() -> None:
+        finalizers, _ = item.session._setupstate.stack.pop(item)
+        these_exceptions = []
+        while finalizers:
+            fin = finalizers.pop()
+            try:
+                fin()
+            except Exception as e:
+                these_exceptions.append(e)
+
+        if len(these_exceptions) == 1:
+            raise these_exceptions[0]
+        elif these_exceptions:
+            msg = f"Errors during tearing down {item}"
+            raise BaseExceptionGroup(msg, these_exceptions[::-1])
+
+    return inner
+
+
+# =========================== # reporting #===========================#
+
+
+@pytest.hookimpl(specname="pytest_runtest_protocol", tryfirst=True)
+def pytest_runtest_protocol_skip_logging_for_group(
+    item: Item, nextitem: Optional[Item]
+) -> Optional[bool]:
+    if not isinstance(item, AsyncioConcurrentGroup):
+        return None
+
+    for childFunc in item._pytest_asyncio_concurrent_children:
+        childFunc.ihook.pytest_runtest_logstart(
+            nodeid=childFunc.nodeid, location=childFunc.location
+        )
+
+    runner.runtestprotocol(item, nextitem=nextitem, log=False)  # disable logging for group function
+
+    for childFunc in item._pytest_asyncio_concurrent_children:
+        childFunc.ihook.pytest_runtest_logfinish(
+            nodeid=childFunc.nodeid, location=childFunc.location
+        )
+
+    return True
+
+
+def _get_asyncio_concurrent_mark(item: Item) -> Optional[Mark]:
+    return item.get_closest_marker("asyncio_concurrent")
+
+
+def _get_asyncio_concurrent_group(item: Item) -> str:
+    marker = item.get_closest_marker("asyncio_concurrent")
+    assert marker is not None
+
+    return marker.kwargs.get("group", f"anonymous_[{uuid.uuid4()}]")

pytest_asyncio_concurrent-0.1.1/pytest_asyncio_concurrent.egg-info/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: pytest-asyncio-concurrent
+Version: 0.1.1
+Summary: Pytest plugin to execute python async tests concurrently.
+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/czl9707/pytest-asyncio-concurrent
+Project-URL: Homepage, https://github.com/czl9707/pytest-asyncio-concurrent
+Project-URL: Issues, https://github.com/czl9707/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"
+
+=========================
+pytest-asyncio-concurrent
+=========================
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio-concurrent.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent
+    :alt: PyPI version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio-concurrent.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent
+    :alt: Python versions
+
+.. image:: https://codecov.io/github/czl9707/pytest-asyncio-concurrent/graph/badge.svg?token=ENWHQBWQML 
+    :target: https://codecov.io/gh/czl9707/pytest-asyncio-concurrent
+    :alt: Testing Coverage
+
+.. image:: https://github.com/czl9707/pytest-asyncio-concurrent/actions/workflows/main.yml/badge.svg
+    :target: https://github.com/czl9707/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 is a solution for 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
+  - Specifying Async Group to control tests that can run together. 
+  - Specifying Timeout to avoid async tests taking forever. (Under Construction)
+- Compatible with ``pytest-asyncio``.
+
+Installation
+------------
+
+You can install "pytest-asyncio-concurrent" via `pip` from `PyPI`::
+
+    $ pip install pytest-asyncio-concurrent
+
+
+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()
+
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    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-0.1.1/pytest_asyncio_concurrent.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.rst
+pyproject.toml
+pytest_asyncio_concurrent/__init__.py
+pytest_asyncio_concurrent/plugin.py
+pytest_asyncio_concurrent.egg-info/PKG-INFO
+pytest_asyncio_concurrent.egg-info/SOURCES.txt
+pytest_asyncio_concurrent.egg-info/dependency_links.txt
+pytest_asyncio_concurrent.egg-info/entry_points.txt
+pytest_asyncio_concurrent.egg-info/requires.txt
+pytest_asyncio_concurrent.egg-info/top_level.txt
+tests/test_fixture.py
+tests/test_grouping.py

pytest_asyncio_concurrent-0.1.1/pytest_asyncio_concurrent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytest_asyncio_concurrent-0.1.1/pytest_asyncio_concurrent.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+asyncio-concurrent = pytest_asyncio_concurrent.plugin

pytest_asyncio_concurrent-0.1.1/pytest_asyncio_concurrent.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pytest>=6.2.0
+
+[testing]
+coverage>=7.6.0

pytest_asyncio_concurrent-0.1.1/pytest_asyncio_concurrent.egg-info/top_level.txt

@@ -0,0 +1 @@
+pytest_asyncio_concurrent

pytest_asyncio_concurrent-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytest_asyncio_concurrent-0.1.1/tests/test_fixture.py

@@ -0,0 +1,160 @@
+from textwrap import dedent
+import pytest
+
+
+def test_fixture_handling(pytester: pytest.Pytester):
+    """Make sure that pytest accepts our fixture."""
+
+    pytester.makeconftest(
+        dedent(
+            """\
+            import pytest
+
+            @pytest.fixture
+            def fixture_a():
+                yield 1
+
+
+            @pytest.fixture
+            def fixture_b():
+                yield 2
+            """
+        )
+    )
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent
+            async def test_fixture_multi(fixture_a, fixture_b):
+                await asyncio.sleep(1)
+                assert fixture_a == 1
+                assert fixture_b == 2
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    result.assert_outcomes(passed=1)
+
+
+def test_fixture_scopes(pytester: pytest.Pytester):
+    """Make sure that pytest accepts our fixture."""
+
+    pytester.makeconftest(
+        dedent(
+            """\
+            import pytest
+
+            @pytest.fixture(scope="function")
+            def fixture_function():
+                yield "fixture_function"
+
+            @pytest.fixture(scope="class")
+            def fixture_class():
+                yield "fixture_class"
+
+            @pytest.fixture(scope="module")
+            def fixture_module():
+                yield "fixture_module"
+
+            @pytest.fixture(scope="session")
+            def fixture_session():
+                yield "fixture_session"
+            """
+        )
+    )
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent
+            async def test_fixture_multi(
+                fixture_function,
+                fixture_class,
+                fixture_module,
+                fixture_session
+            ):
+                await asyncio.sleep(1)
+                assert fixture_function == "fixture_function"
+                assert fixture_class == "fixture_class"
+                assert fixture_module == "fixture_module"
+                assert fixture_session == "fixture_session"
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    result.assert_outcomes(passed=1)
+
+
+def test_fixture_teardown(pytester: pytest.Pytester):
+    """Make sure that pytest accepts our fixture."""
+
+    pytester.makeconftest(
+        dedent(
+            """\
+            import pytest
+
+            @pytest.fixture(scope="function")
+            def fixture_function():
+                yield []
+
+            @pytest.fixture(scope="module")
+            def fixture_module():
+                yield []
+            """
+        )
+    )
+
+    pytester.makepyfile(
+        testA=dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent(group="any")
+            @pytest.mark.parametrize("p", [1, 2, 3])
+            async def test_fixture_multi(fixture_function, fixture_module, p):
+                await asyncio.sleep(p)
+
+                fixture_module.append(p)
+                fixture_function.append(p)
+
+                assert len(fixture_function) == 1
+                assert len(fixture_module) == p
+            """
+        )
+    )
+
+    pytester.makepyfile(
+        testB=dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent
+            @pytest.mark.parametrize("p", [1, 2, 3])
+            async def test_fixture_multi(fixture_function, fixture_module, p):
+                await asyncio.sleep(p)
+
+                fixture_module.append(p)
+                fixture_function.append(p)
+
+                assert len(fixture_function) == 1
+                assert len(fixture_module) == p
+            """
+        )
+    )
+
+    result = pytester.runpytest("testA.py", "testB.py")
+
+    result.assert_outcomes(passed=6)

pytest_asyncio_concurrent-0.1.1/tests/test_grouping.py

@@ -0,0 +1,144 @@
+from textwrap import dedent
+import pytest
+
+
+def test_groups_different(pytester: pytest.Pytester):
+    """Make sure group with different group exceuted seperately."""
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent(group="A")
+            async def test_group_A():
+                await asyncio.sleep(2)
+                assert 1 == 1
+
+            @pytest.mark.asyncio_concurrent(group="B")
+            async def test_group_B():
+                await asyncio.sleep(1)
+                assert 1 == 1
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    assert result.duration >= 3
+    result.assert_outcomes(passed=2)
+
+
+def test_groups_anonymous(pytester: pytest.Pytester):
+    """Make sure tests without group specified treated as different group"""
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent
+            async def test_group_A():
+                await asyncio.sleep(2)
+                assert 1 == 1
+
+            @pytest.mark.asyncio_concurrent
+            async def test_group_B():
+                await asyncio.sleep(1)
+                assert 1 == 1
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    assert result.duration >= 3
+    result.assert_outcomes(passed=2)
+
+
+def test_groups_same(pytester: pytest.Pytester):
+    """Make sure group with same group exceuted together."""
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            @pytest.mark.asyncio_concurrent(group="A")
+            async def test_group_anonymous_A():
+                await asyncio.sleep(2)
+                assert 1 == 1
+
+            @pytest.mark.asyncio_concurrent(group="A")
+            async def test_group_anonymous_B():
+                await asyncio.sleep(1)
+                assert 1 == 1
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    assert result.duration < 3
+    result.assert_outcomes(passed=2)
+
+
+def test_parametrize_without_group(pytester: pytest.Pytester):
+    """Make sure parametrized tests without group specified treated as different group"""
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            g = 0
+
+            @pytest.mark.parametrize("p", [0, 1, 2])
+            @pytest.mark.asyncio_concurrent
+            async def test_parametrize_no_group(p):
+                global g
+                await asyncio.sleep(p)
+
+                assert g == p
+                g += 1
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    result.assert_outcomes(passed=3)
+    assert result.duration >= 3
+
+
+def test_parametrize_with_group(pytester: pytest.Pytester):
+    """Make sure parametrized tests with group specified executed together"""
+
+    pytester.makepyfile(
+        dedent(
+            """\
+            import asyncio
+            import pytest
+
+            g = 0
+
+            @pytest.mark.parametrize("p", [0, 1, 2])
+            @pytest.mark.asyncio_concurrent(group="any")
+            async def test_parametrize_with_group(p):
+                global g
+                await asyncio.sleep(p)
+
+                assert g == p
+                g += 1
+            """
+        )
+    )
+
+    result = pytester.runpytest()
+
+    result.assert_outcomes(passed=3)
+    assert result.duration < 3