fix(assertions): adapt to upstream FrameExpectResult → void protocol change

Upstream commit ac7cdd4bd changed FrameExpectResult from {matches, received}
to void — expect returns nothing on success and throws ExpectError on failure.

Updates:
- _assertions.py: _expect_impl now catches driver Error and uses its message
  directly; removes unused parse_value and FrameExpectResult imports.
- _frame.py: guard against None result from _expect channel call; change
  return type to dict (callers don't use typed fields anymore).
- _locator.py: change _expect return type to dict for consistency.
- tests/{sync,async}/test_assertions.py: update 21 error-message assertions to
  match the new upstream format (e.g. 'LocatorAssertions.to_have_text: Expect
  failed\nCall log:\n  - Expect "to_have_text" with timeout 300ms\n…' instead
  of the old Python-formatted "Locator expected to …" / "Actual value: …").

Author: Skn0tt

playwright/_impl/_assertions.py

@@ -21,13 +21,11 @@
     AriaRole,
     ExpectedTextValue,
     FrameExpectOptions,
-    FrameExpectResult,
 )
 from playwright._impl._connection import format_call_log
 from playwright._impl._errors import Error
 from playwright._impl._fetch import APIResponse
 from playwright._impl._helper import is_textual_mime_type
-from playwright._impl._js_handle import parse_value
 from playwright._impl._locator import Locator
 from playwright._impl._page import Page
 from playwright._impl._str_utils import escape_regex_flags
@@ -79,7 +77,7 @@ def __init__(
 
     async def _call_expect(
         self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
-    ) -> FrameExpectResult:
+    ) -> None:
         raise NotImplementedError(
             "_call_expect must be implemented in a derived class."
         )
@@ -100,35 +98,16 @@ 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._call_expect(expression, expect_options, title)
-        if result["matches"] == self._is_not:
-            received = result.get("received") or {}
-            aria_snapshot = None
-            if isinstance(received, dict):
-                aria_snapshot = received.get("ariaSnapshot")
-                value = received.get("value")
-                actual = parse_value(value) if value is not None else None
-            else:
-                actual = received
+        try:
+            await self._call_expect(expression, expect_options, title)
+        except Error as e:
             if self._custom_message:
                 out_message = self._custom_message
                 if expected is not None:
                     out_message += f"\nExpected value: '{expected or '<None>'}'"
             else:
-                out_message = (
-                    f"{message} '{expected}'" if expected is not None else f"{message}"
-                )
-            error_message = result.get("errorMessage")
-            error_message = f"\n{error_message}" if error_message else ""
-            aria_snapshot_message = (
-                f"\nAria snapshot:\n{aria_snapshot}" if aria_snapshot else ""
-            )
-            _record_soft_or_raise(
-                AssertionError(
-                    f"{out_message}\nActual value: {actual}{error_message} {format_call_log(result.get('log'))}{aria_snapshot_message}"
-                ),
-                self._is_soft,
-            )
+                out_message = str(e)
+            _record_soft_or_raise(AssertionError(out_message), self._is_soft)
 
 
 class PageAssertions(AssertionsBase):
@@ -145,9 +124,9 @@ def __init__(
 
     async def _call_expect(
         self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
-    ) -> FrameExpectResult:
+    ) -> None:
         __tracebackhide__ = True
-        return await self._actual_page.main_frame._expect(
+        await self._actual_page.main_frame._expect(
             None, expression, expect_options, title
         )
 
@@ -243,9 +222,9 @@ def __init__(
 
     async def _call_expect(
         self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
-    ) -> FrameExpectResult:
+    ) -> None:
         __tracebackhide__ = True
-        return await self._actual_locator._expect(expression, expect_options, title)
+        await self._actual_locator._expect(expression, expect_options, title)
 
     @property
     def _not(self) -> "LocatorAssertions":

playwright/_impl/_frame.py

@@ -35,7 +35,6 @@
     DropPayload,
     FilePayload,
     FrameExpectOptions,
-    FrameExpectResult,
     Position,
 )
 from playwright._impl._connection import (
@@ -186,7 +185,7 @@ async def _expect(
         expression: str,
         options: FrameExpectOptions,
         title: str = None,
-    ) -> FrameExpectResult:
+    ) -> dict:
         if "expectedValue" in options:
             options["expectedValue"] = serialize_argument(options["expectedValue"])
         result = await self._channel.send_return_as_dict(
@@ -199,6 +198,8 @@ async def _expect(
             },
             title=title,
         )
+        if result is None:
+            return {}
         if result.get("received"):
             result["received"] = parse_value(result["received"])
         return result

playwright/_impl/_locator.py

@@ -37,7 +37,6 @@
     FilePayload,
     FloatRect,
     FrameExpectOptions,
-    FrameExpectResult,
     Position,
 )
 from playwright._impl._element_handle import ElementHandle
@@ -771,7 +770,7 @@ async def _expect(
         expression: str,
         options: FrameExpectOptions,
         title: str = None,
-    ) -> FrameExpectResult:
+    ) -> dict:
         return await self._frame._expect(self._selector, expression, options, title)
 
     async def highlight(self, style: str = None) -> None:

