tests: Stop passing loop explicitly in tests

In 3.8 a lot of asyncio functions have their `loop` parameter
deprecated.  So we change the semantics of uvloop tests to never
pass the loop explicitly (unless to Future objects, when necessary)

That means that we now also need to set up asyncio/uvloop loop policies
for tests in setUp hooks.

Author: 1st1

tests/test_base.py

@@ -27,7 +27,7 @@ def test_close(self):
         self.loop.close()
 
         # operation blocked when the loop is closed
-        f = asyncio.Future(loop=self.loop)
+        f = asyncio.Future()
         self.assertRaises(RuntimeError, self.loop.run_forever)
         self.assertRaises(RuntimeError, self.loop.run_until_complete, f)
 
@@ -99,7 +99,7 @@ def cb():
 
             meth(cb)
             self.assertIsNone(context)
-            self.loop.run_until_complete(asyncio.sleep(0.05, loop=self.loop))
+            self.loop.run_until_complete(asyncio.sleep(0.05))
 
             self.assertIs(type(context['exception']), ZeroDivisionError)
             self.assertTrue(context['message'].startswith(
@@ -167,9 +167,9 @@ def test_call_later_2(self):
         # libuv cached time.
 
         async def main():
-            await asyncio.sleep(0.001, loop=self.loop)
+            await asyncio.sleep(0.001)
             time.sleep(0.01)
-            await asyncio.sleep(0.01, loop=self.loop)
+            await asyncio.sleep(0.01)
 
         started = time.monotonic()
         self.loop.run_until_complete(main())
@@ -331,7 +331,7 @@ def test_run_until_complete_type_error(self):
             TypeError, self.loop.run_until_complete, 'blah')
 
     def test_run_until_complete_loop(self):
-        task = asyncio.Future(loop=self.loop)
+        task = asyncio.Future()
         other_loop = self.new_loop()
         self.addCleanup(other_loop.close)
         self.assertRaises(
@@ -351,7 +351,7 @@ class ShowStopper(BaseException):
             pass
 
         async def foo(delay):
-            await asyncio.sleep(delay, loop=self.loop)
+            await asyncio.sleep(delay)
 
         def throw():
             raise ShowStopper
@@ -373,7 +373,7 @@ def test_debug_slow_callbacks(self):
         self.loop.call_soon(lambda: time.sleep(0.3))
 
         with mock.patch.object(logger, 'warning') as log:
-            self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop))
+            self.loop.run_until_complete(asyncio.sleep(0))
 
         self.assertEqual(log.call_count, 1)
         # format message
@@ -389,7 +389,7 @@ def test_debug_slow_timer_callbacks(self):
         self.loop.call_later(0.01, lambda: time.sleep(0.3))
 
         with mock.patch.object(logger, 'warning') as log:
-            self.loop.run_until_complete(asyncio.sleep(0.02, loop=self.loop))
+            self.loop.run_until_complete(asyncio.sleep(0.02))
 
         self.assertEqual(log.call_count, 1)
         # format message
@@ -429,7 +429,7 @@ def zero_error(fut):
 
         # Test call_soon (events.Handle)
         with mock.patch.object(logger, 'error') as log:
-            fut = asyncio.Future(loop=self.loop)
+            fut = asyncio.Future()
             self.loop.call_soon(zero_error, fut)
             fut.add_done_callback(lambda fut: self.loop.stop())
             self.loop.run_forever()
@@ -439,7 +439,7 @@ def zero_error(fut):
 
         # Test call_later (events.TimerHandle)
         with mock.patch.object(logger, 'error') as log:
-            fut = asyncio.Future(loop=self.loop)
+            fut = asyncio.Future()
             self.loop.call_later(0.01, zero_error, fut)
             fut.add_done_callback(lambda fut: self.loop.stop())
             self.loop.run_forever()
