timeout vs timedOut

Author: dgozman

packages/playwright/src/matchers/matcherHint.ts

@@ -29,6 +29,7 @@ type MatcherMessageDetails = {
   printedExpected?: string;
   printedReceived?: string;
   printedDiff?: string;
+  timedOut?: boolean;
   timeout?: number;
   errorMessage?: string;
   log?: string[];
@@ -59,7 +60,7 @@ export function formatMatcherMessage(state: ExpectMatcherState, details: Matcher
     message += details.printedExpected + '\n';
   if (details.printedReceived)
     message += details.printedReceived + '\n';
-  if (details.timeout)
+  if (details.timedOut && details.timeout)
     message += `Timeout: ${align ? ' ' : ''}${details.timeout}ms\n`;
   if (details.printedDiff)
     message += details.printedDiff + '\n';

packages/playwright/src/matchers/toBeTruthy.ts

@@ -61,7 +61,8 @@ export async function toBeTruthy(
       matcherName,
       expectation: arg,
       locator,
-      timeout: timedOut ? timeout : undefined,
+      timeout,
+      timedOut,
       printedExpected,
       printedReceived,
       errorMessage,

packages/playwright/src/matchers/toEqual.ts

@@ -89,7 +89,8 @@ export async function toEqual<T>(
       matcherName,
       expectation: 'expected',
       locator,
-      timeout: timedOut ? timeout : undefined,
+      timeout,
+      timedOut,
       printedExpected,
       printedReceived,
       printedDiff,

packages/playwright/src/matchers/toHaveURL.ts

@@ -90,7 +90,7 @@ function toHaveURLMessage(
   expected: Function,
   received: string | undefined,
   pass: boolean,
-  didTimeout: boolean,
+  timedOut: boolean,
   timeout: number,
 ): string {
   const receivedString = received || '';
@@ -115,7 +115,8 @@ function toHaveURLMessage(
   return formatMatcherMessage(state, {
     matcherName,
     expectation: 'expected',
-    timeout: didTimeout ? timeout : undefined,
+    timeout,
+    timedOut,
     printedExpected,
     printedReceived,
     printedDiff,

packages/playwright/src/matchers/toMatchAriaSnapshot.ts

@@ -85,7 +85,6 @@ export async function toMatchAriaSnapshot(
   expected = unshift(expected);
   const { matches: pass, received, log, timedOut, errorMessage } = await locator._expect('to.match.aria', { expectedValue: expected, isNot: this.isNot, timeout });
   const typedReceived = received as MatcherReceived;
-  const receivedText = typedReceived.raw;
 
   const message = () => {
     let printedExpected: string | undefined;
@@ -94,17 +93,18 @@ export async function toMatchAriaSnapshot(
     if (errorMessage) {
       printedExpected = `Expected: ${this.isNot ? 'not ' : ''}${this.utils.printExpected(expected)}`;
     } else if (pass) {
-      const receivedString = printReceivedStringContainExpectedSubstring(receivedText, receivedText.indexOf(expected), expected.length);
+      const receivedString = printReceivedStringContainExpectedSubstring(typedReceived.raw, typedReceived.raw.indexOf(expected), expected.length);
       printedExpected = `Expected: not ${this.utils.printExpected(expected)}`;
       printedReceived = `Received: ${receivedString}`;
     } else {
-      printedDiff = this.utils.printDiffOrStringify(expected, receivedText, 'Expected', 'Received', false);
+      printedDiff = this.utils.printDiffOrStringify(expected, typedReceived.raw, 'Expected', 'Received', false);
     }
     return formatMatcherMessage(this, {
       matcherName,
       expectation: 'expected',
       locator,
-      timeout: timedOut ? timeout : undefined,
+      timeout,
+      timedOut,
       printedExpected,
       printedReceived,
       printedDiff,

packages/playwright/src/matchers/toMatchSnapshot.ts

@@ -381,7 +381,7 @@ export async function toHaveScreenshot(
     // We tried re-generating new snapshot but failed.
     // This can be due to e.g. spinning animation, so we want to show it as a diff.
     if (errorMessage) {
-      const header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout: timedOut ? timeout : undefined });
+      const header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout, timedOut });
       return helper.handleDifferent(actual, undefined, previous, diff, header, errorMessage, log, this._stepInfo);
     }
 
@@ -416,12 +416,12 @@ export async function toHaveScreenshot(
   if (helper.updateSnapshots === 'changed' || helper.updateSnapshots === 'all') {
     if (actual)
       return writeFiles(actual);
-    let header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout: timedOut ? timeout : undefined });
+    let header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout, timedOut });
     header += '  Failed to re-generate expected.\n';
     return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);
   }
 
-  const header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout: timedOut ? timeout : undefined });
+  const header = formatMatcherMessage(this, { matcherName: 'toHaveScreenshot', locator, expectation: 'expected', timeout, timedOut });
   return helper.handleDifferent(actual, expectScreenshotOptions.expected, previous, diff, header, errorMessage, log, this._stepInfo);
 }
 

packages/playwright/src/matchers/toMatchText.ts

@@ -93,7 +93,8 @@ export async function toMatchText(
       matcherName,
       expectation: 'expected',
       locator,
-      timeout: timedOut ? timeout : undefined,
+      timeout,
+      timedOut,
       printedExpected,
       printedReceived,
       printedDiff,

tests/playwright-test/expect-configure.spec.ts

@@ -49,7 +49,7 @@ test('should configure message', async ({ runInlineTest }) => {
   expect(result.passed).toBe(0);
   expect(result.output).toContain('Error: x-foo must be visible');
   expect(result.output).toContain('expect(locator).toBeVisible() failed');
-  expect(result.output).toContain('Timeout:  1ms');
+  expect(result.output).toContain('Timeout: 1ms');
   expect(result.output).toContain('Call log:');
 });
 
@@ -68,7 +68,7 @@ test('should prefer local message', async ({ runInlineTest }) => {
 
   expect(result.output).toContain('Error: overridden');
   expect(result.output).toContain(`expect(locator).toBeVisible() failed`);
-  expect(result.output).toContain('Timeout:  1ms');
+  expect(result.output).toContain('Timeout: 1ms');
   expect(result.output).toContain('Call log:');
 });
 

tests/playwright-test/expect.spec.ts

@@ -68,7 +68,7 @@ test('should include custom expect message with web-first assertions', async ({
 
   expect(result.output).toContain('Error: x-foo must be visible');
   expect(result.output).toContain('expect(locator).toBeVisible() failed');
-  expect(result.output).toContain('Timeout:  1ms');
+  expect(result.output).toContain('Timeout: 1ms');
   expect(result.output).toContain('Call log:');
 });
 
@@ -533,13 +533,13 @@ test('should support toHaveURL with baseURL from webServer', async ({ runInlineT
   }, { workers: 1 });
   const output = result.output;
   expect(output).toContain('expect(page).toHaveURL');
-  expect(output).toContain(`Expected string: \"http://localhost:${port}/kek\"`);
+  expect(output).toContain(`Expected: \"http://localhost:${port}/kek\"`);
   expect(result.passed).toBe(1);
   expect(result.failed).toBe(1);
   expect(result.exitCode).toBe(1);
 });
 
-test('should respect expect.timeout', async ({ runInlineTest }) => {
+test('should respect expect.timeout in toHaveURL', async ({ runInlineTest }) => {
   const result = await runInlineTest({
     'playwright.config.js': `module.exports = { expect: { timeout: 1000 } }`,
     'a.test.ts': `
@@ -550,7 +550,7 @@ test('should respect expect.timeout', async ({ runInlineTest }) => {
         await page.goto('data:text/html,<div>A</div>');
         const error = await expect(page).toHaveURL('data:text/html,<div>B</div>').catch(e => e);
         expect(stripVTControlCharacters(error.message)).toContain('expect(page).toHaveURL(expected) failed');
-        expect(stripVTControlCharacters(error.message)).toContain('Timeout: 1000ms');
+        expect(stripVTControlCharacters(error.message)).toContain('Timeout:  1000ms');
         expect(error.message).toContain('data:text/html,<div>');
       });
       `,
@@ -570,7 +570,7 @@ test('should support toHaveURL predicate', async ({ runInlineTest }) => {
         await page.goto('data:text/html,<div>A</div>');
         const error = await expect(page).toHaveURL(url => url === 'data:text/html,<div>B</div>').catch(e => e);
         expect(stripVTControlCharacters(error.message)).toContain('expect(page).toHaveURL(expected) failed');
-        expect(stripVTControlCharacters(error.message)).toContain('Timeout: 1000ms');
+        expect(stripVTControlCharacters(error.message)).toContain('Timeout:  1000ms');
         expect(error.message).toContain('data:text/html,<div>');
       });
       `,
@@ -615,8 +615,8 @@ test('should print expected/received before timeout', async ({ runInlineTest })
   expect(result.passed).toBe(0);
   expect(result.failed).toBe(1);
   expect(result.output).toContain('Test timeout of 2000ms exceeded.');
-  expect(result.output).toContain('Expected string: "Text 2"');
-  expect(result.output).toContain('Received string: "Text content"');
+  expect(result.output).toContain('Expected: "Text 2"');
+  expect(result.output).toContain('Received: "Text content"');
 });
 
 test('should print pending operations for toHaveText', async ({ runInlineTest }) => {
@@ -634,7 +634,7 @@ test('should print pending operations for toHaveText', async ({ runInlineTest })
   expect(result.exitCode).toBe(1);
   const output = result.output;
   expect(output).toContain(`expect(locator).toHaveText(expected)`);
-  expect(output).toContain('Expected string: "Text"');
+  expect(output).toContain('Expected: "Text"');
   expect(output).toContain('Error: element(s) not found');
   expect(output).toContain('waiting for locator(\'no-such-thing\')');
 });
@@ -690,8 +690,8 @@ test('should print expected/received on Ctrl+C', async ({ interactWithTestRunner
   const result = parseTestRunnerOutput(testProcess.output);
   expect(result.passed).toBe(0);
   expect(result.interrupted).toBe(1);
-  expect(result.output).toContain('Expected string: "Text 2"');
-  expect(result.output).toContain('Received string: "Text content"');
+  expect(result.output).toContain('Expected: "Text 2"');
+  expect(result.output).toContain('Received: "Text content"');
 });
 
 test('should not print timed out error message when test times out', async ({ runInlineTest }) => {
@@ -1024,7 +1024,7 @@ test('should respect timeout from configured expect when used outside of the tes
   expect(code).toBe(1);
   expect(stdout).toBe('');
   expect(stripAnsi(stderr)).toContain('expect(locator).toBeAttached() failed');
-  expect(stripAnsi(stderr)).toContain('Timeout:  10ms');
+  expect(stripAnsi(stderr)).toContain('Timeout: 10ms');
 });
 
 test('should expose timeout to custom matchers', async ({ runInlineTest, runTSC }) => {

tests/playwright-test/watch.spec.ts

@@ -721,7 +721,7 @@ test('should run CT on changed deps', async ({ runWatchTest, writeFiles }) => {
   await testProcess.waitForOutput(`src${path.sep}button.spec.tsx:4:11 › pass`);
   expect(testProcess.output).not.toContain(`src${path.sep}link.spec.tsx`);
   await testProcess.waitForOutput(`Error: expect(locator).toHaveText(expected) failed`);
-  await testProcess.waitForOutput('Timeout: 1000ms');
+  await testProcess.waitForOutput('Timeout:  1000ms');
   await testProcess.waitForOutput('Waiting for file changes.');
 });