test: add sync test variants and make DisposableStub a context manager

Author: Skn0tt

playwright/_impl/_browser_context.py

@@ -438,7 +438,9 @@ async def route(
             ),
         )
         await self._update_interception_patterns()
-        return DisposableStub(lambda: self.unroute(url, handler))
+        return DisposableStub(
+            lambda: self.unroute(url, handler), self._loop, self._dispatcher_fiber
+        )
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None

playwright/_impl/_disposable.py

@@ -12,10 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
+import inspect
+import traceback
+from asyncio import AbstractEventLoop
 from typing import Awaitable, Callable, Dict
 
+import greenlet
+
 from playwright._impl._connection import ChannelOwner
-from playwright._impl._errors import is_target_closed_error
+from playwright._impl._errors import Error, is_target_closed_error
 
 
 class Disposable(ChannelOwner):
@@ -42,8 +48,15 @@ def __repr__(self) -> str:
 
 
 class DisposableStub:
-    def __init__(self, dispose_fn: Callable[[], Awaitable[None]]) -> None:
+    def __init__(
+        self,
+        dispose_fn: Callable[[], Awaitable[None]],
+        loop: AbstractEventLoop,
+        dispatcher_fiber: object,
+    ) -> None:
         self._dispose_fn = dispose_fn
+        self._loop = loop
+        self._dispatcher_fiber = dispatcher_fiber
 
     async def dispose(self) -> None:
         await self._dispose_fn()
@@ -54,6 +67,25 @@ async def __aenter__(self) -> "DisposableStub":
     async def __aexit__(self, *args: object) -> None:
         await self.dispose()
 
+    def __enter__(self) -> "DisposableStub":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self._sync(self.dispose())
+
+    def _sync(self, coro: object) -> object:
+        if self._loop.is_closed():
+            raise Error("Event loop is closed! Is Playwright already stopped?")
+        g_self = greenlet.getcurrent()
+        task = self._loop.create_task(coro)  # type: ignore
+        setattr(task, "__pw_stack__", inspect.stack(0))
+        setattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10))
+        task.add_done_callback(lambda _: g_self.switch())
+        while not task.done():
+            self._dispatcher_fiber.switch()  # type: ignore
+        asyncio._set_running_loop(self._loop)
+        return task.result()
+
     async def close(self) -> None:
         await self.dispose()
 

playwright/_impl/_page.py

@@ -690,7 +690,9 @@ async def route(
             ),
         )
         await self._update_interception_patterns()
-        return DisposableStub(lambda: self.unroute(url, handler))
+        return DisposableStub(
+            lambda: self.unroute(url, handler), self._loop, self._dispatcher_fiber
+        )
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None

playwright/_impl/_screencast.py

@@ -36,6 +36,7 @@ class Screencast:
     def __init__(self, page: "Page") -> None:
         self._page = page
         self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
         self._started = False
         self._save_path: Optional[Union[str, Path]] = None
         self._on_frame: Optional[Callable[[ScreencastFrame], None]] = None
