Interface TestType<TestArgs, WorkerArgs>

describe

test.describe('two tests', () => {
  test('one', async ({ page }) => {
    // ...
  });

  test('two', async ({ page }) => {
    // ...
  });
});
Copy

test.describe(() => {
  test.use({ colorScheme: 'dark' });

  test('one', async ({ page }) => {
    // ...
  });

  test('two', async ({ page }) => {
    // ...
  });
});
Copy

import { test, expect } from '@playwright/test';

test.describe('two tagged tests', {
  tag: '@smoke',
}, () => {
  test('one', async ({ page }) => {
    // ...
  });

  test('two', async ({ page }) => {
    // ...
  });
});
Copy

import { test, expect } from '@playwright/test';

test.describe('two annotated tests', {
  annotation: {
    type: 'issue',
    description: 'https://github.com/microsoft/playwright/issues/23180',
  },
}, () => {
  test('one', async ({ page }) => {
    // ...
  });

  test('two', async ({ page }) => {
    // ...
  });
});
Copy

expect

test('example', async ({ page }) => {
  await test.expect(page).toHaveTitle('Title');
});
Copy

only

test.only('focus this test', async ({ page }) => {
  // Run only focused tests in the entire project.
});
Copy

afterAll

• afterAll(inner): void

• Declares an afterAll hook that is executed once per worker after all tests.

  When called in the scope of a test file, runs after all tests in the file. When called inside a test.describe([title, details, callback]) group, runs after all tests in the group.

  Details

  When multiple afterAll hooks are added, they will run in the order of their registration.

  Note that worker process is restarted on test failures, and afterAll hook runs again in the new worker. Learn more about workers and failures.

  Playwright will continue running all applicable hooks even if some of them have failed.

  • test.afterAll(hookFunction)
  • test.afterAll(title, hookFunction)

  Usage

  test.afterAll(async () => {
    console.log('Done with tests');
    // ...
  });
  Copy

  Alternatively, you can declare a hook with a title.

  test.afterAll('Teardown', async () => {
    console.log('Done with tests');
    // ...
  });
  Copy

  Parameters

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void
• afterAll(title, inner): void

• Declares an afterAll hook that is executed once per worker after all tests.

  When called in the scope of a test file, runs after all tests in the file. When called inside a test.describe([title, details, callback]) group, runs after all tests in the group.

  Details

  When multiple afterAll hooks are added, they will run in the order of their registration.

  Note that worker process is restarted on test failures, and afterAll hook runs again in the new worker. Learn more about workers and failures.

  Playwright will continue running all applicable hooks even if some of them have failed.

  • test.afterAll(hookFunction)
  • test.afterAll(title, hookFunction)

  Usage

  test.afterAll(async () => {
    console.log('Done with tests');
    // ...
  });
  Copy

  Alternatively, you can declare a hook with a title.

  test.afterAll('Teardown', async () => {
    console.log('Done with tests');
    // ...
  });
  Copy

  Parameters

  • title: string

    Hook title.

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void

afterEach

• afterEach(inner): void

• Declares an afterEach hook that is executed after each test.

  When called in the scope of a test file, runs after each test in the file. When called inside a test.describe([title, details, callback]) group, runs after each test in the group.

  You can access all the same Fixtures as the test body itself, and also the TestInfo object that gives a lot of useful information. For example, you can check whether the test succeeded or failed.

  • test.afterEach(hookFunction)
  • test.afterEach(title, hookFunction)

  Details

  When multiple afterEach hooks are added, they will run in the order of their registration.

  Playwright will continue running all applicable hooks even if some of them have failed.

  Usage

  // example.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.afterEach(async ({ page }) => {
    console.log(`Finished ${test.info().title} with status ${test.info().status}`);
  
    if (test.info().status !== test.info().expectedStatus)
      console.log(`Did not run as expected, ended up at ${page.url()}`);
  });
  
  test('my test', async ({ page }) => {
    // ...
  });
  Copy

  Alternatively, you can delcare a hook with a title.

  // example.spec.ts
  test.afterEach('Status check', async ({ page }) => {
    if (test.info().status !== test.info().expectedStatus)
      console.log(`Did not run as expected, ended up at ${page.url()}`);
  });
  Copy

  Parameters

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void
• afterEach(title, inner): void

