Google Playwright Testing Interview Questions & Answers

Create a class that takes a page, defines locators as properties and exposes action methods; instantiate it in a fixture for clean tests.

all waits for every promise and rejects on the first failure; allSettled waits for all and reports each outcome; race settles with the first one to finish.

Integrate axe-core through @axe-core/playwright, run an analysis on the page and assert that there are no violations.

Reusable setup/teardown units injected into tests (page, context, request). You can extend test with custom fixtures such as loggedInPage.

page.route('**/api/items', route => route.fulfill({ json: [...] })) intercepts and replies with test data; route.abort() simulates failures.

Add tags in the title (@smoke) or use the tag option, and run with --grep @smoke or --grep-invert.

Use environment variables or .env files, a baseURL in config, API calls for setup and cleanup, and unique data per run.

Click to open the control, then use getByRole('option') or a text locator for the target item, instead of relying on fragile index-based selectors.

A browser is the engine instance; a context is an isolated session (cookies, storage); a page is a tab inside a context.

test('login', async ({ page }) => { await page.goto('/login'); await page.getByLabel('Email').fill('a@b.com'); await page.getByLabel('Password').fill('secret'); await page.getByRole('button', { name: 'Login' }).click(); await expect(page.getByRole('heading', { name: 'Dashboard' })).toBeVisible(); });

Use a library such as zod or ajv to define the expected schema and parse the response to fail on missing or wrongly typed fields.

User-facing ones: getByRole, getByText, getByLabel, getByPlaceholder and getByTestId, which are more resilient than CSS or XPath.

An object describing how to find an element, re-evaluated on every action so it always targets the current DOM.

A type alias describes a shape or union of values; an enum creates a named set of constants that exists at runtime.

await page.route('**/api/users', route => route.fulfill({ status: 200, json: [{ id: 1, name: 'Test' }] }) );

await request.post('/api/users', { data: { name: 'Asha' } }) automatically sets JSON headers and serialises the payload.

Functions that take other functions as arguments or return them, such as map, filter and reduce, or a helper that wraps retry logic around a test step.

const [newPage] = await Promise.all([ context.waitForEvent('page'), page.getByText('Open').click(), ]); await newPage.waitForLoadState();

const [download] = await Promise.all([ page.waitForEvent('download'), page.getByText('Export').click(), ]); await download.saveAs('reports/file.csv');

waitForSelector is a lower-level wait; locator assertions are preferred as they retry and are more readable.

Destructuring pulls values from arrays or objects into variables; spread expands an array or object into another, useful for copying and merging config.

var is function-scoped and hoisted. let and const are block-scoped; const can't be reassigned (though an object it points to can change). Prefer const, then let.

Capture the download event, save it with download.saveAs, then read the file in Node and assert on name, size or content.

Log in once in a setup project, save storageState to a file and reuse it in other projects or tests.

Use dotenv files per environment, read them in playwright.config and set baseURL and credentials from variables, selecting with an ENV flag.

Both describe object shapes. Interfaces can be extended and merged; type aliases can also describe unions and primitives. Use interfaces for page or test-data shapes, types for unions.

Use device descriptors such as devices['iPhone 13'] in a project config to emulate viewport, user agent and touch.

Run in parallel with sharding, reuse authentication state, set up data through APIs, avoid unnecessary waits, run smoke on every commit and the full suite nightly.

Define projects for chromium, firefox and webkit in playwright.config.ts, set workers, then run: npx playwright test

npm is the Node package manager. package.json lists the project's dependencies and scripts, such as the command that runs the tests.

Create test data through API calls, verify it in the UI and clean up via API, which makes UI tests faster and more reliable.

Register page.on('dialog', d => d.accept()) before the action triggers the dialog.

Assertions like expect(locator).toBeVisible() that retry until they pass or time out, unlike one-off checks.

TypeScript + POM + custom fixtures, environment configs, API helpers for test data, tags like @smoke, sharding across CI machines, retries with traces, HTML/Allure reports, lint and review rules.

Files run in parallel by default; set workers in the config and use test.describe.configure({ mode: 'parallel' }) for tests inside a file.

Read the next page link or IDs from earlier responses, loop until done and assert counts and uniqueness; pass IDs between calls in the same test.

Set them in the context options (geolocation, permissions, timezoneId, locale) to simulate users from other regions.

Define an interface for the payload, cast or validate the parsed JSON to it (for example with zod), and use that type in assertions to catch shape changes.

Record timestamps around the request or use response timing, then assert the duration is under an agreed threshold.

Separate tests, page objects, fixtures, utilities, test data and config; use tags, projects, shared auth setup, linting, code review and a CI pipeline with sharding and reports.

The object behind the request fixture that holds base URL, headers and cookies, and can share cookies with a browser context.

A class receives page in its constructor, stores locators as properties and exposes actions like login(user, pass). Tests call page objects, not raw locators.

A short function syntax that does not have its own this and arguments, taking them from the surrounding scope.

Named configurations that run the same tests across different browsers, devices or environments.

Wait for the popup event with const [popup] = await Promise.all([page.waitForEvent('popup'), page.click('a')]), then interact with popup.

Synchronous code runs line by line and blocks; asynchronous code starts a task and continues, handling the result later with promises or await.

map transforms each item, filter keeps items that match a condition, and reduce combines all items into a single value.

Use page.frameLocator('#frame').getByRole(...) so actions work inside the iframe with auto-waiting.

click simulates a real user click with actionability checks; dispatchEvent fires a DOM event directly without those checks.

test.step groups actions into named steps in reports; annotations such as test.skip, test.fixme and test.slow communicate intent and adjust behaviour.

Cover happy path, validation errors, auth and permissions, boundary values, idempotency, schema, performance and data cleanup.

await expect.soft(locator).toHaveText('...') records the failure but lets the test continue, so you see every mismatch in one run.

Strings in backticks that allow embedded expressions like `Hello ${name}` and multi-line text, useful for building dynamic locators and URLs.

In a fixture or beforeEach, call the API (request.post) to create the user or order, use it in the UI test, then delete it in teardown. It is faster and more reliable than creating data through the UI.