update driver

Author: mxschmitt

playwright/_impl/_api_structures.py

@@ -72,10 +72,9 @@ class LocalStorageEntry(TypedDict):
     value: str
 
 
-class OriginState(TypedDict, total=False):
+class OriginState(TypedDict):
     origin: str
     localStorage: List[LocalStorageEntry]
-    indexedDB: Optional[List[Any]]
 
 
 class PdfMargins(TypedDict, total=False):

playwright/async_api/_generated.py

@@ -13469,7 +13469,7 @@ async def storage_state(
 
         Returns
         -------
-        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}], indexedDB: Union[List[Any], None]}]}
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
         return mapping.from_impl(
@@ -13874,7 +13874,7 @@ async def new_context(
             Dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to fit into
             800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of each page
             will be scaled down if necessary to fit the specified size.
-        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}], indexedDB: Union[Sequence[Any], None]}]}, None]
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
             Learn more about [storage state and auth](../auth.md).
 
             Populates context with given storage state. This option can be used to initialize context with logged-in
@@ -14105,7 +14105,7 @@ async def new_page(
             Dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to fit into
             800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of each page
             will be scaled down if necessary to fit the specified size.
-        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}], indexedDB: Union[Sequence[Any], None]}]}, None]
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
             Learn more about [storage state and auth](../auth.md).
 
             Populates context with given storage state. This option can be used to initialize context with logged-in
@@ -18672,7 +18672,7 @@ async def storage_state(
 
         Returns
         -------
-        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}], indexedDB: Union[List[Any], None]}]}
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
         return mapping.from_impl(
@@ -18730,7 +18730,7 @@ async def new_context(
         timeout : Union[float, None]
             Maximum time in milliseconds to wait for the response. Defaults to `30000` (30 seconds). Pass `0` to disable
             timeout.
-        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}], indexedDB: Union[Sequence[Any], None]}]}, None]
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
             Populates context with given storage state. This option can be used to initialize context with logged-in
             information obtained via `browser_context.storage_state()` or `a_pi_request_context.storage_state()`.
             Either a path to the file with saved storage, or the value returned by one of

playwright/sync_api/_generated.py

@@ -13506,7 +13506,7 @@ def storage_state(
 
         Returns
         -------
-        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}], indexedDB: Union[List[Any], None]}]}
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
         return mapping.from_impl(
@@ -13911,7 +13911,7 @@ def new_context(
             Dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to fit into
             800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of each page
             will be scaled down if necessary to fit the specified size.
-        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}], indexedDB: Union[Sequence[Any], None]}]}, None]
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
             Learn more about [storage state and auth](../auth.md).
 
             Populates context with given storage state. This option can be used to initialize context with logged-in
@@ -14144,7 +14144,7 @@ def new_page(
             Dimensions of the recorded videos. If not specified the size will be equal to `viewport` scaled down to fit into
             800x800. If `viewport` is not configured explicitly the video size defaults to 800x450. Actual picture of each page
             will be scaled down if necessary to fit the specified size.
-        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}], indexedDB: Union[Sequence[Any], None]}]}, None]
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
             Learn more about [storage state and auth](../auth.md).
 
             Populates context with given storage state. This option can be used to initialize context with logged-in
@@ -18799,7 +18799,7 @@ def storage_state(
 
         Returns
         -------
-        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}], indexedDB: Union[List[Any], None]}]}
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
         return mapping.from_impl(
@@ -18857,7 +18857,7 @@ def new_context(
         timeout : Union[float, None]
             Maximum time in milliseconds to wait for the response. Defaults to `30000` (30 seconds). Pass `0` to disable
             timeout.
-        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}], indexedDB: Union[Sequence[Any], None]}]}, None]
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
             Populates context with given storage state. This option can be used to initialize context with logged-in
             information obtained via `browser_context.storage_state()` or `a_pi_request_context.storage_state()`.
             Either a path to the file with saved storage, or the value returned by one of

