@diottodev/runic 1.0.0 → 1.1.0

package/engineering-team/playwright-pro/skills/pw/templates/crud/create.md

@@ -0,0 +1,118 @@
+# Create Entity Template
+
+Tests creating a new entity via form submission.
+
+## Prerequisites
+- Authenticated session via `{{authStorageStatePath}}`
+- Entity type: `{{entityName}}` (e.g. "Project", "Product", "User")
+- App running at `{{baseUrl}}`
+
+---
+
+## TypeScript
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Create {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/new');
+  });
+
+  // Happy path: create with valid data
+  test('creates {{entityName}} with valid data', async ({ page }) => {
+    await page.getByRole('textbox', { name: /name/i }).fill('{{testEntityName}}');
+    await page.getByRole('textbox', { name: /description/i }).fill('{{testEntityDescription}}');
+    await page.getByRole('combobox', { name: /category/i }).selectOption('{{testEntityCategory}}');
+    await page.getByRole('button', { name: /create|save/i }).click();
+    await expect(page).toHaveURL(/\/{{entityName}}s\/\d+/);
+    await expect(page.getByRole('heading', { name: '{{testEntityName}}' })).toBeVisible();
+    await expect(page.getByRole('alert')).toContainText(/created successfully/i);
+  });
+
+  // Happy path: create and add another
+  test('clears form after "save and add another"', async ({ page }) => {
+    await page.getByRole('textbox', { name: /name/i }).fill('{{testEntityName}}');
+    await page.getByRole('button', { name: /save and add another/i }).click();
+    await expect(page.getByRole('textbox', { name: /name/i })).toHaveValue('');
+    await expect(page.getByRole('alert')).toContainText(/created successfully/i);
+  });
+
+  // Error case: required fields missing
+  test('shows validation errors for empty required fields', async ({ page }) => {
+    await page.getByRole('button', { name: /create|save/i }).click();
+    await expect(page.getByText(/name is required/i)).toBeVisible();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s/new');
+  });
+
+  // Error case: duplicate name
+  test('shows error when entity name already exists', async ({ page }) => {
+    await page.getByRole('textbox', { name: /name/i }).fill('{{existingEntityName}}');
+    await page.getByRole('button', { name: /create|save/i }).click();
+    await expect(page.getByRole('alert')).toContainText(/already exists|duplicate/i);
+  });
+
+  // Edge case: max length enforcement
+  test('enforces max length on name field', async ({ page }) => {
+    const longName = 'A'.repeat({{maxNameLength}} + 1);
+    await page.getByRole('textbox', { name: /name/i }).fill(longName);
+    const actualValue = await page.getByRole('textbox', { name: /name/i }).inputValue();
+    expect(actualValue.length).toBeLessThanOrEqual({{maxNameLength}});
+  });
+
+  // Edge case: cancel navigates away without saving
+  test('cancel navigates back without creating', async ({ page }) => {
+    await page.getByRole('textbox', { name: /name/i }).fill('should-not-save');
+    await page.getByRole('button', { name: /cancel/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('cell', { name: 'should-not-save' })).toBeHidden();
+  });
+});
+```
+
+---
+
+## JavaScript
+
+```javascript
+const { test, expect } = require('@playwright/test');
+
+test.describe('Create {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/new');
+  });
+
+  test('creates entity with valid data', async ({ page }) => {
+    await page.getByRole('textbox', { name: /name/i }).fill('{{testEntityName}}');
+    await page.getByRole('textbox', { name: /description/i }).fill('{{testEntityDescription}}');
+    await page.getByRole('button', { name: /create|save/i }).click();
+    await expect(page).toHaveURL(/\/{{entityName}}s\/\d+/);
+    await expect(page.getByRole('alert')).toContainText(/created successfully/i);
+  });
+
+  test('shows validation errors for empty form', async ({ page }) => {
+    await page.getByRole('button', { name: /create|save/i }).click();
+    await expect(page.getByText(/name is required/i)).toBeVisible();
+  });
+
+  test('cancel navigates back without saving', async ({ page }) => {
+    await page.getByRole('textbox', { name: /name/i }).fill('not-saved');
+    await page.getByRole('button', { name: /cancel/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+  });
+});
+```
+
+## Variants
+| Variant | Description |
+|---------|-------------|
+| Happy path | Valid form → entity created → detail page |
+| Save and add | Form cleared, ready for next entry |
+| Required fields | Empty submit → inline validation |
+| Duplicate name | Server error shown |
+| Max length | Input truncated at field max |
+| Cancel | No entity created, returns to list |

package/engineering-team/playwright-pro/skills/pw/templates/crud/delete.md

@@ -0,0 +1,116 @@
+# Delete Entity Template
+
+Tests deletion with confirmation dialog and post-delete behaviour.
+
+## Prerequisites
+- Authenticated session via `{{authStorageStatePath}}`
+- Entity to delete: ID `{{entityId}}`, name `{{entityName}}`
+- App running at `{{baseUrl}}`
+
+---
+
+## TypeScript
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Delete {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  // Happy path: delete from detail page
+  test('deletes entity after confirming dialog', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    const dialog = page.getByRole('dialog', { name: /delete|confirm/i });
+    await expect(dialog).toBeVisible();
+    await expect(dialog).toContainText('{{entityName}}');
+    await dialog.getByRole('button', { name: /delete|confirm/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('alert')).toContainText(/deleted successfully/i);
+    await expect(page.getByRole('link', { name: '{{entityName}}' })).toBeHidden();
+  });
+
+  // Happy path: delete from list view
+  test('deletes entity from list row action', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s');
+    const row = page.getByRole('row', { name: new RegExp('{{entityName}}') });
+    await row.getByRole('button', { name: /delete/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /confirm|delete/i }).click();
+    await expect(row).toBeHidden();
+  });
+
+  // Error case: cancel deletion
+  test('does not delete when cancel is clicked in dialog', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /cancel/i }).click();
+    await expect(page.getByRole('dialog')).toBeHidden();
+    await expect(page).toHaveURL(`{{baseUrl}}/{{entityName}}s/{{entityId}}`);
+    await expect(page.getByRole('heading', { name: '{{entityName}}' })).toBeVisible();
+  });
+
+  // Error case: delete entity with dependents
+  test('shows error when entity has dependent records', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityWithDependentsId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /confirm|delete/i }).click();
+    await expect(page.getByRole('alert')).toContainText(/cannot delete|has dependents/i);
+    await expect(page).toHaveURL(`{{baseUrl}}/{{entityName}}s/{{entityWithDependentsId}}`);
+  });
+
+  // Edge case: confirmation dialog requires typing entity name
+  test('requires typing entity name to confirm deletion', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    const confirmBtn = page.getByRole('dialog').getByRole('button', { name: /confirm|delete/i });
+    await expect(confirmBtn).toBeDisabled();
+    await page.getByRole('textbox', { name: /type.*to confirm/i }).fill('{{entityName}}');
+    await expect(confirmBtn).toBeEnabled();
+    await confirmBtn.click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+  });
+});
+```
+
+---
+
+## JavaScript
+
+```javascript
+const { test, expect } = require('@playwright/test');
+
+test.describe('Delete {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  test('deletes entity after confirming dialog', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /confirm|delete/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('alert')).toContainText(/deleted successfully/i);
+  });
+
+  test('does not delete when cancel clicked', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /cancel/i }).click();
+    await expect(page.getByRole('heading', { name: '{{entityName}}' })).toBeVisible();
+  });
+
+  test('shows error for entity with dependents', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityWithDependentsId}}');
+    await page.getByRole('button', { name: /delete/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /confirm|delete/i }).click();
+    await expect(page.getByRole('alert')).toContainText(/cannot delete/i);
+  });
+});
+```
+
+## Variants
+| Variant | Description |
+|---------|-------------|
+| Delete confirmed | Dialog confirmed → entity removed → list page |
+| Delete from list | Row action → confirm → row removed |
+| Cancel deletion | Dialog cancelled → entity intact |
+| Dependent error | Entity with children → deletion blocked |
+| Type-to-confirm | Confirm button disabled until name typed |