@@ -70,7 +71,7 @@ async def start(
             self._artifact = from_channel(result)
             self._save_path = path
 
-        return DisposableStub(lambda: self.stop())
+        return DisposableStub(lambda: self.stop(), self._loop, self._dispatcher_fiber)
 
     async def stop(self) -> None:
         self._started = False
@@ -94,7 +95,9 @@ async def show_actions(
             None,
             {"duration": duration, "position": position, "fontSize": fontSize},
         )
-        return DisposableStub(lambda: self.hide_actions())
+        return DisposableStub(
+            lambda: self.hide_actions(), self._loop, self._dispatcher_fiber
+        )
 
     async def hide_actions(self) -> None:
         await self._page._channel.send("screencastHideActions", None)
@@ -111,7 +114,9 @@ async def show_overlay(self, html: str, duration: float = None) -> DisposableStu
                 "screencastRemoveOverlay",
                 None,
                 {"id": overlay_id},
-            )
+            ),
+            self._loop,
+            self._dispatcher_fiber,
         )
 
     async def show_chapter(

playwright/_impl/_tracing.py

@@ -144,7 +144,9 @@ async def group(
         self, name: str, location: TracingGroupLocation = None
     ) -> DisposableStub:
         await self._channel.send("tracingGroup", None, locals_to_params(locals()))
-        return DisposableStub(lambda: self.group_end())
+        return DisposableStub(
+            lambda: self.group_end(), self._loop, self._dispatcher_fiber
+        )
 
     async def group_end(self) -> None:
         await self._channel.send(

tests/async/test_debugger.py

@@ -34,8 +34,10 @@ async def test_should_pause_at_next_and_resume(
     await dbg.request_pause()
 
     paused_event = asyncio.Event()
+    handler_called = [0]
 
     def on_paused_state_changed() -> None:
+        handler_called[0] += 1
         if dbg.paused_details is not None:
             assert "Click" in dbg.paused_details["title"]
             paused_event.set()
@@ -47,6 +49,7 @@ def on_paused_state_changed() -> None:
     await asyncio.wait_for(paused_event.wait(), timeout=10)
     await asyncio.wait_for(click_task, timeout=10)
     assert dbg.paused_details is None
+    assert handler_called[0] > 0
 
 
 async def test_should_step_with_next(page: Page, context: BrowserContext) -> None:
@@ -57,8 +60,10 @@ async def test_should_step_with_next(page: Page, context: BrowserContext) -> Non
     await dbg.request_pause()
 
     first_pause_seen = [False]
+    handler_called = [0]
 
     def on_paused_state_changed() -> None:
+        handler_called[0] += 1
         if dbg.paused_details is not None and not first_pause_seen[0]:
             assert "Click" in dbg.paused_details["title"]
             first_pause_seen[0] = True
@@ -71,6 +76,7 @@ def on_paused_state_changed() -> None:
     click_task = asyncio.ensure_future(page.click("div"))
     await asyncio.wait_for(click_task, timeout=10)
     assert dbg.paused_details is None
+    assert handler_called[0] > 0
 
 
 async def test_should_pause_at_pause_call(page: Page, context: BrowserContext) -> None:
@@ -81,8 +87,10 @@ async def test_should_pause_at_pause_call(page: Page, context: BrowserContext) -
     await dbg.request_pause()
 
     paused_event = asyncio.Event()
+    handler_called = [0]
 
     def on_paused_state_changed() -> None:
+        handler_called[0] += 1
         if dbg.paused_details is not None:
             assert "Pause" in dbg.paused_details["title"]
             paused_event.set()
@@ -94,3 +102,4 @@ def on_paused_state_changed() -> None:
     await asyncio.wait_for(paused_event.wait(), timeout=10)
     await asyncio.wait_for(pause_task, timeout=10)
     assert dbg.paused_details is None
+    assert handler_called[0] > 0

tests/sync/test_browser_bind.py

@@ -0,0 +1,31 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.sync_api import Browser
+
+
+def test_should_bind_and_unbind_browser(browser: Browser) -> None:
+    server_info = browser.bind("default")
+    try:
+        assert isinstance(server_info["endpoint"], str)
+    finally:
+        browser.unbind()
+
+
+def test_should_bind_with_custom_host_and_port(browser: Browser) -> None:
+    server_info = browser.bind("my-title", host="127.0.0.1", port=0)
+    try:
+        assert isinstance(server_info["endpoint"], str)
+    finally:
+        browser.unbind()

tests/sync/test_debugger.py

@@ -0,0 +1,92 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from playwright.sync_api import BrowserContext, Page
+
+
+def test_should_return_none_paused_details_initially(
+    context: BrowserContext,
+) -> None:
+    dbg = context.debugger
+    assert dbg.paused_details is None
+
+
+def test_should_pause_at_next_and_resume(page: Page, context: BrowserContext) -> None:
+    page.set_content("<div>click me</div>")
+    dbg = context.debugger
+    assert dbg.paused_details is None
+
+    dbg.request_pause()
+
+    handler_called = [0]
+
+    def on_paused_state_changed() -> None:
+        handler_called[0] += 1
+        if dbg.paused_details is not None:
+            assert "Click" in dbg.paused_details["title"]
+            dbg.resume()
+
+    dbg.on("pausedstatechanged", on_paused_state_changed)
+
+    page.click("div")
+    assert dbg.paused_details is None
+    assert handler_called[0] > 0
+
+
+def test_should_step_with_next(page: Page, context: BrowserContext) -> None:
+    page.set_content("<div>click me</div>")
+    dbg = context.debugger
+    assert dbg.paused_details is None
+
+    dbg.request_pause()
+
+    first_pause_seen = [False]
+    handler_called = [0]
+
+    def on_paused_state_changed() -> None:
+        handler_called[0] += 1
+        if dbg.paused_details is not None and not first_pause_seen[0]:
+            assert "Click" in dbg.paused_details["title"]
+            first_pause_seen[0] = True
+            dbg.next()
+        elif dbg.paused_details is not None and first_pause_seen[0]:
+            dbg.resume()
+
+    dbg.on("pausedstatechanged", on_paused_state_changed)
+
+    page.click("div")
+    assert dbg.paused_details is None
+    assert handler_called[0] > 0
+
+
+def test_should_pause_at_pause_call(page: Page, context: BrowserContext) -> None:
+    page.set_content("<div>click me</div>")
+    dbg = context.debugger
+    assert dbg.paused_details is None
+
+    dbg.request_pause()
+
+    handler_called = [0]
+
+    def on_paused_state_changed() -> None:
+        handler_called[0] += 1
+        if dbg.paused_details is not None:
+            assert "Pause" in dbg.paused_details["title"]
+            dbg.resume()
+
+    dbg.on("pausedstatechanged", on_paused_state_changed)
+
+    page.pause()
+    assert dbg.paused_details is None
+    assert handler_called[0] > 0