rev2

Author: mxschmitt

playwright/_impl/_connection.py

@@ -124,22 +124,7 @@ class ProtocolCallback:
     def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
         self.stack_trace: traceback.StackSummary = traceback.StackSummary()
         self.future = loop.create_future()
-        # The outer task can get cancelled by the user, this forwards the cancellation to the inner task.
-        current_task = asyncio.current_task()
-
-        def cb(task: asyncio.Task) -> None:
-            if current_task:
-                current_task.remove_done_callback(cb)
-            if task.cancelled():
-                self.future.cancel()
-
-        if current_task:
-            current_task.add_done_callback(cb)
-            self.future.add_done_callback(
-                lambda _: current_task.remove_done_callback(cb)
-                if current_task
-                else None
-            )
+        self.current_task = asyncio.current_task()
 
 
 class RootChannelOwner(ChannelOwner):
@@ -251,7 +236,9 @@ def dispatch(self, msg: ParsedMessagePayload) -> None:
         id = msg.get("id")
         if id:
             callback = self._callbacks.pop(id)
-            if callback.future.cancelled():
+            if (
+                callback.current_task and callback.current_task.cancelled()
+            ) or callback.future.cancelled():
                 return
             error = msg.get("error")
             if error:

tests/async/test_asyncio.py

@@ -12,33 +12,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import asyncio
-import contextlib
+import gc
+from typing import Dict
+
+import pytest
 
 from playwright.async_api import async_playwright
 
 
-def test_should_cancel_underlying_calls(browser_name: str):
+async def test_should_cancel_underlying_protocol_calls(
+    browser_name: str, launch_arguments: Dict
+):
     handler_exception = None
 
-    async def main():
-        loop = asyncio.get_running_loop()
+    def exception_handlerdler(loop, context) -> None:
+        nonlocal handler_exception
+        handler_exception = context["exception"]
 
-        def handler(loop, context):
-            nonlocal handler_exception
-            handler_exception = context["exception"]
+    asyncio.get_running_loop().set_exception_handler(exception_handlerdler)
 
-        async with async_playwright() as p:
-            loop.set_exception_handler(handler)
-            browser = await p[browser_name].launch()
-            page = await browser.new_page()
-            task = asyncio.create_task(page.wait_for_selector("will-never-find"))
-            # make sure that the wait_for_selector message was sent to the server (driver)
-            await asyncio.sleep(1)
-            task.cancel()
-            with contextlib.suppress(asyncio.CancelledError):
-                await task
-            await browser.close()
+    async with async_playwright() as p:
+        browser = await p[browser_name].launch(**launch_arguments)
+        page = await browser.new_page()
+        task = asyncio.create_task(page.wait_for_selector("will-never-find"))
+        # make sure that the wait_for_selector message was sent to the server (driver)
+        await asyncio.sleep(0.1)
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await task
+        await browser.close()
 
-    asyncio.run(main())
+    # The actual 'Future exception was never retrieved' is logged inside the Future destructor (__del__).
+    gc.collect()
 
     assert handler_exception is None
+
+    asyncio.get_running_loop().set_exception_handler(None)