[trio.from_thread]

Migrate all uses of `BlockingTrioPortal` in `test_thread.py` to use
`trio.from_thread.*` API instead.

Author: epellis

trio/tests/test_threads.py

@@ -17,13 +17,13 @@
 async def test_do_in_trio_thread():
     trio_thread = threading.current_thread()
 
-    async def check_case(do_in_trio_thread, fn, expected):
+    async def check_case(do_in_trio_thread, fn, expected, trio_token=None):
         record = []
 
         def threadfn():
             try:
                 record.append(("start", threading.current_thread()))
-                x = do_in_trio_thread(fn, record)
+                x = do_in_trio_thread(fn, record, trio_token=trio_token)
                 record.append(("got", x))
             except BaseException as exc:
                 print(exc)
@@ -38,63 +38,48 @@ def threadfn():
             ("start", child_thread), ("f", trio_thread), expected
         ]
 
-    portal = BlockingTrioPortal()
+    token = _core.current_trio_token()
 
     def f(record):
         assert not _core.currently_ki_protected()
         record.append(("f", threading.current_thread()))
         return 2
 
-    await check_case(portal.run_sync, f, ("got", 2))
+    await check_case(run_sync, f, ("got", 2), trio_token=token)
 
     def f(record):
         assert not _core.currently_ki_protected()
         record.append(("f", threading.current_thread()))
         raise ValueError
 
-    await check_case(portal.run_sync, f, ("error", ValueError))
+    await check_case(run_sync, f, ("error", ValueError), trio_token=token)
 
     async def f(record):
         assert not _core.currently_ki_protected()
         await _core.checkpoint()
         record.append(("f", threading.current_thread()))
         return 3
 
-    await check_case(portal.run, f, ("got", 3))
+    await check_case(run, f, ("got", 3), trio_token=token)
 
     async def f(record):
         assert not _core.currently_ki_protected()
         await _core.checkpoint()
         record.append(("f", threading.current_thread()))
         raise KeyError
 
-    await check_case(portal.run, f, ("error", KeyError))
+    await check_case(run, f, ("error", KeyError), trio_token=token)
 
 
 async def test_do_in_trio_thread_from_trio_thread():
-    portal = BlockingTrioPortal()
-
     with pytest.raises(RuntimeError):
-        portal.run_sync(lambda: None)  # pragma: no branch
+        run_sync(lambda: None)  # pragma: no branch
 
     async def foo():  # pragma: no cover
         pass
 
     with pytest.raises(RuntimeError):
-        portal.run(foo)
-
-
-async def test_BlockingTrioPortal_with_explicit_TrioToken():
-    token = _core.current_trio_token()
-
-    def worker_thread(token):
-        with pytest.raises(RuntimeError):
-            BlockingTrioPortal()
-        portal = BlockingTrioPortal(token)
-        return portal.run_sync(threading.current_thread)
-
-    t = await run_sync_in_thread(worker_thread, token)
-    assert t == threading.current_thread()
+        run(foo)
 
 
 def test_run_in_trio_thread_ki():
@@ -103,7 +88,7 @@ def test_run_in_trio_thread_ki():
     record = set()
 
     async def check_run_in_trio_thread():
-        portal = BlockingTrioPortal()
+        token = _core.current_trio_token()
 
         def trio_thread_fn():
             print("in Trio thread")
@@ -121,12 +106,12 @@ async def trio_thread_afn():
         def external_thread_fn():
             try:
                 print("running")
-                portal.run_sync(trio_thread_fn)
+                run_sync(trio_thread_fn, trio_token=token)
             except KeyboardInterrupt:
                 print("ok1")
                 record.add("ok1")
             try:
-                portal.run(trio_thread_afn)
+                run(trio_thread_afn, trio_token=token)
             except KeyboardInterrupt:
                 print("ok2")
                 record.add("ok2")
@@ -153,15 +138,15 @@ async def trio_fn():
         ev.set()
         await _core.wait_task_rescheduled(lambda _: _core.Abort.SUCCEEDED)
 
-    def thread_fn(portal):
+    def thread_fn(token):
         try:
-            portal.run(trio_fn)
+            run(trio_fn, trio_token=token)
         except _core.Cancelled:
             record.append("cancelled")
 
     async def main():
-        portal = BlockingTrioPortal()
-        thread = threading.Thread(target=thread_fn, args=(portal,))
+        token = _core.current_trio_token()
+        thread = threading.Thread(target=thread_fn, args=(token,))
         thread.start()
         await ev.wait()
         assert record == ["sleeping"]
@@ -323,11 +308,11 @@ class state:
         state.running = 0
         state.parked = 0
 
-        portal = BlockingTrioPortal()
+        token = _core.current_trio_token()
 
         def thread_fn(cancel_scope):
             print("thread_fn start")
-            portal.run_sync(cancel_scope.cancel)
+            run_sync(cancel_scope.cancel, trio_token=token)
             with lock:
                 state.ran += 1
                 state.running += 1