chore(roll): roll Playwright to 1.33.0-alpha-apr-12-2023 (microsoft#1859)

Author: mxschmitt

README.md

@@ -4,7 +4,7 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->112.0.5615.29<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->113.0.5672.24<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->16.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | Firefox <!-- GEN:firefox-version -->111.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 

playwright/_impl/_api_structures.py

@@ -64,9 +64,10 @@ class Geolocation(TypedDict, total=False):
     accuracy: Optional[float]
 
 
-class HttpCredentials(TypedDict):
+class HttpCredentials(TypedDict, total=False):
     username: str
     password: str
+    origin: Optional[str]
 
 
 class LocalStorageEntry(TypedDict):

playwright/_impl/_assertions.py

@@ -464,6 +464,21 @@ async def not_to_have_text(
         __tracebackhide__ = True
         await self._not.to_have_text(expected, use_inner_text, timeout, ignore_case)
 
+    async def to_be_attached(
+        self,
+        attached: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.be.attached"
+            if (attached is None or attached is True)
+            else "to.be.detached",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            "Locator expected to be attached",
+        )
+
     async def to_be_checked(
         self,
         timeout: float = None,
@@ -479,6 +494,14 @@ async def to_be_checked(
             "Locator expected to be checked",
         )
 
+    async def not_to_be_attached(
+        self,
+        attached: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_attached(attached=attached, timeout=timeout)
+
     async def not_to_be_checked(
         self,
         timeout: float = None,

playwright/_impl/_browser_type.py

@@ -191,15 +191,17 @@ async def connect(
 
         headers = {**(headers if headers else {}), "x-playwright-browser": self.name}
         local_utils = self._connection.local_utils
-        pipe_channel = await local_utils._channel.send(
-            "connect",
-            {
-                "wsEndpoint": ws_endpoint,
-                "headers": headers,
-                "slowMo": slow_mo,
-                "timeout": timeout,
-            },
-        )
+        pipe_channel = (
+            await local_utils._channel.send_return_as_dict(
+                "connect",
+                {
+                    "wsEndpoint": ws_endpoint,
+                    "headers": headers,
+                    "slowMo": slow_mo,
+                    "timeout": timeout,
+                },
+            )
+        )["pipe"]
         transport = JsonPipeTransport(self._connection._loop, pipe_channel)
 
         connection = Connection(

playwright/_impl/_frame.py

@@ -531,9 +531,18 @@ def locator(
         self,
         selector: str,
         has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
         has: Locator = None,
+        has_not: Locator = None,
     ) -> Locator:
-        return Locator(self, selector, has_text=has_text, has=has)
+        return Locator(
+            self,
+            selector,
+            has_text=has_text,
+            has_not_text=has_not_text,
+            has=has,
+            has_not=has_not,
+        )
 
     def get_by_alt_text(
         self, text: Union[str, Pattern[str]], exact: bool = None

playwright/_impl/_locator.py

@@ -73,7 +73,9 @@ def __init__(
         frame: "Frame",
         selector: str,
         has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
+        has_not: "Locator" = None,
     ) -> None:
         self._frame = frame
         self._selector = selector
@@ -90,6 +92,15 @@ def __init__(
                 has._selector, ensure_ascii=False
             )
 
+        if has_not_text:
+            self._selector += f" >> internal:has-not-text={escape_for_text_selector(has_not_text, exact=False)}"
+
+        if has_not:
+            locator = has_not
+            if locator._frame != frame:
+                raise Error('Inner "has_not" locator must belong to the same frame.')
+            self._selector += " >> internal:has-not=" + json.dumps(locator._selector)
+
     def __repr__(self) -> str:
         return f"<Locator frame={self._frame!r} selector={self._selector!r}>"
 
@@ -211,13 +222,17 @@ def locator(
         self,
         selector_or_locator: Union[str, "Locator"],
         has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
+        has_not: "Locator" = None,
     ) -> "Locator":
         if isinstance(selector_or_locator, str):
             return Locator(
                 self._frame,
                 f"{self._selector} >> {selector_or_locator}",
                 has_text=has_text,
+                has_not_text=has_not_text,
+                has_not=has_not,
                 has=has,
             )
         selector_or_locator = to_impl(selector_or_locator)
@@ -227,6 +242,8 @@ def locator(
             self._frame,
             f"{self._selector} >> {selector_or_locator._selector}",
             has_text=has_text,
+            has_not_text=has_not_text,
+            has_not=has_not,
             has=has,
         )
 
@@ -317,13 +334,25 @@ def nth(self, index: int) -> "Locator":
     def filter(
         self,
         has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
+        has_not: "Locator" = None,
     ) -> "Locator":
         return Locator(
             self._frame,
             self._selector,
             has_text=has_text,
+            has_not_text=has_not_text,
             has=has,
+            has_not=has_not,
+        )
+
+    def or_(self, locator: "Locator") -> "Locator":
+        if locator._frame != self._frame:
+            raise Error("Locators must belong to the same frame.")
+        return Locator(
+            self._frame,
+            self._selector + " >> internal:or=" + json.dumps(locator._selector),
         )
 
     async def focus(self, timeout: float = None) -> None:
@@ -677,14 +706,18 @@ def locator(
         self,
         selector_or_locator: Union["Locator", str],
         has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
+        has_not: "Locator" = None,
     ) -> Locator:
         if isinstance(selector_or_locator, str):
             return Locator(
                 self._frame,
                 f"{self._frame_selector} >> internal:control=enter-frame >> {selector_or_locator}",
                 has_text=has_text,
+                has_not_text=has_not_text,
                 has=has,
+                has_not=has_not,
             )
         selector_or_locator = to_impl(selector_or_locator)
         if selector_or_locator._frame != self._frame:
@@ -693,7 +726,9 @@ def locator(
             self._frame,
             f"{self._frame_selector} >> internal:control=enter-frame >> {selector_or_locator._selector}",
             has_text=has_text,
+            has_not_text=has_not_text,
             has=has,
+            has_not=has_not,
         )
 
     def get_by_alt_text(

playwright/_impl/_network.py

@@ -38,6 +38,7 @@
     from typing import TypedDict
 else:  # pragma: no cover
     from typing_extensions import TypedDict
+
 from urllib import parse
 
 from playwright._impl._api_structures import (
@@ -51,6 +52,7 @@
 from playwright._impl._api_types import Error
 from playwright._impl._connection import (
     ChannelOwner,
+    filter_none,
     from_channel,
     from_nullable_channel,
 )
@@ -278,7 +280,15 @@ def request(self) -> Request:
     async def abort(self, errorCode: str = None) -> None:
         self._check_not_handled()
         await self._race_with_page_close(
-            self._channel.send("abort", locals_to_params(locals()))
+            self._channel.send(
+                "abort",
+                filter_none(
+                    {
+                        "errorCode": errorCode,
+                        "requestUrl": self.request._initializer["url"],
+                    }
+                ),
+            )
         )
         self._report_handled(True)
 
@@ -344,6 +354,8 @@ async def fulfill(
         if length and "content-length" not in headers:
             headers["content-length"] = str(length)
         params["headers"] = serialize_headers(headers)
+        params["requestUrl"] = self.request._initializer["url"]
+
         await self._race_with_page_close(self._channel.send("fulfill", params))
         self._report_handled(True)
 
@@ -402,6 +414,7 @@ async def continue_route() -> None:
 
                 if "headers" in params:
                     params["headers"] = serialize_headers(params["headers"])
+                params["requestUrl"] = self.request._initializer["url"]
                 await self._connection.wrap_api_call(
                     lambda: self._race_with_page_close(
                         self._channel.send(

playwright/_impl/_page.py

@@ -754,9 +754,17 @@ def locator(
         self,
         selector: str,
         has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
         has: "Locator" = None,
+        has_not: "Locator" = None,
     ) -> "Locator":
-        return self._main_frame.locator(selector, has_text=has_text, has=has)
+        return self._main_frame.locator(
+            selector,
+            has_text=has_text,
+            has_not_text=has_not_text,
+            has=has,
+            has_not=has_not,
+        )
 
     def get_by_alt_text(
         self, text: Union[str, Pattern[str]], exact: bool = None