feat(roll): roll Playwright to 1.2.0-next.1595094993390 (#69)

Author: pavelfeldman

driver/package-lock.json

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

driver/package.json

@@ -16,6 +16,7 @@
 from playwright.browser_context import BrowserContext
 from playwright.connection import ChannelOwner, ConnectionScope, from_channel
 from playwright.helper import locals_to_params, ColorScheme
+from playwright.network import serialize_headers
 from playwright.page import Page
 from types import SimpleNamespace
 from typing import Dict, List, Union
@@ -37,9 +38,6 @@ def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None
 
         self._contexts: List[BrowserContext] = list()
         self._channel.on("close", lambda _: self._on_close())
-        self._channel.on(
-            "contextClosed", lambda context: self._contexts.remove(context)
-        )
 
     def _on_close(self) -> None:
         self._is_connected = False
@@ -77,6 +75,8 @@ async def newContext(
         params = locals_to_params(locals())
         if viewport == 0:
             params["viewport"] = None
+        if extraHTTPHeaders:
+            params["extraHTTPHeaders"] = serialize_headers(extraHTTPHeaders)
         channel = await self._channel.send("newContext", params)
         context = from_channel(channel)
         self._contexts.append(context)

playwright/browser.py

@@ -29,7 +29,7 @@
     URLMatch,
     URLMatcher,
 )
-from playwright.network import Request, Route
+from playwright.network import Request, Route, serialize_headers
 from playwright.page import BindingCall, Page, wait_for_event
 from types import SimpleNamespace
 from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
@@ -53,20 +53,18 @@ def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None
         self._owner_page: Optional[Page] = None
         self._is_closed_or_closing = False
 
-        for channel in initializer["pages"]:
-            page = from_channel(channel)
-            self._pages.append(page)
-            page._set_browser_context(self)
         self._channel.on(
             "bindingCall",
-            lambda binding_call: self._on_binding(from_channel(binding_call)),
+            lambda params: self._on_binding(from_channel(params["binding"])),
         )
         self._channel.on("close", lambda _: self._on_close())
-        self._channel.on("page", lambda page: self._on_page(from_channel(page)))
+        self._channel.on(
+            "page", lambda params: self._on_page(from_channel(params["page"]))
+        )
         self._channel.on(
             "route",
-            lambda event: self._on_route(
-                from_channel(event.get("route")), from_channel(event.get("request"))
+            lambda params: self._on_route(
+                from_channel(params.get("route")), from_channel(params.get("request"))
             ),
         )
 
@@ -136,7 +134,9 @@ async def setGeolocation(self, geolocation: Optional[Dict]) -> None:
         await self._channel.send("setGeolocation", dict(geolocation=geolocation))
 
     async def setExtraHTTPHeaders(self, headers: Dict) -> None:
-        await self._channel.send("setExtraHTTPHeaders", dict(headers=headers))
+        await self._channel.send(
+            "setExtraHTTPHeaders", dict(headers=serialize_headers(headers))
+        )
 
     async def setOffline(self, offline: bool) -> None:
         await self._channel.send("setOffline", dict(offline=offline))

playwright/browser_context.py

@@ -21,7 +21,7 @@
 
 class BrowserType(ChannelOwner):
     def __init__(self, scope: ConnectionScope, guid: str, initializer: Dict) -> None:
-        super().__init__(scope, guid, initializer)
+        super().__init__(scope, guid, initializer, True)
 
     @property
     def name(self) -> str:

playwright/browser_type.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import asyncio
+import sys
 import traceback
 from playwright.helper import parse_error, ParsedMessagePayload
 from playwright.transport import Transport
@@ -30,7 +31,13 @@ def __init__(self, scope: "ConnectionScope", guid: str) -> None:
     async def send(self, method: str, params: dict = None) -> Any:
         if params is None:
             params = dict()
-        return await self._scope.send_message_to_server(self._guid, method, params)
+        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:
+            key = next(iter(result))
+            return result[key]
+        return result
 
 
 class ChannelOwner(BaseEventEmitter):
@@ -172,7 +179,13 @@ def _dispatch(self, msg: ParsedMessagePayload) -> None:
             return
 
         object = self._objects[guid]
-        object._channel.emit(method, self._replace_guids_with_channels(params))
+        try:
+            object._channel.emit(method, self._replace_guids_with_channels(params))
+        except Exception:
+            print(
+                "Error dispatching the event",
+                "".join(traceback.format_exception(*sys.exc_info())),
+            )
 
     def _replace_channels_with_guids(self, payload: Any) -> Any:
         if payload is None:

playwright/connection.py

@@ -7,11 +7,11 @@
     },
     {
       "name": "firefox",
-      "revision": "1125"
+      "revision": "1128"
     },
     {
       "name": "webkit",
-      "revision": "1305"
+      "revision": "1308"
     }
   ]
