Fix hang-on-close tests

We do this by
* running the queue until there are no more queued tasks.
* excavating the task from the handle it's queued in and cancelling that
  when the handle is cancelled.

Author: smurfix

tests/test_misc.py

@@ -282,36 +282,39 @@ async def cancel_sleep():
 
 @pytest.mark.trio
 async def test_wrong_context_manager_order():
+    take_down = trio.Event()
     async def work_in_asyncio():
         await asyncio.sleep(0)
 
     async def runner(*, task_status=trio.TASK_STATUS_IGNORED):
-        await trio_asyncio.run_asyncio(work_in_asyncio)
+        await trio_asyncio.aio_as_trio(work_in_asyncio)()
         try:
             task_status.started()
-            await trio.sleep_forever()
+            await take_down.wait()
         finally:
-            await trio_asyncio.run_asyncio(work_in_asyncio)
+            await trio_asyncio.aio_as_trio(work_in_asyncio)()
 
     async with trio.open_nursery() as nursery:
         async with trio_asyncio.open_loop():
             await nursery.start(runner)
+            take_down.set()
 
 
 @pytest.mark.trio
 async def test_keyboard_interrupt_teardown():
     asyncio_loop_closed = trio.Event()
 
     async def work_in_trio_no_matter_what(*, task_status=trio.TASK_STATUS_IGNORED):
-        await trio_asyncio.run_asyncio(work_in_asyncio)
+        await trio_asyncio.aio_as_trio(work_in_asyncio)()
         try:
             # KeyboardInterrupt won't cancel this coroutine thanks to the shield
             with trio.open_cancel_scope(shield=True):
                 task_status.started()
                 await asyncio_loop_closed.wait()
         finally:
             # Hence this call will be exceuted after run_asyncio_loop is cancelled
-            await trio_asyncio.run_asyncio(work_in_asyncio)
+            with pytest.raises(RuntimeError):
+                await trio_asyncio.aio_as_trio(work_in_asyncio)()
 
     async def work_in_asyncio():
         await asyncio.sleep(0)
@@ -331,7 +334,8 @@ async def run_asyncio_loop(nursery, *, task_status=trio.TASK_STATUS_IGNORED):
     import signal
     import threading
     with pytest.raises(KeyboardInterrupt):
-        async with trio.open_nursery() as nursery:
-            await nursery.start(run_asyncio_loop, nursery)
-            # Trigger KeyboardInterrupt that should propagate accross the coroutines
-            signal.pthread_kill(threading.get_ident(), signal.SIGINT)
+        with pytest.warns(RuntimeWarning):
+            async with trio.open_nursery() as nursery:
+                await nursery.start(run_asyncio_loop, nursery)
+                # Trigger KeyboardInterrupt that should propagate accross the coroutines
+                signal.pthread_kill(threading.get_ident(), signal.SIGINT)

trio_asyncio/async_.py

@@ -123,8 +123,11 @@ def _main_loop_exit(self):
             try:
                 await loop.stop().wait()
             finally:
-                await loop._main_loop_exit()
-                loop.close()
-                nursery.cancel_scope.cancel()
-                current_loop.reset(old_loop)
-                current_policy.reset(old_policy)
+                try:
+                    await loop._main_loop_exit()
+                finally:
+                    loop.close()
+                    nursery.cancel_scope.cancel()
+                    current_loop.reset(old_loop)
+                    current_policy.reset(old_policy)
+

trio_asyncio/base.py

@@ -782,6 +782,12 @@ async def _main_loop_exit(self):
         self.stop()
         await self.wait_stopped()
 
+        while True:
+            try:
+                await self._main_loop_one(no_wait=True)
+            except trio.WouldBlock:
+                break
+
         # Kill off unprocessed work
         self._cancel_fds()
         self._cancel_timers()

trio_asyncio/handles.py

@@ -46,9 +46,18 @@ def _init(self, is_sync):
         self._scope = None
 
     def cancel(self):
+        try:
+            task = self._callback.__self__
+        except AttributeError:
+            task = None
+        else:
+            if not isinstance(task, asyncio.Task):
+                task = None
         super().cancel()
         if self._scope is not None:
             self._scope.cancel()
+        elif task is not None:
+            task.cancel()
 
     def _cb_future_cancel(self, f):
         """If a Trio task completes an asyncio Future,