deprecate run_asyncio.

Author: smurfix

tests/aiotest/test_coroutine.py

@@ -1,4 +1,5 @@
 from tests import aiotest
+import trio_asyncio
 import pytest
 from .. import utils as test_utils
 
@@ -46,5 +47,22 @@ async def waiter(asyncio, hello_world, result):
             result.append(value)
 
         result = []
-        await loop.run_asyncio(waiter, config.asyncio, hello_world, result)
+        await trio_asyncio.aio_as_trio(waiter)(config.asyncio, hello_world, result)
+        assert result == ['Future', 'Hello', 'World', '.']
+
+    @pytest.mark.trio
+    async def test_waiter_depr(self, loop, config):
+        async def waiter(asyncio, hello_world, result):
+            fut = asyncio.Future(loop=loop)
+            loop.call_soon(fut.set_result, "Future")
+
+            value = await fut
+            result.append(value)
+
+            value = await hello_world(asyncio, result, 0.001, loop)
+            result.append(value)
+
+        result = []
+        with test_utils.deprecate(self):
+            await loop.run_asyncio(waiter, config.asyncio, hello_world, result)
         assert result == ['Future', 'Hello', 'World', '.']

tests/interop/test_adapter.py

@@ -7,7 +7,7 @@
 from tests import aiotest
 import sys
 from async_generator import asynccontextmanager
-
+from .. import utils as test_utils
 
 class SomeThing:
     flag = 0
@@ -70,7 +70,17 @@ async def test_asyncio_trio(self, loop):
         """Call asyncio from trio"""
 
         sth = SomeThing(loop)
-        res = await loop.run_asyncio(sth.dly_trio)
+        res = await aio_as_trio(sth.dly_trio, loop=loop)()
+        assert res == 8
+        assert sth.flag == 2
+
+    @pytest.mark.trio
+    async def test_asyncio_trio_depr(self, loop):
+        """Call asyncio from trio"""
+
+        sth = SomeThing(loop)
+        with test_utils.deprecate(self):
+            res = await loop.run_asyncio(sth.dly_trio)
         assert res == 8
         assert sth.flag == 2
 

tests/interop/test_calls.py

@@ -60,7 +60,12 @@ async def __aexit__(self, *tb):
 class TestCalls(aiotest.TestCase):
     async def call_t_a(self, proc, *args, loop=None):
         """called from Trio"""
-        return await loop.run_asyncio(proc, *args)
+        return await aio_as_trio(proc, loop=loop)(*args)
+
+    async def call_t_a_depr(self, proc, *args, loop=None):
+        """called from Trio"""
+        with test_utils.deprecate(self):
+            return await loop.run_asyncio(proc, *args)
 
     async def call_a_t(self, proc, *args, loop=None):
         """call from asyncio to an async trio function"""
@@ -78,7 +83,18 @@ async def delay(t):
             await done.wait()
 
         t = loop.time() + 0.1
-        await loop.run_asyncio(delay, t)
+        await aio_as_trio(delay, loop=loop)(t)
+
+    @pytest.mark.trio
+    async def test_call_at_depr(self, loop):
+        async def delay(t):
+            done = asyncio.Event(loop=loop)
+            loop.call_at(t, done.set)
+            await done.wait()
+
+        t = loop.time() + 0.1
+        with test_utils.deprecate(self):
+            await loop.run_asyncio(delay, t)
 
     @pytest.mark.trio
     async def test_asyncio_trio(self, loop):
@@ -90,14 +106,14 @@ async def dly_trio(seen):
             return 8
 
         seen = Seen()
