Type error when using contextlib.asynccontextmanager

I have 2 Python file foo.py and test_foo.py. foo.py:

from contextlib import asynccontextmanager
from typing import AsyncGenerator
class Foo:
    async def bar()->int:
        print("Calling func bar")
        return 1
    async def __aenter__(self):
        return self
    async def __aexit__(self, exc_type, exc, tb):
        return

@asynccontextmanager
async def get_cm() -> AsyncGenerator[Foo, None]:
        yield Foo()

async def call_bar()->int:
    async with get_cm() as foo:
        return await foo.bar()

test_foo.py:

from testslide.dsl import context
from foo import call_bar,Foo
from testslide import StrictMock

module = "foo"

@context
def foo_test(context):
    context.memoize(
        "foo_mock", lambda self: StrictMock(template=Foo, default_context_manager=True)
    )

    @context.before
    async def mock_get_cm(self):
        self.mock_callable(module, "get_cm").to_return_value(
            self.foo_mock
        )
        self.mock_async_callable(self.foo_mock, "bar").to_return_value(3)
    @context.example
    async def test_bar(self):
        self.assertEqual(await call_bar(),3)

When I ran testslide test_foo.py. I hit this type error below.

Failures:

  1) foo test: test bar
    1) TypeError: type of return must be collections.abc.AsyncGenerator; got testslide.strict_mock.FooStrictMock instead: <StrictMock 0x10612BF10 template=foo.Foo testslide_test.py:10>
    Defined at /Users/qxue/testslide_test.py:15
      File ".pyenv/versions/3.8.2/lib/python3.8/asyncio/runners.py", line 43, in run
        return loop.run_until_complete(main)
      File ".pyenv/versions/3.8.2/lib/python3.8/asyncio/base_events.py", line 616, in run_until_complete
        return future.result()
      File "testslide_test.py", line 21, in test_bar
        self.assertEqual(await call_bar(),3)
      File "foo.py", line 20, in call_bar
        async with get_cm() as foo:

[fornellas]

@xueqiao001 thanks for taking the time to report this.

When you declare:

@asynccontextmanager
async def get_cm() -> AsyncGenerator[Foo, None]:
        yield Foo()

You’re annotating that the resulting function after the @asynccontextmanager decorator returns a type of AsyncGenerator[Foo, None]. This is not true:

In [3]: import foo                                                                                                            

In [4]: foo.get_cm()                                                                                                          
Out[4]: <contextlib._AsyncGeneratorContextManager at 0x7fd9488a4d30>

In [5]: type(foo.get_cm())                                                                                                    
Out[5]: contextlib._AsyncGeneratorContextManager

In [6]: type(foo.get_cm()).mro()                                                                                              
Out[6]: 
[contextlib._AsyncGeneratorContextManager,
 contextlib._GeneratorContextManagerBase,
 contextlib.AbstractAsyncContextManager,
 abc.ABC,
 object]

It is confusing, because this is legit:

async def get_cm() -> AsyncGenerator[Foo, None]:
        yield Foo()

In [17]: get_cm()                                                                                                             
Out[17]: <async_generator object get_cm at 0x7fd948a5ae50>

In [18]: type(get_cm())                                                                                                       
Out[18]: async_generator

In [19]: type(get_cm()).mro()                                                                                                 
Out[19]: [async_generator, object]

By changing get_cm to the correct typing annotation:

@asynccontextmanager
async def get_cm() -> AsyncContextManager:
        yield Foo()

This test goes green.

I hope this helped. If I missed something, please re-open this issue.

[fornellas]

Python Upstream bug filed: https://bugs.python.org/issue41231.