kyfx
/
playwright
mirror of https://github.com/microsoft/playwright.git
4
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert "chore: temporarily disable floating promise warning messages (#34957) (#35374)

This commit is contained in:
Adam Gastineau 2025-03-31 07:16:00 -07:00 committed by GitHub
parent aa278d3aed
commit 7f2ceda249
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 241 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
packages/playwright/src/reporters/base.ts
View File

@ -269,8 +269,7 @@ export class TerminalReporter implements ReporterV2 {
if (full && summary.failuresToPrint.length && !this._omitFailures)
this._printFailures(summary.failuresToPrint);
this._printSlowTests();
// TODO: 1.52: Make warning display prettier
// this._printWarnings();
this._printWarnings();
this._printSummary(summaryMessage);
}

20
packages/playwright/src/worker/workerMain.ts
View File

@ -324,17 +324,6 @@ export class WorkerMain extends ProcessRunner {
testInfo._allowSkips = true;
// Create warning if any of the async calls were not awaited in various stages.
const checkForFloatingPromises = (functionDescription: string) => {
if (process.env.PW_DISABLE_FLOATING_PROMISES_WARNING)
return;
if (!testInfo._floatingPromiseScope.hasFloatingPromises())
return;
// TODO: 1.52: Actually build annotations
// testInfo.annotations.push({ type: 'warning', description: `Some async calls were not awaited by the end of ${functionDescription}. This can cause flakiness.` });
testInfo._floatingPromiseScope.clear();
};
await (async () => {
await testInfo._runWithTimeout({ type: 'test' }, async () => {
// Ideally, "trace" would be an config-level option belonging to the
@ -374,8 +363,6 @@ export class WorkerMain extends ProcessRunner {
testFunctionParams = await this._fixtureRunner.resolveParametersForFunction(test.fn, testInfo, 'test', { type: 'test' });
});
checkForFloatingPromises('beforeAll/beforeEach hooks');
if (testFunctionParams === null) {
// Fixture setup failed or was skipped, we should not run the test now.
return;
@ -385,7 +372,6 @@ export class WorkerMain extends ProcessRunner {
// Now run the test itself.
const fn = test.fn; // Extract a variable to get a better stack trace ("myTest" vs "TestCase.myTest [as fn]").
await fn(testFunctionParams, testInfo);
checkForFloatingPromises('the test');
});
})().catch(() => {}); // Ignore the top-level error, it is already inside TestInfo.errors.
@ -443,7 +429,11 @@ export class WorkerMain extends ProcessRunner {
throw firstAfterHooksError;
}).catch(() => {}); // Ignore the top-level error, it is already inside TestInfo.errors.
checkForFloatingPromises('afterAll/afterEach hooks');
// Create warning if any of the async calls were not awaited in various stages.
if (!process.env.PW_DISABLE_FLOATING_PROMISES_WARNING && testInfo._floatingPromiseScope.hasFloatingPromises()) {
testInfo.annotations.push({ type: 'warning', description: `Some async calls were not awaited by the end of the test. This can cause flakiness.` });
testInfo._floatingPromiseScope.clear();
}
if (testInfo._isFailure())
this._isStopped = true;

487
tests/playwright-test/warnings.spec.ts
View File

@ -14,274 +14,257 @@
* limitations under the License.
*/
// import { JSONReport } from 'packages/playwright-test/reporter';
// import { test, expect } from './playwright-test-fixtures';
import { test, expect } from './playwright-test-fixtures';
// const warningSnippet = 'Some async calls were not awaited';
const warningSnippet = 'Some async calls were not awaited by the end of the test';
// test.describe.configure({ mode: 'parallel' });
test.describe.configure({ mode: 'parallel' });
// const getWarnings = (report: JSONReport) => report.suites.flatMap(s => s.specs).flatMap(s => s.tests).flatMap(t => t.annotations).filter(a => a.type === 'warning');
test.describe('await', () => {
test('should not care about non-API promises', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test } from '@playwright/test';
test('test', () => {
new Promise(() => {});
});
`
});
expect(exitCode).toBe(0);
expect(stdout).not.toContain(warningSnippet);
});
// test.describe('await', () => {
// test('should not care about non-API promises', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test } from '@playwright/test';
// test('test', () => {
// new Promise(() => {});
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(0);
// });
test('should warn about missing await on expects when failing', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('custom test name', async ({ page }) => {
expect(page.locator('div')).toHaveText('A', { timeout: 100 });
// Timeout to make sure the expect actually gets processed
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(1);
expect(stdout).toContain(warningSnippet);
expect(stdout).toContain('the test');
expect(stdout).toContain('custom test name');
});
// test('should warn about missing await on expects when failing', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('custom test name', async ({ page }) => {
// expect(page.locator('div')).toHaveText('A', { timeout: 100 });
// });
// `
// });
// expect(exitCode).toBe(1);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// expect(warnings[0].description).toContain('the test');
// });
test('should warn about missing await on expects when passing', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
expect(page.locator('div')).toHaveText('A');
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
// test('should warn about missing await on expects when passing', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// expect(page.locator('div')).toHaveText('A');
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// });
test('should not warn when not missing await on expects when failing', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await expect(page.locator('div')).toHaveText('A', { timeout: 100 });
});
`
});
expect(exitCode).toBe(1);
expect(stdout).not.toContain(warningSnippet);
});
// test('should not warn when not missing await on expects when failing', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await expect(page.locator('div')).toHaveText('A', { timeout: 100 });
// });
// `
// });
// expect(exitCode).toBe(1);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(0);
// });
test('should not warn when not missing await on expects when passing', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
await expect(page.locator('div')).toHaveText('A');
});
`
});
expect(exitCode).toBe(0);
expect(stdout).not.toContain(warningSnippet);
});
// test('should not warn when not missing await on expects when passing', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// await expect(page.locator('div')).toHaveText('A');
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(0);
// });
test('should not warn when using then on expects when passing', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
expect(page.locator('div')).toHaveText('A').then(() => {});
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(0);
expect(stdout).not.toContain(warningSnippet);
});
// test('should not warn when using then on expects when passing', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// expect(page.locator('div')).toHaveText('A').then(() => {});
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(0);
// });
test('should warn about missing await on reject', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
expect(Promise.reject(new Error('foo'))).rejects.toThrow('foo');
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
// test('should warn about missing await on reject', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// expect(Promise.reject(new Error('foo'))).rejects.toThrow('foo');
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// });
test('should warn about missing await on reject.not', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
expect(Promise.reject(new Error('foo'))).rejects.not.toThrow('foo');
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(1);
expect(stdout).toContain(warningSnippet);
});
// test('should warn about missing await on reject.not', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// expect(Promise.reject(new Error('foo'))).rejects.not.toThrow('foo');
// });
// `
// });
// expect(exitCode).toBe(1);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// });
test('should warn about missing await on test.step', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
test.step('step', () => {});
await expect(page.locator('div')).toHaveText('A');
});
`
});
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
// test('should warn about missing await on test.step', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// test.step('step', () => {});
// await expect(page.locator('div')).toHaveText('A');
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// });
test('should not warn when not missing await on test.step', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
await test.step('step', () => {});
await expect(page.locator('div')).toHaveText('A');
});
`
});
expect(exitCode).toBe(0);
expect(stdout).not.toContain(warningSnippet);
});
// test('should not warn when not missing await on test.step', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// await test.step('step', () => {});
// await expect(page.locator('div')).toHaveText('A');
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(0);
// });
test('should warn about missing await on test.step.skip', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
test.step.skip('step', () => {});
await expect(page.locator('div')).toHaveText('A');
});
`
});
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
// test('should warn about missing await on test.step.skip', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// test.step.skip('step', () => {});
// await expect(page.locator('div')).toHaveText('A');
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// });
test('traced promise should be instanceof Promise', async ({ runInlineTest }) => {
const { exitCode } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test('test', async ({ page }) => {
await page.setContent('<div>A</div>');
const expectPromise = expect(page.locator('div')).toHaveText('A');
expect(expectPromise instanceof Promise).toBeTruthy();
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(0);
});
// test('traced promise should be instanceof Promise', async ({ runInlineTest }) => {
// const { exitCode } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test('test', async ({ page }) => {
// await page.setContent('<div>A</div>');
// const expectPromise = expect(page.locator('div')).toHaveText('A');
// expect(expectPromise instanceof Promise).toBeTruthy();
// });
// `
// });
// expect(exitCode).toBe(0);
// });
test('should warn about missing await in before hooks', async ({ runInlineTest }) => {
const group = ['beforeAll', 'beforeEach'];
for (const hook of group) {
await test.step(hook, async () => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
let page;
test.${hook}(async ({ browser }) => {
page = await browser.newPage();
await page.setContent('<div>A</div>');
expect(page.locator('div')).toHaveText('A');
await new Promise(f => setTimeout(f, 1000));
});
test('test ${hook}', async () => {
await expect(page.locator('div')).toBeVisible();
});
`
});
// test('should warn about missing await in before hooks', async ({ runInlineTest }) => {
// const group = ['beforeAll', 'beforeEach'];
// for (const hook of group) {
// await test.step(hook, async () => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// let page;
// test.${hook}(async ({ browser }) => {
// page = await browser.newPage();
// await page.setContent('<div>A</div>');
// expect(page.locator('div')).toHaveText('A');
// });
// test('test ${hook}', async () => {
// await expect(page.locator('div')).toBeVisible();
// });
// `
// });
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
}
});
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// expect(warnings[0].description).toContain(`${group[0]}/${group[1]} hooks`);
// });
// }
// });
test.describe('should warn about missing await in after hooks', () => {
const group = ['afterAll', 'afterEach'];
for (const hook of group) {
test(hook, async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
let page;
test('test ${hook}', async ({ browser }) => {
await expect(Promise.resolve()).resolves.toBe(undefined);
});
test.${hook}(async () => {
expect(Promise.resolve()).resolves.toBe(undefined);
await new Promise(f => setTimeout(f, 1000));
});
`
});
// test.describe('should warn about missing await in after hooks', () => {
// const group = ['afterAll', 'afterEach'];
// for (const hook of group) {
// test(hook, async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// let page;
// test('test ${hook}', async ({ browser }) => {
// await expect(Promise.resolve()).resolves.toBe(undefined);
// });
// test.${hook}(async () => {
// expect(Promise.resolve()).resolves.toBe(undefined);
// });
// `
// });
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
}
});
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(1);
// expect(warnings[0].description).toContain(warningSnippet);
// expect(warnings[0].description).toContain(`${group[0]}/${group[1]} hooks`);
// });
// }
// });
// test('should warn about missing await across hooks and test', async ({ runInlineTest }) => {
// const { exitCode, report } = await runInlineTest({
// 'a.test.ts': `
// import { test, expect } from '@playwright/test';
// test.beforeAll(async () => {
// expect(Promise.resolve()).resolves.toBe(undefined);
// });
// test('test', async () => {
// expect(Promise.resolve()).resolves.toBe(undefined);
// });
// test.afterEach(async () => {
// expect(Promise.resolve()).resolves.toBe(undefined);
// });
// `
// });
// expect(exitCode).toBe(0);
// const warnings = getWarnings(report);
// expect(warnings.length).toEqual(3);
// expect(warnings[0].description).toContain(`${warningSnippet} by the end of beforeAll/beforeEach hooks.`);
// expect(warnings[1].description).toContain(`${warningSnippet} by the end of the test.`);
// expect(warnings[2].description).toContain(`${warningSnippet} by the end of afterAll/afterEach hooks.`);
// });
// });
test('should warn about missing await across hooks and test', async ({ runInlineTest }) => {
const { exitCode, stdout } = await runInlineTest({
'a.test.ts': `
import { test, expect } from '@playwright/test';
test.beforeAll(async () => {
expect(Promise.resolve()).resolves.toBe(undefined);
await new Promise(f => setTimeout(f, 1000));
});
test('test', async () => {
expect(Promise.resolve()).resolves.toBe(undefined);
await new Promise(f => setTimeout(f, 1000));
});
test.afterEach(async () => {
expect(Promise.resolve()).resolves.toBe(undefined);
await new Promise(f => setTimeout(f, 1000));
});
`
});
expect(exitCode).toBe(0);
expect(stdout).toContain(warningSnippet);
});
});