-        res = await loop.run_asyncio(partial(self.call_a_t, loop=loop), dly_trio, seen)
+        res = await aio_as_trio(partial(self.call_a_t, loop=loop), 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 loop.run_asyncio(AioContext(self, loop)) as ctx:
+        async with aio_as_trio(AioContext(self, loop), loop=loop) as ctx:
             assert self.did_it == 2
             self.did_it = 3
         assert self.did_it == 4
@@ -111,7 +127,19 @@ async def _call_trio_ctx():
                 self.did_it = 3
             assert self.did_it == 4
 
-        await loop.run_asyncio(_call_trio_ctx)
+        await aio_as_trio(_call_trio_ctx, loop=loop)()
+
+    @pytest.mark.trio
+    async def test_call_trio_ctx_depr(self, loop):
+        async def _call_trio_ctx():
+            self.did_it = 0
+            async with loop.wrap_trio_context(TrioContext(self)) as ctx:
+                assert self.did_it == 2
+                self.did_it = 3
+            assert self.did_it == 4
+
+        with test_utils.deprecate(self):
+            await loop.run_asyncio(_call_trio_ctx)
 
     @pytest.mark.trio
     async def test_asyncio_trio_sync(self, loop):
@@ -122,7 +150,21 @@ def dly_trio(seen):
             return 8
 
         seen = Seen()
-        res = await loop.run_asyncio(partial(self.call_a_ts, loop=loop), dly_trio, seen)
+        res = await aio_as_trio(partial(self.call_a_ts, loop=loop), loop=loop)(dly_trio, seen)
+        assert res == 8
+        assert seen.flag == 2
+
+    @pytest.mark.trio
+    async def test_asyncio_trio_sync_depr(self, loop):
+        """Call asyncio from trio"""
+
+        def dly_trio(seen):
+            seen.flag |= 2
+            return 8
+
+        seen = Seen()
+        with test_utils.deprecate(self):
+            res = await loop.run_asyncio(partial(self.call_a_ts, loop=loop), dly_trio, seen)
         assert res == 8
         assert seen.flag == 2
 
@@ -138,14 +180,37 @@ async def dly_asyncio(seen):
         assert res == 4
         assert seen.flag == 1
 
+    @pytest.mark.trio
+    async def test_trio_asyncio_depr(self, loop):
+        async def dly_asyncio(seen):
+            await asyncio.sleep(0.01, loop=loop)
+            seen.flag |= 1
+            return 4
+
+        seen = Seen()
+        res = await self.call_t_a_depr(dly_asyncio, seen, loop=loop)
+        assert res == 4
+        assert seen.flag == 1
+
     @pytest.mark.trio
     async def test_asyncio_trio_error(self, loop):
         async def err_trio():
             await trio.sleep(0.01)
             raise RuntimeError("I has another owie")
 
         with pytest.raises(RuntimeError) as err:
-            await loop.run_asyncio(partial(self.call_a_t, loop=loop), err_trio)
+            await aio_as_trio(partial(self.call_a_t, loop=loop), loop=loop)(err_trio)
+        assert err.value.args[0] == "I has another owie"
+
+    @pytest.mark.trio
+    async def test_asyncio_trio_error_depr(self, loop):
+        async def err_trio():
+            await trio.sleep(0.01)
+            raise RuntimeError("I has another owie")
+
+        with pytest.raises(RuntimeError) as err:
+            with test_utils.deprecate(self):
+                await loop.run_asyncio(partial(self.call_a_t, loop=loop), err_trio)
         assert err.value.args[0] == "I has another owie"
 
     @pytest.mark.trio
@@ -155,7 +220,18 @@ def err_trio_sync():
             raise RuntimeError("I has more owie")
 
         with pytest.raises(RuntimeError) as err:
-            await loop.run_asyncio(partial(self.call_a_ts, loop=loop), err_trio_sync)
+            await aio_as_trio(partial(self.call_a_ts, loop=loop), loop=loop)(err_trio_sync)
+        assert err.value.args[0] == "I has more owie"
+
+    @pytest.mark.trio
+    async def test_asyncio_trio_sync_error_depr(self, loop):
+        def err_trio_sync():
+            loop.time()  # verify that the loop is running
+            raise RuntimeError("I has more owie")
+
+        with pytest.raises(RuntimeError) as err:
+            with test_utils.deprecate(self):
+                await loop.run_asyncio(partial(self.call_a_ts, loop=loop), err_trio_sync)
         assert err.value.args[0] == "I has more owie"
 
     @pytest.mark.trio
@@ -168,6 +244,16 @@ async def err_asyncio():
             await self.call_t_a(err_asyncio, loop=loop)
         assert err.value.args[0] == "I has an owie"
 
+    @pytest.mark.trio
+    async def test_trio_asyncio_error_depr(self, loop):
+        async def err_asyncio():
+            await asyncio.sleep(0.01, loop=loop)
+            raise RuntimeError("I has an owie")
+
+        with pytest.raises(RuntimeError) as err:
+            await self.call_t_a_depr(err_asyncio, loop=loop)
+        assert err.value.args[0] == "I has an owie"
+
     @pytest.mark.trio
     async def test_asyncio_trio_cancel_out(self, loop):
         async def cancelled_trio(seen):
@@ -181,7 +267,7 @@ async def cancelled_trio(seen):
 
         seen = Seen()
         with pytest.raises(asyncio.CancelledError):
-            await loop.run_asyncio(partial(self.call_a_t, loop=loop), cancelled_trio, seen)
+            await aio_as_trio(partial(self.call_a_t, loop=loop), loop=loop)(cancelled_trio, seen)
         assert seen.flag == 3
 
     @pytest.mark.trio
@@ -214,6 +300,36 @@ async def check_cancel(proc, seen):
         await check_cancel(cancelled_asyncio, seen)
         assert seen.flag == 1 | 4
 
+    @pytest.mark.trio
+    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)
+            f.cancel()
+            return f.result()  # raises error
+
+        def cancelled_future(seen):
+            seen.flag |= 1
+            f = asyncio.Future(loop=loop)
+            f.cancel()
+            return f  # contains error
+
+        async def check_cancel(proc, seen):
+            with trio.open_cancel_scope() as scope:
+                with pytest.raises(asyncio.CancelledError):
+                    await self.call_t_a_depr(proc, seen, loop=loop)
+            assert not scope.cancel_called
+            seen.flag |= 4
+
+        seen = Seen()
+        await check_cancel(cancelled_future, seen)
+        assert seen.flag == 1 | 4
+
+        seen = Seen()
+        await check_cancel(cancelled_asyncio, seen)
+        assert seen.flag == 1 | 4
+
     @pytest.mark.trio
     async def test_asyncio_trio_cancel_in(self, loop):
         async def in_trio(started, seen):
