Major fixtures rework.

Author: Tinche

.travis.yml

@@ -1,8 +1,7 @@
 language: python
 python:
-  - "3.3"
-  - "3.4"
   - "3.5"
+  - "3.6"
 
 install:
     - pip install tox tox-travis

README.rst

@@ -22,15 +22,6 @@ provides useful fixtures and markers to make testing easier.
         res = await library.do_something()
         assert b'expected result' == res
 
-or, if you're using the pre-Python 3.5 syntax:
-
-.. code-block:: python
-
-    @pytest.mark.asyncio
-    def test_some_asyncio_code():
-        res = yield from library.do_something()
-        assert b'expected result' == res
-
 pytest-asyncio has been strongly influenced by pytest-tornado_.
 
 .. _pytest-tornado: https://github.com/eugeniy/pytest-tornado
@@ -124,25 +115,27 @@ when several unused TCP ports are required in a test.
 
 ``async fixtures``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-This fixtures may be defined as common pytest fixture:
+Asynchronous fixtures are defined similar to ordinary pytest fixtures.
 
 .. code-block:: python
-    
-    @pytest.fixture(scope='function')
+
+    @pytest.fixture
     async def async_gen_fixture():
         yield await asyncio.sleep(0.1)
-        
-    @pytest.fixture(scope='function')
+
+    @pytest.fixture(scope='module')
     async def async_fixture():
         return await asyncio.sleep(0.1)
 
-They behave just like a common fixtures, except that they **must** be function-scoped. 
-That ensures that they a run in the same event loop as test function.
+All scopes are supported, but if you use a non-function scope you will need
+to redefine the ``event_loop`` fixture to have the same or broader scope.
+Async fixtures need the event loop, and so must have the same or narrower scope
+than the ``event_loop`` fixture.
 
 Markers
 -------
 
-``pytest.mark.asyncio(forbid_global_loop=False)``
+``pytest.mark.asyncio``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Mark your test coroutine with this marker and pytest will execute it as an
 asyncio task using the event loop provided by the ``event_loop`` fixture. See
@@ -151,9 +144,6 @@ the introductory section for an example.
 The event loop used can be overriden by overriding the ``event_loop`` fixture
 (see above).
 
