chore: roll Playwright to 1.65.0-next (f33f0b751b) (#3299)

Co-authored-by: microsoft-playwright-automation[bot] <203992400+microsoft-playwright-automation[bot]@users.noreply.github.com>

Author: microsoft-playwright-automation[bot]

DRIVER_VERSION

@@ -1 +1 @@
-b4695e3eb2e6736d1a7b1fd255c4e94f78553660
+f33f0b751be0dd559d86c1ed27ca8baa5f9cb2b2

NODE_VERSION

@@ -1 +1 @@
-24.22.1
+26.13.0

tests/assets/serviceworkers/slow-fallback/sw.html

@@ -0,0 +1,4 @@
+<script>
+  window.registrationPromise = navigator.serviceWorker.register('sw.js');
+  window.activationPromise = new Promise(resolve => navigator.serviceWorker.oncontrollerchange = resolve);
+</script>

tests/assets/serviceworkers/slow-fallback/sw.js

@@ -0,0 +1,9 @@
+self.addEventListener('install', () => self.skipWaiting());
+
+self.addEventListener('activate', event => event.waitUntil(self.clients.claim()));
+
+self.addEventListener('fetch', () => {
+  // Hold the request for a while, then let it fall back to the network.
+  const start = Date.now();
+  while (Date.now() - start < 500) {}
+});

tests/async/library/chromium/test_connect_over_cdp.py

@@ -904,3 +904,50 @@ async def test_CD_035_no_defaults_should_not_affect_new_contexts(
         await browser.close()
     finally:
         await browser_server.close()
+
+
+async def test_CD_053_should_connect_when_another_client_inspects_a_terminated_shared_worker(
+    browser_type: BrowserType, server: Server, launch_arguments: Dict, port: int
+) -> None:
+    pytest.skip("fixme")
+    browser = await launch(browser_type, launch_arguments, port)
+    try:
+        # Another client inspects the shared worker.
+        page = await browser.new_page()
+        inspector = await browser.new_browser_cdp_session()
+        worker_created: asyncio.Future[str] = asyncio.get_running_loop().create_future()
+
+        def on_target_created(event: Dict[str, Any]) -> None:
+            if event["targetInfo"]["type"] == "shared_worker":
+                worker_created.set_result(event["targetInfo"]["targetId"])
+
+        inspector.on("Target.targetCreated", on_target_created)
+        await inspector.send("Target.setDiscoverTargets", {"discover": True})
+        await page.goto(server.PREFIX + "/shared-worker/shared-worker.html")
+        assert await page.evaluate("window.sharedWorkerResponsePromise") == "echo:hello"
+        worker_target_id = await worker_created
+        await inspector.send(
+            "Target.attachToTarget", {"targetId": worker_target_id, "flatten": True}
+        )
+
+        # The last client of the shared worker goes away, so the worker is terminated.
+        # The inspector stays attached, so the worker target lingers without a browser context.
+        await page.close()
+        # Python: poll the CDP target list instead of expect.poll.
+        deadline = asyncio.get_running_loop().time() + 5
+        while True:
+            targets = await inspector.send("Target.getTargets")
+            if not any(
+                info["targetId"] == worker_target_id for info in targets["targetInfos"]
+            ):
+                break
+            assert asyncio.get_running_loop().time() < deadline
+            await asyncio.sleep(0.1)
+
+        # A new client auto-attaches to the lingering worker target.
+        cdp_browser = await browser_type.connect_over_cdp(f"http://127.0.0.1:{port}/")
+        page2 = await cdp_browser.contexts[0].new_page()
+        assert await page2.evaluate("1 + 1") == 2
+        await cdp_browser.close()
+    finally:
+        await browser.close()

tests/async/library/chromium/test_oopif.py

@@ -313,11 +313,13 @@ async def test_OO_012_should_take_screenshot(
     browser: Browser,
     server: Server,
     assert_to_be_golden: Callable[[bytes, str], None],
+    utils: Utils,
 ) -> None:
     await page.set_viewport_size({"width": 500, "height": 500})
     await page.goto(server.PREFIX + "/dynamic-oopif.html")
     assert len(page.frames) == 2
     await assert_oopif_count(browser, 1)
+    await utils.rafraf(page.frames[1])
     assert_to_be_golden(await page.screenshot(), "screenshot-oopif.png")
 
 

tests/async/library/test_browsercontext_har.py

@@ -14,6 +14,7 @@
 
 """Port of tests/library/browsercontext-har.spec.ts."""
 
+import io
 import json
 import re
 import zipfile
@@ -316,6 +317,24 @@ async def test_HA_085_should_round_trip_har_zip(
     )
 
 
+async def test_HA_114_should_reject_a_malformed_har_zip(
+    context_factory: Callable[..., Awaitable[BrowserContext]], tmp_path: Path
+) -> None:
+    # Python: zipfile builds the in-memory archive instead of yazl's output stream.
+    output = io.BytesIO()
+    with zipfile.ZipFile(output, "w") as zip_file:
+        zip_file.writestr("aa/x.har", b"{}")
+    # yauzl reports '..' in an entry name as an 'error' event while reading entries.
+    zip_data = output.getvalue().replace(b"aa/x.har", b"../x.har")
+    har_path = tmp_path / "malformed.har.zip"
+    har_path.write_bytes(zip_data)
+
+    context = await context_factory()
+    with pytest.raises(Error) as exc_info:
+        await context.route_from_har(har_path)
+    assert "invalid relative path: ../x.har" in exc_info.value.message
+
+
 async def test_HA_086_should_produce_extracted_zip(
     context_factory: Callable[..., Awaitable[BrowserContext]],
     server: Server,

tests/async/library/test_browsercontext_user_agent.py

@@ -19,7 +19,7 @@
 
 import pytest
 
-from playwright.async_api import Browser, BrowserContext, Error, Playwright
+from playwright.async_api import Browser, BrowserContext, Error, Playwright, Route
 from tests.server import Server, TestServerRequest
 from tests.utils import chromium_version_less_than, must
 
@@ -41,6 +41,25 @@ async def test_UA_001_should_work(browser: Browser, server: Server) -> None:
     await context.close()
 
 
+async def test_UA_007_should_preserve_custom_user_agent_in_route_fetch(
+    context_factory: Callable[..., Awaitable[BrowserContext]], server: Server
+) -> None:
+    context = await context_factory(user_agent="my-custom-user-agent")
+    page = await context.new_page()
+
+    async def handle(route: Route) -> None:
+        await route.fulfill(response=await route.fetch())
+
+    await page.route("**/empty.html", handle)
+    request, server_request, _ = await asyncio.gather(
+        page.wait_for_event("request", predicate=lambda r: r.url == server.EMPTY_PAGE),
+        server.wait_for_request("/empty.html"),
+        page.goto(server.EMPTY_PAGE),
+    )
+    assert request.headers["user-agent"] == "my-custom-user-agent"
+    assert server_request.getHeader("user-agent") == "my-custom-user-agent"
+
+
 async def test_UA_002_should_work_for_subframes(
     browser: Browser, server: Server, utils: Utils
 ) -> None:

tests/async/library/test_capabilities.py

@@ -183,27 +183,19 @@ async def test_CA_011_should_not_crash_on_show_directory_picker(
     await page.goto(server.EMPTY_PAGE)
     # "User activation is required to show a file picker." - so we click first.
     await page.locator("body").click()
-    picker = asyncio.create_task(
-        page.evaluate(
-            """async () => {
-      const dir = await window.showDirectoryPicker();
-      return dir.name;
-      // In headless it throws (aborted), in headed it stalls (Test ended) and waits for the picker to be accepted.
+    await page.evaluate(
+        """() => {
+      window.showDirectoryPicker().catch(e => { window.__pickerError = String(e); });
     }"""
-        )
     )
     # The dialog will not be accepted, so we just wait for some time to
     # to give the browser a chance to crash.
     await page.wait_for_timeout(3_000)
-    if picker.done():
-        error = picker.exception()
-        assert isinstance(error, Error)
-        assert re.search(
-            r"(DOMException|AbortError): .*The user aborted a request", error.message
-        )
-    else:
-        # In headed mode the picker stalls until the test ends.
-        picker.add_done_callback(lambda task: task.exception())
+    # In headless it throws (aborted), in headed it stalls and waits for the picker to be accepted.
+    error = await page.evaluate("() => window.__pickerError ?? 'stalled'")
+    assert re.search(
+        r"((DOMException|AbortError): .*The user aborted a request|stalled)", error
+    )
 
 
 async def test_CA_012_should_not_crash_on_storage_get_directory(

tests/async/library/test_multiclient.py

@@ -563,3 +563,50 @@ async def test_MC_018_should_stop_tracing_upon_disconnect(
     await disconnect(playwright, page_a)
 
     await page_b.context.tracing.start()
+
+
+@pytest.mark.slow
+async def test_MC_020_should_run_locator_handlers_after_reconnecting_with_a_pending_callback(
+    playwright: Playwright,
+    connect: Callable[..., Awaitable[Browser]],
+    remote_server: RemoteServer,
+    server: Server,
+) -> None:
+    browser = await connect(remote_server.ws_endpoint)
+    page = await browser.new_page()
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = 0
+
+    async def handler() -> None:
+        nonlocal called
+        called += 1
+        await asyncio.Future()
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+    await page.evaluate(
+        """() => {
+        window.setupAnnoyingInterstitial('none', 1);
+    }"""
+    )
+    with pytest.raises(Error) as exc_info:
+        await page.locator("#target").click(timeout=1000)
+    assert "Timeout 1000ms exceeded" in exc_info.value.message
+    assert called == 1
+
+    await disconnect(playwright, page)
+
+    reconnected_browser = await connect(remote_server.ws_endpoint)
+    reconnected_page = reconnected_browser.contexts[0].pages[0]
+
+    async def reconnected_handler() -> None:
+        await reconnected_page.locator("#close").click()
+
+    await reconnected_page.add_locator_handler(
+        reconnected_page.get_by_text("This interstitial covers the button"),
+        reconnected_handler,
+    )
+    await reconnected_page.locator("#target").click(timeout=3000)
+    assert await reconnected_page.evaluate("window.clicked") == 1