figured out loop_factory :)

Author: Vizonex

pytest_asyncio/plugin.py

@@ -49,6 +49,7 @@
     PytestPluginManager,
 )
 
+from typing import Callable
 if sys.version_info >= (3, 10):
     from typing import ParamSpec
 else:
@@ -134,6 +135,7 @@ def fixture(
     *,
     scope: _ScopeName | Callable[[str, Config], _ScopeName] = ...,
     loop_scope: _ScopeName | None = ...,
+    loop_factory: _ScopeName | Callable[[], AbstractEventLoop] = ...,
     params: Iterable[object] | None = ...,
     autouse: bool = ...,
     ids: (
@@ -151,6 +153,7 @@ def fixture(
     *,
     scope: _ScopeName | Callable[[str, Config], _ScopeName] = ...,
     loop_scope: _ScopeName | None = ...,
+    loop_factory: _ScopeName | Callable[[], AbstractEventLoop] = ...,
     params: Iterable[object] | None = ...,
     autouse: bool = ...,
     ids: (
@@ -165,20 +168,21 @@ def fixture(
 def fixture(
     fixture_function: FixtureFunction[_P, _R] | None = None,
     loop_scope: _ScopeName | None = None,
+    loop_factory: _ScopeName | Callable[[], AbstractEventLoop] = ...,
     **kwargs: Any,
 ) -> (
     FixtureFunction[_P, _R]
     | Callable[[FixtureFunction[_P, _R]], FixtureFunction[_P, _R]]
 ):
     if fixture_function is not None:
-        _make_asyncio_fixture_function(fixture_function, loop_scope)
+        _make_asyncio_fixture_function(fixture_function, loop_scope, loop_factory)
         return pytest.fixture(fixture_function, **kwargs)
 
     else:
 
         @functools.wraps(fixture)
         def inner(fixture_function: FixtureFunction[_P, _R]) -> FixtureFunction[_P, _R]:
-            return fixture(fixture_function, loop_scope=loop_scope, **kwargs)
+            return fixture(fixture_function, loop_factory=loop_factory, loop_scope=loop_scope, **kwargs)
 
         return inner
 
@@ -188,12 +192,13 @@ def _is_asyncio_fixture_function(obj: Any) -> bool:
     return getattr(obj, "_force_asyncio_fixture", False)
 
 
-def _make_asyncio_fixture_function(obj: Any, loop_scope: _ScopeName | None) -> None:
+def _make_asyncio_fixture_function(obj: Any, loop_scope: _ScopeName | None, loop_factory: _ScopeName | None) -> None:
     if hasattr(obj, "__func__"):
         # instance method, check the function object
         obj = obj.__func__
     obj._force_asyncio_fixture = True
     obj._loop_scope = loop_scope
+    obj._loop_factory = loop_factory
 
 
 def _is_coroutine_or_asyncgen(obj: Any) -> bool:
@@ -280,14 +285,14 @@ def pytest_report_header(config: Config) -> list[str]:
 
 
 def _fixture_synchronizer(
-    fixturedef: FixtureDef, runner: Runner, request: FixtureRequest
+    fixturedef: FixtureDef, runner: Runner, request: FixtureRequest, loop_factory: Callable[[], AbstractEventLoop]
 ) -> Callable:
     """Returns a synchronous function evaluating the specified fixture."""
     fixture_function = resolve_fixture_function(fixturedef, request)
     if inspect.isasyncgenfunction(fixturedef.func):
-        return _wrap_asyncgen_fixture(fixture_function, runner, request)  # type: ignore[arg-type]
+        return _wrap_asyncgen_fixture(fixture_function, runner, request, loop_factory)  # type: ignore[arg-type]
     elif inspect.iscoroutinefunction(fixturedef.func):
-        return _wrap_async_fixture(fixture_function, runner, request)  # type: ignore[arg-type]
+        return _wrap_async_fixture(fixture_function, runner, request, loop_factory)  # type: ignore[arg-type]
     else:
         return fixturedef.func
 
@@ -302,6 +307,7 @@ def _wrap_asyncgen_fixture(
     ],
     runner: Runner,
     request: FixtureRequest,
+    loop_factory:Callable[[], AbstractEventLoop]
 ) -> Callable[AsyncGenFixtureParams, AsyncGenFixtureYieldType]:
     @functools.wraps(fixture_function)
     def _asyncgen_fixture_wrapper(
@@ -331,6 +337,9 @@ async def async_finalizer() -> None:
                     msg = "Async generator fixture didn't stop."
                     msg += "Yield only once."
                     raise ValueError(msg)
+            if loop_factory:
+                _loop = loop_factory()
+                asyncio.set_event_loop(_loop)
 
             runner.run(async_finalizer(), context=context)
             if reset_contextvars is not None:
@@ -352,6 +361,7 @@ def _wrap_async_fixture(
     ],
     runner: Runner,
     request: FixtureRequest,
+    loop_factory: Callable[[], AbstractEventLoop] | None = None
 ) -> Callable[AsyncFixtureParams, AsyncFixtureReturnType]:
     @functools.wraps(fixture_function)
     def _async_fixture_wrapper(
@@ -363,8 +373,12 @@ async def setup():
             return res
 
         context = contextvars.copy_context()
-        result = runner.run(setup(), context=context)
 
+        # ensure loop_factory gets ran before we start running...
+        if loop_factory:
+            asyncio.set_event_loop(loop_factory())
+
+        result = runner.run(setup(), context=context)
         # Copy the context vars modified by the setup task into the current
         # context, and (if needed) add a finalizer to reset them.
         #
@@ -417,8 +431,6 @@ def restore_contextvars():
 class PytestAsyncioFunction(Function):
     """Base class for all test functions managed by pytest-asyncio."""
 
-    loop_factory: Callable[[], AbstractEventLoop] | None
-
     @classmethod
     def item_subclass_for(cls, item: Function, /) -> type[PytestAsyncioFunction] | None:
         """
@@ -433,12 +445,7 @@ def item_subclass_for(cls, item: Function, /) -> type[PytestAsyncioFunction] | N
         return None
 
     @classmethod
-    def _from_function(
-        cls,
-        function: Function,
-        loop_factory: Callable[[], AbstractEventLoop] | None = None,
-        /,
-    ) -> Function:
+    def _from_function(cls, function: Function, /) -> Function:
         """
         Instantiates this specific PytestAsyncioFunction type from the specified
         Function item.
@@ -454,7 +461,6 @@ def _from_function(
             keywords=function.keywords,
             originalname=function.originalname,
         )
-        subclass_instance.loop_factory = loop_factory
         subclass_instance.own_markers = function.own_markers
         assert subclass_instance.own_markers == function.own_markers
         return subclass_instance
@@ -516,6 +522,16 @@ def _can_substitute(item: Function) -> bool:
         func = item.obj
         return inspect.iscoroutinefunction(func)
 
+<<<<<<< HEAD
+=======
+    def runtest(self) -> None:
+        # print(self.obj.pytestmark[0].__dict__)
+        synchronized_obj = wrap_in_sync(self.obj, self.obj.pytestmark[0].kwargs.get('loop_factory', None))
+        with MonkeyPatch.context() as c:
+            c.setattr(self, "obj", synchronized_obj)
+            super().runtest()
+
+>>>>>>> edfbfef (figured out loop_factory :))
 
 class AsyncGenerator(PytestAsyncioFunction):
     """Pytest item created by an asynchronous generator"""
@@ -618,27 +634,9 @@ def pytest_pycollect_makeitem_convert_async_functions_to_subclass(
                     node.config
                 ) == Mode.AUTO and not node.get_closest_marker("asyncio"):
                     node.add_marker("asyncio")
-                if asyncio_marker := node.get_closest_marker("asyncio"):
-                    if loop_factory := asyncio_marker.kwargs.get("loop_factory", None):
-                        # multiply if loop_factory is an iterable object of factories
-                        if hasattr(loop_factory, "__iter__"):
-                            updated_item = [
-                                specialized_item_class._from_function(node, lf)
-                                for lf in loop_factory
-                            ]
-                        else:
-                            updated_item = specialized_item_class._from_function(
-                                node, loop_factory
-                            )
-                    else:
-                        updated_item = specialized_item_class._from_function(node)
-
-        # we could have multiple factroies to test if so,
-        # multiply the number of functions for us...
-        if isinstance(updated_item, list):
-            updated_node_collection.extend(updated_item)
-        else:
-            updated_node_collection.append(updated_item)
+                if node.get_closest_marker("asyncio"):
+                    updated_item = specialized_item_class._from_function(node)
+        updated_node_collection.append(updated_item)
     hook_result.force_result(updated_node_collection)
 
 
@@ -740,12 +738,12 @@ def _synchronize_coroutine(
     Return a sync wrapper around a coroutine executing it in the
     specified runner and context.
     """
-
     @functools.wraps(func)
     def inner(*args, **kwargs):
         coro = func(*args, **kwargs)
         runner.run(coro, context=context)
 
+        asyncio.set_event_loop(_last_loop)
     return inner
 
 
@@ -765,17 +763,12 @@ def pytest_fixture_setup(fixturedef: FixtureDef, request) -> object | None:
         or default_loop_scope
         or fixturedef.scope
     )
-    # XXX: Currently Confused as to where to debug and harvest and get the runner to use the loop_factory argument.
     loop_factory = getattr(fixturedef.func, "loop_factory", None)
 
-    print(f"LOOP FACTORY: {loop_factory} {fixturedef.func}")
-    sys.stdout.flush()
-
     runner_fixture_id = f"_{loop_scope}_scoped_runner"
-    runner: Runner = request.getfixturevalue(runner_fixture_id)
-
-    synchronizer = _fixture_synchronizer(fixturedef, runner, request)
-    _make_asyncio_fixture_function(synchronizer, loop_scope)
+    runner = request.getfixturevalue(runner_fixture_id)
+    synchronizer = _fixture_synchronizer(fixturedef, runner, request, loop_factory)
+    _make_asyncio_fixture_function(synchronizer, loop_scope, loop_factory)
     with MonkeyPatch.context() as c:
         c.setattr(fixturedef, "func", synchronizer)
         hook_result = yield
@@ -798,12 +791,9 @@ def _get_marked_loop_scope(
 ) -> _ScopeName:
     assert asyncio_marker.name == "asyncio"
     if asyncio_marker.args or (
-        asyncio_marker.kwargs
-        and set(asyncio_marker.kwargs) - {"loop_scope", "scope", "loop_factory"}
+        asyncio_marker.kwargs and set(asyncio_marker.kwargs) - {"loop_scope", "scope", "loop_factory"}
     ):
-        raise ValueError(
-            "mark.asyncio accepts only keyword arguments 'loop_scope', 'loop_factory'."
-        )
+        raise ValueError("mark.asyncio accepts only a keyword arguments 'loop_scope' or 'loop_factory'")
     if "scope" in asyncio_marker.kwargs:
         if "loop_scope" in asyncio_marker.kwargs:
             raise pytest.UsageError(_DUPLICATE_LOOP_SCOPE_DEFINITION_ERROR)