In progress changes from v1.53.0 release

Author: agg23

playwright/_impl/_assertions.py

@@ -51,6 +51,7 @@ async def _expect_impl(
         expect_options: FrameExpectOptions,
         expected: Any,
         message: str,
+        # title: str,
     ) -> None:
         __tracebackhide__ = True
         expect_options["isNot"] = self._is_not
@@ -60,6 +61,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._actual_locator._expect(expression, expect_options)
         if result["matches"] == self._is_not:
             actual = result.get("received")

playwright/_impl/_browser.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
@@ -38,12 +37,9 @@
     HarMode,
     ReducedMotion,
     ServiceWorkersPolicy,
-    async_readfile,
     locals_to_params,
     make_dirs_for_file,
-    prepare_record_har_options,
 )
-from playwright._impl._network import serialize_headers, to_client_certificates_protocol
 from playwright._impl._page import Page
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -65,12 +61,41 @@ def __init__(
         self._cr_tracing_path: Optional[str] = None
 
         self._contexts: List[BrowserContext] = []
+        self._traces_dir: Optional[str] = None
+        self._channel.on(
+            "context",
+            lambda context: self._did_create_context(cast(BrowserContext, context)),
+        )
         self._channel.on("close", lambda _: self._on_close())
         self._close_reason: Optional[str] = None
 
     def __repr__(self) -> str:
         return f"<Browser type={self._browser_type} version={self.version}>"
 
+    def connect_to_browser_type(
+        self,
+        browser_type: BrowserType,
+        traces_dir: Optional[str] = None,
+    ) -> None:
+        # Note: when using connect(), `browserType` is different from `this.parent`.
+        # This is why browser type is not wired up in the constructor, and instead this separate method is called later on.
+        self._browser_type = browser_type
+        self._traces_dir = traces_dir
+        for context in self._contexts:
+            context._tracing._traces_dir = traces_dir
+            browser_type._playwright.selectors._contextsForSelectors.append(context)
+
+    def _did_create_context(self, context: BrowserContext) -> None:
+        context._browser = self
+        self._contexts.append(context)
+        # Note: when connecting to a browser, initial contexts arrive before `_browserType` is set,
+        # and will be configured later in `ConnectToBrowserType`.
+        if self._browser_type:
+            context._tracing._traces_dir = self._traces_dir
+            self._browser_type._playwright.selectors._contextsForSelectors.append(
+                context
+            )
+
     def _on_close(self) -> None:
         self._is_connected = False
         self.emit(Browser.Events.Disconnected, self)
@@ -126,11 +151,19 @@ async def new_context(
         clientCertificates: List[ClientCertificate] = None,
     ) -> BrowserContext:
         params = locals_to_params(locals())
-        await prepare_browser_context_params(params)
+        await self._browser_type.prepare_browser_context_params(params)
 
         channel = await self._channel.send("newContext", params)
         context = cast(BrowserContext, from_channel(channel))
-        self._browser_type._did_create_context(context, params, {})
+        await context.initialize_har_from_options(
+            {
+                "recordHarPath": recordHarPath,
+                "recordHarContent": recordHarContent,
+                "recordHarOmitContent": recordHarOmitContent,
+                "recordHarUrlFilter": recordHarUrlFilter,
+                "recordHarMode": recordHarMode,
+            }
+        )
         return context
 
     async def new_page(
@@ -181,6 +214,7 @@ async def inner() -> Page:
             context._owner_page = page
             return page
 
+        # TODO: Args
         return await self._connection.wrap_api_call(inner)
 
     async def close(self, reason: str = None) -> None:
@@ -226,43 +260,3 @@ async def stop_tracing(self) -> bytes:
                 f.write(buffer)
             self._cr_tracing_path = None
         return buffer
-
-
-async def prepare_browser_context_params(params: Dict) -> None:
-    if params.get("noViewport"):
-        del params["noViewport"]
-        params["noDefaultViewport"] = True
-    if "defaultBrowserType" in params:
-        del params["defaultBrowserType"]
-    if "extraHTTPHeaders" in params:
-        params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
-    if "recordHarPath" in params:
-        params["recordHar"] = prepare_record_har_options(params)
-        del params["recordHarPath"]
-    if "recordVideoDir" in params:
-        params["recordVideo"] = {"dir": Path(params["recordVideoDir"]).absolute()}
-        if "recordVideoSize" in params:
-            params["recordVideo"]["size"] = params["recordVideoSize"]
-            del params["recordVideoSize"]
-        del params["recordVideoDir"]
-    if "storageState" in params:
-        storageState = params["storageState"]
-        if not isinstance(storageState, dict):
-            params["storageState"] = json.loads(
-                (await async_readfile(storageState)).decode()
-            )
-    if params.get("colorScheme", None) == "null":
-        params["colorScheme"] = "no-override"
-    if params.get("reducedMotion", None) == "null":
-        params["reducedMotion"] = "no-override"
-    if params.get("forcedColors", None) == "null":
-        params["forcedColors"] = "no-override"
-    if params.get("contrast", None) == "null":
-        params["contrast"] = "no-override"
-    if "acceptDownloads" in params:
-        params["acceptDownloads"] = "accept" if params["acceptDownloads"] else "deny"
-
-    if "clientCertificates" in params:
-        params["clientCertificates"] = await to_client_certificates_protocol(
-            params["clientCertificates"]
-        )

playwright/_impl/_browser_context.py

@@ -66,7 +66,6 @@
     async_writefile,
     locals_to_params,
     parse_error,
-    prepare_record_har_options,
     to_impl,
 )
 from playwright._impl._network import (
@@ -106,6 +105,7 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        # Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
         # circular import workaround:
         self._browser: Optional["Browser"] = None
         if parent.__class__.__name__ == "Browser":
@@ -220,7 +220,7 @@ def __init__(
                 BrowserContext.Events.RequestFailed: "requestFailed",
             }
         )
-        self._close_was_called = False
+        self._closing_or_closed = False
 
     def __repr__(self) -> str:
         return f"<BrowserContext browser={self.browser}>"
@@ -237,7 +237,7 @@ async def _on_route(self, route: Route) -> None:
         route_handlers = self._routes.copy()
         for route_handler in route_handlers:
             # If the page or the context was closed we stall all requests right away.
-            if (page and page._close_was_called) or self._close_was_called:
+            if (page and page._close_was_called) or self._closing_or_closed:
                 return
             if not route_handler.matches(route.request.url):
                 continue
@@ -310,14 +310,22 @@ def pages(self) -> List[Page]:
     def browser(self) -> Optional["Browser"]:
         return self._browser
 
-    def _set_options(self, context_options: Dict, browser_options: Dict) -> None:
-        self._options = context_options
-        if self._options.get("recordHar"):
-            self._har_recorders[""] = {
-                "path": self._options["recordHar"]["path"],
-                "content": self._options["recordHar"].get("content"),
-            }
-        self._tracing._traces_dir = browser_options.get("tracesDir")
+    async def initialize_har_from_options(self, options: Dict) -> None:
+        record_har_path = str(options["recordHarPath"])
+        if not record_har_path or len(record_har_path) == 0:
+            return
+        default_policy = "attach" if record_har_path.endswith(".zip") else "embed"
+        content_policy = options.get(
+            "recordHarContent",
+            "omit" if options["recordHarOmitContent"] is True else default_policy,
+        )
+        await self._record_into_har(
+            har=record_har_path,
+            page=None,
+            url=options["recordHarUrlFilter"],
+            update_content=content_policy,
+            update_mode=options.get("recordHarMode", "full"),
+        )
 
     async def new_page(self) -> Page:
         if self._owner_page:
@@ -476,22 +484,25 @@ async def _record_into_har(
         update_content: HarContentPolicy = None,
         update_mode: HarMode = None,
     ) -> None:
+        update_content = update_content or "attach"
         params: Dict[str, Any] = {
-            "options": prepare_record_har_options(
-                {
-                    "recordHarPath": har,
-                    "recordHarContent": update_content or "attach",
-                    "recordHarMode": update_mode or "minimal",
-                    "recordHarUrlFilter": url,
-                }
-            )
+            "options": {
+                "zip": str(har).endswith(".zip"),
+                "content": update_content,
+                "urlGlob": url if isinstance(url, str) else None,
+                "urlRegexSource": url.pattern if isinstance(url, Pattern) else None,
+                "urlRegexFlags": (
+                    escape_regex_flags(url) if isinstance(url, Pattern) else None
+                ),
+                "mode": update_mode or "minimal",
+            }
         }
         if page:
             params["page"] = page._channel
         har_id = await self._channel.send("harStart", params)
         self._har_recorders[har_id] = {
             "path": str(har),
-            "content": update_content or "attach",
+            "content": update_content,
         }
 
     async def route_from_har(
@@ -557,20 +568,21 @@ def expect_event(
     def _on_close(self) -> None:
         if self._browser:
             self._browser._contexts.remove(self)
+            self._browser._browser_type._playwright.selectors._contextsForSelectors.remove(
+                self
+            )
 
         self._dispose_har_routers()
         self._tracing._reset_stack_counter()
         self.emit(BrowserContext.Events.Close, self)
 
     async def close(self, reason: str = None) -> None:
-        if self._close_was_called:
+        if self._closing_or_closed:
             return
         self._close_reason = reason
-        self._close_was_called = True
+        self._closing_or_closed = True
 
-        await self._channel._connection.wrap_api_call(
-            lambda: self.request.dispose(reason=reason), True
-        )
+        await self.request.dispose(reason=reason)
 
         async def _inner_close() -> None:
             for har_id, params in self._har_recorders.items():