@@ -562,31 +562,34 @@ def test_shutdown_asyncgens_01(self):
             raise unittest.SkipTest()
 
         waiter = self._compile_agen(
-            '''async def waiter(timeout, finalized, loop):
+            '''async def waiter(timeout, finalized):
                 try:
-                    await asyncio.sleep(timeout, loop=loop)
+                    await asyncio.sleep(timeout)
                     yield 1
                 finally:
-                    await asyncio.sleep(0, loop=loop)
+                    await asyncio.sleep(0)
                     finalized.append(1)
             ''')
 
         async def wait():
-            async for _ in waiter(1, finalized, self.loop):
+            async for _ in waiter(1, finalized):
                 pass
 
         t1 = self.loop.create_task(wait())
         t2 = self.loop.create_task(wait())
 
-        self.loop.run_until_complete(asyncio.sleep(0.1, loop=self.loop))
+        self.loop.run_until_complete(asyncio.sleep(0.1))
 
+        t1.cancel()
+        t2.cancel()
         self.loop.run_until_complete(self.loop.shutdown_asyncgens())
         self.assertEqual(finalized, [1, 1])
 
-        # Silence warnings
-        t1.cancel()
-        t2.cancel()
-        self.loop.run_until_complete(asyncio.sleep(0.1, loop=self.loop))
+        for t in {t1, t2}:
+            try:
+                self.loop.run_until_complete(t)
+            except asyncio.CancelledError:
+                pass
 
     def test_shutdown_asyncgens_02(self):
         if not hasattr(self.loop, 'shutdown_asyncgens'):
@@ -601,20 +604,20 @@ def logger(loop, context):
             if expected in context['message']:
                 logged += 1
 
-        waiter = self._compile_agen('''async def waiter(timeout, loop):
+        waiter = self._compile_agen('''async def waiter(timeout):
             try:
-                await asyncio.sleep(timeout, loop=loop)
+                await asyncio.sleep(timeout)
                 yield 1
             finally:
                 1 / 0
         ''')
 
         async def wait():
-            async for _ in waiter(1, self.loop):
+            async for _ in waiter(1):
                 pass
 
         t = self.loop.create_task(wait())
-        self.loop.run_until_complete(asyncio.sleep(0.1, loop=self.loop))
+        self.loop.run_until_complete(asyncio.sleep(0.1))
 
         self.loop.set_exception_handler(logger)
         self.loop.run_until_complete(self.loop.shutdown_asyncgens())
@@ -623,7 +626,7 @@ async def wait():
 
         # Silence warnings
         t.cancel()
-        self.loop.run_until_complete(asyncio.sleep(0.1, loop=self.loop))
+        self.loop.run_until_complete(asyncio.sleep(0.1))
 
     def test_shutdown_asyncgens_03(self):
         if not hasattr(self.loop, 'shutdown_asyncgens'):
@@ -640,14 +643,14 @@ async def foo():
             await waiter().asend(None)
 
         self.loop.run_until_complete(foo())
-        self.loop.run_until_complete(asyncio.sleep(0.01, loop=self.loop))
+        self.loop.run_until_complete(asyncio.sleep(0.01))
 
     def test_inf_wait_for(self):
         async def foo():
-            await asyncio.sleep(0.1, loop=self.loop)
+            await asyncio.sleep(0.1)
             return 123
         res = self.loop.run_until_complete(
-            asyncio.wait_for(foo(), timeout=float('inf'), loop=self.loop))
+            asyncio.wait_for(foo(), timeout=float('inf')))
         self.assertEqual(res, 123)
 
 

tests/test_context.py

@@ -19,14 +19,13 @@ async def fractions(t, precision, x, y):
             with decimal.localcontext() as ctx:
                 ctx.prec = precision
                 a = decimal.Decimal(x) / decimal.Decimal(y)
-                await asyncio.sleep(t, loop=self.loop)
+                await asyncio.sleep(t)
                 b = decimal.Decimal(x) / decimal.Decimal(y ** 2)
                 return a, b
 
         async def main():
             r1, r2 = await asyncio.gather(
-                fractions(0.1, 3, 1, 3), fractions(0.2, 6, 1, 3),
-                loop=self.loop)
+                fractions(0.1, 3, 1, 3), fractions(0.2, 6, 1, 3))
 
             return r1, r2
 