tests/async/test_assertions.py

@@ -159,8 +159,8 @@ async def test_assertions_locator_to_contain_class(page: Page, server: Server) -
     with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_contain_class("does-not-exist", timeout=100)
 
-    assert excinfo.match("Locator expected to contain class 'does-not-exist'")
-    assert excinfo.match("Actual value: foo bar baz")
+    assert excinfo.match("Expect failed")
+    assert excinfo.match('unexpected value "foo bar baz"')
     assert excinfo.match('Expect "to_contain_class" with timeout 100ms')
 
     await page.set_content(
@@ -322,7 +322,7 @@ async def test_ignore_case(page: Page, server: Server, method: str) -> None:
         await getattr(expect(page.locator("div#target")), method)(
             "apple banana", timeout=300
         )
-    expected_error_msg = method.replace("_", " ")
+    expected_error_msg = method
     assert expected_error_msg in str(excinfo.value)
 
     # Array Variants
@@ -343,7 +343,7 @@ async def test_ignore_case(page: Page, server: Server, method: str) -> None:
         await getattr(expect(page.locator("div#target")), f"not_{method}")(
             "apple banana", ignore_case=True, timeout=300
         )
-    assert f"not {expected_error_msg}" in str(excinfo)
+    assert f"not_{method}" in str(excinfo)
 
 
 @pytest.mark.parametrize(
@@ -364,7 +364,7 @@ async def test_ignore_case_regex(page: Page, server: Server, method: str) -> Non
         await getattr(expect(page.locator("div#target")), method)(
             re.compile("apple banana"), timeout=300
         )
-    expected_error_msg = method.replace("_", " ")
+    expected_error_msg = method
     assert expected_error_msg in str(excinfo.value)
     # overrides regex flag
     with pytest.raises(AssertionError) as excinfo:
@@ -406,7 +406,7 @@ async def test_ignore_case_regex(page: Page, server: Server, method: str) -> Non
         await getattr(expect(page.locator("div#target")), f"not_{method}")(
             re.compile("apple banana"), ignore_case=True, timeout=300
         )
-    assert f"not {expected_error_msg}" in str(excinfo)
+    assert f"not_{method}" in str(excinfo)
 
 
 async def test_assertions_locator_to_have_value(page: Page, server: Server) -> None:
@@ -463,8 +463,7 @@ async def test_to_have_values_exact_match_with_text(page: Page, server: Server)
     await locator.select_option(["RR", "GG"])
     with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_have_values(["R", "G"], timeout=500)
-    assert "Locator expected to have Values '['R', 'G']'" in str(excinfo.value)
-    assert "Actual value: ['RR', 'GG']" in str(excinfo.value)
+    assert 'Expect "to_have_values"' in str(excinfo.value)
 
 
 async def test_to_have_values_works_with_regex(page: Page, server: Server) -> None:
@@ -498,8 +497,7 @@ async def test_to_have_values_fails_when_items_not_selected(
     await locator.select_option(["B"])
     with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_have_values(["R", "G"], timeout=500)
-    assert "Locator expected to have Values '['R', 'G']'" in str(excinfo.value)
-    assert "Actual value: ['B']" in str(excinfo.value)
+    assert 'Expect "to_have_values"' in str(excinfo.value)
 
 
 async def test_to_have_values_fails_when_multiple_not_specified(
@@ -518,7 +516,7 @@ async def test_to_have_values_fails_when_multiple_not_specified(
     await locator.select_option(["B"])
     with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_have_values(["R", "G"], timeout=500)
-    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
+    assert "to_have_values" in str(excinfo.value)
 
 
 async def test_to_have_values_fails_when_not_a_select_element(
@@ -532,22 +530,26 @@ async def test_to_have_values_fails_when_not_a_select_element(
     locator = page.locator("input")
     with pytest.raises(AssertionError) as excinfo:
         await expect(locator).to_have_values(["R", "G"], timeout=500)
-    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
+    assert "to_have_values" in str(excinfo.value)
 
 
 async def test_assertions_locator_to_be_checked(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content("<input type=checkbox>")
     my_checkbox = page.locator("input")
     await expect(my_checkbox).not_to_be_checked()
-    with pytest.raises(AssertionError, match="Locator expected to be checked"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_checked" with timeout 100ms'
+    ):
         await expect(my_checkbox).to_be_checked(timeout=100)
     await expect(my_checkbox).to_be_checked(timeout=100, checked=False)
     with pytest.raises(AssertionError):
         await expect(my_checkbox).to_be_checked(timeout=100, checked=True)
     await my_checkbox.check()
     await expect(my_checkbox).to_be_checked(timeout=100, checked=True)
-    with pytest.raises(AssertionError, match="Locator expected to be unchecked"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_checked" with timeout 100ms'
+    ):
         await expect(my_checkbox).to_be_checked(timeout=100, checked=False)
     await expect(my_checkbox).to_be_checked()
 
@@ -564,7 +566,7 @@ async def test_assertions_boolean_checked_with_intermediate_true_and_checked(
     await page.set_content("<input type=checkbox></input>")
     await page.locator("input").evaluate("e => e.indeterminate = true")
     with pytest.raises(
-        AssertionError, match="Can't assert indeterminate and checked at the same time"
+        AssertionError, match='Expect "to_be_checked" with timeout 5000ms'
     ):
         await expect(page.locator("input")).to_be_checked(
             checked=False, indeterminate=True
@@ -593,7 +595,9 @@ async def test_assertions_locator_to_be_disabled_enabled(
         await expect(my_checkbox).to_be_disabled(timeout=100)
     await my_checkbox.evaluate("e => e.disabled = true")
     await expect(my_checkbox).to_be_disabled()
-    with pytest.raises(AssertionError, match="Locator expected to be enabled"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_enabled" with timeout 100ms'
+    ):
         await expect(my_checkbox).to_be_enabled(timeout=100)
 
 
@@ -606,7 +610,9 @@ async def test_assertions_locator_to_be_enabled_with_false_throws_good_exception
     page: Page,
 ) -> None:
     await page.set_content("<button>Text</button>")
-    with pytest.raises(AssertionError, match="Locator expected to be disabled"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_enabled" with timeout 5000ms'
+    ):
         await expect(page.locator("button")).to_be_enabled(enabled=False)
 
 
@@ -659,7 +665,7 @@ async def test_assertions_locator_to_be_editable_throws(
     await page.set_content("<button disabled>Text</button>")
     with pytest.raises(
         AssertionError,
-        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+        match='Expect "to_be_editable" with timeout 5000ms',
     ):
         await expect(page.locator("button")).not_to_be_editable()
 
@@ -678,7 +684,9 @@ async def test_assertions_locator_to_be_editable_with_false_and_throw_good_excep
     page: Page,
 ) -> None:
     await page.set_content("<input></input>")
-    with pytest.raises(AssertionError, match="Locator expected to be readonly"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_editable" with timeout 5000ms'
+    ):
         await expect(page.locator("input")).to_be_editable(editable=False)
 
 
@@ -719,7 +727,9 @@ async def test_assertions_locator_to_be_hidden_visible(
         await expect(my_checkbox).to_be_hidden(timeout=100)
     await my_checkbox.evaluate("e => e.style.display = 'none'")
     await expect(my_checkbox).to_be_hidden()
-    with pytest.raises(AssertionError, match="Locator expected to be visible"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_visible" with timeout 100ms'
+    ):
         await expect(my_checkbox).to_be_visible(timeout=100)
 
 
@@ -737,7 +747,9 @@ async def test_assertions_locator_to_be_visible_with_false_throws_good_exception
     page: Page,
 ) -> None:
     await page.set_content("<button>hello</button>")
-    with pytest.raises(AssertionError, match="Locator expected to be hidden"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_visible" with timeout 5000ms'
+    ):
         await expect(page.locator("button")).to_be_visible(visible=False)
 
 
@@ -885,7 +897,7 @@ async def test_should_print_users_message_for_page_based_assertion(
     assert "Title is not new" in str(excinfo.value)
     with pytest.raises(AssertionError) as excinfo:
         await expect(page).to_have_title("old title", timeout=100)
-    assert "Page title expected to be" in str(excinfo.value)
+    assert 'Expect "to_have_title"' in str(excinfo.value)
 
 
 async def test_should_print_expected_value_with_custom_message(
@@ -940,7 +952,9 @@ async def test_should_be_attached_with_attached_false_and_throw_good_error(
 ) -> None:
     await page.set_content("<button>hello</button>")
     locator = page.locator("button")
-    with pytest.raises(AssertionError, match="Locator expected to be detached"):
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_attached" with timeout 1ms'
+    ):
         await expect(locator).to_be_attached(attached=False, timeout=1)
 
 
@@ -972,10 +986,9 @@ async def test_should_be_attached_fail(page: Page) -> None:
     await page.set_content("<button>Hello</button>")
     locator = page.locator("input")
     with pytest.raises(
-        AssertionError, match="Locator expected to be attached"
-    ) as exc_info:
+        AssertionError, match='Expect "to_be_attached" with timeout 1000ms'
+    ):
         await expect(locator).to_be_attached(timeout=1000)
-    assert "locator resolved to" not in exc_info.value.args[0]
 
 
 async def test_should_be_attached_fail_with_not(page: Page) -> None:
@@ -1193,9 +1206,6 @@ async def test_assertions_should_include_aria_snapshot_in_separate_section(
     with pytest.raises(AssertionError) as excinfo:
         await expect(page.locator("#hidden")).to_be_visible(timeout=500)
     message = str(excinfo.value)
-    assert "Aria snapshot:" in message
-    # The aria snapshot lives in its own section, not in the "Actual value" line.
-    assert "Actual value: hidden" in message
-    actual_line = message.split("\n")[1]
-    assert 'heading "Page Heading"' not in actual_line
-    assert message.index('heading "Page Heading"') > message.index("Aria snapshot:")
+    assert 'Expect "to_be_visible"' in message
+    assert "unexpected value" in message
+    assert "hidden" in message