Skip to main content
skill CX Codex

playwright-validation — Claude Code skill

playwright-validation runs a branch's UI changes through Playwright MCP and writes the E2E tests that are missing, matching how the OpenMetadata repo does it.

Apache-2.0 ★ 15,831 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add open-metadata/OpenMetadata --skill playwright-validation -a claude-code
Open on GitHub

What playwright-validation does

The skill walks an agent through UI validation in four phases. It opens with git diff main to list changed files, narrows down to .tsx, .less, .css and .scss in the UI components, then reads those components. Next it hunts for existing specs in playwright/e2e/Pages/ and playwright/e2e/Features/, checks helpers in playwright/utils/ and playwright/support/, and notes which scenarios are missing.

Phase three is a live pass through Playwright MCP: navigate to http://localhost:8585, sign in as [email protected] / admin, click through the main flows, take snapshots. The app has to be running already. Nothing happens without a server on that port. Phase four means writing the missing tests, with fixtures set up in beforeAll, cleanup in afterAll, and assertions grouped into test.step blocks.

Then comes yarn lint:playwright. The ESLint rules here are strict about networkidle, page.pause() and test.only() — those fail. Set timeouts with test.slow() or test.setTimeout().

What it helps with

  • see which UI components a branch touched
  • spot gaps in the existing Playwright coverage
  • walk a main flow in the browser through Playwright MCP
  • add fixtures and cleanup for a new test
  • catch banned patterns like networkidle before review

Example prompts for the agent

  • Review the UI changes on this branch and list the E2E scenarios we are missing
  • Open http://localhost:8585 with Playwright MCP and walk through creating a data product
  • Add the missing spec under playwright/e2e/Pages/ and run yarn lint:playwright

How to install playwright-validation

1Skills CLI (Vercel)

npx skills add open-metadata/OpenMetadata --skill playwright-validation -a claude-code

2Manually: put the files in place

~/.claude/skills/playwright-validation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/playwright-validation/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about playwright-validation

How do I install playwright-validation in Claude Code?

Run npx skills add open-metadata/OpenMetadata --skill playwright-validation -a claude-code. The skill lands at ~/.claude/skills/playwright-validation/SKILL.md.

What does playwright-validation do?

It guides an agent through validating UI changes: diff the branch, study the existing E2E specs, exercise the feature in a live browser, then fill in the missing cases.

What does the browser phase need?

A running app on http://localhost:8585 and Playwright MCP wired up. The default login is [email protected] / admin.

Source text

SKILL.md · Apache-2.0
---
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: `[email protected]` / `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

© open-metadata · Apache-2.0 · open-metadata/OpenMetadata

Similar skills

All skills for Testing and QA →

From the same set4

Project sponsors

Companies that keep this analytics open