embarrassingly passing tests

Author: altendky

pytest_twisted.py

@@ -124,17 +124,22 @@ def init_twisted_greenlet():
         _config.external_reactor = True
 
 
-def stop_twisted_greenlet():
-    if _instances.gr_twisted:
-        _instances.reactor.stop()
-        _instances.gr_twisted.switch()
+# def stop_twisted_greenlet():
+#     if _instances.gr_twisted:
+#         _instances.reactor.stop()
+#         _instances.gr_twisted.switch()
 
 
 class _CoroutineWrapper:
     def __init__(self, coroutine, mark):
+        # TODO: really an async def now, maybe, if that worked out
         self.coroutine = coroutine
+        self.__name__ = self.coroutine.__name__ + 'ptcr'
         self.mark = mark
 
+    # def __call__(self):
+    #     print()
+
 
 def _marked_async_fixture(mark):
     @functools.wraps(pytest.fixture)
@@ -147,17 +152,28 @@ def fixture(*args, **kwargs):
         if scope != 'function':
             raise AsyncFixtureUnsupportedScopeError.from_scope(scope=scope)
 
+        # def marker(f):
+        #     @functools.wraps(f)
+        #     def w(*args, **kwargs):
+        #         return _CoroutineWrapper(
+        #             coroutine=f(*args, **kwargs),
+        #             mark=mark,
+        #         )
+        #
+        #     return w
+
         def marker(f):
-            @functools.wraps(f)
-            def w(*args, **kwargs):
-                return _CoroutineWrapper(
-                    coroutine=f(*args, **kwargs),
-                    mark=mark,
-                )
+            f._pytest_twisted_coroutine_wrapper = _CoroutineWrapper(
+                coroutine=f,
+                mark=mark,
+            )
 
-            return w
+            return f
 
         def decorator(f):
+            # result = pytest.fixture(*args, **kwargs)(
+            #     _CoroutineWrapper(coroutine=f, mark=mark),
+            # )
             result = pytest.fixture(*args, **kwargs)(marker(f))
 
             return result
@@ -171,55 +187,266 @@ def decorator(f):
 async_yield_fixture = _marked_async_fixture('async_yield_fixture')
 
 
+def pytest_fixture_setup(fixturedef, request):
+    maybe_wrapper = getattr(
+        fixturedef.func,
+        '_pytest_twisted_coroutine_wrapper',
+        None,
+    )
+    if not isinstance(maybe_wrapper, _CoroutineWrapper):
+        return None
+
+    if _instances.gr_twisted is not None:
+        if _instances.gr_twisted.dead:
+            raise RuntimeError("twisted reactor has stopped")
+
+        def in_reactor(d, f, *args):
+            return defer.maybeDeferred(f, *args).chainDeferred(d)
+
+        d = defer.Deferred()
+        _instances.reactor.callLater(
+            0.0, in_reactor, d, _pytest_fixture_setup, fixturedef, request, maybe_wrapper
+        )
+        result = blockon_default(d)
+    else:
+        if not _instances.reactor.running:
+            raise RuntimeError("twisted reactor is not running")
+        result = blockingCallFromThread(
+            _instances.reactor, _pytest_fixture_setup, fixturedef, request, maybe_wrapper
+        )
+    # return None
+    return result
+
+
+async_yield_fixture_cache = {}
+
+
 @defer.inlineCallbacks
-def _pytest_pyfunc_call(pyfuncitem):
-    testfunction = pyfuncitem.obj
+def _pytest_fixture_setup(fixturedef, request, wrapper):
+    # return None
+    #
+    # if not isinstance(fixturedef.func, _CoroutineWrapper):
+    #     return None
+
+    fixture_function = fixturedef.func
+
     async_generators = []
