Skip to content

ever-co/ever-works / .agents/skills/playwright-best-practices

playwright-best-practices

Verified

Use when writing Playwright tests, fixing flaky tests, debugging failures, implementing Page Object Model, configuring CI/CD, optimizing performance, mocking APIs, handling authentication or OAuth, testing accessibility (axe-core), file uploads/downloads, date/time mocking, WebSockets, geolocation, permissions, multi-tab/popup flows, mobile/responsive layouts, touch gestures, GraphQL, error handling, offline mode, multi-user collaboration, third-party services (payments, email verification), console error monitoring, global setup/teardown, test annotations (skip, fixme, slow), test tags (@smoke, @fast, @critical, filtering with --grep), project dependencies, security testing (XSS, CSRF, auth), performance budgets (Web Vitals, Lighthouse), iframes, component testing, canvas/WebGL, service workers/PWA, test coverage, i18n/localization, Electron apps, or browser extension testing. Covers E2E, component, API, visual, accessibility, security, Electron, and extension testing.

FileKindSize
LICENSE.mdmarkdown1.0 KB
README.mdmarkdown9.9 KB
SKILL.mdskill md25.7 KB
advanced/authentication-flows.mdmarkdown10.4 KB
advanced/authentication.mdmarkdown29.4 KB
advanced/clock-mocking.mdmarkdown9.4 KB
advanced/mobile-testing.mdmarkdown10.3 KB
advanced/multi-context.mdmarkdown8.2 KB
advanced/multi-user.mdmarkdown10.9 KB
advanced/network-advanced.mdmarkdown10.1 KB
advanced/third-party.mdmarkdown11.1 KB
architecture/pom-vs-fixtures.mdmarkdown11.4 KB
architecture/test-architecture.mdmarkdown14.3 KB
architecture/when-to-mock.mdmarkdown11.9 KB
browser-apis/browser-apis.mdmarkdown10.1 KB
browser-apis/iframes.mdmarkdown11.1 KB
browser-apis/service-workers.mdmarkdown13.1 KB
browser-apis/websockets.mdmarkdown9.9 KB
core/annotations.mdmarkdown10.4 KB
core/assertions-waiting.mdmarkdown9.1 KB
core/configuration.mdmarkdown13.7 KB
core/fixtures-hooks.mdmarkdown11.2 KB
core/global-setup.mdmarkdown12.4 KB
core/locators.mdmarkdown6.4 KB
core/page-object-model.mdmarkdown7.7 KB
core/projects-dependencies.mdmarkdown8.1 KB
core/test-data.mdmarkdown11.3 KB
core/test-suite-structure.mdmarkdown9.1 KB
core/test-tags.mdmarkdown6.7 KB
debugging/console-errors.mdmarkdown9.3 KB
debugging/debugging.mdmarkdown14.7 KB
debugging/error-testing.mdmarkdown9.2 KB
debugging/flaky-tests.mdmarkdown14.5 KB
frameworks/angular.mdmarkdown18.9 KB
frameworks/nextjs.mdmarkdown13.4 KB
frameworks/react.mdmarkdown17.5 KB
frameworks/vue.mdmarkdown17.3 KB
infrastructure-ci-cd/ci-cd.mdmarkdown10.4 KB
infrastructure-ci-cd/docker.mdmarkdown7.0 KB
infrastructure-ci-cd/github-actions.mdmarkdown15.1 KB
infrastructure-ci-cd/gitlab.mdmarkdown10.9 KB
infrastructure-ci-cd/other-providers.mdmarkdown14.2 KB
infrastructure-ci-cd/parallel-sharding.mdmarkdown11.6 KB
infrastructure-ci-cd/performance.mdmarkdown11.3 KB
infrastructure-ci-cd/reporting.mdmarkdown11.4 KB
infrastructure-ci-cd/test-coverage.mdmarkdown12.0 KB
testing-patterns/accessibility.mdmarkdown8.7 KB
testing-patterns/api-testing.mdmarkdown23.5 KB
testing-patterns/browser-extensions.mdmarkdown13.0 KB
testing-patterns/canvas-webgl.mdmarkdown12.3 KB
testing-patterns/component-testing.mdmarkdown11.0 KB
testing-patterns/drag-drop.mdmarkdown17.4 KB
testing-patterns/electron.mdmarkdown12.8 KB
testing-patterns/file-operations.mdmarkdown10.0 KB
testing-patterns/file-upload-download.mdmarkdown16.5 KB
testing-patterns/forms-validation.mdmarkdown21.3 KB
testing-patterns/graphql-testing.mdmarkdown8.6 KB
testing-patterns/i18n.mdmarkdown12.3 KB
testing-patterns/performance-testing.mdmarkdown11.5 KB
testing-patterns/security-testing.mdmarkdown11.5 KB
testing-patterns/visual-regression.mdmarkdown18.4 KB

browser-apis/browser-apis.md

View on GitHub
# Browser APIs: Geolocation, Permissions & More

## Table of Contents