package/engineering-team/playwright-pro/skills/pw/templates/crud/read.md

@@ -0,0 +1,117 @@
+# Read Entity Template
+
+Tests viewing entity details and list view with correct data display.
+
+## Prerequisites
+- Authenticated session via `{{authStorageStatePath}}`
+- Seeded entity with ID `{{entityId}}` and name `{{entityName}}`
+- App running at `{{baseUrl}}`
+
+---
+
+## TypeScript
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Read {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  // Happy path: detail page
+  test('displays entity details correctly', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await expect(page.getByRole('heading', { name: '{{expectedTitle}}' })).toBeVisible();
+    await expect(page.getByText('{{expectedField}}')).toBeVisible();
+    await expect(page.getByText('{{expectedCategory}}')).toBeVisible();
+  });
+
+  // Happy path: list view shows all items
+  test('displays list of entities', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('table')).toBeVisible();
+    const rows = page.getByRole('row').filter({ hasNot: page.getByRole('columnheader') });
+    await expect(rows).toHaveCount({{expectedItemCount}});
+  });
+
+  // Happy path: list item links to detail
+  test('clicking list item navigates to detail page', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s');
+    await page.getByRole('link', { name: '{{expectedTitle}}' }).click();
+    await expect(page).toHaveURL(`{{baseUrl}}/{{entityName}}s/{{entityId}}`);
+  });
+
+  // Happy path: breadcrumb navigation
+  test('breadcrumb shows correct path', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await expect(page.getByRole('navigation', { name: /breadcrumb/i })).toContainText('{{entityName}}s');
+    await expect(page.getByRole('navigation', { name: /breadcrumb/i })).toContainText('{{expectedTitle}}');
+  });
+
+  // Error case: non-existent entity shows 404
+  test('shows 404 for non-existent entity', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/999999');
+    await expect(page.getByRole('heading', { name: /404|not found/i })).toBeVisible();
+  });
+
+  // Edge case: loading state resolves to data
+  test('shows data after loading completes', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    // Skeleton/spinner should be gone, data visible
+    await expect(page.getByTestId('skeleton')).toBeHidden();
+    await expect(page.getByRole('heading', { name: '{{expectedTitle}}' })).toBeVisible();
+  });
+
+  // Edge case: empty list state
+  test('shows empty state when no entities exist', async ({ page }) => {
+    // Assumes a fresh context or filter that returns no results
+    await page.goto('{{baseUrl}}/{{entityName}}s?filter={{emptyFilter}}');
+    await expect(page.getByText(/no {{entityName}}s found/i)).toBeVisible();
+    await expect(page.getByRole('button', { name: /create|add/i })).toBeVisible();
+  });
+});
+```
+
+---
+
+## JavaScript
+
+```javascript
+const { test, expect } = require('@playwright/test');
+
+test.describe('Read {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  test('displays entity details correctly', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await expect(page.getByRole('heading', { name: '{{expectedTitle}}' })).toBeVisible();
+    await expect(page.getByText('{{expectedField}}')).toBeVisible();
+  });
+
+  test('displays list of entities with correct count', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s');
+    const rows = page.getByRole('row').filter({ hasNot: page.getByRole('columnheader') });
+    await expect(rows).toHaveCount({{expectedItemCount}});
+  });
+
+  test('shows 404 for non-existent entity', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/999999');
+    await expect(page.getByRole('heading', { name: /404|not found/i })).toBeVisible();
+  });
+
+  test('shows empty state when list is empty', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s?filter={{emptyFilter}}');
+    await expect(page.getByText(/no {{entityName}}s found/i)).toBeVisible();
+  });
+});
+```
+
+## Variants
+| Variant | Description |
+|---------|-------------|
+| Detail view | Entity fields rendered correctly |
+| List view | Correct row count in table |
+| List → detail | Clicking row/link navigates correctly |
+| Breadcrumb | Path reflects current location |
+| 404 | Non-existent ID shows not-found page |
+| Loading → data | Skeleton hidden, data visible after load |
+| Empty list | No-results state with call to action |

package/engineering-team/playwright-pro/skills/pw/templates/crud/soft-delete.md

@@ -0,0 +1,113 @@
+# Soft Delete (Archive/Restore) Template
+
+Tests archiving an entity, viewing archived items, and restoring them.
+
+## Prerequisites
+- Authenticated session via `{{authStorageStatePath}}`
+- Active entity: ID `{{entityId}}`, name `{{entityName}}`
+- Archived entity: ID `{{archivedEntityId}}`
+- App running at `{{baseUrl}}`
+
+---
+
+## TypeScript
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Soft Delete — Archive & Restore', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  // Happy path: archive entity
+  test('archives entity and removes from active list', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /archive/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /archive|confirm/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('alert')).toContainText(/archived/i);
+    await expect(page.getByRole('link', { name: '{{entityName}}' })).toBeHidden();
+  });
+
+  // Happy path: archived entity appears in archived view
+  test('archived entity visible in archived list', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s?status=archived');
+    await expect(page.getByRole('link', { name: '{{entityName}}' })).toBeVisible();
+  });
+
+  // Happy path: restore archived entity
+  test('restores archived entity to active list', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s?status=archived');
+    const row = page.getByRole('row', { name: new RegExp('{{entityName}}') });
+    await row.getByRole('button', { name: /restore/i }).click();
+    await expect(page.getByRole('alert')).toContainText(/restored/i);
+    await expect(row).toBeHidden();
+
+    await page.goto('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('link', { name: '{{entityName}}' })).toBeVisible();
+  });
+
+  // Happy path: active list does not show archived by default
+  test('active list does not include archived entities', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('link', { name: /{{archivedEntityName}}/i })).toBeHidden();
+  });
+
+  // Error case: archived entity cannot be edited
+  test('archived entity edit button is disabled', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{archivedEntityId}}');
+    await expect(page.getByRole('button', { name: /edit/i })).toBeDisabled();
+    await expect(page.getByText(/archived/i)).toBeVisible();
+  });
+
+  // Edge case: permanently delete archived entity
+  test('permanently deletes archived entity', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{archivedEntityId}}');
+    await page.getByRole('button', { name: /delete permanently/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /delete permanently/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s?status=archived');
+    await expect(page.getByRole('link', { name: '{{archivedEntityName}}' })).toBeHidden();
+  });
+});
+```
+
+---
+
+## JavaScript
+
+```javascript
+const { test, expect } = require('@playwright/test');
+
+test.describe('Soft Delete — Archive & Restore', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  test('archives entity and removes from active list', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /archive/i }).click();
+    await page.getByRole('dialog').getByRole('button', { name: /archive|confirm/i }).click();
+    await expect(page).toHaveURL('{{baseUrl}}/{{entityName}}s');
+    await expect(page.getByRole('link', { name: '{{entityName}}' })).toBeHidden();
+  });
+
+  test('restores archived entity to active list', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s?status=archived');
+    await page.getByRole('row', { name: new RegExp('{{entityName}}') })
+      .getByRole('button', { name: /restore/i }).click();
+    await expect(page.getByRole('alert')).toContainText(/restored/i);
+  });
+
+  test('archived entity edit button is disabled', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{archivedEntityId}}');
+    await expect(page.getByRole('button', { name: /edit/i })).toBeDisabled();
+  });
+});
+```
+
+## Variants
+| Variant | Description |
+|---------|-------------|
+| Archive | Entity moved to archived list, removed from active |
+| Archived list | Archived items visible with status=archived filter |
+| Restore | Archived entity returned to active list |
+| Active list clean | Archived items hidden from default view |
+| Edit disabled | Archived entity cannot be edited |
+| Permanent delete | Hard-delete of archived entity |