• Declares an afterEach hook that is executed after each test.

  When called in the scope of a test file, runs after each test in the file. When called inside a test.describe([title, details, callback]) group, runs after each test in the group.

  You can access all the same Fixtures as the test body itself, and also the TestInfo object that gives a lot of useful information. For example, you can check whether the test succeeded or failed.

  • test.afterEach(hookFunction)
  • test.afterEach(title, hookFunction)

  Details

  When multiple afterEach hooks are added, they will run in the order of their registration.

  Playwright will continue running all applicable hooks even if some of them have failed.

  Usage

  // example.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.afterEach(async ({ page }) => {
    console.log(`Finished ${test.info().title} with status ${test.info().status}`);
  
    if (test.info().status !== test.info().expectedStatus)
      console.log(`Did not run as expected, ended up at ${page.url()}`);
  });
  
  test('my test', async ({ page }) => {
    // ...
  });
  Copy

  Alternatively, you can delcare a hook with a title.

  // example.spec.ts
  test.afterEach('Status check', async ({ page }) => {
    if (test.info().status !== test.info().expectedStatus)
      console.log(`Did not run as expected, ended up at ${page.url()}`);
  });
  Copy

  Parameters

  • title: string

    Hook title.

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void

beforeAll

• beforeAll(inner): void

• Declares a beforeAll hook that is executed once per worker process before all tests.

  When called in the scope of a test file, runs before all tests in the file. When called inside a test.describe([title, details, callback]) group, runs before all tests in the group.

  You can use test.afterAll([title, hookFunction]) to teardown any resources set up in beforeAll.

  • test.beforeAll(hookFunction)
  • test.beforeAll(title, hookFunction)

  Details

  When multiple beforeAll hooks are added, they will run in the order of their registration.

  Note that worker process is restarted on test failures, and beforeAll hook runs again in the new worker. Learn more about workers and failures.

  Playwright will continue running all applicable hooks even if some of them have failed.

  Usage

  // example.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.beforeAll(async () => {
    console.log('Before tests');
  });
  
  test.afterAll(async () => {
    console.log('After tests');
  });
  
  test('my test', async ({ page }) => {
    // ...
  });
  Copy

  Alternatively, you can declare a hook with a title.

  // example.spec.ts
  test.beforeAll('Setup', async () => {
    console.log('Before tests');
  });
  Copy

  Parameters

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void
• beforeAll(title, inner): void

• Declares a beforeAll hook that is executed once per worker process before all tests.

  When called in the scope of a test file, runs before all tests in the file. When called inside a test.describe([title, details, callback]) group, runs before all tests in the group.

  You can use test.afterAll([title, hookFunction]) to teardown any resources set up in beforeAll.

  • test.beforeAll(hookFunction)
  • test.beforeAll(title, hookFunction)

  Details

  When multiple beforeAll hooks are added, they will run in the order of their registration.

  Note that worker process is restarted on test failures, and beforeAll hook runs again in the new worker. Learn more about workers and failures.

  Playwright will continue running all applicable hooks even if some of them have failed.

  Usage

  // example.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.beforeAll(async () => {
    console.log('Before tests');
  });
  
  test.afterAll(async () => {
    console.log('After tests');
  });
  
  test('my test', async ({ page }) => {
    // ...
  });
  Copy

  Alternatively, you can declare a hook with a title.

  // example.spec.ts
  test.beforeAll('Setup', async () => {
    console.log('Before tests');
  });
  Copy

  Parameters

  • title: string

    Hook title.

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void

beforeEach

• beforeEach(inner): void

• Declares a beforeEach hook that is executed before each test.

  When called in the scope of a test file, runs before each test in the file. When called inside a test.describe([title, details, callback]) group, runs before each test in the group.

  You can access all the same Fixtures as the test body itself, and also the TestInfo object that gives a lot of useful information. For example, you can navigate the page before starting the test.

  You can use test.afterEach([title, hookFunction]) to teardown any resources set up in beforeEach.

  • test.beforeEach(hookFunction)
  • test.beforeEach(title, hookFunction)

  Details

  When multiple beforeEach hooks are added, they will run in the order of their registration.

  Playwright will continue running all applicable hooks even if some of them have failed.

  Usage

  // example.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.beforeEach(async ({ page }) => {
    console.log(`Running ${test.info().title}`);
    await page.goto('https://my.start.url/');
  });
  
  test('my test', async ({ page }) => {
    expect(page.url()).toBe('https://my.start.url/');
  });
  Copy

  Alternatively, you can declare a hook with a title.

  // example.spec.ts
  test.beforeEach('Open start URL', async ({ page }) => {
    console.log(`Running ${test.info().title}`);
    await page.goto('https://my.start.url/');
  });
  Copy

  Parameters

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void
• beforeEach(title, inner): void