1. [Geolocation](#geolocation)
2. [Permissions](#permissions)
3. [Clipboard](#clipboard)
4. [Notifications](#notifications)
5. [Camera & Microphone](#camera--microphone)

## Geolocation

### Mock Location

```typescript
test('shows nearby stores', async ({ context }) => {
	// Grant permission and set location
	await context.grantPermissions(['geolocation']);
	await context.setGeolocation({ latitude: 37.7749, longitude: -122.4194 }); // San Francisco

	const page = await context.newPage();
	await page.goto('/store-finder');
	await page.getByRole('button', { name: 'Find Nearby' }).click();

	await expect(page.getByText('San Francisco')).toBeVisible();
});
```

### Geolocation Fixture

```typescript
// fixtures/geolocation.fixture.ts
import { test as base } from '@playwright/test';

type Coordinates = { latitude: number; longitude: number; accuracy?: number };

type GeoFixtures = {
	setLocation: (coords: Coordinates) => Promise<void>;
};

export const test = base.extend<GeoFixtures>({
	setLocation: async ({ context }, use) => {
		await context.grantPermissions(['geolocation']);

		await use(async (coords) => {
			await context.setGeolocation({
				latitude: coords.latitude,
				longitude: coords.longitude,
				accuracy: coords.accuracy ?? 100
			});
		});
	}
});

// Usage
test('delivery zone check', async ({ page, setLocation }) => {
	await setLocation({ latitude: 40.7128, longitude: -74.006 }); // NYC

	await page.goto('/delivery');

	await expect(page.getByText('Delivery available')).toBeVisible();
});
```

### Test Location Changes

```typescript
test('tracks location updates', async ({ context }) => {
	await context.grantPermissions(['geolocation']);

	const page = await context.newPage();
	await page.goto('/tracking');

	// Initial location
	await context.setGeolocation({ latitude: 37.7749, longitude: -122.4194 });
	await page.getByRole('button', { name: 'Start Tracking' }).click();

	await expect(page.getByTestId('location')).toContainText('37.7749');

	// Move to new location
	await context.setGeolocation({ latitude: 37.8044, longitude: -122.2712 });

	// Trigger location update
	await page.evaluate(() => {
		navigator.geolocation.getCurrentPosition(() => {});
	});

	await expect(page.getByTestId('location')).toContainText('37.8044');
});
```

### Test Geolocation Denial

```typescript
test('handles location denied', async ({ browser }) => {
	// Create context without geolocation permission
	const context = await browser.newContext({
		permissions: [] // No permissions
	});

	const page = await context.newPage();
	await page.goto('/store-finder');
	await page.getByRole('button', { name: 'Find Nearby' }).click();

	await expect(page.getByText('Location access denied')).toBeVisible();
	await expect(page.getByLabel('Enter ZIP code')).toBeVisible();

	await context.close();
});
```

## Permissions

### Grant Permissions

```typescript
test('notifications with permission', async ({ context }) => {
	await context.grantPermissions(['notifications']);

	const page = await context.newPage();
	await page.goto('/alerts');

	// Notification API should work
	const permission = await page.evaluate(() => Notification.permission);
	expect(permission).toBe('granted');
});
```

### Test Permission Denied

```typescript
test('handles notification permission denied', async ({ browser }) => {
	const context = await browser.newContext({
		permissions: [] // Deny all
	});

	const page = await context.newPage();
	await page.goto('/notifications');

	await page.getByRole('button', { name: 'Enable Notifications' }).click();

	await expect(page.getByText('Please enable notifications')).toBeVisible();

	await context.close();
});
```

### Multiple Permissions

```typescript
test('video call with permissions', async ({ context }) => {
	await context.grantPermissions(['camera', 'microphone', 'notifications']);

	const page = await context.newPage();
	await page.goto('/video-call');

	// All permissions should be granted
	const permissions = await page.evaluate(async () => ({
		camera: await navigator.permissions.query({
			name: 'camera' as PermissionName
		}),
		microphone: await navigator.permissions.query({
			name: 'microphone' as PermissionName
		})
	}));

	expect(permissions.camera.state).toBe('granted');
	expect(permissions.microphone.state).toBe('granted');
});
```

## Clipboard

### Test Copy to Clipboard

```typescript
test('copy button works', async ({ page, context }) => {
	// Grant clipboard permissions
	await context.grantPermissions(['clipboard-read', 'clipboard-write']);

	await page.goto('/share');

	await page.getByRole('button', { name: 'Copy Link' }).click();

	// Read clipboard content
	const clipboardContent = await page.evaluate(() => navigator.clipboard.readText());

	expect(clipboardContent).toContain('https://example.com/share/');
});
```

### Test Paste from Clipboard

```typescript
test('paste from clipboard', async ({ page, context }) => {
	await context.grantPermissions(['clipboard-read', 'clipboard-write']);

	await page.goto('/editor');

	// Write to clipboard
	await page.evaluate(() => navigator.clipboard.writeText('Pasted content'));

	// Trigger paste
	await page.getByLabel('Content').focus();
	await page.keyboard.press('Control+V');

	await expect(page.getByLabel('Content')).toHaveValue('Pasted content');
});
```

### Clipboard Fixture

```typescript
// fixtures/clipboard.fixture.ts
import { test as base } from '@playwright/test';

type ClipboardFixtures = {
	clipboard: {
		write: (text: string) => Promise<void>;
		read: () => Promise<string>;
	};
};

export const test = base.extend<ClipboardFixtures>({
	clipboard: async ({ page, context }, use) => {
		await context.grantPermissions(['clipboard-read', 'clipboard-write']);

		await use({
			write: async (text) => {
				await page.evaluate((t) => navigator.clipboard.writeText(t), text);
			},
			read: async () => {
				return page.evaluate(() => navigator.clipboard.readText());
			}
		});
	}
});
```

## Notifications

### Mock Notification API

```typescript
test('shows browser notification', async ({ page }) => {
	const notifications: any[] = [];

	// Mock Notification constructor
	await page.addInitScript(() => {
		(window as any).__notifications = [];
		(window as any).Notification = class {
			constructor(title: string, options?: NotificationOptions) {
				(window as any).__notifications.push({ title, ...options });
			}
			static permission = 'granted';
			static requestPermission = async () => 'granted';
		};
	});

	await page.goto('/alerts');
	await page.getByRole('button', { name: 'Notify Me' }).click();

	// Check notification was created
	const created = await page.evaluate(() => (window as any).__notifications);
	expect(created).toHaveLength(1);
	expect(created[0].title).toBe('New Alert');
});
```

### Test Notification Click

```typescript
test('notification click handler', async ({ page }) => {
	await page.addInitScript(() => {
		(window as any).Notification = class {
			onclick: (() => void) | null = null;
			constructor(title: string) {
				// Simulate click after creation
				setTimeout(() => this.onclick?.(), 100);
			}
			static permission = 'granted';
			static requestPermission = async () => 'granted';
		};
	});

	await page.goto('/messages');
	await page.evaluate(() => {
		new Notification('New Message');
	});

	// Should navigate to messages when notification clicked
	await expect(page).toHaveURL(/\/messages/);
});
```

## Camera & Microphone

### Mock Media Devices

```typescript
test('video preview works', async ({ page, context }) => {
	await context.grantPermissions(['camera']);

	// Mock getUserMedia
	await page.addInitScript(() => {
		navigator.mediaDevices.getUserMedia = async () => {
			const canvas = document.createElement('canvas');
			canvas.width = 640;
			canvas.height = 480;
			return canvas.captureStream();
		};
	});

	await page.goto('/video-settings');
	await page.getByRole('button', { name: 'Start Camera' }).click();

	await expect(page.getByTestId('video-preview')).toBeVisible();
});
```

### Test Media Device Selection

```typescript
test('switch camera', async ({ page }) => {
	await page.addInitScript(() => {
		navigator.mediaDevices.enumerateDevices = async () =>
			[
				{
					deviceId: 'cam1',
					kind: 'videoinput',
					label: 'Front Camera',
					groupId: '1'
				},
				{
					deviceId: 'cam2',
					kind: 'videoinput',
					label: 'Back Camera',
					groupId: '2'
				}
			] as MediaDeviceInfo[];

		navigator.mediaDevices.getUserMedia = async () => {
			const canvas = document.createElement('canvas');
			return canvas.captureStream();
		};
	});

	await page.goto('/camera');

	// Should show camera options
	await expect(page.getByRole('combobox', { name: 'Camera' })).toBeVisible();
	await expect(page.getByText('Front Camera')).toBeVisible();
	await expect(page.getByText('Back Camera')).toBeVisible();
});
```

### Test Media Errors

```typescript
test('handles camera access error', async ({ page }) => {
	await page.addInitScript(() => {
		navigator.mediaDevices.getUserMedia = async () => {
			throw new DOMException('Permission denied', 'NotAllowedError');
		};
	});

	await page.goto('/video-call');
	await page.getByRole('button', { name: 'Join Call' }).click();

	await expect(page.getByText('Camera access denied')).toBeVisible();
	await expect(page.getByRole('button', { name: 'Join Audio Only' })).toBeVisible();
});
```

## Anti-Patterns to Avoid

| Anti-Pattern                  | Problem                           | Solution                            |
| ----------------------------- | --------------------------------- | ----------------------------------- |
| Not granting permissions      | Tests fail with permission errors | Use `context.grantPermissions()`    |
| Testing real geolocation      | Flaky, environment-dependent      | Mock with `setGeolocation()`        |
| Not testing permission denial | Misses error handling             | Test both granted and denied states |
| Using real camera/mic         | CI has no devices                 | Mock `getUserMedia`                 |

## Related References

- **Fixtures**: See [fixtures-hooks.md](../core/fixtures-hooks.md) for context fixtures
- **Mobile**: See [mobile-testing.md](../advanced/mobile-testing.md) for device emulation
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall