Core roll changes

Author: agg23

playwright/_impl/_assertions.py

@@ -20,6 +20,7 @@
     AriaRole,
     ExpectedTextValue,
     FrameExpectOptions,
+    FrameExpectResult,
 )
 from playwright._impl._connection import format_call_log
 from playwright._impl._errors import Error
@@ -45,6 +46,13 @@ def __init__(
         self._is_not = is_not
         self._custom_message = message
 
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        raise NotImplementedError(
+            "_call_expect must be implemented in a derived class."
+        )
+
     async def _expect_impl(
         self,
         expression: str,
@@ -61,7 +69,7 @@ async def _expect_impl(
             message = message.replace("expected to", "expected not to")
         if "useInnerText" in expect_options and expect_options["useInnerText"] is None:
             del expect_options["useInnerText"]
-        result = await self._actual_locator._expect(expression, expect_options, title)
+        result = await self._call_expect(expression, expect_options, title)
         if result["matches"] == self._is_not:
             actual = result.get("received")
             if self._custom_message:
@@ -88,6 +96,14 @@ def __init__(
         super().__init__(page.locator(":root"), timeout, is_not, message)
         self._actual_page = page
 
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        __tracebackhide__ = True
+        return await self._actual_page.main_frame._expect(
+            None, expression, expect_options, title
+        )
+
     @property
     def _not(self) -> "PageAssertions":
         return PageAssertions(
@@ -122,7 +138,7 @@ async def to_have_url(
         ignoreCase: bool = None,
     ) -> None:
         __tracebackhide__ = True
-        base_url = self._actual_page.context._options.get("baseURL")
+        base_url = self._actual_page.context.base_url
         if isinstance(urlOrRegExp, str) and base_url:
             urlOrRegExp = urljoin(base_url, urlOrRegExp)
         expected_text = to_expected_text_values([urlOrRegExp], ignoreCase=ignoreCase)
@@ -155,6 +171,12 @@ def __init__(
         super().__init__(locator, timeout, is_not, message)
         self._actual_locator = locator
 
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        __tracebackhide__ = True
+        return await self._actual_locator._expect(expression, expect_options, title)
+
     @property
     def _not(self) -> "LocatorAssertions":
         return LocatorAssertions(

playwright/_impl/_browser_context.py

@@ -119,6 +119,7 @@ def __init__(
         self._options: Dict[str, Any] = initializer["options"]
         self._background_pages: Set[Page] = set()
         self._service_workers: Set[Worker] = set()
+        self._base_url: Optional[str] = self._options.get("baseURL")
         self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
         self._har_recorders: Dict[str, HarRecordingMetadata] = {}
         self._request: APIRequestContext = from_channel(initializer["requestContext"])
@@ -302,6 +303,14 @@ def pages(self) -> List[Page]:
     def browser(self) -> Optional["Browser"]:
         return self._browser
 
+    @property
+    def base_url(self) -> Optional[str]:
+        return self._base_url
+
+    @property
+    def videos_dir(self) -> Optional[str]:
+        return self._options.get("recordVideo")
+
     async def _initialize_har_from_options(
         self,
         record_har_path: Optional[Union[Path, str]],
@@ -426,7 +435,7 @@ async def route(
         self._routes.insert(
             0,
             RouteHandler(
-                self._options.get("baseURL"),
+                self._base_url,
                 url,
                 handler,
                 True if self._dispatcher_fiber else False,
@@ -454,17 +463,16 @@ async def _unroute_internal(
         behavior: Literal["default", "ignoreErrors", "wait"] = None,
     ) -> None:
         self._routes = remaining
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
         await self._update_interception_patterns()
-        if behavior is None or behavior == "default":
-            return
-        await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
 
     async def route_web_socket(
         self, url: URLMatch, handler: WebSocketRouteHandlerCallback
     ) -> None:
         self._web_socket_routes.insert(
             0,
-            WebSocketRouteHandler(self._options.get("baseURL"), url, handler),
+            WebSocketRouteHandler(self._base_url, url, handler),
         )
         await self._update_web_socket_interception_patterns()
 

playwright/_impl/_frame.py

@@ -30,7 +30,13 @@
 
 from pyee import EventEmitter
 
-from playwright._impl._api_structures import AriaRole, FilePayload, Position
+from playwright._impl._api_structures import (
+    AriaRole,
+    FilePayload,
+    FrameExpectOptions,
+    FrameExpectResult,
+    Position,
+)
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
@@ -56,6 +62,7 @@
     Serializable,
     add_source_url_to_script,
     parse_result,
+    parse_value,
     serialize_argument,
 )
 from playwright._impl._locator import (
@@ -170,6 +177,29 @@ def _setup_navigation_waiter(self, wait_name: str, timeout: float = None) -> Wai
         waiter.reject_on_timeout(timeout, f"Timeout {timeout}ms exceeded.")
         return waiter
 
+    async def _expect(
+        self,
+        selector: Optional[str],
+        expression: str,
+        options: FrameExpectOptions,
+        title: str = None,
+    ) -> FrameExpectResult:
+        if "expectedValue" in options:
+            options["expectedValue"] = serialize_argument(options["expectedValue"])
+        result = await self._channel.send_return_as_dict(
+            "expect",
+            self._timeout,
+            {
+                "selector": selector,
+                "expression": expression,
+                **options,
+            },
+            title=title,
+        )
+        if result.get("received"):
+            result["received"] = parse_value(result["received"])
+        return result
+
     def expect_navigation(
         self,
         url: URLMatch = None,
@@ -194,7 +224,7 @@ def predicate(event: Any) -> bool:
                 return True
             waiter.log(f'  navigated to "{event["url"]}"')
             return url_matches(
-                cast("Page", self._page)._browser_context._options.get("baseURL"),
+                cast("Page", self._page)._browser_context.base_url,
                 event["url"],
                 url,
             )
@@ -227,9 +257,7 @@ async def wait_for_url(
         timeout: float = None,
     ) -> None:
         assert self._page
-        if url_matches(
-            self._page._browser_context._options.get("baseURL"), self.url, url
-        ):
+        if url_matches(self._page._browser_context.base_url, self.url, url):
             await self._wait_for_load_state_impl(state=waitUntil, timeout=timeout)
             return
         async with self.expect_navigation(
@@ -801,7 +829,7 @@ async def uncheck(
         await self._channel.send("uncheck", self._timeout, locals_to_params(locals()))
 
     async def wait_for_timeout(self, timeout: float) -> None:
-        await self._channel.send("waitForTimeout", None, locals_to_params(locals()))
+        await self._channel.send("waitForTimeout", None, {"waitTimeout": timeout})
 
     async def wait_for_function(
         self,

playwright/_impl/_helper.py

@@ -189,6 +189,16 @@ def map_token(original: str, replacement: str) -> str:
 
     # Escaped `\\?` behaves the same as `?` in our glob patterns.
     match = match.replace(r"\\?", "?")
+    # Special case about: URLs as they are not relative to base_url
+    if (
+        match.startswith("about:")
+        or match.startswith("data:")
+        or match.startswith("chrome:")
+        or match.startswith("edge:")
+        or match.startswith("file:")
+    ):
+        # about: and data: URLs are not relative to base_url, so we return them as is.
+        return match
     # Glob symbols may be escaped in the URL and some of them such as ? affect resolution,
     # so we replace them with safe components first.
     processed_parts = []

playwright/_impl/_locator.py

@@ -47,7 +47,7 @@
     monotonic_time,
     to_impl,
 )
-from playwright._impl._js_handle import Serializable, parse_value, serialize_argument
+from playwright._impl._js_handle import Serializable
 from playwright._impl._str_utils import (
     escape_for_attribute_selector,
     escape_for_text_selector,
@@ -722,21 +722,7 @@ async def _expect(
         options: FrameExpectOptions,
         title: str = None,
     ) -> FrameExpectResult:
-        if "expectedValue" in options:
-            options["expectedValue"] = serialize_argument(options["expectedValue"])
-        result = await self._frame._channel.send_return_as_dict(
-            "expect",
-            self._frame._timeout,
-            {
-                "selector": self._selector,
-                "expression": expression,
-                **options,
-            },
-            title=title,
-        )
-        if result.get("received"):
-            result["received"] = parse_value(result["received"])
-        return result
+        return await self._frame._expect(self._selector, expression, options, title)
 
     async def highlight(self) -> None:
         await self._frame._highlight(self._selector)

playwright/_impl/_network.py

@@ -733,10 +733,13 @@ async def _after_handle(self) -> None:
         if self._connected:
             return
         # Ensure that websocket is "open" and can send messages without an actual server connection.
-        await self._channel.send(
-            "ensureOpened",
-            None,
-        )
+        try:
+            await self._channel.send(
+                "ensureOpened",
+                None,
+            )
+        except Exception:
+            pass
 
 
 class WebSocketRouteHandler:

playwright/_impl/_page.py

@@ -388,9 +388,7 @@ def frame(self, name: str = None, url: URLMatch = None) -> Optional[Frame]:
         for frame in self._frames:
             if name and frame.name == name:
                 return frame
-            if url and url_matches(
-                self._browser_context._options.get("baseURL"), frame.url, url
-            ):
+            if url and url_matches(self._browser_context.base_url, frame.url, url):
                 return frame
 
         return None
@@ -682,7 +680,7 @@ async def route(
         self._routes.insert(
             0,
             RouteHandler(
-                self._browser_context._options.get("baseURL"),
+                self._browser_context.base_url,
                 url,
                 handler,
                 True if self._dispatcher_fiber else False,
@@ -710,24 +708,21 @@ async def _unroute_internal(
         behavior: Literal["default", "ignoreErrors", "wait"] = None,
     ) -> None:
         self._routes = remaining
-        await self._update_interception_patterns()
-        if behavior is None or behavior == "default":
-            return
-        await asyncio.gather(
-            *map(
-                lambda route: route.stop(behavior),  # type: ignore
-                removed,
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(
+                *map(
+                    lambda route: route.stop(behavior),  # type: ignore
+                    removed,
+                )
             )
-        )
+        await self._update_interception_patterns()
 
     async def route_web_socket(
         self, url: URLMatch, handler: WebSocketRouteHandlerCallback
     ) -> None:
         self._web_socket_routes.insert(
             0,
-            WebSocketRouteHandler(
-                self._browser_context._options.get("baseURL"), url, handler
-            ),
+            WebSocketRouteHandler(self._browser_context.base_url, url, handler),
         )
         await self._update_web_socket_interception_patterns()
 
@@ -1186,7 +1181,7 @@ def video(
         # Note: we are creating Video object lazily, because we do not know
         # BrowserContextOptions when constructing the page - it is assigned
         # too late during launchPersistentContext.
-        if not self._browser_context._options.get("recordVideo"):
+        if not self._browser_context.videos_dir:
             return None
         return self._force_video()
 
@@ -1273,7 +1268,7 @@ def expect_request(
         def my_predicate(request: Request) -> bool:
             if not callable(urlOrPredicate):
                 return url_matches(
-                    self._browser_context._options.get("baseURL"),
+                    self._browser_context.base_url,
                     request.url,
                     urlOrPredicate,
                 )
@@ -1305,7 +1300,7 @@ def expect_response(
         def my_predicate(request: Response) -> bool:
             if not callable(urlOrPredicate):
                 return url_matches(
-                    self._browser_context._options.get("baseURL"),
+                    self._browser_context.base_url,
                     request.url,
                     urlOrPredicate,
                 )

playwright/_impl/_selectors.py

@@ -37,6 +37,10 @@ async def register(
         path: Union[str, Path] = None,
         contentScript: bool = None,
     ) -> None:
+        if any(engine for engine in self._selector_engines if engine["name"] == name):
+            raise Error(
+                f'Selectors.register: "{name}" selector engine has been already registered'
+            )
         if not script and not path:
             raise Error("Either source or path should be specified")
         if path:

tests/async/conftest.py

@@ -153,7 +153,7 @@ def action_titles(self) -> Locator:
 
     @property
     def stack_frames(self) -> Locator:
-        return self.page.get_by_test_id("stack-trace-list").locator(".list-view-entry")
+        return self.page.get_by_role("list", name="Stack Trace").get_by_role("listitem")
 
     async def select_action(self, title: str, ordinal: int = 0) -> None:
         await self.page.locator(".action-title", has_text=title).nth(ordinal).click()

tests/async/test_browsercontext.py

@@ -118,9 +118,9 @@ async def test_page_event_should_propagate_default_viewport_to_the_page(
 
 
 async def test_page_event_should_respect_device_scale_factor(browser: Browser) -> None:
-    context = await browser.new_context(device_scale_factor=3)
+    context = await browser.new_context(device_scale_factor=3.5)
     page = await context.new_page()
-    assert await page.evaluate("window.devicePixelRatio") == 3
+    assert await page.evaluate("window.devicePixelRatio") == 3.5
     await context.close()