webapp-testing
/webapp-testing
Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.
- Author
- khaledsaeed18 ↗
- Repository
- dotclaude ↗
- Licence
- MIT
- Last repository change
- 25.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.
Original author description
Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.
How it works
- Step 1: Check for Playwright and a running app
- Step 2: Identify what to verify
- Step 3: Write the Playwright script
- Step 4: Interaction patterns
- Step 5: Run and report
- Common failure patterns to check
SKILL.md preview
---
name: webapp-testing
description: Verify a web application works in a real browser with Playwright, covering navigation, form submission, interactions, console errors, screenshots, and responsive layout. Use when a UI feature needs end-to-end confirmation, a form flow must complete, or a change needs regression checking. Requires Node.js and installs Playwright if absent.
---
Test the application in a real browser rather than claiming it works from a code read alone. A passing type-check or unit test does not mean the page renders, the form submits, or the network request succeeds. Run the app, drive it with Playwright, and report what actually happened.
## Step 1: Check for Playwright and a running app
```bash
# Check if Playwright is installed
npx playwright --version 2>/dev/null || echo "not installed"
# Check if there is an existing Playwright config
ls playwright.config.ts playwright.config.js 2>/dev/null
```
If Playwright is not installed, install it:
```bash
npm install --save-dev @playwright/test
npx playwright install chromium
```
Check whether the dev server is already running. If not, start it before writing tests. Use the project's start script - check `package.json` for the correct command (`npm run dev`, `npm start`, etc.). The server must be running for Playwright to connect.
## Step 2: Identify what to verify
Before writing any test, state the scenario in plain terms:
- What page or URL does the scenario start from?
- What actions does the user take? (navigate, click, type, submit, wait)
- What is the expected outcome? (page title changes, element appears, URL changes, form resets, API call completes)
- Are there any states to verify along the way? (loading indicator, validation message, success confirmation)
If the user has not specified a scenario, default to: navigate to the app's root, confirm it loads without console errors, and take a screenshot.
## Step 3: Write the Playwright script
Write a focused script that tests the specified scenario. Keep each script to one scenario.
```typescript
import { chromium } from "@playwright/test";
const browser = await chromium.launch({ headless: true });
const context = await browser.newContext({
viewport: { width: 1280, height: 720 },
});
const page = await context.newPage();
// Collect console errors throughout the session
const consoleErrors: string[] = [];
page.on("console", (msg) => {
if (msg.type() === "error") consoleErrors.push(msg.text());
});
// Collect failed network requests
const networkErrors: string[] = [];
page.on("requestfailed", (request) => {
networkErrors.push(`${request.method()} ${request.url()} - ${request.failure()?.errorText}`);
});
try {
// Navigate and wait for the page to be ready
await page.goto("http://localhost:3000", { waitUntil: "networkidle" });
// Take a screenshot of the initial state
await page.screenshot({ path: "screenshot-initial.png", fullPage: true });
// Example: verify a heading is present
const heading = await page.locator("h1").first().textContent();
console.log(`Page heading: ${heading}`);
// Example: fill and submit a form
// await page.fill('[name="email"]', 'test@example.com');
// await page.fill('[name="password"]', 'test-password');
// await page.click('[type="submit"]');
// await page.waitForURL('**/dashboard');
// Take a final screenshot
await page.screenshot({ path: "screenshot-final.png", fullPage: true });
console.log("Console errors:", consoleErrors.length === 0 ? "none" : consoleErrors);
console.log("Network errors:", networkErrors.length === 0 ? "none" : networkErrors);
} finally {
await browser.close();
}
```
Adapt the script to the actual scenario. Replace the example interactions with the specific steps needed.
## Step 4: Interaction patterns
Use these patterns for common UI actions:
**Waiting correctly:**
```typescript
// Wait for a specific element to appear (not arbitrary sleep)
await page.waitForSelector(".success-message", { state: "visible" });
// Wait for navigation
await page.waitForURL("**/dashboard");
// Wait for a network request to complete
await page.waitForResponse((resp) => resp.url().includes("/api/login") && resp.status() === 200);
```
**Forms:**
```typescript
await page.fill('[name="email"]', "user@example.com");
await page.selectOption("select#country", "US");
await page.check('[name="terms"]');
await page.click('[type="submit"]');
```
**Responsive layout:**
```typescript
// Mobile viewport
await page.setViewportSize({ width: 375, height: 812 });
await page.screenshot({ path: "screenshot-mobile.png" });
// Tablet
await page.setViewportSize({ width: 768, height: 1024 });
await page.screenshot({ path: "screenshot-tablet.png" });
```
**Checking visibility and content:**
```typescript
const isVisible = await page.locator(".error-banner").isVisible();
const text = await page.locator(".status-message").textContent();
const count = await page.locator(".list-item").count();
```
## Step 5: Run and report
```bash
npx ts-node test-scenario.ts
# or if using @playwright/test:
npx playwright test
```
Report the outcome as:
**Passed:** what was verified (page loaded, form submitted, URL changed, specific elements present), the screenshot paths, and the console/network error counts.
**Failed:** the exact step that failed, the error message, what the page looked like at failure (screenshot path), any console errors collected, and any failed network requests.
Do not report "the test ran" as success. Report what was actually observed: the page title, the presence or absence of specific elements, whether the expected URL was reached, and whether any console errors fired.
## Common failure patterns to check
- **Hydration errors:** React/Next.js console errors starting with "Hydration failed" or "Text content did not match"
- **Missing environment variables:** `undefined` values appearing in rendered output where a URL or key should be
- **Network failures:** API calls returning 401, 404, or 500 visible in the network error list
- **Layout breaking at mobile widths:** elements overlapping or overflowing at 375px
- **Form validation not triggering:** submit button reachable without filling required fields
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · khaledsaeed18/dotclaude | 100 | MIT |
| Navinspire-ia/navin | 100 | AGPL-3.0 |
| Reprograme/redevkit | 100 | MIT |
| wrongstack/wrongstack | 100 | MIT |
| baysao/dot.agents | 100 | Apache-2.0 |
| patriotai/ai-lab | 100 | MIT |
| alebgl77/claude-inc | 100 | MIT |
| jeffersonvalente/cardume | 100 | MIT |
| JZKK720/cubecloud-skills-bundle-kit | 100 | MIT |
Identical content appears in 1 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 6a20f5c80401 (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
- 100playwright
Run browser-based E2E tests, capture screenshots, and validate user flows using Playwright with visible Chrome. Use this skill when testing a web UI end-to-end, capturing screenshots for visual review, checking responsive layouts, or auditing accessibility in a real browser.… - 100e2e-playwright-testing
End-to-end testing with Playwright for web applications. Use when writing E2E tests, browser automation, form submission testing, or user flow testing. Triggers on "playwright", "e2e test", "browser test", "end-to-end", "form flow testing", or test files in tests/e2e/. - 95memstack-development-webapp-testing
Use when the user says 'write browser tests', 'test this page', 'playwright test', 'e2e test', 'end to end test', 'browser test', 'test the UI', or needs Playwright-based browser testing for a web application. Do NOT use for unit tests, API tests, or non-browser testing. - 90browser-verification
Verify frontend changes in a real browser, including layout, console errors, responsive states, network failures, screenshots, and interactions. Use after local or deployed web UI changes, visual fixes, forms, navigation, asset updates, canvas or 3D work, or whenever browser… - 100browser-verification
Use when a completed task changed UI-affecting files and browser verification is needed during /work. Checks visual elements, interactions, and console errors in a real browser via Playwright. Not a standalone skill. - 100webapp-visual-testing
Use when a browser-facing UI needs visual verification, a layout bug or visual regression is reported, accessibility of an interactive component needs checking, or a browser workflow must be exercised end-to-end.