Skip to main content
rule official · GitHub

playwright-typescript — GitHub Copilot rule: Playwright tests

This rule tells Copilot how to write Playwright tests: role-based locators, auto-retrying assertions, one file per feature. Useful when an agent writes the tests.

Install into GitHub Copilot · Manually: put the files in place All methods and platforms ↓
.github/instructions/playwright-typescript.instructions.md
Open on GitHub

What playwright-typescript does

The rule spells out how Playwright tests should be generated. Locators are role-based — getByRole, getByLabel, getByText — and interactions are grouped with test.step(). Assertions are web-first and start with await, like await expect(locator).toHaveText(). No manual waiting: the rule asks you to lean on Playwright's built-in auto-waiting instead of hard-coded pauses or raised timeouts.

Structure is fixed too. A file opens with import { test, expect } from '@playwright/test';, related tests sit inside test.describe(), and shared setup goes into beforeEach. Tests live in the tests/ directory, named <feature-or-page>.spec.ts, one file per major feature or page. Titles follow the pattern "Feature - Specific action or scenario".

There is a worked example: a movie search that checks the accessibility tree with toMatchAriaSnapshot. The run order is npx playwright test --project=chromium first, then reading failures and fixing locators. One thing to watch: the rule carries applyTo: '**', so its instructions reach files that have nothing to do with tests. For GitHub Copilot the file goes to .github/instructions/playwright-typescript.instructions.md.

What it helps with

  • keep Playwright tests in one style across a team
  • swap brittle CSS selectors for role-based locators
  • drop hard-coded waits and manual timeouts from tests
  • lay out test files and describe blocks consistently
  • verify a component's accessibility tree instead of single nodes

Example prompts for the agent

  • generate a Playwright test for the search page following this rule
  • rewrite this test with role-based locators and test.step()
  • add a toMatchAriaSnapshot check for the results block

How to install playwright-typescript

Manually: put the files in place

.github/instructions/playwright-typescript.instructions.md

The applyTo field sets which files it applies to

Step by step, with commands for each platform: AGENTS.md vs CLAUDE.md: what they are and which one to use

Questions about playwright-typescript

How do I install playwright-typescript in GitHub Copilot?

Create .github/instructions/playwright-typescript.instructions.md in your repository and paste the rule into it. Copilot picks it up when generating code.

What does playwright-typescript do?

It gives Copilot instructions for writing Playwright tests: which locators to use, how to build assertions, and how to name and place files.

Does the rule affect anything besides tests?

It sets applyTo: '**', so the scope is the whole project. The locator and assertion guidance applies to files unrelated to testing as well.

Source text

playwright-typescript.instructions.md · MIT
---
description: 'Playwright test generation instructions'
applyTo: '**'
---

## Test Writing Guidelines

### Code Quality Standards
- **Locators**: Prioritize user-facing, role-based locators (`getByRole`, `getByLabel`, `getByText`, etc.) for resilience and accessibility. Use `test.step()` to group interactions and improve test readability and reporting.
- **Assertions**: Use auto-retrying web-first assertions. These assertions start with the `await` keyword (e.g., `await expect(locator).toHaveText()`). Avoid `expect(locator).toBeVisible()` unless specifically testing for visibility changes.
- **Timeouts**: Rely on Playwright's built-in auto-waiting mechanisms. Avoid hard-coded waits or increased default timeouts.
- **Clarity**: Use descriptive test and step titles that clearly state the intent. Add comments only to explain complex logic or non-obvious interactions.


### Test Structure
- **Imports**: Start with `import { test, expect } from '@playwright/test';`.
- **Organization**: Group related tests for a feature under a `test.describe()` block.
- **Hooks**: Use `beforeEach` for setup actions common to all tests in a `describe` block (e.g., navigating to a page).
- **Titles**: Follow a clear naming convention, such as `Feature - Specific action or scenario`.


### File Organization
- **Location**: Store all test files in the `tests/` directory.
- **Naming**: Use the convention `<feature-or-page>.spec.ts` (e.g., `login.spec.ts`, `search.spec.ts`).
- **Scope**: Aim for one test file per major application feature or page.

### Assertion Best Practices
- **UI Structure**: Use `toMatchAriaSnapshot` to verify the accessibility tree structure of a component. This provides a comprehensive and accessible snapshot.
- **Element Counts**: Use `toHaveCount` to assert the number of elements found by a locator.
- **Text Content**: Use `toHaveText` for exact text matches and `toContainText` for partial matches.
- **Navigation**: Use `toHaveURL` to verify the page URL after an action.


## Example Test Structure

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

test.describe('Movie Search Feature', () => {
  test.beforeEach(async ({ page }) => {
    // Navigate to the application before each test
    await page.goto('https://debs-obrien.github.io/playwright-movies-app');
  });

  test('Search for a movie by title', async ({ page }) => {
    await test.step('Activate and perform search', async () => {
      await page.getByRole('search').click();
      const searchInput = page.getByRole('textbox', { name: 'Search Input' });
      await searchInput.fill('Garfield');
      await searchInput.press('Enter');
    });

    await test.step('Verify search results', async () => {
      // Verify the accessibility tree of the search results
      await expect(page.getByRole('main')).toMatchAriaSnapshot(`
        - main:
          - heading "Garfield" [level=1]
          - heading "search results" [level=2]
          - list "movies":
            - listitem "movie":
              - link "poster of The Garfield Movie The Garfield Movie rating":
                - /url: /playwright-movies-app/movie?id=tt5779228&page=1
                - img "poster of The Garfield Movie"
                - heading "The Garfield Movie" [level=2]
      `);
    });
  });
});
```

## Test Execution Strategy

1. **Initial Run**: Execute tests with `npx playwright test --project=chromium`
2. **Debug Failures**: Analyze test failures and identify root causes
3. **Iterate**: Refine locators, assertions, or test logic as needed
4. **Validate**: Ensure tests pass consistently and cover the intended functionality
5. **Report**: Provide feedback on test results and any issues discovered

## Quality Checklist

Before finalizing tests, ensure:
- [ ] All locators are accessible and specific and avoid strict mode violations
- [ ] Tests are grouped logically and follow a clear structure
- [ ] Assertions are meaningful and reflect user expectations
- [ ] Tests follow consistent naming conventions
- [ ] Code is properly formatted and commented

© github · MIT · github/awesome-copilot

Similar IDE rules

Everything for Testing and QA →

From the same set732

The whole set →

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor