First stab at fixing the tests

Author: smurfix

setup.py

@@ -77,7 +77,7 @@
     python_requires=">=3.6",  # temporary, for RTD
     keywords=["async", "io", "trio", "asyncio", "trio-asyncio"],
     setup_requires=['pytest-runner'],
-    tests_require=['pytest', 'outcome'],
+    tests_require=['pytest >= 5.4', 'outcome'],
     classifiers=[
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",

tests/aiotest/test_callback.py

@@ -45,8 +45,7 @@ async def test_close(self, loop, config):
         await loop.stop().wait()
         loop.close()
 
-        @config.asyncio.coroutine
-        def test():
+        async def test():
             pass
 
         func = lambda: False

tests/aiotest/test_coroutine.py

@@ -7,7 +7,7 @@
 async def hello_world(asyncio, result, delay, loop):
     result.append("Hello")
     # retrieve the event loop from the policy
-    await asyncio.sleep(delay, loop=loop)
+    await asyncio.sleep(delay)
     result.append('World')
     return "."
 

tests/interop/test_adapter.py

@@ -57,33 +57,33 @@ async def dly_trio_depr(self):
     async def dly_asyncio_depr(self):
         if sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.flag |= 1
         return 4
 
     @aio_as_trio
     async def dly_asyncio_adapted(self):
         if sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.flag |= 1
         return 4
 
     async def dly_asyncio(self, do_test=True):
         if do_test and sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.flag |= 1
         return 4
 
     async def iter_asyncio(self, do_test=True):
         if do_test and sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         yield 1
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         yield 2
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.flag |= 1
 
     async def iter_trio(self):
@@ -98,10 +98,10 @@ async def iter_trio(self):
 
     @asynccontextmanager
     async def ctx_asyncio(self):
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.flag |= 1
         yield self
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.flag |= 2
 
     @asynccontextmanager

tests/interop/test_calls.py

@@ -48,7 +48,7 @@ async def __aenter__(self):
         self.parent.did_it = 1
         if sys.version_info >= (3, 7):
             assert sniffio.current_async_library() == "asyncio"
-        await asyncio.sleep(0.01, loop=self.loop)
+        await asyncio.sleep(0.01)
         self.parent.did_it = 2
         return self
 
@@ -60,7 +60,7 @@ async def __aexit__(self, *tb):
 class TestCalls(aiotest.TestCase):
     async def call_t_a(self, proc, *args, loop=None):
         """called from Trio"""
-        return await aio_as_trio(proc, loop=loop)(*args)
+        return await aio_as_trio(proc)(*args)
 
     async def call_t_a_depr(self, proc, *args, loop=None):
         """called from Trio"""
@@ -69,7 +69,7 @@ async def call_t_a_depr(self, proc, *args, loop=None):
 
     async def call_a_t(self, proc, *args, loop=None):
         """call from asyncio to an async trio function"""
-        return await trio_as_aio(proc, loop=loop)(*args)
+        return await trio_as_aio(proc)(*args)
 
     async def call_a_t_depr(self, proc, *args, loop=None):
         """call from asyncio to an async trio function"""
@@ -83,17 +83,17 @@ async def call_a_ts(self, proc, *args, loop=None):
     @pytest.mark.trio
     async def test_call_at(self, loop):
         async def delay(t):
-            done = asyncio.Event(loop=loop)
+            done = asyncio.Event()
             loop.call_at(t, done.set)
             await done.wait()
 
         t = loop.time() + 0.1
-        await aio_as_trio(delay, loop=loop)(t)
+        await aio_as_trio(delay)(t)
 
     @pytest.mark.trio
     async def test_call_at_depr(self, loop):
         async def delay(t):
-            done = asyncio.Event(loop=loop)
+            done = asyncio.Event()
             loop.call_at(t, done.set)
             await done.wait()
 
@@ -111,7 +111,7 @@ async def dly_trio(seen):
             return 8
 
         seen = Seen()
-        res = await aio_as_trio(partial(self.call_a_t, loop=loop), loop=loop)(dly_trio, seen)
+        res = await aio_as_trio(partial(self.call_a_t, loop=loop))(dly_trio, seen)
         assert res == 8
         assert seen.flag == 2
 
@@ -125,14 +125,14 @@ async def dly_trio(seen):
             return 8
 
         seen = Seen()
-        res = await aio_as_trio(partial(self.call_a_t_depr, loop=loop), loop=loop)(dly_trio, seen)
+        res = await aio_as_trio(partial(self.call_a_t_depr, loop=loop))(dly_trio, seen)
         assert res == 8
         assert seen.flag == 2
 
     @pytest.mark.trio
     async def test_call_asyncio_ctx(self, loop):
         self.did_it = 0
-        async with aio_as_trio(AioContext(self, loop), loop=loop) as ctx:
+        async with aio_as_trio(AioContext(self, loop)) as ctx:
             assert ctx.parent is self
             assert self.did_it == 2
             self.did_it = 3
@@ -148,7 +148,7 @@ async def _call_trio_ctx():
                 self.did_it = 3
             assert self.did_it == 4
 
-        await aio_as_trio(_call_trio_ctx, loop=loop)()
+        await aio_as_trio(_call_trio_ctx)()
 
     @pytest.mark.trio
     async def test_call_trio_ctx_depr(self, loop):
@@ -172,7 +172,7 @@ def dly_trio(seen):
             return 8
 
         seen = Seen()
-        res = await aio_as_trio(partial(self.call_a_ts, loop=loop), loop=loop)(dly_trio, seen)
+        res = await aio_as_trio(partial(self.call_a_ts, loop=loop))(dly_trio, seen)
         assert res == 8
         assert seen.flag == 2
 
@@ -193,7 +193,7 @@ def dly_trio(seen):
     @pytest.mark.trio
     async def test_trio_asyncio(self, loop):
         async def dly_asyncio(seen):
-            await asyncio.sleep(0.01, loop=loop)
+            await asyncio.sleep(0.01)
             seen.flag |= 1
             return 4
 
@@ -205,7 +205,7 @@ async def dly_asyncio(seen):
     @pytest.mark.trio
     async def test_trio_asyncio_depr(self, loop):
         async def dly_asyncio(seen):
-            await asyncio.sleep(0.01, loop=loop)
+            await asyncio.sleep(0.01)
             seen.flag |= 1
             return 4
 
@@ -221,7 +221,7 @@ async def err_trio():
             raise RuntimeError("I has another owie")
 
         with pytest.raises(RuntimeError) as err:
-            await aio_as_trio(partial(self.call_a_t, loop=loop), loop=loop)(err_trio)
+            await aio_as_trio(partial(self.call_a_t, loop=loop))(err_trio)
         assert err.value.args[0] == "I has another owie"
 
     @pytest.mark.trio
@@ -231,7 +231,7 @@ async def err_trio():
             raise RuntimeError("I has another owie")
 
         with pytest.raises(RuntimeError) as err:
-            await aio_as_trio(partial(self.call_a_t_depr, loop=loop), loop=loop)(err_trio)
+            await aio_as_trio(partial(self.call_a_t_depr, loop=loop))(err_trio)
         assert err.value.args[0] == "I has another owie"
 
     @pytest.mark.trio
@@ -253,7 +253,8 @@ async def err_trio():
 
         with pytest.raises(RuntimeError) as err:
             with test_utils.deprecate(self):
-                await loop.run_asyncio(partial(self.call_a_t_depr, loop=loop), err_trio)
+                await loop.run_asyncio(partial(self.call_a_t_depr,
+                    loop=loop), err_trio)
         assert err.value.args[0] == "I has another owie"
 
     @pytest.mark.trio
@@ -263,7 +264,7 @@ def err_trio_sync():
             raise RuntimeError("I has more owie")
 
         with pytest.raises(RuntimeError) as err:
-            await aio_as_trio(partial(self.call_a_ts, loop=loop), loop=loop)(err_trio_sync)
+            await aio_as_trio(partial(self.call_a_ts, loop=loop))(err_trio_sync)
         assert err.value.args[0] == "I has more owie"
 
     @pytest.mark.trio
@@ -280,7 +281,7 @@ def err_trio_sync():
     @pytest.mark.trio
     async def test_trio_asyncio_error(self, loop):
         async def err_asyncio():
-            await asyncio.sleep(0.01, loop=loop)
+            await asyncio.sleep(0.01)
             raise RuntimeError("I has an owie")
 
         with pytest.raises(RuntimeError) as err:
@@ -290,7 +291,7 @@ async def err_asyncio():
     @pytest.mark.trio
     async def test_trio_asyncio_error_depr(self, loop):
         async def err_asyncio():
-            await asyncio.sleep(0.01, loop=loop)
+            await asyncio.sleep(0.01)
             raise RuntimeError("I has an owie")
 
         with pytest.raises(RuntimeError) as err:
@@ -310,21 +311,21 @@ async def cancelled_trio(seen):
 
         seen = Seen()
         with pytest.raises(asyncio.CancelledError):
-            await aio_as_trio(partial(self.call_a_t, loop=loop), loop=loop)(cancelled_trio, seen)
+            await aio_as_trio(partial(self.call_a_t, loop=loop))(cancelled_trio, seen)
         assert seen.flag == 3
 
     @pytest.mark.trio
     async def test_trio_asyncio_cancel_out(self, loop):
         async def cancelled_asyncio(seen):
             seen.flag |= 1
-            await asyncio.sleep(0.01, loop=loop)
-            f = asyncio.Future(loop=loop)
+            await asyncio.sleep(0.01)
+            f = asyncio.Future()
             f.cancel()
             return f.result()  # raises error
 
         def cancelled_future(seen):
             seen.flag |= 1
-            f = asyncio.Future(loop=loop)
+            f = asyncio.Future()
             f.cancel()
             return f  # contains error
 
@@ -347,14 +348,14 @@ async def check_cancel(proc, seen):
     async def test_trio_asyncio_cancel_out_depr(self, loop):
         async def cancelled_asyncio(seen):
             seen.flag |= 1
-            await asyncio.sleep(0.01, loop=loop)
-            f = asyncio.Future(loop=loop)
+            await asyncio.sleep(0.01)
+            f = asyncio.Future()
             f.cancel()
             return f.result()  # raises error
 
         def cancelled_future(seen):
             seen.flag |= 1
-            f = asyncio.Future(loop=loop)
+            f = asyncio.Future()
             f.cancel()
             return f  # contains error
 
@@ -387,7 +388,7 @@ async def in_trio(started, seen):
                 seen.flag |= 2
 
         async def cancel_asyncio(seen):
-            started = asyncio.Event(loop=loop)
+            started = asyncio.Event()
             f = asyncio.ensure_future(self.call_a_t(in_trio, started, seen, loop=loop))
             await started.wait()
             f.cancel()
@@ -396,15 +397,15 @@ async def cancel_asyncio(seen):
             seen.flag |= 8
 
         seen = Seen()
-        await aio_as_trio(cancel_asyncio, loop=loop)(seen)
+        await aio_as_trio(cancel_asyncio)(seen)
         assert seen.flag == 1 | 2 | 8
 
     @pytest.mark.trio
     async def test_trio_asyncio_cancel_in(self, loop):
         async def in_asyncio(started, seen):
             started.set()
             try:
-                await asyncio.sleep(9999, loop=loop)
+                await asyncio.sleep(9999)
             except asyncio.CancelledError:
                 seen.flag |= 1
             except trio.Cancelled:
@@ -431,7 +432,7 @@ async def test_trio_asyncio_cancel_in_depr(self, loop):
         async def in_asyncio(started, seen):
             started.set()
             try:
-                await asyncio.sleep(9999, loop=loop)
+                await asyncio.sleep(9999)
             except asyncio.CancelledError:
                 seen.flag |= 1
             except trio.Cancelled:
@@ -527,7 +528,7 @@ def err_asyncio():
     async def test_trio_asyncio_generator(self, loop):
         async def dly_asyncio():
             yield 1
-            await asyncio.sleep(0.01, loop=loop)
+            await asyncio.sleep(0.01)
             yield 2
 
         with test_utils.deprecate(self):
@@ -557,7 +558,7 @@ async def cancel_soon(nursery):
             await trio.sleep(0.01)
             nursery.cancel_scope.cancel()
 
-        hold = asyncio.Event(loop=loop)
+        hold = asyncio.Event()
         seen = Seen()
 
         with test_utils.deprecate(self):
@@ -571,7 +572,7 @@ async def cancel_soon(nursery):
     async def test_trio_asyncio_iterator(self, loop):
         async def slow_nums():
             for n in range(1, 6):
-                await asyncio.sleep(0.01, loop=loop)
+                await asyncio.sleep(0.01)
                 yield n
 
         sum = 0
@@ -583,13 +584,11 @@ async def slow_nums():
     async def test_trio_asyncio_iterator_depr(self, loop):
         async def slow_nums():
             for n in range(1, 6):
-                await asyncio.sleep(0.01, loop=loop)
+                await asyncio.sleep(0.01)
                 yield n
 
         sum = 0
         # with test_utils.deprecate(self): ## not yet
-        async for n in aio_as_trio(
-            slow_nums(), loop=loop
-        ):
+        async for n in aio_as_trio(slow_nums()):
             sum += n
         assert sum == 15

tests/test_aio_subprocess.py

@@ -20,12 +20,12 @@ class MySubprocessProtocol(asyncio.SubprocessProtocol):
     def __init__(self, loop):
         self.state = 'INITIAL'
         self.transport = None
-        self.connected = asyncio.Future(loop=loop)
-        self.completed = asyncio.Future(loop=loop)
-        self.disconnects = {fd: asyncio.Future(loop=loop) for fd in range(3)}
+        self.connected = asyncio.Future()
+        self.completed = asyncio.Future()
+        self.disconnects = {fd: asyncio.Future() for fd in range(3)}
         self.data = {1: b'', 2: b''}
         self.returncode = None
-        self.got_data = {1: asyncio.Event(loop=loop), 2: asyncio.Event(loop=loop)}
+        self.got_data = {1: asyncio.Event(), 2: asyncio.Event()}
 
     def connection_made(self, transport):
         self.transport = transport