• Declares a beforeEach hook that is executed before each test.

  When called in the scope of a test file, runs before each test in the file. When called inside a test.describe([title, details, callback]) group, runs before each test in the group.

  You can access all the same Fixtures as the test body itself, and also the TestInfo object that gives a lot of useful information. For example, you can navigate the page before starting the test.

  You can use test.afterEach([title, hookFunction]) to teardown any resources set up in beforeEach.

  • test.beforeEach(hookFunction)
  • test.beforeEach(title, hookFunction)

  Details

  When multiple beforeEach hooks are added, they will run in the order of their registration.

  Playwright will continue running all applicable hooks even if some of them have failed.

  Usage

  // example.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.beforeEach(async ({ page }) => {
    console.log(`Running ${test.info().title}`);
    await page.goto('https://my.start.url/');
  });
  
  test('my test', async ({ page }) => {
    expect(page.url()).toBe('https://my.start.url/');
  });
  Copy

  Alternatively, you can declare a hook with a title.

  // example.spec.ts
  test.beforeEach('Open start URL', async ({ page }) => {
    console.log(`Running ${test.info().title}`);
    await page.goto('https://my.start.url/');
  });
  Copy

  Parameters

  • title: string

    Hook title.

  • inner: ((args, testInfo) => any)

    • • (args, testInfo): any

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns any

  Returns void

extend

• extend<T, W>(fixtures): TestType<TestArgs & T, WorkerArgs & W>

• Extends the test object by defining fixtures and/or options that can be used in the tests.

  Usage

  First define a fixture and/or an option.

  import { test as base } from '@playwright/test';
  import { TodoPage } from './todo-page';
  
  export type Options = { defaultItem: string };
  
  // Extend basic test by providing a "defaultItem" option and a "todoPage" fixture.
  export const test = base.extend<Options & { todoPage: TodoPage }>({
    // Define an option and provide a default value.
    // We can later override it in the config.
    defaultItem: ['Do stuff', { option: true }],
  
    // Define a fixture. Note that it can use built-in fixture "page"
    // and a new option "defaultItem".
    todoPage: async ({ page, defaultItem }, use) => {
      const todoPage = new TodoPage(page);
      await todoPage.goto();
      await todoPage.addToDo(defaultItem);
      await use(todoPage);
      await todoPage.removeAll();
    },
  });
  Copy

  Then use the fixture in the test.

  // example.spec.ts
  import { test } from './my-test';
  
  test('test 1', async ({ todoPage }) => {
    await todoPage.addToDo('my todo');
    // ...
  });
  Copy

  Configure the option in config file.

  // playwright.config.ts
  import { defineConfig } from '@playwright/test';
  import type { Options } from './my-test';
  
  export default defineConfig<Options>({
    projects: [
      {
        name: 'shopping',
        use: { defaultItem: 'Buy milk' },
      },
      {
        name: 'wellbeing',
        use: { defaultItem: 'Exercise!' },
      },
    ]
  });
  Copy

  Learn more about fixtures and parametrizing tests.

  Type Parameters

  • T extends KeyValue

  • W extends KeyValue = {}

  Parameters

  • fixtures: Fixtures<T, W, TestArgs, WorkerArgs>

    An object containing fixtures and/or options. Learn more about fixtures format.

  Returns TestType<TestArgs & T, WorkerArgs & W>

fail

• fail(title, body): void

