Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

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

Adam Gastineau7f2ceda2492c
diff --git a/packages/playwright/src/reporters/base.ts b/packages/playwright/src/reporters/base.ts
index 58b98a9574..97b41d27a0 100644
--- a/packages/playwright/src/reporters/base.ts
+++ b/packages/playwright/src/reporters/base.ts
@@ -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);
}
diff --git a/packages/playwright/src/worker/workerMain.ts b/packages/playwright/src/worker/workerMain.ts
index 54f5bf6968..e7110517ec 100644
--- a/packages/playwright/src/worker/workerMain.ts
+++ b/packages/playwright/src/worker/workerMain.ts
@@ -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;
diff --git a/tests/playwright-test/warnings.spec.ts b/tests/playwright-test/warnings.spec.ts
index 2734c9593e..a19910bd10 100644
--- a/tests/playwright-test/warnings.spec.ts
+++ b/tests/playwright-test/warnings.spec.ts
@@ -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);
+ });
+});