@@ -44,7 +43,7 @@ def test_task_context_1(self):
         cvar = contextvars.ContextVar('cvar', default='nope')
 
         async def sub():
-            await asyncio.sleep(0.01, loop=self.loop)
+            await asyncio.sleep(0.01)
             self.assertEqual(cvar.get(), 'nope')
             cvar.set('something else')
 
@@ -83,7 +82,7 @@ def fut_on_done(fut):
                 for i in range(3):
                     # Test that task passed its context to add_done_callback:
                     cvar.set('yes{}-{}'.format(i, j))
-                    await asyncio.sleep(0.001, loop=self.loop)
+                    await asyncio.sleep(0.001)
                     self.assertEqual(cvar.get(), 'yes{}-{}'.format(i, j))
 
         task = self.loop.create_task(main())
@@ -101,8 +100,7 @@ def test_task_context_3(self):
         async def sub(num):
             for i in range(10):
                 cvar.set(num + i)
-                await asyncio.sleep(
-                    random.uniform(0.001, 0.05), loop=self.loop)
+                await asyncio.sleep(random.uniform(0.001, 0.05))
                 self.assertEqual(cvar.get(), num + i)
 
         async def main():
@@ -111,8 +109,7 @@ async def main():
                 task = self.loop.create_task(sub(random.randint(0, 10)))
                 tasks.append(task)
 
-            await asyncio.gather(
-                *tasks, loop=self.loop, return_exceptions=True)
+            await asyncio.gather(*tasks, return_exceptions=True)
 
         self.loop.run_until_complete(main())
 
@@ -134,7 +131,7 @@ async def sub():
 
         async def main():
             await self.loop.create_task(sub())
-            await asyncio.sleep(0.01, loop=self.loop)
+            await asyncio.sleep(0.01)
 
         task = self.loop.create_task(main())
         self.loop.run_until_complete(task)

tests/test_cython.py

@@ -16,7 +16,7 @@ def test_cython_coro_is_coroutine(self):
         self.assertEqual(_test_coroutine_1.__qualname__, '_test_coroutine_1')
         self.assertEqual(_test_coroutine_1.__name__, '_test_coroutine_1')
         self.assertTrue(asyncio.iscoroutine(coro))
-        fut = asyncio.ensure_future(coro, loop=self.loop)
+        fut = asyncio.ensure_future(coro)
         self.assertTrue(isinstance(fut, asyncio.Future))
         self.assertTrue(isinstance(fut, asyncio.Task))
         fut.cancel()

tests/test_dealloc.py

@@ -50,8 +50,7 @@ def main():
             proc = await asyncio.create_subprocess_exec(
                 cmd, b'-W', b'ignore', b'-c', prog,
                 stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                loop=self.loop)
+                stderr=subprocess.PIPE)
 
             await proc.wait()
             out = await proc.stdout.read()

tests/test_dns.py

@@ -168,7 +168,7 @@ def test_getaddrinfo_close_loop(self):
         async def run():
             fut = self.loop.create_task(
                 self.loop.getaddrinfo('example.com', 80))
-            await asyncio.sleep(0, loop=self.loop)
+            await asyncio.sleep(0)
             fut.cancel()
             self.loop.stop()
 

tests/test_executors.py

@@ -19,9 +19,9 @@ async def run():
                 coros = []
                 for i in range(0, 10):
                     coros.append(self.loop.run_in_executor(pool, fib, i))
-                res = await asyncio.gather(*coros, loop=self.loop)
+                res = await asyncio.gather(*coros)
             self.assertEqual(res, fib10)
-            await asyncio.sleep(0.01, loop=self.loop)
+            await asyncio.sleep(0.01)
 
         fib10 = [fib(i) for i in range(10)]
         self.loop.run_until_complete(run())