• Marks a test as "should fail". Playwright runs this test and ensures that it is actually failing. This is useful for documentation purposes to acknowledge that some functionality is broken until it is fixed.

  To declare a "failing" test:

  • test.fail(title, body)
  • test.fail(title, details, body)

  To annotate test as "failing" at runtime:

  • test.fail(condition, description)
  • test.fail(callback, description)
  • test.fail()

  Usage

  You can declare a test as failing, so that Playwright ensures it actually fails.

  import { test, expect } from '@playwright/test';
  
  test.fail('not yet ready', async ({ page }) => {
    // ...
  });
  Copy

  If your test fails in some configurations, but not all, you can mark the test as failing inside the test body based on some condition. We recommend passing a description argument in this case.

  import { test, expect } from '@playwright/test';
  
  test('fail in WebKit', async ({ page, browserName }) => {
    test.fail(browserName === 'webkit', 'This feature is not implemented for Mac yet');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "should fail" based on some condition with a single test.fail(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fail(({ browserName }) => browserName === 'webkit', 'not implemented yet');
  
  test('fail in WebKit 1', async ({ page }) => {
    // ...
  });
  test('fail in WebKit 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fail() without arguments inside the test body to always mark the test as failed. We recommend declaring a failing test with test.fail(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fail();
    // ...
  });
  Copy

  Parameters

  • title: string

    Test title.

  • body: ((args, testInfo) => void | Promise<void>)

    Test body that takes one or two arguments: an object with fixtures and optional TestInfo.

    • • (args, testInfo): void | Promise<void>

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns void | Promise<void>

  Returns void
• fail(title, details, body): void

• Marks a test as "should fail". Playwright runs this test and ensures that it is actually failing. This is useful for documentation purposes to acknowledge that some functionality is broken until it is fixed.

  To declare a "failing" test:

  • test.fail(title, body)
  • test.fail(title, details, body)

  To annotate test as "failing" at runtime:

  • test.fail(condition, description)
  • test.fail(callback, description)
  • test.fail()

  Usage

  You can declare a test as failing, so that Playwright ensures it actually fails.

  import { test, expect } from '@playwright/test';
  
  test.fail('not yet ready', async ({ page }) => {
    // ...
  });
  Copy

  If your test fails in some configurations, but not all, you can mark the test as failing inside the test body based on some condition. We recommend passing a description argument in this case.

  import { test, expect } from '@playwright/test';
  
  test('fail in WebKit', async ({ page, browserName }) => {
    test.fail(browserName === 'webkit', 'This feature is not implemented for Mac yet');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "should fail" based on some condition with a single test.fail(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fail(({ browserName }) => browserName === 'webkit', 'not implemented yet');
  
  test('fail in WebKit 1', async ({ page }) => {
    // ...
  });
  test('fail in WebKit 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fail() without arguments inside the test body to always mark the test as failed. We recommend declaring a failing test with test.fail(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fail();
    // ...
  });
  Copy

  Parameters

  • title: string

    Test title.

  • details: TestDetails

    See test.(call)(title[, details, body]) for test details description.

  • body: ((args, testInfo) => void | Promise<void>)

    Test body that takes one or two arguments: an object with fixtures and optional TestInfo.

    • • (args, testInfo): void | Promise<void>

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns void | Promise<void>

  Returns void
• fail(condition, description?): void

• Marks a test as "should fail". Playwright runs this test and ensures that it is actually failing. This is useful for documentation purposes to acknowledge that some functionality is broken until it is fixed.

  To declare a "failing" test:

  • test.fail(title, body)
  • test.fail(title, details, body)

  To annotate test as "failing" at runtime:

  • test.fail(condition, description)
  • test.fail(callback, description)
  • test.fail()

  Usage

  You can declare a test as failing, so that Playwright ensures it actually fails.

  import { test, expect } from '@playwright/test';
  
  test.fail('not yet ready', async ({ page }) => {
    // ...
  });
  Copy

  If your test fails in some configurations, but not all, you can mark the test as failing inside the test body based on some condition. We recommend passing a description argument in this case.

  import { test, expect } from '@playwright/test';
  
  test('fail in WebKit', async ({ page, browserName }) => {
    test.fail(browserName === 'webkit', 'This feature is not implemented for Mac yet');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "should fail" based on some condition with a single test.fail(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fail(({ browserName }) => browserName === 'webkit', 'not implemented yet');
  
  test('fail in WebKit 1', async ({ page }) => {
    // ...
  });
  test('fail in WebKit 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fail() without arguments inside the test body to always mark the test as failed. We recommend declaring a failing test with test.fail(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fail();
    // ...
  });
  Copy

  Parameters

  • condition: boolean

    Test is marked as "should fail" when the condition is true.

  • Optional description: string

    Optional description that will be reflected in a test report.

    Optional

  Returns void
• fail(callback, description?): void

• Marks a test as "should fail". Playwright runs this test and ensures that it is actually failing. This is useful for documentation purposes to acknowledge that some functionality is broken until it is fixed.

  To declare a "failing" test:

  • test.fail(title, body)
  • test.fail(title, details, body)

  To annotate test as "failing" at runtime:

  • test.fail(condition, description)
  • test.fail(callback, description)
  • test.fail()

  Usage

  You can declare a test as failing, so that Playwright ensures it actually fails.

  import { test, expect } from '@playwright/test';
  
  test.fail('not yet ready', async ({ page }) => {
    // ...
  });
  Copy

  If your test fails in some configurations, but not all, you can mark the test as failing inside the test body based on some condition. We recommend passing a description argument in this case.

  import { test, expect } from '@playwright/test';
  
  test('fail in WebKit', async ({ page, browserName }) => {
    test.fail(browserName === 'webkit', 'This feature is not implemented for Mac yet');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "should fail" based on some condition with a single test.fail(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fail(({ browserName }) => browserName === 'webkit', 'not implemented yet');
  
  test('fail in WebKit 1', async ({ page }) => {
    // ...
  });
  test('fail in WebKit 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fail() without arguments inside the test body to always mark the test as failed. We recommend declaring a failing test with test.fail(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fail();
    // ...
  });
  Copy

  Parameters

  • callback: ((args) => boolean)

    A function that returns whether to mark as "should fail", based on test fixtures. Test or tests are marked as "should fail" when the return value is true.

    • • (args): boolean

      • Parameters

        • args: TestArgs & WorkerArgs

        Returns boolean

  • Optional description: string

    Optional description that will be reflected in a test report.

    Optional

  Returns void
• fail(): void

• Marks a test as "should fail". Playwright runs this test and ensures that it is actually failing. This is useful for documentation purposes to acknowledge that some functionality is broken until it is fixed.

  To declare a "failing" test:

  • test.fail(title, body)
  • test.fail(title, details, body)

  To annotate test as "failing" at runtime:

  • test.fail(condition, description)
  • test.fail(callback, description)
  • test.fail()

  Usage

  You can declare a test as failing, so that Playwright ensures it actually fails.

  import { test, expect } from '@playwright/test';
  
  test.fail('not yet ready', async ({ page }) => {
    // ...
  });
  Copy

  If your test fails in some configurations, but not all, you can mark the test as failing inside the test body based on some condition. We recommend passing a description argument in this case.

  import { test, expect } from '@playwright/test';
  
  test('fail in WebKit', async ({ page, browserName }) => {
    test.fail(browserName === 'webkit', 'This feature is not implemented for Mac yet');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "should fail" based on some condition with a single test.fail(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fail(({ browserName }) => browserName === 'webkit', 'not implemented yet');
  
  test('fail in WebKit 1', async ({ page }) => {
    // ...
  });
  test('fail in WebKit 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fail() without arguments inside the test body to always mark the test as failed. We recommend declaring a failing test with test.fail(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fail();
    // ...
  });
  Copy

  Returns void

fixme

• fixme(title, body): void

• Mark a test as "fixme", with the intention to fix it. Playwright will not run the test past the test.fixme() call.

  To declare a "fixme" test:

  • test.fixme(title, body)
  • test.fixme(title, details, body)

  To annotate test as "fixme" at runtime:

  • test.fixme(condition, description)
  • test.fixme(callback, description)
  • test.fixme()

  Usage

  You can declare a test as to be fixed, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.fixme('to be fixed', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be fixed in some configurations, but not all, you can mark the test as "fixme" inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.fixme call.

  import { test, expect } from '@playwright/test';
  
  test('to be fixed in Safari', async ({ page, browserName }) => {
    test.fixme(browserName === 'webkit', 'This feature breaks in Safari for some reason');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "fixme" based on some condition with a single test.fixme(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fixme(({ browserName }) => browserName === 'webkit', 'Should figure out the issue');
  
  test('to be fixed in Safari 1', async ({ page }) => {
    // ...
  });
  test('to be fixed in Safari 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fixme() without arguments inside the test body to always mark the test as failed. We recommend using test.fixme(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fixme();
    // ...
  });
  Copy

  Parameters

  • title: string

    Test title.

  • body: ((args, testInfo) => void | Promise<void>)

    Test body that takes one or two arguments: an object with fixtures and optional TestInfo.

    • • (args, testInfo): void | Promise<void>

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns void | Promise<void>

  Returns void
• fixme(title, details, body): void

• Mark a test as "fixme", with the intention to fix it. Playwright will not run the test past the test.fixme() call.

  To declare a "fixme" test:

  • test.fixme(title, body)
  • test.fixme(title, details, body)

  To annotate test as "fixme" at runtime:

  • test.fixme(condition, description)
  • test.fixme(callback, description)
  • test.fixme()

  Usage

  You can declare a test as to be fixed, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.fixme('to be fixed', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be fixed in some configurations, but not all, you can mark the test as "fixme" inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.fixme call.

  import { test, expect } from '@playwright/test';
  
  test('to be fixed in Safari', async ({ page, browserName }) => {
    test.fixme(browserName === 'webkit', 'This feature breaks in Safari for some reason');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "fixme" based on some condition with a single test.fixme(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fixme(({ browserName }) => browserName === 'webkit', 'Should figure out the issue');
  
  test('to be fixed in Safari 1', async ({ page }) => {
    // ...
  });
  test('to be fixed in Safari 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fixme() without arguments inside the test body to always mark the test as failed. We recommend using test.fixme(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fixme();
    // ...
  });
  Copy

  Parameters

  • title: string

    Test title.

  • details: TestDetails

    See test.(call)(title[, details, body]) for test details description.

  • body: ((args, testInfo) => void | Promise<void>)

    Test body that takes one or two arguments: an object with fixtures and optional TestInfo.

    • • (args, testInfo): void | Promise<void>

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns void | Promise<void>

  Returns void
• fixme(): void

• Mark a test as "fixme", with the intention to fix it. Playwright will not run the test past the test.fixme() call.

  To declare a "fixme" test:

  • test.fixme(title, body)
  • test.fixme(title, details, body)

  To annotate test as "fixme" at runtime:

  • test.fixme(condition, description)
  • test.fixme(callback, description)
  • test.fixme()

  Usage

  You can declare a test as to be fixed, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.fixme('to be fixed', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be fixed in some configurations, but not all, you can mark the test as "fixme" inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.fixme call.

  import { test, expect } from '@playwright/test';
  
  test('to be fixed in Safari', async ({ page, browserName }) => {
    test.fixme(browserName === 'webkit', 'This feature breaks in Safari for some reason');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "fixme" based on some condition with a single test.fixme(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fixme(({ browserName }) => browserName === 'webkit', 'Should figure out the issue');
  
  test('to be fixed in Safari 1', async ({ page }) => {
    // ...
  });
  test('to be fixed in Safari 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fixme() without arguments inside the test body to always mark the test as failed. We recommend using test.fixme(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fixme();
    // ...
  });
  Copy

  Returns void
• fixme(condition, description?): void

• Mark a test as "fixme", with the intention to fix it. Playwright will not run the test past the test.fixme() call.

  To declare a "fixme" test:

  • test.fixme(title, body)
  • test.fixme(title, details, body)

  To annotate test as "fixme" at runtime:

  • test.fixme(condition, description)
  • test.fixme(callback, description)
  • test.fixme()

  Usage

  You can declare a test as to be fixed, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.fixme('to be fixed', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be fixed in some configurations, but not all, you can mark the test as "fixme" inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.fixme call.

  import { test, expect } from '@playwright/test';
  
  test('to be fixed in Safari', async ({ page, browserName }) => {
    test.fixme(browserName === 'webkit', 'This feature breaks in Safari for some reason');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "fixme" based on some condition with a single test.fixme(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fixme(({ browserName }) => browserName === 'webkit', 'Should figure out the issue');
  
  test('to be fixed in Safari 1', async ({ page }) => {
    // ...
  });
  test('to be fixed in Safari 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fixme() without arguments inside the test body to always mark the test as failed. We recommend using test.fixme(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fixme();
    // ...
  });
  Copy

  Parameters

  • condition: boolean

    Test is marked as "should fail" when the condition is true.

  • Optional description: string

    Optional description that will be reflected in a test report.

    Optional

  Returns void
• fixme(callback, description?): void

• Mark a test as "fixme", with the intention to fix it. Playwright will not run the test past the test.fixme() call.

  To declare a "fixme" test:

  • test.fixme(title, body)
  • test.fixme(title, details, body)

  To annotate test as "fixme" at runtime:

  • test.fixme(condition, description)
  • test.fixme(callback, description)
  • test.fixme()

  Usage

  You can declare a test as to be fixed, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.fixme('to be fixed', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be fixed in some configurations, but not all, you can mark the test as "fixme" inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.fixme call.

  import { test, expect } from '@playwright/test';
  
  test('to be fixed in Safari', async ({ page, browserName }) => {
    test.fixme(browserName === 'webkit', 'This feature breaks in Safari for some reason');
    // ...
  });
  Copy

  You can mark all tests in a file or test.describe([title, details, callback]) group as "fixme" based on some condition with a single test.fixme(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.fixme(({ browserName }) => browserName === 'webkit', 'Should figure out the issue');
  
  test('to be fixed in Safari 1', async ({ page }) => {
    // ...
  });
  test('to be fixed in Safari 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.fixme() without arguments inside the test body to always mark the test as failed. We recommend using test.fixme(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.fixme();
    // ...
  });
  Copy

  Parameters

  • callback: ((args) => boolean)

    A function that returns whether to mark as "should fail", based on test fixtures. Test or tests are marked as "should fail" when the return value is true.

    • • (args): boolean

      • Parameters

        • args: TestArgs & WorkerArgs

        Returns boolean

  • Optional description: string

    Optional description that will be reflected in a test report.

    Optional

  Returns void

info

• info(): TestInfo

• Returns information about the currently running test. This method can only be called during the test execution, otherwise it throws.

  Usage

  test('example test', async ({ page }) => {
    // ...
    await test.info().attach('screenshot', {
      body: await page.screenshot(),
      contentType: 'image/png',
    });
  });
  Copy

  Returns TestInfo

setTimeout

• setTimeout(timeout): void

• Changes the timeout for the test. Zero means no timeout. Learn more about various timeouts.

  Timeout for the currently running test is available through testInfo.timeout.

  Usage

  • Changing test timeout.

    test('very slow test', async ({ page }) => {
      test.setTimeout(120000);
      // ...
    });
    Copy

  • Changing timeout from a slow beforeEach or afterEach hook. Note that this affects the test timeout that is shared with beforeEach/afterEach hooks.

    test.beforeEach(async ({ page }, testInfo) => {
      // Extend timeout for all tests running this hook by 30 seconds.
      test.setTimeout(testInfo.timeout + 30000);
    });
    Copy

  • Changing timeout for a beforeAll or afterAll hook. Note this affects the hook's timeout, not the test timeout.

    test.beforeAll(async () => {
      // Set timeout for this hook.
      test.setTimeout(60000);
    });
    Copy

  • Changing timeout for all tests in a test.describe([title, details, callback]) group.

    test.describe('group', () => {
      // Applies to all tests in this group.
      test.describe.configure({ timeout: 60000 });
    
      test('test one', async () => { /* ... */ });
      test('test two', async () => { /* ... */ });
      test('test three', async () => { /* ... */ });
    });
    Copy

  Parameters

  • timeout: number

    Timeout in milliseconds.

  Returns void

skip

• skip(title, body): void

• Skip a test. Playwright will not run the test past the test.skip() call.

  Skipped tests are not supposed to be ever run. If you intent to fix the test, use test.fixme([title, details, body, condition, callback, description]) instead.

  To declare a skipped test:

  • test.skip(title, body)
  • test.skip(title, details, body)

  To skip a test at runtime:

  • test.skip(condition, description)
  • test.skip(callback, description)
  • test.skip()

  Usage

  You can declare a skipped test, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.skip('never run', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be skipped in some configurations, but not all, you can skip the test inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.skip call.

  import { test, expect } from '@playwright/test';
  
  test('Safari-only test', async ({ page, browserName }) => {
    test.skip(browserName !== 'webkit', 'This feature is Safari-only');
    // ...
  });
  Copy

  You can skip all tests in a file or test.describe([title, details, callback]) group based on some condition with a single test.skip(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.skip(({ browserName }) => browserName !== 'webkit', 'Safari-only');
  
  test('Safari-only test 1', async ({ page }) => {
    // ...
  });
  test('Safari-only test 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.skip() without arguments inside the test body to always mark the test as failed. We recommend using test.skip(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.skip();
    // ...
  });
  Copy

  Parameters

  • title: string

    Test title.

  • body: ((args, testInfo) => void | Promise<void>)

    Test body that takes one or two arguments: an object with fixtures and optional TestInfo.

    • • (args, testInfo): void | Promise<void>

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns void | Promise<void>

  Returns void
• skip(title, details, body): void

• Skip a test. Playwright will not run the test past the test.skip() call.

  Skipped tests are not supposed to be ever run. If you intent to fix the test, use test.fixme([title, details, body, condition, callback, description]) instead.

  To declare a skipped test:

  • test.skip(title, body)
  • test.skip(title, details, body)

  To skip a test at runtime:

  • test.skip(condition, description)
  • test.skip(callback, description)
  • test.skip()

  Usage

  You can declare a skipped test, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.skip('never run', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be skipped in some configurations, but not all, you can skip the test inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.skip call.

  import { test, expect } from '@playwright/test';
  
  test('Safari-only test', async ({ page, browserName }) => {
    test.skip(browserName !== 'webkit', 'This feature is Safari-only');
    // ...
  });
  Copy

  You can skip all tests in a file or test.describe([title, details, callback]) group based on some condition with a single test.skip(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.skip(({ browserName }) => browserName !== 'webkit', 'Safari-only');
  
  test('Safari-only test 1', async ({ page }) => {
    // ...
  });
  test('Safari-only test 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.skip() without arguments inside the test body to always mark the test as failed. We recommend using test.skip(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.skip();
    // ...
  });
  Copy

  Parameters

  • title: string

    Test title.

  • details: TestDetails

    See test.(call)(title[, details, body]) for test details description.

  • body: ((args, testInfo) => void | Promise<void>)

    Test body that takes one or two arguments: an object with fixtures and optional TestInfo.

    • • (args, testInfo): void | Promise<void>

      • Parameters

        • args: TestArgs & WorkerArgs

        • testInfo: TestInfo

        Returns void | Promise<void>

  Returns void
• skip(): void

• Skip a test. Playwright will not run the test past the test.skip() call.

  Skipped tests are not supposed to be ever run. If you intent to fix the test, use test.fixme([title, details, body, condition, callback, description]) instead.

  To declare a skipped test:

  • test.skip(title, body)
  • test.skip(title, details, body)

  To skip a test at runtime:

  • test.skip(condition, description)
  • test.skip(callback, description)
  • test.skip()

  Usage

  You can declare a skipped test, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.skip('never run', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be skipped in some configurations, but not all, you can skip the test inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.skip call.

  import { test, expect } from '@playwright/test';
  
  test('Safari-only test', async ({ page, browserName }) => {
    test.skip(browserName !== 'webkit', 'This feature is Safari-only');
    // ...
  });
  Copy

  You can skip all tests in a file or test.describe([title, details, callback]) group based on some condition with a single test.skip(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.skip(({ browserName }) => browserName !== 'webkit', 'Safari-only');
  
  test('Safari-only test 1', async ({ page }) => {
    // ...
  });
  test('Safari-only test 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.skip() without arguments inside the test body to always mark the test as failed. We recommend using test.skip(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.skip();
    // ...
  });
  Copy

  Returns void
• skip(condition, description?): void

• Skip a test. Playwright will not run the test past the test.skip() call.

  Skipped tests are not supposed to be ever run. If you intent to fix the test, use test.fixme([title, details, body, condition, callback, description]) instead.

  To declare a skipped test:

  • test.skip(title, body)
  • test.skip(title, details, body)

  To skip a test at runtime:

  • test.skip(condition, description)
  • test.skip(callback, description)
  • test.skip()

  Usage

  You can declare a skipped test, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.skip('never run', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be skipped in some configurations, but not all, you can skip the test inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.skip call.

  import { test, expect } from '@playwright/test';
  
  test('Safari-only test', async ({ page, browserName }) => {
    test.skip(browserName !== 'webkit', 'This feature is Safari-only');
    // ...
  });
  Copy

  You can skip all tests in a file or test.describe([title, details, callback]) group based on some condition with a single test.skip(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.skip(({ browserName }) => browserName !== 'webkit', 'Safari-only');
  
  test('Safari-only test 1', async ({ page }) => {
    // ...
  });
  test('Safari-only test 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.skip() without arguments inside the test body to always mark the test as failed. We recommend using test.skip(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.skip();
    // ...
  });
  Copy

  Parameters

  • condition: boolean

    Test is marked as "should fail" when the condition is true.

  • Optional description: string

    Optional description that will be reflected in a test report.

    Optional

  Returns void
• skip(callback, description?): void

• Skip a test. Playwright will not run the test past the test.skip() call.

  Skipped tests are not supposed to be ever run. If you intent to fix the test, use test.fixme([title, details, body, condition, callback, description]) instead.

  To declare a skipped test:

  • test.skip(title, body)
  • test.skip(title, details, body)

  To skip a test at runtime:

  • test.skip(condition, description)
  • test.skip(callback, description)
  • test.skip()

  Usage

  You can declare a skipped test, and Playwright will not run it.

  import { test, expect } from '@playwright/test';
  
  test.skip('never run', async ({ page }) => {
    // ...
  });
  Copy

  If your test should be skipped in some configurations, but not all, you can skip the test inside the test body based on some condition. We recommend passing a description argument in this case. Playwright will run the test, but abort it immediately after the test.skip call.

  import { test, expect } from '@playwright/test';
  
  test('Safari-only test', async ({ page, browserName }) => {
    test.skip(browserName !== 'webkit', 'This feature is Safari-only');
    // ...
  });
  Copy

  You can skip all tests in a file or test.describe([title, details, callback]) group based on some condition with a single test.skip(callback, description) call.

  import { test, expect } from '@playwright/test';
  
  test.skip(({ browserName }) => browserName !== 'webkit', 'Safari-only');
  
  test('Safari-only test 1', async ({ page }) => {
    // ...
  });
  test('Safari-only test 2', async ({ page }) => {
    // ...
  });
  Copy

  You can also call test.skip() without arguments inside the test body to always mark the test as failed. We recommend using test.skip(title, body) instead.

  import { test, expect } from '@playwright/test';
  
  test('less readable', async ({ page }) => {
    test.skip();
    // ...
  });
  Copy

  Parameters

  • callback: ((args) => boolean)

    A function that returns whether to mark as "should fail", based on test fixtures. Test or tests are marked as "should fail" when the return value is true.

    • • (args): boolean

      • Parameters

        • args: TestArgs & WorkerArgs

        Returns boolean

  • Optional description: string

    Optional description that will be reflected in a test report.

    Optional

  Returns void