Skip to content
Skills Library
Programming · Testing

playwright-validation

/playwright-validation

Use when validating UI changes in a branch require Playwright E2E testing. Reviews branch changes, validates UI with Playwright MCP, and adds missing test cases.

Licence
Apache-2.0
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Use when validating UI changes in a branch require Playwright E2E testing. Reviews branch changes, validates UI with Playwright MCP, and adds missing test cases.

Original author description

Use when validating UI changes in a branch require Playwright E2E testing. Reviews branch changes, validates UI with Playwright MCP, and adds missing test cases.

How it works

  1. When to Use
  2. Workflow
  3. Common Test Utilities
  4. Checklist Before Completion
  5. Example: Data Contract Inheritance Tests
Original SKILL.md headings · 175 lines, 712 words
SKILL.md preview
---
name: playwright-validation
description: Use when validating UI changes in a branch require Playwright E2E testing. Reviews branch changes, validates UI with Playwright MCP, and adds missing test cases.
---

# Playwright Validation Skill

This skill guides you through validating UI changes and ensuring comprehensive Playwright E2E test coverage.

## When to Use

- After completing UI feature development
- Before creating a PR for UI changes
- When reviewing UI-related branches
- To verify existing Playwright tests cover all scenarios

## Workflow

### Phase 1: Review Branch Changes

1. **Identify changed files vs main:**
   ```bash
   git diff main --stat
   git diff main --name-only | grep -E "\.(tsx?|less|css|scss)$"
   ```

2. **Focus on UI component changes:**
   ```bash
   git diff main -- "openmetadata-ui/src/main/resources/ui/src/components/**" --stat
   ```

3. **Check for existing Playwright tests:**
   ```bash
   git diff main --name-only | grep -E "playwright.*\.spec\.ts$"
   ```

4. **Read the changed component files** to understand the UI modifications

### Phase 2: Review Existing Playwright Tests

1. **Locate relevant test files:**
   - Check `playwright/e2e/Pages/` for page-level tests
   - Check `playwright/e2e/Features/` for feature-specific tests
   - Use Glob/Grep to find tests related to the feature

2. **Analyze test coverage:**
   - Read the existing test file(s)
   - Identify the test scenarios already covered
   - Note any gaps in coverage based on the UI changes

3. **Review test utilities:**
   - Check `playwright/utils/` for helper functions
   - Check `playwright/support/` for entity classes and fixtures

### Phase 3: Validate with Playwright MCP

1. **Start the browser and navigate:**
   ```
   mcp__playwright__browser_navigate to http://localhost:8585
   ```

2. **Authenticate if needed:**
   - Use `mcp__playwright__browser_fill_form` for login
   - Default admin: `admin@open-metadata.org` / `admin`

3. **Navigate to the feature area:**
   - Use `mcp__playwright__browser_click` for navigation
   - Use `mcp__playwright__browser_snapshot` to inspect page state

4. **Validate UI behavior:**
   - Test the main user flows
   - Verify visual elements (icons, badges, labels)
   - Check interactive elements (buttons, dropdowns, forms)
   - Verify state changes and API calls

5. **Document findings:**
   - Note what works correctly
   - Identify any issues or missing functionality
   - List scenarios not covered by existing tests

### Phase 4: Add Missing Test Cases

1. **Create a TodoWrite checklist** of missing test scenarios

2. **For each missing test case:**

   a. **Add necessary test fixtures** in `beforeAll`:
      - Create new entity instances (TableClass, DataProduct, etc.)
      - Set up required relationships (domains, assets)

   b. **Add cleanup** in `afterAll`:
      - Delete created entities in reverse order

   c. **Write the test** following the pattern:
      ```typescript
      test('Descriptive Test Name - What it validates', async ({ page }) => {
        test.setTimeout(300000);

        await test.step('Step description', async () => {
          // Test actions and assertions
        });

        await test.step('Next step', async () => {
          // More actions and assertions
        });
      });
      ```