@@ -237,7 +353,7 @@ async def cancel_asyncio(seen):
             seen.flag |= 8
 
         seen = Seen()
-        await loop.run_asyncio(cancel_asyncio, seen)
+        await aio_as_trio(cancel_asyncio, loop=loop)(seen)
         assert seen.flag == 1 | 2 | 8
 
     @pytest.mark.trio
@@ -267,6 +383,33 @@ async def cancel_trio(seen):
         await cancel_trio(seen)
         assert seen.flag == 1 | 2 | 8
 
+    @pytest.mark.trio
+    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)
+            except asyncio.CancelledError:
+                seen.flag |= 1
+            except trio.Cancelled:
+                seen.flag |= 16
+            else:
+                seen.flag |= 4
+            finally:
+                seen.flag |= 2
+
+        async def cancel_trio(seen):
+            started = trio.Event()
+            async with trio.open_nursery() as nursery:
+                nursery.start_soon(partial(self.call_t_a_depr, loop=loop), in_asyncio, started, seen)
+                await started.wait()
+                nursery.cancel_scope.cancel()
+            seen.flag |= 8
+
+        seen = Seen()
+        await cancel_trio(seen)
+        assert seen.flag == 1 | 2 | 8
+
     @pytest.mark.trio
     async def test_trio_asyncio_cancel_direct(self, loop):
         def in_asyncio(started, seen):
@@ -291,6 +434,30 @@ async def cancel_trio(seen):
             await cancel_trio(seen)
         assert seen.flag == 1 | 8
 
+    @pytest.mark.trio
+    async def test_trio_asyncio_cancel_direct_depr(self, loop):
+        def in_asyncio(started, seen):
+            # This is intentionally not async
+            seen.flag |= 1
+            raise asyncio.CancelledError()
+
+        async def cancel_trio(seen):
+            started = trio.Event()
+            try:
+                async with trio.open_nursery() as nursery:
+                    nursery.start_soon(
+                        partial(self.call_t_a_depr, loop=loop), in_asyncio, started, seen
+                    )
+                    await started.wait()
+                    nursery.cancel_scope.cancel()
+            finally:
+                seen.flag |= 8
+
+        seen = Seen()
+        with pytest.raises(asyncio.CancelledError):
+            await cancel_trio(seen)
+        assert seen.flag == 1 | 8
+
     @pytest.mark.trio
     async def test_trio_asyncio_error_direct(self, loop):
         def err_asyncio():
@@ -301,6 +468,16 @@ def err_asyncio():
             await self.call_t_a(err_asyncio, loop=loop)
         assert err.value.args[0] == "I has an owie"
 
+    @pytest.mark.trio
+    async def test_trio_asyncio_error_direct_depr(self, loop):
+        def err_asyncio():
+            # This is intentionally not async
+            raise RuntimeError("I has an owie")
+
+        with pytest.raises(RuntimeError) as err:
+            await self.call_t_a_depr(err_asyncio, loop=loop)
+        assert err.value.args[0] == "I has an owie"
+
     @pytest.mark.trio
     async def test_trio_asyncio_generator(self, loop):
         async def dly_asyncio():
@@ -366,6 +543,6 @@ async def slow_nums():
 
         sum = 0
         # with test_utils.deprecate(self): ## not yet
-        async for n in loop.run_asyncio(slow_nums()):
+        async for n in aio_as_trio(slow_nums(), loop=loop):
             sum += n
         assert sum == 15