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

advanced/third-party.md

View on GitHub
# Third-Party Service Mocking

## Table of Contents

1. [OAuth/SSO Mocking](#oauthsso-mocking)
2. [Payment Gateway Mocking](#payment-gateway-mocking)
3. [Email Verification](#email-verification)
4. [SMS Verification](#sms-verification)
5. [Analytics & Tracking](#analytics--tracking)

## OAuth/SSO Mocking

### Mock Google OAuth

```typescript
test('Google OAuth login', async ({ page }) => {
	// Mock the OAuth callback
	await page.route('**/auth/google/callback**', (route) => {
		const url = new URL(route.request().url());
		// Simulate successful OAuth by redirecting with token
		route.fulfill({
			status: 302,
			headers: {
				Location: '/dashboard?token=mock-jwt-token'
			}
		});
	});

	// Mock the token verification endpoint
	await page.route('**/api/auth/verify', (route) =>
		route.fulfill({
			json: {
				valid: true,
				user: {
					id: '123',
					email: 'test@gmail.com',
					name: 'Test User'
				}
			}
		})
	);

	await page.goto('/login');
	await page.getByRole('button', { name: 'Sign in with Google' }).click();

	await expect(page.getByText('Welcome, Test User')).toBeVisible();
});
```

### OAuth Fixture

```typescript
// fixtures/oauth.fixture.ts
type OAuthProvider = 'google' | 'github' | 'microsoft';

type OAuthUser = {
	id: string;
	email: string;
	name: string;
	avatar?: string;
};

type OAuthFixtures = {
	mockOAuth: (provider: OAuthProvider, user: OAuthUser) => Promise<void>;
};

export const test = base.extend<OAuthFixtures>({
	mockOAuth: async ({ page }, use) => {
		await use(async (provider, user) => {
			// Mock callback redirect
			await page.route(`**/auth/${provider}/callback**`, (route) =>
				route.fulfill({
					status: 302,
					headers: { Location: `/auth/success?provider=${provider}` }
				})
			);

			// Mock session/user endpoint
			await page.route('**/api/auth/session', (route) =>
				route.fulfill({
					json: { user, provider, authenticated: true }
				})
			);

			// Mock user info endpoint
			await page.route('**/api/me', (route) => route.fulfill({ json: user }));
		});
	}
});

// Usage
test('login with GitHub', async ({ page, mockOAuth }) => {
	await mockOAuth('github', {
		id: 'gh-123',
		email: 'dev@github.com',
		name: 'GitHub User'
	});

	await page.goto('/login');
	await page.getByRole('button', { name: 'Sign in with GitHub' }).click();

	await expect(page.getByText('Welcome, GitHub User')).toBeVisible();
});
```

### Mock SAML SSO

```typescript
test('SAML SSO login', async ({ page }) => {
	// Mock SAML assertion consumer service
	await page.route('**/saml/acs', async (route) => {
		route.fulfill({
			status: 302,
			headers: {
				Location: '/dashboard',
				'Set-Cookie': 'session=mock-saml-session; Path=/; HttpOnly'
			}
		});
	});

	// Mock session validation
	await page.route('**/api/session', (route) =>
		route.fulfill({
			json: {
				user: { email: 'user@company.com', name: 'SSO User' },
				provider: 'saml'
			}
		})
	);

	await page.goto('/login');
	await page.getByRole('button', { name: 'SSO Login' }).click();

	await expect(page).toHaveURL('/dashboard');
});
```

## Payment Gateway Mocking

### Mock Stripe

```typescript
test('Stripe checkout', async ({ page }) => {
	// Mock Stripe.js
	await page.addInitScript(() => {
		(window as any).Stripe = () => ({
			elements: () => ({
				create: () => ({
					mount: () => {},
					on: () => {},
					destroy: () => {}
				})
			}),
			confirmCardPayment: async () => ({
				paymentIntent: { status: 'succeeded', id: 'pi_mock_123' }
			}),
			createPaymentMethod: async () => ({
				paymentMethod: { id: 'pm_mock_123' }
			})
		});
	});

	// Mock backend payment endpoint
	await page.route('**/api/create-payment-intent', (route) =>
		route.fulfill({
			json: { clientSecret: 'pi_mock_123_secret_mock' }
		})
	);

	await page.route('**/api/confirm-payment', (route) =>
		route.fulfill({
			json: { success: true, orderId: 'order-123' }
		})
	);

	await page.goto('/checkout');
	await page.getByRole('button', { name: 'Pay $99.99' }).click();

	await expect(page.getByText('Payment successful')).toBeVisible();
});
```

### Mock PayPal

```typescript
test('PayPal checkout', async ({ page }) => {
	// Mock PayPal SDK
	await page.addInitScript(() => {
		(window as any).paypal = {
			Buttons: () => ({
				render: () => Promise.resolve(),
				isEligible: () => true
			}),
			FUNDING: { PAYPAL: 'paypal', CARD: 'card' }
		};
	});

	// Mock PayPal order creation
	await page.route('**/api/paypal/create-order', (route) =>
		route.fulfill({
			json: { orderId: 'PAYPAL-ORDER-123' }
		})
	);

	// Mock PayPal capture
	await page.route('**/api/paypal/capture', (route) =>
		route.fulfill({
			json: { success: true, transactionId: 'TXN-123' }
		})
	);

	await page.goto('/checkout');

	// Simulate PayPal approval callback
	await page.evaluate(() => {
		(window as any).onPayPalApprove?.({ orderID: 'PAYPAL-ORDER-123' });
	});

	await expect(page.getByText('Order confirmed')).toBeVisible();
});
```

### Payment Fixture

```typescript
// fixtures/payment.fixture.ts
type PaymentFixtures = {
	mockStripe: (options?: { failPayment?: boolean }) => Promise<void>;
};

export const test = base.extend<PaymentFixtures>({
	mockStripe: async ({ page }, use) => {
		await use(async (options = {}) => {
			await page.addInitScript(
				([shouldFail]) => {
					(window as any).Stripe = () => ({
						elements: () => ({
							create: () => ({
								mount: () => {},
								on: (event: string, handler: Function) => {
									if (event === 'ready') setTimeout(handler, 100);
								},
								destroy: () => {}
							})
						}),
						confirmCardPayment: async () => {
							if (shouldFail) {
								return { error: { message: 'Card declined' } };
							}
							return { paymentIntent: { status: 'succeeded' } };
						}
					});
				},
				[options.failPayment]
			);
		});
	}
});

// Usage
test('handles declined card', async ({ page, mockStripe }) => {
	await mockStripe({ failPayment: true });

	await page.goto('/checkout');
	await page.getByRole('button', { name: 'Pay' }).click();

	await expect(page.getByText('Card declined')).toBeVisible();
});
```

## Email Verification

### Mock Email API

```typescript
test('email verification flow', async ({ page, request }) => {
	let verificationToken: string;

	// Capture the verification email
	await page.route('**/api/send-verification', async (route) => {
		const body = route.request().postDataJSON();
		verificationToken = `mock-token-${Date.now()}`;

		// Don't actually send email, just store token
		route.fulfill({
			json: { sent: true, messageId: 'msg-123' }
		});
	});

	// Mock token verification
	await page.route('**/api/verify-email**', (route) => {
		const url = new URL(route.request().url());
		const token = url.searchParams.get('token');

		if (token === verificationToken) {
			route.fulfill({ json: { verified: true } });
		} else {
			route.fulfill({ status: 400, json: { error: 'Invalid token' } });
		}
	});

	await page.goto('/signup');
	await page.getByLabel('Email').fill('test@example.com');
	await page.getByRole('button', { name: 'Sign Up' }).click();

	await expect(page.getByText('Check your email')).toBeVisible();

	// Simulate clicking email link
	await page.goto(`/verify?token=${verificationToken}`);

	await expect(page.getByText('Email verified')).toBeVisible();
});
```

### Use Mailinator/Temp Mail

```typescript
// fixtures/email.fixture.ts
type EmailFixtures = {
	getVerificationEmail: (inbox: string) => Promise<{ link: string }>;
};

export const test = base.extend<EmailFixtures>({
	getVerificationEmail: async ({ request }, use) => {
		await use(async (inbox) => {
			// Poll Mailinator API for new email
			const response = await request.get(`https://api.mailinator.com/v2/domains/public/inboxes/${inbox}`, {
				headers: {
					Authorization: `Bearer ${process.env.MAILINATOR_API_KEY}`
				}
			});

			const messages = await response.json();
			const latest = messages.msgs[0];

			// Get full message
			const msgResponse = await request.get(
				`https://api.mailinator.com/v2/domains/public/inboxes/${inbox}/messages/${latest.id}`,
				{
					headers: {
						Authorization: `Bearer ${process.env.MAILINATOR_API_KEY}`
					}
				}
			);

			const message = await msgResponse.json();

			// Extract verification link from HTML
			const linkMatch = message.parts[0].body.match(/href="([^"]*verify[^"]*)"/);
			return { link: linkMatch?.[1] || '' };
		});
	}
});
```

## SMS Verification

### Mock SMS API

```typescript
test('SMS verification', async ({ page }) => {
	let smsCode: string;

	// Capture SMS send
	await page.route('**/api/send-sms', (route) => {
		smsCode = Math.random().toString().slice(2, 8); // 6-digit code

		route.fulfill({
			json: { sent: true, messageId: 'sms-123' }
		});
	});

	// Mock code verification
	await page.route('**/api/verify-sms', (route) => {
		const body = route.request().postDataJSON();

		if (body.code === smsCode) {
			route.fulfill({ json: { verified: true } });
		} else {
			route.fulfill({ status: 400, json: { error: 'Invalid code' } });
		}
	});

	await page.goto('/verify-phone');
	await page.getByLabel('Phone').fill('+1234567890');
	await page.getByRole('button', { name: 'Send Code' }).click();

	// Enter the code
	await page.getByLabel('Verification Code').fill(smsCode);
	await page.getByRole('button', { name: 'Verify' }).click();

	await expect(page.getByText('Phone verified')).toBeVisible();
});
```

## Analytics & Tracking

### Block Analytics in Tests

```typescript
test.beforeEach(async ({ page }) => {
	// Block all analytics/tracking
	await page.route(/google-analytics|googletagmanager|facebook|hotjar|segment|mixpanel|amplitude/, (route) =>
		route.abort()
	);
});
```

### Mock Analytics for Verification

```typescript
test('tracks purchase event', async ({ page }) => {
	const analyticsEvents: any[] = [];

	// Capture analytics calls
	await page.route('**/api/analytics/**', (route) => {
		analyticsEvents.push(route.request().postDataJSON());
		route.fulfill({ status: 200 });
	});

	// Mock analytics SDK
	await page.addInitScript(() => {
		(window as any).analytics = {
			track: (event: string, props: any) => {
				fetch('/api/analytics/track', {
					method: 'POST',
					body: JSON.stringify({ event, props })
				});
			}
		};
	});

	await page.goto('/checkout');
	await page.getByRole('button', { name: 'Complete Purchase' }).click();

	// Verify analytics event was sent
	expect(analyticsEvents).toContainEqual(
		expect.objectContaining({
			event: 'Purchase Completed',
			props: expect.objectContaining({ amount: expect.any(Number) })
		})
	);
});
```

## Anti-Patterns to Avoid

| Anti-Pattern              | Problem                        | Solution                |
| ------------------------- | ------------------------------ | ----------------------- |
| Using real OAuth in tests | Slow, needs credentials, flaky | Mock OAuth endpoints    |
| Real payment processing   | Charges real money, slow       | Use test mode or mock   |
| Waiting for real emails   | Very slow, unreliable          | Mock email API          |
| Not mocking analytics     | Pollutes analytics data        | Block or mock analytics |

## Related References

- **Network Mocking**: See [network-advanced.md](network-advanced.md) for route patterns
- **Authentication**: See [fixtures-hooks.md](../core/fixtures-hooks.md) for auth patterns
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: 472kUpdated 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: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated 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