chore(expect): preserve received value on Frame.expect success

Restores `received` in the FrameExpect success response so matchers and
trace viewer can use it. `toMatchAriaSnapshot` needs it to write
rebaselines in `--update-snapshots=all` mode; the trace viewer's "Return
value" section uses it to display the matched text.

Author: dgozman

packages/playwright-core/src/client/frame.ts

@@ -492,8 +492,12 @@ export class Frame extends ChannelOwner<channels.FrameChannel> implements api.Fr
     const params: channels.FrameExpectParams = { expression, ...options, isNot: !!options.isNot };
     params.expectedValue = serializeArgument(options.expectedValue);
     try {
-      await this._channel.expect(params);
-      return { matches: !params.isNot };
+      const channelResult = await this._channel.expect(params);
+      const received = channelResult.received ? {
+        value: channelResult.received.value !== undefined ? parseResult(channelResult.received.value) : undefined,
+        ariaSnapshot: channelResult.received.ariaSnapshot,
+      } : undefined;
+      return { matches: !params.isNot, received };
     } catch (e) {
       if (!(e instanceof PlaywrightError) || !e.details)
         throw e;

packages/playwright-core/src/protocol/validator.ts

@@ -1620,7 +1620,12 @@ scheme.FrameExpectParams = tObject({
   isNot: tBoolean,
   timeout: tFloat,
 });
-scheme.FrameExpectResult = tOptional(tObject({}));
+scheme.FrameExpectResult = tObject({
+  received: tOptional(tObject({
+    value: tOptional(tType('SerializedValue')),
+    ariaSnapshot: tOptional(tString),
+  })),
+});
 scheme.FrameExpectErrorDetails = tObject({
   received: tOptional(tObject({
     value: tOptional(tType('SerializedValue')),

packages/playwright-core/src/server/dispatchers/frameDispatcher.ts

@@ -280,7 +280,15 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameChannel, Br
       expectedValue = parseAriaSnapshotUnsafe(yaml, expectedValue);
     progress.log(`${renderTitleForCall(progress.metadata)}${params.timeout ? ` with timeout ${params.timeout}ms` : ''}`);
     try {
-      await this._frame.expect(progress, params.selector, { ...params, expectedValue });
+      const result = await this._frame.expect(progress, params.selector, { ...params, expectedValue });
+      if (result.received === undefined)
+        return {};
+      return {
+        received: {
+          value: result.received.value !== undefined ? serializeResult(result.received.value) : undefined,
+          ariaSnapshot: result.received.ariaSnapshot,
+        },
+      };
     } catch (e) {
       if (e instanceof ExpectError && e.details.received && 'value' in e.details.received)
         e.details.received.value = serializeResult(e.details.received.value);

packages/playwright-core/src/server/frames.ts

@@ -1466,7 +1466,7 @@ export class Frame extends SdkObject<FrameEventMap> {
     return progress.wait(timeout);
   }
 
-  async expect(progress: Progress, selector: string | undefined, options: FrameExpectParams): Promise<void> {
+  async expect(progress: Progress, selector: string | undefined, options: FrameExpectParams): Promise<{ received?: ExpectReceived }> {
     // `isSet` distinguishes "not collected yet" from "collected with received: undefined".
     const lastIntermediateResult: { isSet: boolean, received?: ExpectReceived, errorMessage?: string } = { isSet: false };
     try {
@@ -1481,15 +1481,15 @@ export class Frame extends SdkObject<FrameEventMap> {
       try {
         const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
         if (resultOneShot.matches !== options.isNot)
-          return;
+          return { received: resultOneShot.received };
       } catch (e) {
         if (this.isNonRetriableError(e))
           throw e;
         // Ignore any other errors from one-shot, we'll handle them during retries.
       }
 
       // Step 3: auto-retry expect with increasing timeouts. Bounded by the total remaining time.
-      await this.retryWithProgressAndBackoff(progress, async (progress, continuePolling) => {
+      const result = await this.retryWithProgressAndBackoff(progress, async (progress, continuePolling) => {
         await this._page.performActionPreChecks(progress);
         const { matches, received } = await this._expectInternal(progress, selector, options, lastIntermediateResult, false);
         if (matches === options.isNot) {
@@ -1500,6 +1500,7 @@ export class Frame extends SdkObject<FrameEventMap> {
         }
         return { matches, received };
       });
+      return { received: result.received };
     } catch (e) {
       let message = 'Expect failed';
       const details: ExpectErrorDetails = {};

packages/protocol/spec/frame.yml

@@ -764,6 +764,12 @@ Frame:
         useInnerText: boolean?
         isNot: boolean
         timeout: float
+      returns:
+        received:
+          type: object?
+          properties:
+            value: SerializedValue?
+            ariaSnapshot: string?
       errorDetails:
         received:
           type: object?

packages/protocol/src/channels.d.ts

@@ -2961,7 +2961,12 @@ export type FrameExpectOptions = {
   expectedValue?: SerializedArgument,
   useInnerText?: boolean,
 };
-export type FrameExpectResult = void;
+export type FrameExpectResult = {
+  received?: {
+    value?: SerializedValue,
+    ariaSnapshot?: string,
+  },
+};
 export type FrameExpectErrorDetails = {
   received?: {
     value?: SerializedValue,

tests/library/trace-viewer.spec.ts

@@ -370,7 +370,6 @@ test('should show params and return value', async ({ showTraceViewer }) => {
     /locator:locator\('button'\)/,
     /expression:"to.have.text"/,
     /timeout:10000/,
-    /matches:true/,
     /received:"Click"/,
   ]);
 });