From b6e0b0382798c0d3b8986beedd4af455fc559807 Mon Sep 17 00:00:00 2001 From: Yury Semikhatsky Date: Thu, 30 Apr 2026 10:36:30 -0700 Subject: [PATCH] chore: roll Playwright to 1.60.0-alpha-1777566615000 --- README.md | 6 +- package-lock.json | 26 +- package.json | 4 +- skills/playwright-cli/SKILL.md | 14 +- .../references/playwright-tests.md | 2 +- .../references/spec-driven-testing.md | 305 ++++++++++++++++++ 6 files changed, 333 insertions(+), 24 deletions(-) create mode 100644 skills/playwright-cli/references/spec-driven-testing.md diff --git a/README.md b/README.md index d2e60fa..b7a0962 100644 --- a/README.md +++ b/README.md @@ -239,7 +239,8 @@ playwright-cli unroute [pattern] # remove route(s) ```bash playwright-cli console [min-level] # list console messages -playwright-cli network # list all network requests since loading the page +playwright-cli requests # list all network requests since loading the page +playwright-cli request # show details for a specific request playwright-cli run-code # run playwright code snippet playwright-cli run-code --filename=f # run playwright code from a file playwright-cli tracing-start # start trace recording @@ -248,7 +249,7 @@ playwright-cli video-start [filename] # start video recording playwright-cli video-chapter # add a chapter marker to the video playwright-cli video-stop # stop video recording playwright-cli show # open the visual dashboard -playwright-cli show --annotate # open dashboard and prompt user for input +playwright-cli annotate # launch dashboard for UI review / design feedback playwright-cli generate-locator <ref> # generate a playwright locator for an element playwright-cli highlight <ref> # show a persistent highlight overlay playwright-cli highlight <ref> --style= # highlight with a custom CSS style @@ -555,6 +556,7 @@ The installed skill includes detailed reference guides for common tasks: * **Request mocking** — intercept and mock network requests * **Running Playwright code** — execute arbitrary Playwright scripts * **Browser session management** — manage multiple browser sessions +* **Spec-driven testing (plan / generate / heal)** — drive tests from a written spec * **Storage state (cookies, localStorage)** — persist and restore browser state * **Test generation** — generate Playwright tests from interactions * **Tracing** — record and inspect execution traces diff --git a/package-lock.json b/package-lock.json index 18b33bd..c5c20aa 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,13 +9,13 @@ "version": "0.1.9", "license": "Apache-2.0", "dependencies": { - "playwright": "1.60.0-alpha-1777077614000" + "playwright": "1.60.0-alpha-1777566615000" }, "bin": { "playwright-cli": "playwright-cli.js" }, "devDependencies": { - "@playwright/test": "1.60.0-alpha-1777077614000", + "@playwright/test": "1.60.0-alpha-1777566615000", "@types/node": "^25.2.1" }, "engines": { @@ -23,13 +23,13 @@ } }, "node_modules/@playwright/test": { - "version": "1.60.0-alpha-1777077614000", - "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.60.0-alpha-1777077614000.tgz", - "integrity": "sha512-zBcSZTwgke+UR/pUj/hjhX1npshDd8Rc5faF/VB9TOooocPBe1QxaMRbacTXKBvz69dwx0idRW2ZIYWagQlO5Q==", + "version": "1.60.0-alpha-1777566615000", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.60.0-alpha-1777566615000.tgz", + "integrity": "sha512-EBGZI/5WjEhIvXsa+6q7XrYDif1YyL9bmp7t6IKN4Aa/OWedI7Pw9a6Calk5Uqx6SNCco8qTXHpBI95+5+mvww==", "dev": true, "license": "Apache-2.0", "dependencies": { - "playwright": "1.60.0-alpha-1777077614000" + "playwright": "1.60.0-alpha-1777566615000" }, "bin": { "playwright": "cli.js" @@ -63,12 +63,12 @@ } }, "node_modules/playwright": { - "version": "1.60.0-alpha-1777077614000", - "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.60.0-alpha-1777077614000.tgz", - "integrity": "sha512-Uykk/hbDlIaw4aZZZHMni6I0Y9eBtC7+UzH3QwTh9pJEEuYVq14y7F3bcHNCNCI0sLkY0oEiWK+2VeOtB6vUDQ==", + "version": "1.60.0-alpha-1777566615000", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.60.0-alpha-1777566615000.tgz", + "integrity": "sha512-ENFFNacDBbDBLUtn4FsdZowN9CxsO22/xlgvhgiyzW6FM/PoWM5GSwNl2c0LMvcFYkmmPbB6uGHFL9T2U9ufVQ==", "license": "Apache-2.0", "dependencies": { - "playwright-core": "1.60.0-alpha-1777077614000" + "playwright-core": "1.60.0-alpha-1777566615000" }, "bin": { "playwright": "cli.js" @@ -81,9 +81,9 @@ } }, "node_modules/playwright-core": { - "version": "1.60.0-alpha-1777077614000", - "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.60.0-alpha-1777077614000.tgz", - "integrity": "sha512-cAEm1N5jh0WMr9/EG4nPDbR326paHfMFa2FyHibhIfDGTswbKv8sYvaa9S0UXkgITdv4h6lQfcsD9Dl73lFZsg==", + "version": "1.60.0-alpha-1777566615000", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.60.0-alpha-1777566615000.tgz", + "integrity": "sha512-68GgyVu5NAgQzU8YdbYS/PZCStmiJoV3kclnAIb9Yau+wj23O1pLyMprw2MgenE0lIBU5aFvkHdv/LB8oMd1Xg==", "license": "Apache-2.0", "bin": { "playwright-core": "cli.js" diff --git a/package.json b/package.json index 95cca03..dc8b06e 100644 --- a/package.json +++ b/package.json @@ -18,11 +18,11 @@ "test": "playwright test" }, "devDependencies": { - "@playwright/test": "1.60.0-alpha-1777077614000", + "@playwright/test": "1.60.0-alpha-1777566615000", "@types/node": "^25.2.1" }, "dependencies": { - "playwright": "1.60.0-alpha-1777077614000" + "playwright": "1.60.0-alpha-1777566615000" }, "bin": { "playwright-cli": "playwright-cli.js" diff --git a/skills/playwright-cli/SKILL.md b/skills/playwright-cli/SKILL.md index bde0b60..4111868 100644 --- a/skills/playwright-cli/SKILL.md +++ b/skills/playwright-cli/SKILL.md @@ -153,7 +153,8 @@ playwright-cli unroute ```bash playwright-cli console playwright-cli console warning -playwright-cli network +playwright-cli requests +playwright-cli request 5 playwright-cli run-code "async page => await page.context().grantPermissions(['geolocation'])" playwright-cli run-code --filename=script.js playwright-cli tracing-start @@ -162,8 +163,8 @@ playwright-cli video-start video.webm playwright-cli video-chapter "Chapter Title" --description="Details" --duration=2000 playwright-cli video-stop -# launch the dashboard with annotation prompt to ask the user for input -playwright-cli show --annotate +# launch the dashboard for UI review / design feedback — user annotates the page, you receive the annotated screenshot, snapshot, and notes +playwright-cli annotate # generate a Playwright locator for an element from its ref or selector playwright-cli generate-locator e5 --raw @@ -351,7 +352,7 @@ playwright-cli open https://example.com playwright-cli click e4 playwright-cli fill e7 "test" playwright-cli console -playwright-cli network +playwright-cli requests playwright-cli close ``` @@ -366,11 +367,11 @@ playwright-cli close ## Example: Interactive session -Ask the user to annotate the UI. User can provide contextual tasks or ask contextual questions using annotations: +Ask the user for UI review or design feedback. The user draws boxes on the live page and types comments; you receive the annotated screenshot, the snapshot of the marked region, and the user's notes. Use this whenever the user asks for "UI review", "design feedback", or to "ask the user what they think / want / mean": ```bash playwright-cli open https://example.com -playwright-cli show --annotate +playwright-cli annotate ``` ## Specific tasks @@ -379,6 +380,7 @@ playwright-cli show --annotate * **Request mocking** [references/request-mocking.md](references/request-mocking.md) * **Running Playwright code** [references/running-code.md](references/running-code.md) * **Browser session management** [references/session-management.md](references/session-management.md) +* **Spec-driven testing (plan / generate / heal)** [references/spec-driven-testing.md](references/spec-driven-testing.md) * **Storage state (cookies, localStorage)** [references/storage-state.md](references/storage-state.md) * **Test generation** [references/test-generation.md](references/test-generation.md) * **Tracing** [references/tracing.md](references/tracing.md) diff --git a/skills/playwright-cli/references/playwright-tests.md b/skills/playwright-cli/references/playwright-tests.md index 47627c2..bec2ec9 100644 --- a/skills/playwright-cli/references/playwright-tests.md +++ b/skills/playwright-cli/references/playwright-tests.md @@ -14,7 +14,7 @@ PLAYWRIGHT_HTML_OPEN=never npm run special-test-command To debug a failing Playwright test, run it with `--debug=cli` option. This command will pause the test at the start and print the debugging instructions. -**IMPORTANT**: run the command in the background and check the output until "Debugging Instructions" is printed. +**IMPORTANT**: run the command in the background and check the output until "Debugging Instructions" is printed. Make sure to stop the command after you have finished. Once instructions containing a session name are printed, use `playwright-cli` to attach the session and explore the page. diff --git a/skills/playwright-cli/references/spec-driven-testing.md b/skills/playwright-cli/references/spec-driven-testing.md new file mode 100644 index 0000000..5097a67 --- /dev/null +++ b/skills/playwright-cli/references/spec-driven-testing.md @@ -0,0 +1,305 @@ +# Spec-driven testing (plan → generate → heal) + +End-to-end workflow for authoring and maintaining Playwright tests using `playwright-cli`. The three sections below can be used independently: + +- **Planning** — explore the app, produce a spec file describing what to test. +- **Generate** — turn a spec into Playwright test files. Update the spec if it's vague or stale. +- **Heal** — diagnose failing tests, fix the code, reconcile the spec with reality. + +All three lean on the same mechanic: run `npx playwright test --debug=cli` in the background, then `playwright-cli attach tw-XXXX` to drive the paused page interactively. See [playwright-tests.md](playwright-tests.md) for the debug/attach mechanics and [test-generation.md](test-generation.md) for how every `playwright-cli` action emits Playwright TypeScript. + +--- + +## 1. Planning + +Goal: produce a spec file (e.g. `specs/<feature>.plan.md`) that enumerates the scenarios to test. **Always** write the spec to a file. + +### 1.1 Prerequisite: workspace + +Check the workspace has Playwright installed before anything else: + +```bash +# Either of these confirms a workspace: +test -f playwright.config.ts || test -f playwright.config.js +npx --no-install playwright --version +``` + +If there is no Playwright install, bootstrap one and let the user pick the defaults: + +```bash +npm init playwright@latest +``` + +### 1.2 Prerequisite: seed test + +A **seed test** is a minimal test that lands the page in the state every scenario starts from: navigation to the app, any required login, feature flags, etc. Scenarios assume a fresh start *after* the seed. `--debug=cli` pauses *inside* this test, so the seed is where every planning and generation session begins. + +Minimum viable seed: + +```ts +// tests/seed.spec.ts +import { test } from '@playwright/test'; + +test('seed', async ({ page }) => { + await page.goto('https://example.com/'); +}); +``` + +Preferred — push navigation into a fixture so scenario tests reuse it: + +```ts +// tests/fixtures.ts +import { test as baseTest } from '@playwright/test'; +export { expect } from '@playwright/test'; + +export const test = baseTest.extend({ + page: async ({ page }, use) => { + await page.goto('https://example.com/'); + await use(page); + }, +}); +``` + +```ts +// tests/seed.spec.ts +import { test } from './fixtures'; + +test('seed', async ({ page }) => { + // Fixture already navigates. This empty body tells agents where to start. +}); +``` + +If no seed exists, create one that at least navigates to the app. + +### 1.3 Explore the app + +Launch the app via the seed in the background and attach: + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test tests/seed.spec.ts --debug=cli +# wait for "Debugging Instructions" and the session name tw-XXXX +playwright-cli attach tw-XXXX +``` + +Resume so the seed runs, then probe the app: + +```bash +playwright-cli resume # resume so that seed test runs fully +playwright-cli snapshot # inventory of interactive elements +playwright-cli click e5 # follow a flow +playwright-cli eval "location.href" # read URL / state +playwright-cli annotate # ask the user to point at something +``` + +Map out: + +- Interactive surfaces (forms, buttons, lists, filters, modals). +- Primary user journeys end-to-end. +- Edge cases: empty states, validation errors, very long input, boundary values. +- Persistence: reload, local/session storage, URL fragments. +- Navigation: which controls change the URL, back/forward behaviour. + +**Important**: Do not just open the app url with playwright-cli, always go through the test to capture any custom setup done there. +**Important**: Stop the background test when done exploring. + +### 1.4 Write the spec file + +Save under `specs/<feature>.plan.md`. Use this structure: + +```markdown +# <Feature> Test Plan + +## Application Overview + +<One paragraph describing what the feature does and why it matters.> + +## Test Scenarios + +### 1. <Group Name> + +**Seed:** `tests/seed.spec.ts` + +#### 1.1. <kebab-case-scenario-name> + +**File:** `tests/<group>/<kebab-case-scenario-name>.spec.ts` + +**Steps:** + 1. <Concrete user step> + - expect: <observable outcome> + - expect: <another observable outcome> + 2. <Next step> + - expect: <outcome> + +#### 1.2. <next-scenario> +... + +### 2. <Next Group> + +**Seed:** `tests/seed.spec.ts` +... +``` + +Guidelines: + +- Each scenario is independent and starts from the seed's fresh state — never chain scenarios. +- Scenario names are kebab-case and match the test file name (`should-add-single-todo` → `should-add-single-todo.spec.ts`). +- Cover happy path, edge cases, validation, negative flows, persistence. +- Write steps at the user level ("Type 'Buy milk' into the input"), not the API level ("call `fill`"). +- Put observable outcomes in `- expect:` bullets; each becomes an assertion during generation. + +--- + +## 2. Generate + +Goal: take a spec file and produce Playwright test files. Optionally update the spec if it has drifted. + +### 2.1 Inputs + +- **Spec file**, e.g. `specs/basic-operations.plan.md`. +- **Target**: either a single scenario (e.g. `1.2`), a whole group (`1`), or all. +- **Seed file**, read from the `**Seed:**` line of the scenario's group. + +### 2.2 Generate one scenario + +For each target scenario, in sequence (never in parallel — scenarios share the seed session): + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test <seed-file> --debug=cli # background +playwright-cli attach tw-XXXX +# resume +``` + +**Do not** just open the app url with playwright-cli, always go through the test to capture any custom setup done there. + +Walk the scenario's `Steps:` one by one with `playwright-cli`, treating the spec as the plan and the live app as the source of truth. If a step is vague ("click the button" — which button?), references an element that no longer exists, or contradicts the app's actual behaviour, use your judgement: update the spec to match what the app really does, then keep going. Editing the spec mid-generation is expected. + +Every action prints the equivalent Playwright TypeScript (see [test-generation.md](test-generation.md)): + +```bash +playwright-cli snapshot # find refs +playwright-cli fill e3 "John Doe" # -> page.getByRole('textbox', {...}).fill(...) +playwright-cli press Enter +playwright-cli click e7 +``` + +For each `- expect:` bullet, add an explicit assertion. See [test-generation.md](test-generation.md) for details. + +Collect the generated code and write the test file at the path given in the spec: + +```ts +// spec: specs/basic-operations.plan.md +// seed: tests/seed.spec.ts +import { test, expect } from './fixtures'; // or '@playwright/test' if no fixtures file + +test.describe('Singing in and out', () => { + test('should sign in', async ({ page }) => { + // 1. Navigate to the application + // (handled by the seed fixture) + + // 2. Type 'John Doe' into the username field + await page.getByRole('textbox', { name: 'username' }).fill('John Doe'); + + // 3. Type password + await page.getByRole('textbox', { name: 'password' }).fill('TestPassword'); + + // 4. Press Enter to submit + await page.getByRole('textbox', { name: 'password' }).press('Enter'); + + await expect(page.getByRole('heading')).toContainText('Welcome, John Doe!'); + }); +}); +``` + +Rules: + +- **One test per file.** File path, describe name, and test name come verbatim from the spec (minus the ordinal). +- Prefix each numbered step with a `// N. <step text>` comment before its actions. +- Use the describe group name verbatim from the spec (no `1.` ordinal). +- Import from `./fixtures` if the project has one; otherwise `@playwright/test`. +- **Important**: close the CLI session and stop the background test before moving to the next scenario. + +### 2.3 Generate multiple scenarios + +Loop 2.2 over the targeted scenarios one at a time, restarting the seed between each so every test starts from a clean page. This is safe to parallelise due to unique generated session names - just make sure each test run is stopped. + +### 2.4 Run generated tests + +After generation, run the new tests once: + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test tests/<group>/<scenario>.spec.ts +``` + +Any failure goes to Section 3. + +--- + +## 3. Heal + +Goal: fix failing tests, and update the spec if the app's intended behaviour changed. + +### 3.1 Find failing tests + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test +``` + +Record the list of failing `<file>:<line>` entries and process them one at a time. Do not attempt parallel fixes — shared state and the single CLI session make that fragile. + +### 3.2 Debug one failure + +Run the single failing test in debug mode in the background, then attach: + +```bash +PLAYWRIGHT_HTML_OPEN=never npx playwright test tests/<group>/<scenario>.spec.ts:<line> --debug=cli +# wait for "Debugging Instructions" and the tw-XXXX session name +playwright-cli attach tw-XXXX +``` + +The test is paused at the start. Step forward or run to until just before the failing action or assertion, then diagnose: + +```bash +playwright-cli snapshot # did the element change / move / rename? +playwright-cli console # app-side errors? +playwright-cli network # failed request? wrong payload? +playwright-cli annotate # ask the user to point somewhere +``` + +Common causes: selector drift, new wrapper element, label/ARIA rename, timing (transition, async load), assertion text updated in the app, test data leaking between runs. + +Rehearse the corrected interaction with `playwright-cli` — the generated code in the output is what you paste back into the test. + +### 3.3 Apply the fix + +Edit the test file: update the locator, assertion, step order, or inputs to match the corrected behaviour. Stop the background debug run. Rerun the single test to confirm green. + +Never skip hooks or add sleeps as a fix. Never use `networkidle`. + +### 3.4 Reconcile with the spec + +Open the spec referenced by the `// spec:` header in the test file and locate the scenario that matches the test. + +- **Fix was purely technical** (locator drift, better assertion shape) and the spec's user-level behaviour still matches the app → leave the spec alone. +- **Fix changed user-visible steps, inputs, order, or expected outcomes** that the spec describes → update the spec to match reality. Keep the scenario id and file path stable; only the step / expect lines change. +- **Unclear whether the app change is intentional** (spec is stale) **or a regression** (test was right, app is wrong) → **stop and ask the user**. Provide: + - the scenario id (e.g. `2.3`), + - the spec lines that no longer match, + - the observed app behaviour (quote a snapshot excerpt or a concrete outcome). + +Only after the user answers, either update the spec (intentional change) or file/flag the test as covering a bug (regression). + +### 3.5 Iteration and giving up + +- Fix failures one at a time; rerun after each. +- If after thorough investigation you are confident the test is correct but the app is wrong *and* the user has confirmed it's a bug: mark the test `test.fixme(...)` with a comment pointing at the user's decision or issue link. Never silently skip. + +--- + +## Cross-references + +| For... | See | +|---|---| +| `--debug=cli` / attach mechanics | [playwright-tests.md](playwright-tests.md) | +| How `playwright-cli` actions become TS | [test-generation.md](test-generation.md) | +| Mocking requests during exploration/generation | [request-mocking.md](request-mocking.md) | +| Managing the CLI browser session | [session-management.md](session-management.md) |