feat(roll): roll Playwright to 1.2.0-next.1595486491367 (#83)

Author: mxschmitt

driver/package.json

@@ -13,7 +13,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright": "1.2.0-next.1595094993390"
+    "playwright": "1.2.0-next.1595486491367"
   },
   "devDependencies": {
     "pkg": "^4.4.9"

playwright/accessibility.py

@@ -12,21 +12,62 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from playwright.connection import Channel
 from playwright.element_handle import ElementHandle
 
 
+def _ax_node_from_protocol(axNode: Dict[str, Any]) -> Dict[str, Any]:
+    result = {**axNode}
+    if "valueNumber" in axNode:
+        result["value"] = axNode["valueNumber"]
+    elif "valueString" in axNode:
+        result["value"] = axNode["valueString"]
+
+    if "checked" in axNode:
+        result["checked"] = (
+            True
+            if axNode.get("checked") == "checked"
+            else (
+                False if axNode.get("checked") == "unchecked" else axNode.get("checked")
+            )
+        )
+
+    if "pressed" in axNode:
+        result["pressed"] = (
+            True
+            if axNode.get("pressed") == "pressed"
+            else (
+                False if axNode.get("pressed") == "released" else axNode.get("pressed")
+            )
+        )
+
+    if axNode.get("children"):
+        result["children"] = list(map(_ax_node_from_protocol, axNode["children"]))
+    if "valueNumber" in result:
+        del result["valueNumber"]
+    if "valueString" in result:
+        del result["valueString"]
+    return result
+
+
 class Accessibility:
     def __init__(self, channel: Channel) -> None:
         self._channel = channel
         self._sync_owner: Any = None
 
     async def snapshot(
         self, interestingOnly: bool = True, root: ElementHandle = None
-    ) -> Dict:
+    ) -> Optional[Dict[str, Any]]:
         root = root._channel if root else None
-        return await self._channel.send(
-            "accessibilitySnapshot", dict(root=root, interestingOnly=interestingOnly)
+        result = await self._channel.send(
+            "accessibilitySnapshot",
+            dict(root=root, interestingOnly=interestingOnly),
+            unpack_first_key=False,
+        )
+        return (
+            _ax_node_from_protocol(result["rootAXNode"])
+            if result.get("rootAXNode")
+            else None
         )

playwright/browser.py

@@ -76,6 +76,7 @@ async def newContext(
         params = locals_to_params(locals())
         if viewport == 0:
             params["viewport"] = None
+            params["noDefaultViewport"] = True
         if extraHTTPHeaders:
             params["extraHTTPHeaders"] = serialize_headers(extraHTTPHeaders)
         channel = await self._channel.send("newContext", params)

playwright/connection.py

@@ -30,13 +30,15 @@ def __init__(self, scope: "ConnectionScope", guid: str) -> None:
         self._guid = guid
         self._object: Optional[ChannelOwner] = None
 
-    async def send(self, method: str, params: dict = None) -> Any:
+    async def send(
+        self, method: str, params: dict = None, unpack_first_key: bool = True
+    ) -> Any:
         if params is None:
             params = dict()
         result = await self._scope.send_message_to_server(self._guid, method, params)
         # Protocol now has named return values, assume result is one level deeper unless
         # there is explicit ambiguity.
-        if isinstance(result, dict) and len(result) == 1:
+        if unpack_first_key and isinstance(result, dict) and len(result) == 1:
             key = next(iter(result))
             return result[key]
         return result
@@ -174,7 +176,7 @@ def _dispatch(self, msg: ParsedMessagePayload) -> None:
             callback = self._callbacks.pop(id)
             error = msg.get("error")
             if error:
-                parsed_error = parse_error(error)
+                parsed_error = parse_error(error["error"])  # type: ignore
                 parsed_error.stack = callback.stack_trace
                 callback.future.set_exception(parsed_error)
             else:

playwright/drivers/browsers.json

@@ -3,11 +3,11 @@
   "browsers": [
     {
       "name": "chromium",
-      "revision": "786218"
+      "revision": "790602"
     },
     {
       "name": "firefox",
-      "revision": "1128"
+      "revision": "1137"
     },
     {
       "name": "webkit",

playwright/frame.py

@@ -58,7 +58,7 @@
 class Frame(ChannelOwner):
     def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None:
         super().__init__(scope, guid, initializer)
-        self._parent_frame = from_nullable_channel(initializer["parentFrame"])
+        self._parent_frame = from_nullable_channel(initializer.get("parentFrame"))
         if self._parent_frame:
             self._parent_frame._child_frames.append(self)
         self._name = initializer["name"]

playwright/js_handle.py

@@ -88,15 +88,6 @@ async def jsonValue(self) -> Any:
         return parse_result(await self._channel.send("jsonValue"))
 
 
-def is_primitive_value(value: Any) -> bool:
-    return (
-        isinstance(value, bool)
-        or isinstance(value, int)
-        or isinstance(value, float)
-        or isinstance(value, str)
-    )
-
-
 def serialize_value(value: Any, handles: List[JSHandle], depth: int) -> Any:
     if isinstance(value, JSHandle):
         h = len(handles)
@@ -119,17 +110,25 @@ def serialize_value(value: Any, handles: List[JSHandle], depth: int) -> Any:
             return dict(v="NaN")
     if isinstance(value, datetime):
         return dict(d=value.isoformat() + "Z")
-    if is_primitive_value(value):
-        return value
+    if isinstance(value, bool):
+        return {"b": value}
+    if isinstance(value, int):
+        return {"n": value}
+    if isinstance(value, float):
+        return {"f": value}
+    if isinstance(value, str):
+        return {"s": value}
 
     if isinstance(value, list):
         result = list(map(lambda a: serialize_value(a, handles, depth + 1), value))
         return dict(a=result)
 
     if isinstance(value, dict):
-        result: Dict[str, Any] = dict()  # type: ignore
+        result = []  # type: ignore
         for name in value:
-            result[name] = serialize_value(value[name], handles, depth + 1)
+            result.append(
+                {"k": name, "v": serialize_value(value[name], handles, depth + 1)}
+            )
         return dict(o=result)
     return dict(v="undefined")
 
@@ -168,10 +167,16 @@ def parse_value(value: Any) -> Any:
 
         if "o" in value:
             o = value["o"]
-            result = dict()
-            for name in o:
-                result[name] = parse_value(o[name])
-            return result
+            return {e["k"]: parse_value(e["v"]) for e in o}
+
+        if "n" in value:
+            return value["n"]
+
+        if "s" in value:
+            return value["s"]
+
+        if "b" in value:
+            return value["b"]
     return value
 
 

playwright/main.py

@@ -66,7 +66,7 @@ async def async_init() -> None:
     connection = Connection(
         proc.stdout, proc.stdin, create_remote_object, asyncio.get_event_loop()
     )
-    playwright_async = await connection.wait_for_object_with_known_name("playwright")
+    playwright_async = await connection.wait_for_object_with_known_name("Playwright")
 
 
 if sys.platform == "win32":

playwright/network.py

@@ -32,7 +32,7 @@ class Request(ChannelOwner):
     def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None:
         super().__init__(scope, guid, initializer)
         self._redirected_from: Optional["Request"] = from_nullable_channel(
-            initializer["redirectedFrom"]
+            initializer.get("redirectedFrom")
         )
         self._redirected_to: Optional["Request"] = None
         if self._redirected_from:
@@ -53,7 +53,10 @@ def method(self) -> str:
 
     @property
     def postData(self) -> Optional[str]:
-        return self._initializer["postData"]
+        b64_content = self._initializer.get("postData")
+        if not b64_content:
+            return None
+        return base64.b64decode(bytes(b64_content, "utf-8")).decode()
 
     @property
     def headers(self) -> Dict[str, str]:

playwright/object_factory.py

@@ -40,40 +40,40 @@ def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None
 def create_remote_object(
     scope: ConnectionScope, type: str, guid: str, initializer: Dict
 ) -> Any:
-    if type == "bindingCall":
+    if type == "BindingCall":
         return BindingCall(scope, guid, initializer)
-    if type == "browser":
+    if type == "Browser":
         return Browser(scope, guid, initializer)
-    if type == "browserServer":
+    if type == "BrowserServer":
         return BrowserServer(scope, guid, initializer)
-    if type == "browserType":
+    if type == "BrowserType":
         return BrowserType(scope, guid, initializer)
-    if type == "context":
+    if type == "BrowserContext":
         return BrowserContext(scope, guid, initializer)
-    if type == "consoleMessage":
+    if type == "ConsoleMessage":
         return ConsoleMessage(scope, guid, initializer)
-    if type == "dialog":
+    if type == "Dialog":
         return Dialog(scope, guid, initializer)
-    if type == "download":
+    if type == "Download":
         return Download(scope, guid, initializer)
-    if type == "elementHandle":
+    if type == "ElementHandle":
         return ElementHandle(scope, guid, initializer)
-    if type == "frame":
+    if type == "Frame":
         return Frame(scope, guid, initializer)
-    if type == "jsHandle":
+    if type == "JSHandle":
         return JSHandle(scope, guid, initializer)
-    if type == "page":
+    if type == "Page":
         return Page(scope, guid, initializer)
-    if type == "playwright":
+    if type == "Playwright":
         return Playwright(scope, guid, initializer)
-    if type == "request":
+    if type == "Request":
         return Request(scope, guid, initializer)
-    if type == "response":
+    if type == "Response":
         return Response(scope, guid, initializer)
-    if type == "route":
+    if type == "Route":
         return Route(scope, guid, initializer)
-    if type == "worker":
+    if type == "Worker":
         return Worker(scope, guid, initializer)
-    if type == "selectors":
+    if type == "Selectors":
         return Selectors(scope, guid, initializer)
     return DummyObject(scope, guid, initializer)