-    funcargs = pyfuncitem.funcargs
-    if hasattr(pyfuncitem, "_fixtureinfo"):
-        testargs = {}
-        for arg in pyfuncitem._fixtureinfo.argnames:
-            if isinstance(funcargs[arg], _CoroutineWrapper):
-                wrapper = funcargs[arg]
-
-                if wrapper.mark == 'async_fixture':
-                    arg_value = yield defer.ensureDeferred(
-                        wrapper.coroutine
-                    )
-                elif wrapper.mark == 'async_yield_fixture':
-                    async_generators.append((arg, wrapper))
-                    arg_value = yield defer.ensureDeferred(
-                        wrapper.coroutine.__anext__(),
-                    )
-                else:
-                    raise UnrecognizedCoroutineMarkError.from_mark(
-                        mark=wrapper.mark,
-                    )
-            else:
-                arg_value = funcargs[arg]
-
-            testargs[arg] = arg_value
+
+    kwargs = {
+        name: request.getfixturevalue(name)
+        for name in fixturedef.argnames
+    }
+
+    if wrapper.mark == 'async_fixture':
+        arg_value = yield defer.ensureDeferred(
+            fixture_function(**kwargs)
+        )
+    elif wrapper.mark == 'async_yield_fixture':
+        # async_generators.append((arg, wrapper))
+        coroutine = fixture_function(**kwargs)
+        # TODO: use request.addfinalizer() instead?
+        async_yield_fixture_cache[request.param_index] = coroutine
+        arg_value = yield defer.ensureDeferred(
+            coroutine.__anext__(),
+        )
     else:
-        testargs = funcargs
-    result = yield testfunction(**testargs)
+        raise UnrecognizedCoroutineMarkError.from_mark(
+            mark=wrapper.mark,
+        )
 
-    async_generator_deferreds = [
-        (arg, defer.ensureDeferred(g.coroutine.__anext__()))
-        for arg, g in reversed(async_generators)
-    ]
+    fixturedef.cached_result = (arg_value, request.param_index, None)
+
+    return arg_value
+
+    # async_generator_deferreds = [
+    #     (arg, defer.ensureDeferred(g.coroutine.__anext__()))
+    #     for arg, g in reversed(async_generators)
+    # ]
+    #
+    # for arg, d in async_generator_deferreds:
+    #     try:
+    #         yield d
+    #     except StopAsyncIteration:
+    #         continue
+    #     else:
+    #         raise AsyncGeneratorFixtureDidNotStopError.from_generator(
+    #             generator=arg,
+    #         )
+
+
+# @defer.inlineCallbacks
+# def _pytest_fixture_post_finalizer(fixturedef, request, coroutine):
+#     try:
+#         yield defer.ensureDeferred(
+#             coroutine.__anext__(),
+#         )
+#     except StopAsyncIteration:
+#         # TODO: i don't remember why this makes sense...
+#         pass
+#     else:
+#         raise AsyncGeneratorFixtureDidNotStopError.from_generator(
+#             generator=coroutine,
+#         )
+
+
+# TODO: but don't we want to do the finalizer?  not wait until post it?
+def pytest_fixture_post_finalizer(fixturedef, request):
+    maybe_coroutine = async_yield_fixture_cache.pop(request.param_index, None)
+
+    if maybe_coroutine is None:
+        return None
+
+    coroutine = maybe_coroutine
+
+    to_be_torn_down.append(defer.ensureDeferred(coroutine.__anext__()))
+    return None
+
+    # try:
+    #     if _instances.gr_twisted is not None:
+    #         if _instances.gr_twisted.dead:
+    #             raise RuntimeError("twisted reactor has stopped")
+    #
+    #         def in_reactor(d, f, *args):
+    #             return defer.maybeDeferred(f, *args).chainDeferred(d)
+    #
+    #         d = defer.Deferred()
+    #         _instances.reactor.callLater(
+    #             0.0, in_reactor, d, _pytest_fixture_post_finalizer, fixturedef, request, coroutine
+    #         )
+    #         result = blockon_default(d)
+    #     else:
+    #         if not _instances.reactor.running:
+    #             raise RuntimeError("twisted reactor is not running")
+    #         result = blockingCallFromThread(
+    #             _instances.reactor, _pytest_fixture_post_finalizer, fixturedef, request, coroutine
+    #         )
+    # except StopAsyncIteration as e:
+    #     print(e)
+    #
+    # # async_yield_fixture_cache.pop(request.param_index)
+    #
+    # # return None
+    return result
 