-If ``forbid_global_loop`` is true, ``asyncio.get_event_loop()`` will result
-in exceptions, ensuring your tests are always passing the event loop explicitly.
-
 In order to make your test code a little more concise, the pytest |pytestmark|_
 feature can be used to mark entire modules or classes with this marker.
 Only test coroutines will be affected (by default, coroutines prefixed by
@@ -165,7 +155,7 @@ Only test coroutines will be affected (by default, coroutines prefixed by
     import pytest
 
     # All test coroutines will be treated as marked.
-    pytestmark = pytest.mark.asyncio(forbid_global_loop=True)
+    pytestmark = pytest.mark.asyncio
 
     async def test_example(event_loop):
         """No marker!"""
@@ -174,7 +164,7 @@ Only test coroutines will be affected (by default, coroutines prefixed by
 .. |pytestmark| replace:: ``pytestmark``
 .. _pytestmark: http://doc.pytest.org/en/latest/example/markers.html#marking-whole-classes-or-modules
 
-``pytest.mark.asyncio_process_pool(forbid_global_loop=False)``
+``pytest.mark.asyncio_process_pool``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The ``asyncio_process_pool`` marker is almost identical to the ``asyncio``
 marker, except the event loop used will have a
@@ -185,11 +175,11 @@ Changelog
 
 0.6.0 (UNRELEASED)
 ~~~~~~~~~~~~~~~~~~
+- Support for Python versions pre-3.5 has been dropped.
 - ``pytestmark`` now works on both module and class level.
-- Using ``forbid_global_loop`` now allows tests to use ``asyncio`` 
-  subprocesses.
-  `#36 <https://github.com/pytest-dev/pytest-asyncio/issues/36>`_
-- support for async and async gen fixtures
+- The ``forbid_global_loop`` parameter has been removed.
+- Support for async and async gen fixtures has been added.
+  `#45 <https://github.com/pytest-dev/pytest-asyncio/pull/45>`_
 
 0.5.0 (2016-09-07)
 ~~~~~~~~~~~~~~~~~~

pytest_asyncio/plugin.py

@@ -10,20 +10,6 @@
 from _pytest.python import transfer_markers
 
 
-class ForbiddenEventLoopPolicy(asyncio.DefaultEventLoopPolicy):
-    """An event loop policy that raises errors on most operations.
-
-    Operations involving child watchers are permitted."""
-
-    def get_event_loop(self):
-        """Not allowed."""
-        raise NotImplementedError
-
-    def set_event_loop(self, _):
-        """Not allowed."""
-        raise NotImplementedError
-
-
 def _is_coroutine(obj):
     """Check to see if an object is really an asyncio coroutine."""
     return asyncio.iscoroutinefunction(obj) or inspect.isgeneratorfunction(obj)
@@ -62,54 +48,86 @@ def pytest_pycollect_makeitem(collector, name, obj):
 @pytest.hookimpl(hookwrapper=True)
 def pytest_fixture_setup(fixturedef, request):
     """Adjust the event loop policy when an event loop is produced."""
+    if inspect.isasyncgenfunction(fixturedef.func):
+        # This is an async generator function. Wrap it accordingly.
+        f = fixturedef.func
+
+        strip_event_loop = False
+        if 'event_loop' not in fixturedef.argnames:
+            fixturedef.argnames += ('event_loop', )
+            strip_event_loop = True
+        strip_request = False
+        if 'request' not in fixturedef.argnames:
+            fixturedef.argnames += ('request', )
+            strip_request = True
+
+        def wrapper(*args, **kwargs):
+            loop = kwargs['event_loop']
+            request = kwargs['request']
+            if strip_event_loop:
+                del kwargs['event_loop']
+            if strip_request:
+                del kwargs['request']
+
+            gen_obj = f(*args, **kwargs)
+
+            async def setup():
+                res = await gen_obj.__anext__()
+                return res
+
+            def finalizer():
+                """Yield again, to finalize."""
+                async def async_finalizer():
+                    try:
+                        await gen_obj.__anext__()
+                    except StopAsyncIteration:
+                        pass
+                    else:
+                        msg = "Async generator fixture didn't stop."
+                        msg += "Yield only once."
+                        raise ValueError(msg)
+
+                loop.run_until_complete(async_finalizer())
+
+            request.addfinalizer(finalizer)
+
+            return loop.run_until_complete(setup())
+
+        fixturedef.func = wrapper
+
+    elif inspect.iscoroutinefunction(fixturedef.func):
+        # Just a coroutine, not an async generator.
+        f = fixturedef.func
+
+        strip_event_loop = False
+        if 'event_loop' not in fixturedef.argnames:
+            fixturedef.argnames += ('event_loop', )
+            strip_event_loop = True
+
+        def wrapper(*args, **kwargs):
+            loop = kwargs['event_loop']
+            if strip_event_loop:
+                del kwargs['event_loop']
+
+            async def setup():
+                res = await f(*args, **kwargs)
+                return res
+
+            return loop.run_until_complete(setup())
+
+        fixturedef.func = wrapper
+
     outcome = yield
 
     if fixturedef.argname == "event_loop" and 'asyncio' in request.keywords:
         loop = outcome.get_result()
         for kw in _markers_2_fixtures.keys():
             if kw not in request.keywords:
                 continue
-            forbid_global_loop = (request.keywords[kw].kwargs
-                                  .get('forbid_global_loop', False))
-
             policy = asyncio.get_event_loop_policy()
-            if forbid_global_loop:
-                asyncio.set_event_loop_policy(ForbiddenEventLoopPolicy())
-                asyncio.get_child_watcher().attach_loop(loop)
-                fixturedef.addfinalizer(lambda: asyncio.set_event_loop_policy(policy))
-            else:
-                old_loop = policy.get_event_loop()
-                policy.set_event_loop(loop)
-                fixturedef.addfinalizer(lambda: policy.set_event_loop(old_loop))
-
-
-@asyncio.coroutine
-def initialize_async_fixtures(funcargs, testargs):
-    """
-    Get async generator fixtures first value, and await coroutine fixtures
-    """
-    for name, value in funcargs.items():
-        if name not in testargs:
-            continue
-        if sys.version_info >= (3, 6) and inspect.isasyncgen(value):
-            try:
-                testargs[name] = yield from value.__anext__()
-            except StopAsyncIteration:
-                raise RuntimeError("async generator didn't yield") from None
-        elif sys.version_info >= (3, 5) and inspect.iscoroutine(value):
-            testargs[name] = yield from value
-
-
-@asyncio.coroutine
-def finalize_async_fixtures(funcargs, testargs):
-    for name, value in funcargs.items():
-        if sys.version_info >= (3, 6) and inspect.isasyncgen(value):
-            try:
-                yield from value.__anext__()
-            except StopAsyncIteration:
-                continue
-            else:
-                raise RuntimeError("async generator didn't stop")
+            old_loop = policy.get_event_loop()
+            policy.set_event_loop(loop)
+            fixturedef.addfinalizer(lambda: policy.set_event_loop(old_loop))
 
 
 @pytest.mark.tryfirst
@@ -126,16 +144,8 @@ def pytest_pyfunc_call(pyfuncitem):
             testargs = {arg: funcargs[arg]
                         for arg in pyfuncitem._fixtureinfo.argnames}
 
-            @asyncio.coroutine
-            def func_executor(event_loop):
-                """Ensure that test function and async fixtures run in one loop"""
-                yield from initialize_async_fixtures(funcargs, testargs)
-                try:
-                    yield from asyncio.async(pyfuncitem.obj(**testargs), loop=event_loop)
-                finally:
-                    yield from finalize_async_fixtures(funcargs, testargs)
-
-            event_loop.run_until_complete(func_executor(event_loop))
+            event_loop.run_until_complete(
+                asyncio.async(pyfuncitem.obj(**testargs), loop=event_loop))
             return True
 
 

setup.py

@@ -35,18 +35,14 @@ def find_version(*file_paths):
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",
         "License :: OSI Approved :: Apache Software License",
-        "Programming Language :: Python :: 3.3",
-        "Programming Language :: Python :: 3.4",
         "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
         "Topic :: Software Development :: Testing",
         "Framework :: Pytest",
     ],
     install_requires=[
         'pytest >= 3.0.6',
     ],
-    extras_require={
-        ':python_version == "3.3"': ['asyncio']
-    },
     entry_points={
         'pytest11': ['asyncio = pytest_asyncio.plugin'],
     },

tests/async_fixtures/test_async_fixtures_35.py

@@ -23,19 +23,3 @@ async def test_async_fixture(async_fixture, mock):
     assert mock.call_count == 1
     assert mock.call_args_list[-1] == unittest.mock.call(START)
     assert async_fixture is RETVAL
-
-
-@pytest.fixture(scope='module')
-async def async_fixture_module_cope():
-    return await asyncio.sleep(0.1, result=RETVAL)
-
-
-@pytest.mark.asyncio
-async def test_async_fixture_module_cope1(async_fixture_module_cope):
-    assert async_fixture_module_cope is RETVAL
-
-
-@pytest.mark.asyncio
-@pytest.mark.xfail(reason='Only function scoped async fixtures are supported')
-async def test_async_fixture_module_cope2(async_fixture_module_cope):
-    assert async_fixture_module_cope is RETVAL

tests/async_fixtures/test_async_fixtures_scope.py

@@ -0,0 +1,24 @@
+"""
+We support module-scoped async fixtures, but only if the event loop is
+module-scoped too.
+"""
+import asyncio
+import pytest
+
+
+@pytest.fixture(scope='module')
+def event_loop():
+    """A module-scoped event loop."""
+    return asyncio.new_event_loop()
+
+
+@pytest.fixture(scope='module')
+async def async_fixture():
+    await asyncio.sleep(0.1)
+    return 1
+
+
+@pytest.mark.asyncio
+async def test_async_fixture_scope(async_fixture):
+    assert async_fixture == 1
+    await asyncio.sleep(0.1)

tests/async_fixtures/test_nested.py

@@ -0,0 +1,25 @@
+import asyncio
+import pytest
+
+
+@pytest.fixture()
+async def async_inner_fixture():
+    await asyncio.sleep(0.01)
+    print('inner start')
+    yield True
+    print('inner stop')
+
+
+@pytest.fixture()
+async def async_fixture_outer(async_inner_fixture, event_loop):
+    await asyncio.sleep(0.01)
+    print('outer start')
+    assert async_inner_fixture is True
+    yield True
+    print('outer stop')
+
+
+@pytest.mark.asyncio
+async def test_async_fixture(async_fixture_outer):
+    assert async_fixture_outer is True
+    print('test_async_fixture')