[trio.from_thread]

Add back in some unit tests for the legacy `BlockingTrioPortal` to
ensure that the new `trio.from_thread` can handle being called from
`portal.run()` and `portal.run_sync()`.

Author: epellis

trio/_threads.py

@@ -8,7 +8,7 @@
 import trio
 
 from ._sync import CapacityLimiter
-from ._core import enable_ki_protection, disable_ki_protection, RunVar
+from ._core import enable_ki_protection, disable_ki_protection, RunVar, _entry_queue
 
 __all__ = [
     "run_sync_in_thread",
@@ -332,6 +332,9 @@ def _run_fn_as_system_task(cb, fn, *args, trio_token=None):
     raised exceptions canceling all tasks should be noted.
     """
 
+    if trio_token and not isinstance(trio_token, _entry_queue.TrioToken):
+        raise RuntimeError("Passed kwarg trio_token is not of type TrioToken")
+
     if not trio_token:
         try:
             trio_token = TOKEN_LOCAL.token
@@ -340,6 +343,10 @@ def _run_fn_as_system_task(cb, fn, *args, trio_token=None):
                 "this thread wasn't created by Trio, pass kwarg trio_token=..."
             )
 
+    # TODO: This is only necessary for compatibility with BlockingTrioPortal.
+    # once that is deprecated, this check should no longer be necessary because
+    # thread local storage (or the absence of) is sufficient to check if trio
+    # is running in a thread or not.
     try:
         trio.hazmat.current_task()
     except RuntimeError:

trio/tests/test_threads.py

@@ -515,3 +515,40 @@ async def test_from_thread_no_token():
 
     with pytest.raises(RuntimeError):
         run_sync(_core.current_time)
+
+
+def test_run_fn_as_system_task_catched_badly_typed_token():
+    with pytest.raises(RuntimeError):
+        run_sync(_core.current_time, trio_token="Not TrioTokentype")
+
+
+async def test_do_in_trio_thread_from_trio_thread():
+    # This check specifically confirms that a RuntimeError will be raised if
+    # the old BlockingTrIoPortal API calls into a trio loop while already
+    # running inside of one.
+    portal = BlockingTrioPortal()
+
+    with pytest.raises(RuntimeError):
+        portal.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():
+    # This tests the deprecated BlockingTrioPortal with a token passed in to
+    # confirm that both methods of making a portal are supported by
+    # trio.from_thread
+    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()