-    for arg, d in async_generator_deferreds:
-        try:
-            yield d
-        except StopAsyncIteration:
-            continue
+
+@defer.inlineCallbacks
+def tear_it_down(deferred):
+    try:
+        yield deferred
+    except StopAsyncIteration:
+        return
+    except Exception as e:
+        e = e
+    else:
+        e = None
+
+    raise AsyncGeneratorFixtureDidNotStopError.from_generator(
+        generator=deferred,
+    )
+
+
+to_be_torn_down = []
+
+# TODO: https://docs.pytest.org/en/latest/reference.html#_pytest.hookspec.pytest_runtest_protocol
+#       claims it should also take a nextItem but that triggers a direct error
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_teardown(item):
+    yield
+
+    # deferreds = []
+    #
+    # while len(to_be_torn_down) > 0:
+    #     coroutine = to_be_torn_down.pop(0)
+    #     deferreds.append(defer.ensureDeferred(coroutine.__anext__()))
+    #
+    # for deferred in deferreds:
+    while len(to_be_torn_down) > 0:
+        deferred = to_be_torn_down.pop(0)
+        if _instances.gr_twisted is not None:
+            if _instances.gr_twisted.dead:
+                raise RuntimeError("twisted reactor has stopped")
+
+            def in_reactor(d, f, *args):
+                # return f.chainDeferred(d)
+                return defer.maybeDeferred(f, *args).chainDeferred(d)
+
+            d = defer.Deferred()
+            _instances.reactor.callLater(
+                0.0, in_reactor, d, tear_it_down, deferred
+            )
+            blockon_default(d)
+            # blockon_default(tear_it_down(deferred))
         else:
-            raise AsyncGeneratorFixtureDidNotStopError.from_generator(
-                generator=arg,
+            if not _instances.reactor.running:
+                raise RuntimeError("twisted reactor is not running")
+            blockingCallFromThread(
+                _instances.reactor, tear_it_down, deferred,
             )
+            # blockingCallFromThread(
+            #     _instances.reactor, tear_it_down, deferred
+            # )
+
+    return None
+
 
+@defer.inlineCallbacks
+def _pytest_pyfunc_call(pyfuncitem):
+    kwargs = {name: value for name, value in pyfuncitem.funcargs.items() if name in pyfuncitem._fixtureinfo.argnames}
+    result = yield pyfuncitem.obj(**kwargs)
     defer.returnValue(result)
 
+    return
+    # print()
+    #
+    # testfunction = pyfuncitem.obj
+    # async_generators = []
+    # funcargs = pyfuncitem.funcargs
+    # if hasattr(pyfuncitem, "_fixtureinfo"):
+    #     testargs = {}
+    #     for arg in pyfuncitem._fixtureinfo.argnames:
+    #         if isinstance(funcargs[arg], _CoroutineWrapper):
+    #             wrapper = funcargs[arg]
+    #
+    #             if wrapper.mark == 'async_fixture':
+    #                 arg_value = yield defer.ensureDeferred(
+    #                     wrapper.coroutine
+    #                 )
+    #             elif wrapper.mark == 'async_yield_fixture':
+    #                 async_generators.append((arg, wrapper))
+    #                 arg_value = yield defer.ensureDeferred(
+    #                     wrapper.coroutine.__anext__(),
+    #                 )
+    #             else:
+    #                 raise UnrecognizedCoroutineMarkError.from_mark(
+    #                     mark=wrapper.mark,
+    #                 )
+    #         else:
+    #             arg_value = funcargs[arg]
+    #
+    #         testargs[arg] = arg_value
+    # else:
+    #     testargs = funcargs
+    # result = yield testfunction(**testargs)
+    #
+    # async_generator_deferreds = [
+    #     (arg, defer.ensureDeferred(g.coroutine.__anext__()))
+    #     for arg, g in reversed(async_generators)
+    # ]
+    #
+    # for arg, d in async_generator_deferreds:
+    #     try:
+    #         yield d
+    #     except StopAsyncIteration:
+    #         continue
+    #     else:
+    #         raise AsyncGeneratorFixtureDidNotStopError.from_generator(
+    #             generator=arg,
+    #         )
+    #
+    # defer.returnValue(result)
+
 
 def pytest_pyfunc_call(pyfuncitem):
     if _instances.gr_twisted is not None:
@@ -243,9 +470,10 @@ def in_reactor(d, f, *args):
     return True
 
 
+# TODO: switch to some plugin callback to guarantee order before other fixtures?
 @pytest.fixture(scope="session", autouse=True)
 def twisted_greenlet(request):
-    request.addfinalizer(stop_twisted_greenlet)
+    # request.addfinalizer(stop_twisted_greenlet)
     return _instances.gr_twisted