package/engineering-team/playwright-pro/skills/pw/templates/crud/update.md

@@ -0,0 +1,129 @@
+# Update Entity Template
+
+Tests editing an entity via form and inline edit interactions.
+
+## Prerequisites
+- Authenticated session via `{{authStorageStatePath}}`
+- Existing entity ID: `{{entityId}}`, name: `{{originalEntityName}}`
+- App running at `{{baseUrl}}`
+
+---
+
+## TypeScript
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('Update {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  // Happy path: edit via form
+  test('updates entity via edit form', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}/edit');
+    const nameField = page.getByRole('textbox', { name: /name/i });
+    await nameField.clear();
+    await nameField.fill('{{updatedEntityName}}');
+    await page.getByRole('button', { name: /save|update/i }).click();
+    await expect(page).toHaveURL(`{{baseUrl}}/{{entityName}}s/{{entityId}}`);
+    await expect(page.getByRole('heading', { name: '{{updatedEntityName}}' })).toBeVisible();
+    await expect(page.getByRole('alert')).toContainText(/updated successfully/i);
+  });
+
+  // Happy path: inline edit
+  test('updates name via inline edit', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /edit name/i }).click();
+    const inlineInput = page.getByRole('textbox', { name: /name/i });
+    await inlineInput.clear();
+    await inlineInput.fill('{{updatedEntityName}}');
+    await inlineInput.press('Enter');
+    await expect(page.getByRole('heading', { name: '{{updatedEntityName}}' })).toBeVisible();
+  });
+
+  // Happy path: edit then navigate away — unsaved changes warning
+  test('warns before discarding unsaved changes', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}/edit');
+    await page.getByRole('textbox', { name: /name/i }).fill('unsaved-change');
+    await page.getByRole('link', { name: /cancel|back/i }).click();
+    await expect(page.getByRole('dialog', { name: /unsaved changes/i })).toBeVisible();
+    await page.getByRole('button', { name: /discard/i }).click();
+    await expect(page).toHaveURL(`{{baseUrl}}/{{entityName}}s/{{entityId}}`);
+    await expect(page.getByRole('heading', { name: '{{originalEntityName}}' })).toBeVisible();
+  });
+
+  // Error case: clearing required field
+  test('shows validation error when required field is cleared', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}/edit');
+    await page.getByRole('textbox', { name: /name/i }).clear();
+    await page.getByRole('button', { name: /save|update/i }).click();
+    await expect(page.getByText(/name is required/i)).toBeVisible();
+    await expect(page).toHaveURL(`{{baseUrl}}/{{entityName}}s/{{entityId}}/edit`);
+  });
+
+  // Error case: conflict (optimistic update failure)
+  test('handles concurrent edit conflict gracefully', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}/edit');
+    // Simulate another user modifying the record
+    await page.request.put(`{{baseUrl}}/api/{{entityName}}s/{{entityId}}`, {
+      data: { name: 'modified-by-other', version: 999 },
+    });
+    await page.getByRole('textbox', { name: /name/i }).fill('my-change');
+    await page.getByRole('button', { name: /save|update/i }).click();
+    await expect(page.getByRole('alert')).toContainText(/conflict|modified by another/i);
+  });
+
+  // Edge case: inline edit cancelled with Escape
+  test('cancels inline edit on Escape key', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /edit name/i }).click();
+    await page.getByRole('textbox', { name: /name/i }).fill('should-not-save');
+    await page.keyboard.press('Escape');
+    await expect(page.getByRole('heading', { name: '{{originalEntityName}}' })).toBeVisible();
+  });
+});
+```
+
+---
+
+## JavaScript
+
+```javascript
+const { test, expect } = require('@playwright/test');
+
+test.describe('Update {{entityName}}', () => {
+  test.use({ storageState: '{{authStorageStatePath}}' });
+
+  test('updates entity via edit form', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}/edit');
+    await page.getByRole('textbox', { name: /name/i }).clear();
+    await page.getByRole('textbox', { name: /name/i }).fill('{{updatedEntityName}}');
+    await page.getByRole('button', { name: /save|update/i }).click();
+    await expect(page.getByRole('heading', { name: '{{updatedEntityName}}' })).toBeVisible();
+  });
+
+  test('shows validation error when required field cleared', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}/edit');
+    await page.getByRole('textbox', { name: /name/i }).clear();
+    await page.getByRole('button', { name: /save|update/i }).click();
+    await expect(page.getByText(/name is required/i)).toBeVisible();
+  });
+
+  test('cancels inline edit on Escape', async ({ page }) => {
+    await page.goto('{{baseUrl}}/{{entityName}}s/{{entityId}}');
+    await page.getByRole('button', { name: /edit name/i }).click();
+    await page.getByRole('textbox', { name: /name/i }).fill('nope');
+    await page.keyboard.press('Escape');
+    await expect(page.getByRole('heading', { name: '{{originalEntityName}}' })).toBeVisible();
+  });
+});
+```
+
+## Variants
+| Variant | Description |
+|---------|-------------|
+| Edit form | Full edit form → save → detail page |
+| Inline edit | Click field → type → Enter to save |
+| Unsaved changes | Navigation shows discard confirmation |
+| Required field | Cleared required field → validation |
+| Conflict | Concurrent edit → conflict error |
+| Escape cancel | Inline edit cancelled, original value restored |