3. **Test patterns to cover:**
   - Happy path (expected behavior)
   - Edge cases (empty states, max values)
   - Error handling (invalid inputs, failed requests)
   - State transitions (before/after actions)
   - UI feedback (loading states, success/error messages)
   - Permissions (disabled buttons, restricted actions)

4. **Run Playwright lint check:**
   ```bash
   yarn lint:playwright
   ```
   Every `playwright/*` and `om-playwright/*` guardrail rule is `error` severity. Repo-wide `openmetadata-playwright/*` rules set their own, and may sit at `warn` while their call sites migrate — read the severity column in the handbook's **ESLint Enforcement** table rather than assuming.

## Common Test Utilities

### Navigation
```typescript
import { sidebarClick } from '../../utils/sidebar';
import { redirectToHomePage } from '../../utils/common';
import { selectDataProduct, selectDomain } from '../../utils/domain';
```

### Waiting
```typescript
import { waitForAllLoadersToDisappear } from '../../utils/entity';
await waitForAllLoadersToDisappear(page);
await expect(page.getByTestId('content')).toBeVisible();
// NEVER use: page.waitForLoadState('networkidle') — blocked by ESLint
```

### API Responses
```typescript
const response = page.waitForResponse('/api/v1/endpoint*');
await someAction();
await response;
expect((await response).status()).toBe(200);
```

### Assertions
```typescript
await expect(page.getByTestId('element')).toBeVisible();
await expect(page.getByTestId('element')).toContainText('text');
await expect(page.locator('.class')).not.toBeVisible();
```

## Checklist Before Completion

- [ ] All UI changes have corresponding test coverage
- [ ] Tests cover both positive and negative scenarios
- [ ] Tests verify visual indicators (icons, badges, states)
- [ ] Tests validate API interactions
- [ ] `yarn lint:playwright` passes with zero errors
- [ ] No `networkidle`, `page.pause()`, or `test.only()` usage (blocked by ESLint)
- [ ] Test fixtures are properly created and cleaned up
- [ ] Test timeouts use `test.slow()` (preferred) or `test.setTimeout()`

## Example: Data Contract Inheritance Tests

For reference, see the comprehensive test coverage in:
`playwright/e2e/Pages/DataContractInheritance.spec.ts`

This file demonstrates:
- Multiple entity setup in beforeAll
- Domain assignment patches
- Contract creation and validation
- Inheritance icon verification
- Action button state verification (disabled/enabled)
- API response validation (POST vs PATCH)
- Fallback behavior testing

Versions

The database has no other skills named playwright-validation.

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 0520fb2ce16a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100uat-testing
    End-to-end User Acceptance Testing for web applications. Analyzes branch changes and specs to generate exhaustive test cases, sets up the local environment, executes tests via Playwright browser automation, and produces a pass/fail results report with screenshots and fix…
  • 100playwright-testing
    UI/E2E test automation with Playwright MCP. Use when the user asks to "test the UI", "automate browser tests", "check the page", "take a screenshot", "run Playwright", "write E2E tests", or anything about browser-based testing.
  • 85playwright-qa
    QA engineering workflows on top of Playwright. Use when a QA engineer asks to design test cases from a ticket, PRD or acceptance criteria, decide what to automate, write a bug report from a failing test or trace, convert manual test cases (TestRail, Xray, CSV) into Playwright…
  • 100playwright-best-practices
    Use when writing or modifying Playwright tests (.spec.ts, .test.ts with @playwright/test imports).
  • 100e2e-testing
    Plans, generates, runs, and heals Playwright end-to-end tests through a spec-first loop with Playwright Test Agents and `@playwright/mcp`. Use when adding E2E coverage or hardening a flaky flow; triggers on "add e2e", "test this flow", "verify the user journey", "/e2e-testing".
  • 100pw-init
    Set up Playwright in a project. Use when user says "set up playwright", "add e2e tests", "configure playwright", "testing setup", "init playwright", or "add test infrastructure".

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.