-}
+}

playwright/drivers/browsers.json

@@ -13,19 +13,22 @@
 # limitations under the License.
 
 import base64
+import mimetypes
+import os
 import sys
 from playwright.connection import (
     ConnectionScope,
     from_nullable_channel,
 )
 from playwright.helper import (
     FilePayload,
-    SelectOption,
-    locals_to_params,
     KeyboardModifier,
     MouseButton,
+    SelectOption,
+    locals_to_params,
 )
 from playwright.js_handle import parse_result, serialize_argument, JSHandle
+
 from typing import (
     Any,
     Callable,
@@ -113,10 +116,12 @@ async def dblclick(
 
     async def selectOption(
         self, values: "ValuesToSelect", timeout: int = None, noWaitAfter: bool = None
-    ) -> None:
+    ) -> List[str]:
         params = locals_to_params(locals())
-        params["values"] = convertSelectOptionValues(values)
-        await self._channel.send("selectOption", params)
+        if "values" in params:
+            values = params.pop("values")
+            params = {**params, **convert_select_option_values(values)}
+        return await self._channel.send("selectOption", params)
 
     async def fill(
         self, value: str, timeout: int = None, noWaitAfter: bool = None
@@ -132,7 +137,9 @@ async def setInputFiles(
         timeout: int = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("setInputFiles", locals_to_params(locals()))
+        params = locals_to_params(locals())
+        params["files"] = normalize_file_payloads(files)
+        await self._channel.send("setInputFiles", params)
 
     async def focus(self) -> None:
         await self._channel.send("focus")
@@ -230,11 +237,38 @@ async def evalOnSelectorAll(
 ]
 
 
-def convertSelectOptionValues(arg: ValuesToSelect) -> Any:
+def convert_select_option_values(arg: ValuesToSelect) -> Any:
     if arg is None:
-        return []
-    if isinstance(arg, ElementHandle):
-        return arg._channel
-    if isinstance(arg, list) and len(arg) and isinstance(arg[0], ElementHandle):
-        return list(map(lambda e: e._channel, arg))
-    return arg
+        return dict()
+    arg_list = arg if isinstance(arg, list) else [arg]
+    if not len(arg_list):
+        return dict()
+    if isinstance(arg_list[0], ElementHandle):
+        element_list = cast(List[ElementHandle], arg_list)
+        return dict(elements=list(map(lambda e: e._channel, element_list)))
+    if isinstance(arg_list[0], str):
+        return dict(options=list(map(lambda e: dict(value=e), arg_list)))
+    return dict(options=arg_list)
+
+
+def normalize_file_payloads(
+    files: Union[str, FilePayload, List[str], List[FilePayload]]
+) -> List[FilePayload]:
+    file_list = files if isinstance(files, list) else [files]
+    file_payloads: List[FilePayload] = []
+    for item in file_list:
+        if isinstance(item, str):
+            with open(item, mode="rb") as fd:
+                file: FilePayload = {
+                    "name": os.path.basename(item),
+                    "mimeType": mimetypes.guess_type(item)[0]
+                    or "application/octet-stream",
+                    "buffer": base64.b64encode(fd.read()).decode(),
+                }
+                file_payloads.append(file)
+        else:
+            if isinstance(item["buffer"], bytes):
+                item["buffer"] = base64.b64encode(item["buffer"]).decode()
+            file_payloads.append(item)
+
+    return file_payloads