setup.py

@@ -21,7 +21,7 @@
 import zipfile
 from typing import Dict
 
-driver_version = "1.51.0-beta-1741166263000"
+driver_version = "1.51.0-beta-1741261385000"
 
 base_wheel_bundles = [
     {

tests/async/test_browsercontext_storage_state.py

@@ -16,7 +16,7 @@
 import json
 from pathlib import Path
 
-from playwright.async_api import Browser, BrowserContext, Page
+from playwright.async_api import Browser, BrowserContext, Page, StorageState
 from tests.server import Server
 
 
@@ -44,30 +44,30 @@ async def test_should_capture_local_storage(context: BrowserContext) -> None:
 
 
 async def test_should_set_local_storage(browser: Browser) -> None:
-    context = await browser.new_context(
-        storage_state={
-            "origins": [
+    storage_state: StorageState = {
+        "origins": [
+            {
+                "origin": "https://www.example.com",
+                "localStorage": [{"name": "name1", "value": "value1"}],
+            }
+        ]
+    }
+    # We intentionally hide the indexed_db part in our API for now
+    storage_state["origins"][0]["indexedDB"] = [  # type: ignore
+        {
+            "name": "db",
+            "version": 42,
+            "stores": [
                 {
-                    "origin": "https://www.example.com",
-                    "localStorage": [{"name": "name1", "value": "value1"}],
-                    "indexedDB": [
-                        {
-                            "name": "db",
-                            "version": 42,
-                            "stores": [
-                                {
-                                    "name": "store",
-                                    "autoIncrement": False,
-                                    "records": [{"key": "bar", "value": "foo"}],
-                                    "indexes": [],
-                                }
-                            ],
-                        }
-                    ],
+                    "name": "store",
+                    "autoIncrement": False,
+                    "records": [{"key": "bar", "value": "foo"}],
+                    "indexes": [],
                 }
-            ]
+            ],
         }
-    )
+    ]
+    context = await browser.new_context(storage_state=storage_state)
 
     page = await context.new_page()
     await page.route(

tests/sync/test_browsercontext_storage_state.py

@@ -15,7 +15,8 @@
 import json
 from pathlib import Path
 
-from playwright.sync_api import Browser, BrowserContext
+from playwright.sync_api import Browser, BrowserContext, Page, StorageState
+from tests.server import Server
 
 
 def test_should_capture_local_storage(context: BrowserContext) -> None:
@@ -41,22 +42,53 @@ def test_should_capture_local_storage(context: BrowserContext) -> None:
 
 
 def test_should_set_local_storage(browser: Browser) -> None:
-    context = browser.new_context(
-        storage_state={
-            "origins": [
+    storage_state: StorageState = {
+        "origins": [
+            {
+                "origin": "https://www.example.com",
+                "localStorage": [{"name": "name1", "value": "value1"}],
+            }
+        ]
+    }
+    # We intentionally hide the indexed_db part in our API for now
+    storage_state["origins"][0]["indexedDB"] = [  # type: ignore
+        {
+            "name": "db",
+            "version": 42,
+            "stores": [
                 {
-                    "origin": "https://www.example.com",
-                    "localStorage": [{"name": "name1", "value": "value1"}],
+                    "name": "store",
+                    "autoIncrement": False,
+                    "records": [{"key": "bar", "value": "foo"}],
+                    "indexes": [],
                 }
-            ]
+            ],
         }
-    )
+    ]
+    context = browser.new_context(storage_state=storage_state)
 
     page = context.new_page()
     page.route("**/*", lambda route: route.fulfill(body="<html></html>"))
     page.goto("https://www.example.com")
     local_storage = page.evaluate("window.localStorage")
     assert local_storage == {"name1": "value1"}
+
+    indexed_db = page.evaluate(
+        """async () => {
+        return new Promise((resolve, reject) => {
+            const openRequest = indexedDB.open('db', 42);
+            openRequest.addEventListener('success', () => {
+                const db = openRequest.result;
+                const transaction = db.transaction('store', 'readonly');
+                const getRequest = transaction.objectStore('store').get('bar');
+                getRequest.addEventListener('success', () => resolve(getRequest.result));
+                getRequest.addEventListener('error', () => reject(getRequest.error));
+            });
+            openRequest.addEventListener('error', () => reject(openRequest.error));
+        });
+    }"""
+    )
+    assert indexed_db == "foo"
     context.close()
 
 
@@ -95,3 +127,48 @@ def test_should_round_trip_through_the_file(
     cookie = page2.evaluate("document.cookie")
     assert cookie == "username=John Doe"
     context2.close()
+
+
+def test_should_serialise_indexed_db(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """async () => {
+            await new Promise((resolve, reject) => {
+                const openRequest = indexedDB.open('db', 42);
+                openRequest.onupgradeneeded = () => {
+                openRequest.result.createObjectStore('store');
+                };
+                openRequest.onsuccess = () => {
+                const request = openRequest.result.transaction('store', 'readwrite')
+                    .objectStore('store')
+                    .put('foo', 'bar');
+                request.addEventListener('success', resolve);
+                request.addEventListener('error', reject);
+                };
+            });
+        }"""
+    )
+    assert page.context.storage_state() == {"cookies": [], "origins": []}
+    assert page.context.storage_state(indexed_db=True) == {
+        "cookies": [],
+        "origins": [
+            {
+                "origin": f"http://localhost:{server.PORT}",
+                "localStorage": [],
+                "indexedDB": [
+                    {
+                        "name": "db",
+                        "version": 42,
+                        "stores": [
+                            {
+                                "name": "store",
+                                "autoIncrement": False,
+                                "records": [{"key": "bar", "value": "foo"}],
+                                "indexes": [],
+                            }
+                        ],
+                    }
+                ],
+            }
+        ],
+    }

tests/sync/test_fetch_global.py

@@ -323,3 +323,41 @@ def test_should_serialize_null_values_in_json(
     assert response.status == 200
     assert response.text() == '{"foo": null}'
     request.dispose()
+
+
+def test_should_throw_when_fail_on_status_code_is_true(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = playwright.request.new_context(fail_on_status_code=True)
+    with pytest.raises(Error, match="404 Not Found"):
+        request.fetch(server.EMPTY_PAGE)
+    request.dispose()
+
+
+def test_should_not_throw_when_fail_on_status_code_is_false(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = playwright.request.new_context(fail_on_status_code=False)
+    response = request.fetch(server.EMPTY_PAGE)
+    assert response.status == 404
+    request.dispose()

tests/sync/test_locators.py

@@ -493,6 +493,28 @@ def test_should_combine_visible_with_other_selectors(page: Page) -> None:
     )
 
 
+def test_should_support_filter_visible(page: Page) -> None:
+    page.set_content(
+        """<div>
+    <div class="item" style="display: none">Hidden data0</div>
+    <div class="item">visible data1</div>
+    <div class="item" style="display: none">Hidden data1</div>
+    <div class="item">visible data2</div>
+    <div class="item" style="display: none">Hidden data2</div>
+    <div class="item">visible data3</div>
+    </div>
+    """
+    )
+    locator = page.locator(".item").filter(visible=True).nth(1)
+    expect(locator).to_have_text("visible data2")
+    expect(
+        page.locator(".item").filter(visible=True).get_by_text("data3")
+    ).to_have_text("visible data3")
+    expect(
+        page.locator(".item").filter(visible=False).get_by_text("data1")
+    ).to_have_text("Hidden data1")
+
+
 def test_locator_count_should_work_with_deleted_map_in_main_world(page: Page) -> None:
     page.evaluate("Map = 1")
     page.locator("#searchResultTableDiv .x-grid3-row").count()