Tauri Playwright

https://github.com/srsholmes/tauri-playwright
Admin
Tauri Playwright enables Playwright E2E testing for Tauri desktop apps, supporting multiple testing...
Tokens:69,524
Snippets:757
Trust Score:9.2
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Full Test Setup with TauriProcessManager and PluginClient

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/process-manager.md

Demonstrates how to set up a full test environment by starting the Tauri app, connecting to the Playwright plugin, and performing a basic 'ping' operation. Ensure the `socketPath` is accessible and the Tauri application is configured to use the plugin.

```typescript
import { TauriProcessManager } from '@srsholmes/tauri-playwright';
import { PluginClient } from '@srsholmes/tauri-playwright';

async function setupTest() {
  const socketPath = '/tmp/tauri-playwright.sock';
  
  const manager = new TauriProcessManager({
    command: 'cargo',
    args: ['tauri', 'dev'],
    cwd: '/path/to/app',
    features: ['e2e-testing'],
    socketPath,
    startTimeout: 120,
  });

  try {
    // Start the app
    await manager.start();
    console.log('Tauri app started');

    // Connect to the plugin
    const client = new PluginClient(socketPath);
    await client.connect();

    // Use client for testing...
    const response = await client.send({ type: 'ping' });
    console.log('Plugin responded:', response.ok);

    return { client, manager };
  } catch (err) {
    manager.stop();
    throw err;
  }
}

async function runTests() {
  const { client, manager } = await setupTest();

  try {
    // Run your tests here
    // ...
  } finally {
    client.disconnect();
    manager.stop();
  }
}

runTests().catch(console.error);
```

--------------------------------

### Windows TCP Support with TauriProcessManager

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/process-manager.md

This example shows how to configure and start the `TauriProcessManager` using a TCP port, which is useful as a fallback on Windows. It then demonstrates connecting a `PluginClient` to the started process via the TCP port.

```typescript
const manager = new TauriProcessManager({
  command: 'cargo',
  args: ['tauri', 'dev'],
  tcpPort: 6274, // Windows TCP port
  startTimeout: 120,
});

const { tcpPort } = await manager.start();
const client = new PluginClient(undefined, tcpPort);
```

--------------------------------

### Tauri Wait For Window Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Example of waiting for a window that starts with 'viewer-' and asserting its content.

```typescript
const viewer = await tauriPage.waitForWindow(
  (w) => w.label.startsWith('viewer-'),
  { timeout: 10000 }
);
await expect(viewer.getByTestId('file-name')).toHaveText('photo.jpg');
```

--------------------------------

### Example App Development Commands

Source: https://github.com/srsholmes/tauri-playwright/blob/main/CLAUDE.md

Commands for running the example Tauri application in development mode and with Playwright integration.

```bash
cd examples/hello-world
pnpm dev
pnpm tauri:dev
cargo tauri dev --features e2e-testing
npx playwright test --config e2e/playwright.config.ts --project=browser-only
npx playwright test --config e2e/playwright.config.ts --project=tauri
```

--------------------------------

### Tauri Multi-Window Examples

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Examples demonstrating how to target and interact with specific Tauri windows.

```typescript
const mainWindow = tauriPage.window('main');
const settingsWindow = tauriPage.window('settings');
await settingsWindow.click('[data-testid="save"]');
```

--------------------------------

### Tauri Mode Quick Start

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/README.md

Illustrates how to configure and run tauri-playwright in Tauri mode for true end-to-end testing of the actual desktop application. Includes an example test for greeting via IPC.

```APIDOC
## Tauri Mode (Real App, True E2E)

### Description
This mode runs your Tauri application directly and interacts with it through its native interface, providing the most accurate end-to-end testing experience.

### Usage
```typescript
export const { test, expect } = createTauriTest({
  devUrl: 'http://localhost:1420',
  tauriCommand: 'cargo tauri dev --features e2e-testing',
  mcpSocket: '/tmp/tauri-playwright.sock',
});

test('greet via IPC', async ({ tauriPage }) => {
  await tauriPage.fill('[data-testid="name"]', 'World');
  await tauriPage.click('[data-testid="greet-btn"]');
  await expect(tauriPage.locator('[data-testid="greeting"]')).toContainText('Hello, World!');
});
```
```

--------------------------------

### Browser Mode Quick Start

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/README.md

Demonstrates how to set up and use tauri-playwright in browser mode, which utilizes mocked IPC for faster testing. Includes an example test case for a counter increment.

```APIDOC
## Browser Mode (Mocked IPC, Fastest)

### Description
This mode is ideal for rapid development and testing where direct interaction with the Tauri backend is not required. It uses mocked IPC handlers for quick feedback.

### Usage
```typescript
import { createTauriTest } from '@srsholmes/tauri-playwright';

export const { test, expect } = createTauriTest({
  devUrl: 'http://localhost:1420',
  ipcMocks: {
    greet: (args) => `Hello, ${args?.name}!`,
  },
});

test('counter increments', async ({ tauriPage }) => {
  await tauriPage.click('[data-testid="btn-increment"]');
  await expect(tauriPage.locator('[data-testid="counter"]')).toContainText('1');
});
```
```

--------------------------------

### start

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/process-manager.md

Starts the Tauri app process and waits for the plugin socket to become available. It monitors stdout/stderr for a 'listening' signal.

```APIDOC
## start

Starts the Tauri app and waits for the plugin socket to become available.

### Description

Spawns the process and monitors stdout/stderr for the "listening" signal.

### Method

`async start(): Promise<{ socketPath?: string; tcpPort?: number }>`

### Returns

Object with either `socketPath` (Unix) or `tcpPort` (TCP), indicating the socket type that became available.

### Throws

- Error if the process exits with non-zero code
- Error if the socket doesn't become available within `startTimeout` seconds
- Error if the process fails to spawn

### Example

```typescript
const manager = new TauriProcessManager({
  command: 'cargo',
  args: ['tauri', 'dev'],
  cwd: process.cwd(),
  features: ['e2e-testing'],
  socketPath: '/tmp/tauri-playwright.sock',
  startTimeout: 120,
});

const { socketPath } = await manager.start();
console.log(`Plugin listening at ${socketPath}`);

// Use socketPath to create PluginClient
const client = new PluginClient(socketPath);
await client.connect();
```
```

--------------------------------

### Tauri Keyboard and Mouse Examples

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Examples of using the keyboard and mouse objects to perform actions like typing, pressing keys, and clicking.

```typescript
await tauriPage.keyboard.press('Enter');
await tauriPage.keyboard.type('hello', { delay: 50 });
await tauriPage.mouse.click(100, 200);
await tauriPage.mouse.move(300, 400);
```

--------------------------------

### Install Playwright Packages

Source: https://github.com/srsholmes/tauri-playwright/blob/main/README.md

Install the necessary tauri-playwright and playwright packages using pnpm and install Playwright's browser binaries.

```bash
pnpm add -D @srsholmes/tauri-playwright @playwright/test
npx playwright install chromium
```

--------------------------------

### Start Video Recording with startRecording

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Begin recording the Tauri window using native frame capture. Configure the output directory and frames per second.

```typescript
async startRecording(options?: {
  path?: string;
  fps?: number;
}): Promise<{ dir: string; fps: number }>
```

--------------------------------

### Wire Protocol Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/socket-client.md

Illustrates the newline-delimited JSON format for requests and responses between the client and the plugin.

```text
Request:  {"type":"click","selector":"#btn","timeout_ms":5000}\nResponse: {"ok":true,"data":null}\n
```

--------------------------------

### CSS and Classes Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/expect.md

An example demonstrating assertions related to CSS classes, styles, and attributes. It covers checking `toHaveClass`, `toHaveCSS`, and `toHaveAttribute`.

```typescript
test('css and classes', async ({ tauriPage }) => {
  const element = tauriPage.locator('[data-testid="status"]');
  
  // Should have active class
  await expect(element).toHaveClass('active');
  
  // Should have specific CSS color
  await expect(element).toHaveCSS('color', 'rgb(0, 128, 0)');
  
  // Should have data attribute
  await expect(element).toHaveAttribute('data-status', 'ready');
});
```

--------------------------------

### Full Workflow Example with Socket Client

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/socket-client.md

Demonstrates a complete workflow using the PluginClient to connect to a Tauri Playwright socket, perform actions like navigation, clicking, and evaluating JavaScript, and handling multiple windows. Ensure the socket server is running before executing.

```typescript
import { PluginClient } from '@srsholmes/tauri-playwright';

async function testWorkflow() {
  const client = new PluginClient('/tmp/tauri-playwright.sock');
  
  try {
    // Connect
    await client.connect();
    console.log('Connected');

    // Health check
    let response = await client.send({ type: 'ping' });
    console.log('Ping:', response.ok);

    // Navigate
    await client.send({ type: 'goto', url: 'http://localhost:1420' });

    // Click button
    response = await client.send({
      type: 'click',
      selector: '[data-testid="submit"]',
      timeout_ms: 5000,
    });
    console.log('Click succeeded:', response.ok);

    // Get page title
    response = await client.send({ type: 'title' });
    console.log('Title:', response.data);

    // Evaluate JavaScript
    response = await client.send({
      type: 'eval',
      script: 'document.body.innerText.length',
    });
    console.log('Page text length:', response.data);

    // List windows
    response = await client.send({ type: 'list_windows' });
    console.log('Windows:', response.data);

    // Target specific window
    if (response.ok && Array.isArray(response.data)) {
      const windows = response.data as Array<{ label: string }>;
      if (windows.length > 1) {
        response = await client.send({
          window: windows[1].label,
          type: 'click',
          selector: '#button',
        });
        console.log('Clicked in window:', windows[1].label);
      }
    }
  } finally {
    client.disconnect();
  }
}

testWorkflow().catch(console.error);
```

--------------------------------

### Start Tauri App or Wait for Socket

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/process-manager.md

This code snippet demonstrates how to use the `TauriProcessManager` within a test fixture. It either starts the Tauri application using a provided command or waits for an existing application to become available via its socket.

```typescript
if (config.tauriCommand) {
  // User wants us to start the app
  const parts = config.tauriCommand.split(' ');
  processManager = new TauriProcessManager({
    command: parts[0],
    args: parts.slice(1),
    cwd: config.tauriCwd,
    features: config.tauriFeatures,
    socketPath,
    startTimeout: config.startTimeout ?? 120,
  });
  await processManager.start();
} else {
  // Assume app is already running; just wait for socket
  const pm = new TauriProcessManager({ socketPath });
  await pm.waitForSocket(30000);
}
```

--------------------------------

### Tauri Page Semantic Selector Examples

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Examples demonstrating how to use semantic selectors to find elements on a Tauri page.

```typescript
const submitButton = tauriPage.getByRole('button', { name: 'Submit' });
const input = tauriPage.getByLabel('Email');
const message = tauriPage.getByText('Hello World');
```

--------------------------------

### TauriPage Full Workflow Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Demonstrates a complete test workflow for a Tauri application using the tauriPage fixture. Covers navigation, user input, form submission, assertions, locator usage, state checks, keyboard events, and screenshots.

```typescript
import { test, expect } from './fixtures';

test('complete workflow', async ({ tauriPage }) => {
  // Navigation
  await tauriPage.goto('http://localhost:1420');

  // Interaction
  await tauriPage.fill('[data-testid="name"]', 'Alice');
  await tauriPage.click('[data-testid="submit"]');

  // Assertion
  await expect(tauriPage.locator('[data-testid="greeting"]')).toContainText('Hello, Alice');

  // Locators
  const button = tauriPage.getByRole('button', { name: 'Save' });
  await button.click();

  // State checks
  const isVisible = await tauriPage.isVisible('[data-testid="success-message"]');
  expect(isVisible).toBe(true);

  // Keyboard
  await tauriPage.keyboard.press('Tab');
  await tauriPage.keyboard.type('search term');

  // Screenshot
  const screenshot = await tauriPage.screenshot();
  console.log('Screenshot size:', screenshot.length, 'bytes');
});
```

--------------------------------

### List Operations Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/expect.md

An example showcasing list operations using `toHaveCount` and iterating through elements. It demonstrates verifying the initial count, adding an item, and verifying the updated count.

```typescript
test('list operations', async ({ tauriPage }) => {
  const items = tauriPage.locator('[data-testid="item"]');
  
  // Should have 3 items initially
  await expect(items).toHaveCount(3);
  
  // Add an item
  await tauriPage.click('[data-testid="add-item"]');
  
  // Now should have 4
  await expect(items).toHaveCount(4);
  
  // All should be visible
  const allItems = await items.all();
  for (const item of allItems) {
    await expect(item).toBeVisible();
  }
});
```

--------------------------------

### Negation Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/expect.md

An example demonstrating the use of `.not` for negation assertions. It checks that an error element is not visible and does not contain specific text, then triggers the error and verifies its presence.

```typescript
test('negation', async ({ tauriPage }) => {
  const error = tauriPage.locator('[data-testid="error"]');
  
  // Should not be visible initially
  await expect(error).not.toBeVisible();
  
  // Should not have text
  await expect(error).not.toContainText('Error occurred');
  
  // Trigger error
  await tauriPage.click('[data-testid="trigger-error"]');
  
  // Now it should be visible
  await expect(error).toBeVisible();
  await expect(error).toContainText('Error occurred');
});
```

--------------------------------

### Start Tauri Process and Wait for Socket

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/process-manager.md

Starts the Tauri application process and waits for its plugin socket to become available. This is essential for establishing communication with the running application for testing purposes.

```typescript
const { socketPath } = await manager.start();
console.log(`Plugin listening at ${socketPath}`);

// Use socketPath to create PluginClient
const client = new PluginClient(socketPath);
await client.connect();
```

--------------------------------

### Get Target Window Label

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Get the webview window label that the current page targets, if any.

```typescript
get targetWindow(): string | undefined
```

--------------------------------

### Form Validation Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/expect.md

An example demonstrating form validation using various expect assertions. It covers checking visibility, enabled state, input values, checkbox states, and navigation.

```typescript
import { test, expect } from './fixtures';

test('form validation', async ({ tauriPage }) => {
  // Elements should be visible
  await expect(tauriPage.locator('form')).toBeVisible();
  await expect(tauriPage.getByRole('button', { name: 'Submit' })).toBeEnabled();

  // Fill form
  const emailInput = tauriPage.getByLabel('Email');
  await emailInput.fill('test@example.com');
  
  // Verify value
  await expect(emailInput).toHaveValue('test@example.com');

  // Check checkbox
  const termsCheckbox = tauriPage.locator('[data-testid="terms"]');
  await termsCheckbox.check();
  await expect(termsCheckbox).toBeChecked();

  // Submit
  const submitButton = tauriPage.getByRole('button', { name: 'Submit' });
  await submitButton.click();

  // Success message appears
  const successMessage = tauriPage.locator('[data-testid="success"]');
  await expect(successMessage).toContainText('Form submitted successfully');
  
  // Verify page navigated
  await expect(tauriPage).toHaveURL('/dashboard');
});
```

--------------------------------

### Interactive Elements Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/expect.md

An example demonstrating assertions on interactive elements like buttons. It covers checking if a button is enabled or disabled based on a checkbox state.

```typescript
test('interactive elements', async ({ tauriPage }) => {
  // Button enabled initially
  const button = tauriPage.getByRole('button', { name: 'Delete' });
  await expect(button).toBeEnabled();

  // Check something that disables the button
  const checkbox = tauriPage.locator('[data-testid="confirm"]');
  await checkbox.check();
  
  // Now button should be disabled
  await expect(button).toBeDisabled();

  // Uncheck to enable
  await checkbox.uncheck();
  await expect(button).toBeEnabled();
});
```

--------------------------------

### Socket Protocol Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/README.md

Illustrates the newline-delimited JSON format for requests and responses in the socket protocol. Supports multi-window targeting with the `window` field.

```json
Request:  {"type":"click","selector":"#btn","timeout_ms":5000}
Response: {"ok":true,"data":null}
```

```json
{"window":"settings","type":"click","selector":"#save"}
```

--------------------------------

### Install Dialog Handler

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Installs an interception handler for JavaScript dialogs (alert, confirm, prompt). Options can control default confirmation behavior and prompt text.

```typescript
async installDialogHandler(options?: {
  defaultConfirm?: boolean;
  defaultPromptText?: string;
}): Promise<void>
```

--------------------------------

### Simple Tauri App Setup with Default Plugin

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/plugin-config.md

Initializes the Tauri Playwright plugin using its default configuration within a Tauri application's main function.

```rust
use tauri_plugin_playwright;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_playwright::init())  // Uses defaults
        .run(tauri::generate_context!())
        .expect("error running app");
}
```

--------------------------------

### Complete Tauri Playwright Test Setup

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/ipc-mock.md

Configure tauri-playwright with mock data, IPC handlers, and application context for comprehensive testing. This setup allows for mocking various IPC commands and injecting initial state.

```typescript
// fixtures.ts
import { createTauriTest } from '@srsholmes/tauri-playwright';

// Mock data
const MOCK_USERS = [
  { id: 1, name: 'Alice', email: 'alice@example.com', role: 'admin' },
  { id: 2, name: 'Bob', email: 'bob@example.com', role: 'user' },
  { id: 3, name: 'Charlie', email: 'charlie@example.com', role: 'user' },
];

const MOCK_SETTINGS = {
  theme: 'dark',
  language: 'en',
  notifications: true,
};

export const { test, expect } = createTauriTest({
  devUrl: 'http://localhost:1420',
  
  // Inject variables for handlers
  ipcContext: {
    MOCK_USERS,
    MOCK_SETTINGS,
    APP_VERSION: '2.1.0',
  },
  
  // Define handlers
  ipcMocks: {
    // Simple query
    get_version: () => APP_VERSION,
    
    // Configuration
    get_settings: () => MOCK_SETTINGS,
    
    // Update settings
    update_settings: (args) => {
      return { ...MOCK_SETTINGS, ...args };
    },
    
    // User list
    get_users: () => MOCK_USERS,
    
    // Single user
    get_user: (args) => {
      const user = MOCK_USERS.find(u => u.id === args?.id);
      return user || null;
    },
    
    // Search users
    search_users: (args) => {
      const query = (args?.query || '').toLowerCase();
      return MOCK_USERS.filter(u =>
        u.name.toLowerCase().includes(query) ||
        u.email.toLowerCase().includes(query)
      );
    },
    
    // Create user
    create_user: (args) => {
      const newUser = {
        id: Math.max(...MOCK_USERS.map(u => u.id)) + 1,
        name: args?.name || 'Unknown',
        email: args?.email || '',
        role: args?.role || 'user',
      };
      MOCK_USERS.push(newUser);
      return newUser;
    },
    
    // Delete user
    delete_user: (args) => {
      const index = MOCK_USERS.findIndex(u => u.id === args?.id);
      if (index !== -1) {
        MOCK_USERS.splice(index, 1);
        return true;
      }
      return false;
    },
    
    // Async-like (return Promise)
    fetch_data: (args) => {
      if (!args?.url) {
        throw new Error('URL is required');
      }
      return {
        url: args.url,
        status: 200,
        data: { result: 'success' },
      };
    },
    
    // Plugin command
    'plugin:dialog|open': () => '/path/to/file.txt',
  },
});
```

```typescript
// tests/user-management.spec.ts
import { test, expect } from '../fixtures';
import { getCapturedInvokes } from '@srsholmes/tauri-playwright';

test('list users', async ({ tauriPage }) => {
  await tauriPage.goto('http://localhost:1420/users');
  
  const items = tauriPage.locator('[data-testid="user-item"]');
  await expect(items).toHaveCount(3);
  
  await expect(items.first()).toContainText('Alice');
  await expect(items.nth(1)).toContainText('Bob');
});

test('search users', async ({ tauriPage }) => {
  await tauriPage.goto('http://localhost:1420/users');
  
  const search = tauriPage.getByPlaceholder('Search...');
  await search.fill('alice');
  
  const items = tauriPage.locator('[data-testid="user-item"]');
  await expect(items).toHaveCount(1);
  await expect(items.first()).toContainText('Alice');
});

test('create user', async ({ tauriPage }) => {
  await tauriPage.goto('http://localhost:1420/users');
  
  await tauriPage.fill('[data-testid="name"]', 'Diana');
  await tauriPage.fill('[data-testid="email"]', 'diana@example.com');
  await tauriPage.click('[data-testid="create-btn"]');
  
  // Assert IPC call was made
  const calls = await getCapturedInvokes(tauriPage.playwrightPage);
  const createCall = calls.find(c => c.cmd === 'create_user');
  
  expect(createCall).toBeDefined();
  expect(createCall?.args.name).toBe('Diana');
  expect(createCall?.args.email).toBe('diana@example.com');
});

test('get settings', async ({ tauriPage }) => {
  await tauriPage.goto('http://localhost:1420/settings');
  
  // Settings should reflect mock data
  await expect(tauriPage.locator('[data-testid="theme"]')).toHaveValue('dark');
  await expect(tauriPage.locator('[data-testid="language"]')).toHaveValue('en');
});
```

--------------------------------

### Cross-Mode Testing with BrowserPageAdapter

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/browser-page-adapter.md

This example demonstrates how to write tests that function identically across different execution modes (browser with mocked IPC and real Tauri app). It navigates, interacts with form elements, and asserts content, with conditional logic for mode-specific actions like listing windows in the Tauri mode.

```typescript
import { test, expect } from './fixtures';

test('works in all modes', async ({ tauriPage, mode }) => {
  // Same test code for all modes
  
  // Navigate
  await tauriPage.goto('http://localhost:1420');
  
  // Fill form
  await tauriPage.fill('[data-testid="name"]', 'Alice');
  await tauriPage.click('[data-testid="submit"]');
  
  // Assert
  await expect(tauriPage.locator('[data-testid="greeting"]')).toContainText('Hello, Alice');
  
  // Mode-specific behavior
  if (mode === 'browser') {
    console.log('Running in browser mode with mocked IPC');
  } else if (mode === 'tauri') {
    console.log('Running in real Tauri app');
    
    // Can use TauriPage-specific features
    const windows = await tauriPage.listWindows();
    console.log('Windows:', windows);
  }
});
```

--------------------------------

### installDialogHandler

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Installs a handler to intercept and manage JavaScript dialogs (alert, confirm, prompt) within the web page.

```APIDOC
## installDialogHandler

### Description
Install dialog interception (alert/confirm/prompt).

### Method
`async installDialogHandler(options?: { defaultConfirm?: boolean; defaultPromptText?: string }): Promise<void>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Path Parameters
- **options.defaultConfirm** (boolean) - Optional - Automatically confirms dialogs. Defaults to `true`.
- **options.defaultPromptText** (string) - Optional - Sets the default text for prompt dialogs.

### Request Example
```typescript
await tauriPage.installDialogHandler({ defaultConfirm: false });
```

### Response
#### Success Response (200)
- **void** - Indicates the dialog handler was successfully installed.
```

--------------------------------

### Tauri App Setup with Custom Socket Path

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/plugin-config.md

Configures the Tauri Playwright plugin with a custom socket path before initializing the Tauri application.

```rust
use tauri_plugin_playwright::{init_with_config, PluginConfig};

fn main() {
    let config = PluginConfig::new()
        .socket_path("/var/tmp/playwright.sock");

    tauri::Builder::default()
        .plugin(init_with_config(config))
        .run(tauri::generate_context!())
        .expect("error running app");
}
```

--------------------------------

### Multi-Window Testing with Tauri Playwright

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/INDEX.md

This example demonstrates how to handle and interact with multiple windows in a Tauri application. It shows waiting for a specific window to appear based on its label and then performing an action within that window.

```typescript
const viewer = await tauriPage.waitForWindow(w => w.label.startsWith('viewer-'));
await viewer.click('[data-testid="button"]');
```

--------------------------------

### Complete Tauri App Setup with Playwright Plugin

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/plugin-config.md

Integrates the Playwright plugin into your Tauri application. Ensure the `e2e-testing` feature is enabled during development.

```rust
#![cfg_attr( all(not(debug_assertions), target_os = "windows"), windows_subsystem = "windows" )]

use tauri_plugin_playwright::{init_with_config, PluginConfig};

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

pub fn run() {
    let mut builder = tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet]);

    // Add playwright plugin for testing
    #[cfg(feature = "e2e-testing")]
    {
        let config = PluginConfig::new()
            .socket_path(
                std::env::var("TAURI_PLAYWRIGHT_SOCKET")
                    .unwrap_or_else(|_| "/tmp/tauri-playwright.sock".to_string())
            )
            .window_label("main");
        builder = builder.plugin(init_with_config(config));
    }

    builder
        .run(tauri::generate_context!())
        .expect("error running app");
}
```

--------------------------------

### TauriMouse Click Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/keyboard-mouse.md

Perform left or right clicks at specified coordinates. Ensure the tauriPage object is initialized.

```typescript
await tauriPage.mouse.click(100, 200);
```

```typescript
await tauriPage.mouse.click(300, 400, { button: 'right' }); // Right-click
```

--------------------------------

### CDP Mode Quick Start

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/README.md

Shows how to use tauri-playwright in CDP (Chrome DevTools Protocol) mode, which is useful for testing applications running on Windows WebView2 and leverages the full Playwright capabilities.

```APIDOC
### CDP Mode (Windows WebView2, Full Playwright)

### Description
This mode connects to a running Tauri application instance via the Chrome DevTools Protocol, allowing for advanced debugging and testing scenarios, especially with WebView2.

### Usage
```typescript
export const { test, expect } = createTauriTest({
  devUrl: 'http://localhost:1420',
  cdpEndpoint: 'http://localhost:9222',
});

// Same test code works in all modes
```
```

--------------------------------

### Keyboard Input Simulation

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/INDEX.md

This example shows how to simulate keyboard input using Tauri Playwright. It covers pressing key combinations, typing text with a delay, and simulating the Enter key press, which is useful for form interactions and shortcuts.

```typescript
await tauriPage.keyboard.press('Control+A');
await tauriPage.keyboard.type('search text', { delay: 50 });
await tauriPage.keyboard.press('Enter');
```

--------------------------------

### Set Timeout for App Startup

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/configuration.md

Configure the maximum time in seconds to wait for the Tauri app to start and the plugin socket to become ready. Increase this value for applications with longer startup times.

```typescript
startTimeout: 60   // 60 seconds (default behavior)
```

```typescript
startTimeout: 30   // Fail faster for quick-starting apps
```

```typescript
startTimeout: 180  // Give slow builds more time
```

--------------------------------

### Specify Tauri Application Command

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/configuration.md

Define the command to start your Tauri application for Tauri mode. If omitted, it assumes the app is already running. Include all necessary flags and arguments.

```typescript
tauriCommand: 'cargo tauri dev'
```

```typescript
tauriCommand: 'cargo tauri dev --features e2e-testing'
```

```typescript
tauriCommand: 'npm run tauri:dev'
```

```typescript
tauriCommand: 'RUST_LOG=debug cargo tauri dev'
```

--------------------------------

### Tauri Mode Setup

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/README.md

Configure tauri-playwright for Tauri mode to test against a real app. This mode uses a specified Tauri command and a socket for communication.

```typescript
export const { test, expect } = createTauriTest({
  devUrl: 'http://localhost:1420',
  tauriCommand: 'cargo tauri dev --features e2e-testing',
  mcpSocket: '/tmp/tauri-playwright.sock',
});

test('greet via IPC', async ({ tauriPage }) => {
  await tauriPage.fill('[data-testid="name"]', 'World');
  await tauriPage.click('[data-testid="greet-btn"]');
  await expect(tauriPage.locator('[data-testid="greeting"]')).toContainText('Hello, World!');
});
```

--------------------------------

### Tauri Playwright Locator Chaining Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-locator.md

Demonstrates advanced locator chaining, filtering, and interaction within a Tauri application context. Includes finding elements by text, refining with nth, using nested semantic selectors, and evaluating custom JavaScript.

```typescript
import { test, expect } from './fixtures';

test('locator chaining', async ({ tauriPage }) => {
  // Get a list
  const list = tauriPage.locator('[data-testid="user-list"]');

  // Find items with specific text
  const aliceItem = list.filter({ hasText: 'Alice' });
  await aliceItem.click();

  // Refine with nth
  const items = tauriPage.locator('[data-testid="item"]');
  const thirdItem = items.nth(2);
  const text = await thirdItem.innerText();
  expect(text).toContain('Item 3');

  // Nested semantic selectors
  const form = tauriPage.locator('form');
  const emailInput = form.getByLabel('Email');
  await emailInput.fill('test@example.com');

  // Evaluate custom logic
  const hasDataAttr = await tauriPage
    .locator('[data-testid="element"]')
    .evaluate('el => el.hasAttribute("data-custom")');
  expect(hasDataAttr).toBe(true);

  // Get multiple elements
  const allItems = await items.all();
  expect(allItems).toHaveLength(5);
  for (const item of allItems) {
    const isVisible = await item.isVisible();
    expect(isVisible).toBe(true);
  }
});
```

--------------------------------

### Constructor

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/socket-client.md

Initializes a new instance of the PluginClient. You must provide either a socketPath for Unix sockets or a tcpPort for TCP connections.

```APIDOC
## Constructor

```typescript
constructor(
  socketPath?: string,
  tcpPort?: number
)
```

### Parameters

*   **socketPath** (string) - Optional - Unix socket path (exclusive with tcpPort)
*   **tcpPort** (number) - Optional - TCP port (exclusive with socketPath)

At least one of `socketPath` or `tcpPort` must be provided.

### Example

```typescript
// Unix socket
const client = new PluginClient('/tmp/tauri-playwright.sock');

// TCP (Windows)
const client = new PluginClient(undefined, 6274);
```
```

--------------------------------

### Constructor

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Initializes a new instance of the TauriPage class. It requires a client for communication and optionally accepts a default window label.

```APIDOC
## Constructor

```typescript
constructor(
  client: PluginClient,
  defaultWindow?: string
)
```

### Parameters

- **client** (PluginClient) - Required - Shared socket client for command communication
- **defaultWindow** (string) - Optional - Webview window label; when set, every command targets that window
```

--------------------------------

### Enable CDP on Windows

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/configuration.md

Instructions to enable the Chrome DevTools Protocol for WebView2 on Windows by setting an environment variable.

```bash
WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS="--remote-debugging-port=9222" cargo tauri dev
```

--------------------------------

### goto

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Navigates the web page to a specified URL.

```APIDOC
## goto

### Description
Navigate to a URL.

### Method
`async goto(url: string): Promise<void>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Path Parameters
- **url** (string) - Required - The URL to navigate to.

### Request Example
```typescript
await tauriPage.goto('https://example.com');
```

### Response
#### Success Response (200)
- **void** - Indicates successful navigation.
```

--------------------------------

### Constructor

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/process-manager.md

Initializes a new instance of the TauriProcessManager with the specified process configuration.

```APIDOC
## Constructor

Initializes a new instance of the TauriProcessManager.

### Parameters

#### Request Body

- **config** (ProcessConfig) - Required - Process configuration object

### ProcessConfig

| Property | Type | Required | Default | Description |
|---|---|---|---|---|
| command | string | No | 'cargo' | Command to run |
| args | string[] | No | ['tauri', 'dev'] | Command arguments |
| cwd | string | No | process.cwd() | Working directory |
| features | string[] | No | — | Cargo features to enable |
| socketPath | string | No | '/tmp/tauri-playwright.sock' | Unix socket path (exclusive with tcpPort) |
| tcpPort | number | No | — | TCP port for Windows fallback (exclusive with socketPath) |
| startTimeout | number | No | 120 | Startup timeout in seconds |
```

--------------------------------

### Instantiate PluginClient

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/socket-client.md

Instantiate the PluginClient by providing either a Unix socket path or a TCP port. At least one must be provided.

```typescript
const client = new PluginClient('/tmp/tauri-playwright.sock');
```

```typescript
const client = new PluginClient(undefined, 6274);
```

--------------------------------

### Targeting Windows with Socket Client

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/socket-client.md

Demonstrates how to send commands to the default window or a specific window using the `window` field.

```typescript
// Target default window (plugin's configured default)
await client.send({
  type: 'click',
  selector: '#button',
});
```

```typescript
// Target specific window
await client.send({
  window: 'viewer',
  type: 'click',
  selector: '#button',
});
```

```typescript
// List all windows
const response = await client.send({ type: 'list_windows' });
// response.data is WindowInfo[]
```

--------------------------------

### Basic Test in Browser Mode

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/browser-page-adapter.md

Demonstrates a typical test case using the tauriPage adapter, which works identically in both browser and tauri/cdp modes.

```typescript
import { test, expect } from './fixtures';

test('works in browser mode', async ({ tauriPage }) => {
  // tauriPage is a BrowserPageAdapter in browser mode
  // tauriPage is a TauriPage in tauri/cdp mode
  
  // Same code works in both!
  await tauriPage.click('[data-testid="button"]');
  await expect(tauriPage.locator('[data-testid="result"]')).toContainText('Success');
});
```

--------------------------------

### Counting

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/browser-page-adapter.md

Get the number of elements that match the locator.

```APIDOC
## count

### Description
Returns the number of elements that match the locator.

### Method
`locator.count()`

### Parameters
None
```

--------------------------------

### Initialize Tauri Playwright Plugin with Custom Configuration

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/configuration.md

Initialize the Tauri Playwright plugin with custom settings for socket path, TCP port, and window label.

```rust
use tauri_plugin_playwright::{init_with_config, PluginConfig};

let mut builder = tauri::Builder::default()
    .plugin(init_with_config(
        PluginConfig::new()
            .socket_path("/tmp/my-app-pw.sock")
            .tcp_port(6274)
            .window_label("main")
    ));
```

--------------------------------

### Get Current URL

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Retrieves the current URL of the web page.

```typescript
async url(): Promise<string>
```

--------------------------------

### Get Page Title

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Retrieves the current title of the web page.

```typescript
async title(): Promise<string>
```

--------------------------------

### Build and Test Commands

Source: https://github.com/srsholmes/tauri-playwright/blob/main/CLAUDE.md

Common commands for building, testing, linting, and formatting within the monorepo. Use filters to target specific packages.

```bash
pnpm build
pnpm test:unit
pnpm test:e2e
pnpm lint
pnpm format
pnpm --filter @srsholmes/tauri-playwright build
pnpm --filter @srsholmes/tauri-playwright test
```

--------------------------------

### TauriProcessManager

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/MANIFEST.txt

Manages the lifecycle of the Tauri application process, including starting, stopping, and monitoring.

```APIDOC
## TauriProcessManager Class

### Description
Manages the lifecycle of the Tauri application process during testing. This includes starting the application, monitoring its status, and gracefully shutting it down.

### Methods
Provides functionalities to control the application process, ensuring a clean test environment.

#### Example Usage
```javascript
// Assuming 'processManager' is an instance of TauriProcessManager

// Start the Tauri application
await processManager.start();

// Check if the application is running
const isRunning = processManager.isRunning();

// Stop the Tauri application
await processManager.stop();
```

### Key Features
- **Process Control**: Start and stop the Tauri application process.
- **Status Monitoring**: Check if the application process is currently running.
- **Lifecycle Management**: Ensures proper cleanup and management of the application process throughout the test execution.
```

--------------------------------

### Initialize Tauri Playwright Plugin with Defaults

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/configuration.md

Initialize the Tauri Playwright plugin using default configurations for socket path and window label.

```rust
use tauri_plugin_playwright::init;

let mut builder = tauri::Builder::default()
    .plugin(init());
```

--------------------------------

### Get Full Page HTML

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Retrieves the entire HTML content of the current web page.

```typescript
async content(): Promise<string>
```

--------------------------------

### Get Element Text Content

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Retrieves the text content of an element. This method auto-waits for the element to exist.

```typescript
async textContent(selector: string, options?: TimeoutOption): Promise<string | null>
```

--------------------------------

### connect

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/socket-client.md

Establishes a connection to the plugin's socket server. This method sets up the necessary interfaces for message parsing.

```APIDOC
## connect

```typescript
async connect(): Promise<void>
```

### Description

Connect to the plugin's socket server. Establishes the connection and sets up the readline interface for message parsing.

### Throws

Error if connection fails or neither socket path nor TCP port is configured.

### Example

```typescript
const client = new PluginClient('/tmp/tauri-playwright.sock');
await client.connect();
console.log('Connected to plugin');
```
```

--------------------------------

### Get Inner HTML of Element

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-locator.md

Retrieves the inner HTML of an element. This method auto-waits for the element to exist.

```typescript
async innerHTML(options?: TimeoutOption): Promise<string>
```

--------------------------------

### Enable CDP Mode on Windows

Source: https://github.com/srsholmes/tauri-playwright/blob/main/README.md

Launch your Tauri application with CDP enabled by setting the `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS` environment variable.

```bash
# Launch with CDP enabled
WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS="--remote-debugging-port=9222" cargo tauri dev
```

--------------------------------

### Create Tauri Test Fixtures

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/README.md

Set up test fixtures by creating a Tauri test instance. Configure development server URL, mock IPC handlers, and context variables for browser mode testing.

```typescript
// fixtures.ts
import { createTauriTest } from '@srsholmes/tauri-playwright';

const MOCK_USERS = [
  { id: 1, name: 'Alice', role: 'admin' },
  { id: 2, name: 'Bob', role: 'user' },
];

export const { test, expect } = createTauriTest({
  devUrl: 'http://localhost:1420',
  ipcContext: { MOCK_USERS },
  ipcMocks: {
    get_users: () => MOCK_USERS,
    get_user: (args) => MOCK_USERS.find(u => u.id === args.id),
    create_user: (args) => {
      const newUser = { id: Math.max(...MOCK_USERS.map(u => u.id)) + 1, ...args };
      MOCK_USERS.push(newUser);
      return newUser;
    },
  },
});
```

--------------------------------

### Get Text Content of Element

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-locator.md

Retrieves the text content of an element. This method auto-waits for the element to exist.

```typescript
async textContent(options?: TimeoutOption): Promise<string | null>
```

--------------------------------

### TauriMouse Double Click Example

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/keyboard-mouse.md

Execute a double-click action at the given coordinates. This method requires the tauriPage object.

```typescript
async dblclick(x: number, y: number): Promise<void>
```

--------------------------------

### Discover and Interact with a New Tauri Window

Source: https://github.com/srsholmes/tauri-playwright/blob/main/README.md

Use `waitForWindow` to discover a newly opened window and scope `TauriPage` commands to it. Match windows based on stable properties like label prefix, URL, or title. The original `tauriPage` continues to drive the main window.

```typescript
test('viewer opens and shows the file', async ({ tauriPage }) => {
  await tauriPage.click('[data-testid="btn-open-viewer"]');

  // Poll until a window matching the predicate appears (default 5s timeout).
  // Match on whatever is stable for your app — here, the label prefix the app
  // assigns when it opens the window (e.g. `viewer-<timestamp>`). You can also
  // match on `w.url` or `w.title`.
  const viewer = await tauriPage.waitForWindow((w) => w.label.startsWith('viewer-'));

  // From here, every command on `viewer` targets that window. The original
  // `tauriPage` still drives the main window.
  await expect(viewer.getByTestId('file-name')).toHaveText('photo.jpg');
  await viewer.click('[data-testid="btn-close"]');
});

```

--------------------------------

### Get Captured Dialogs

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Retrieves an array of dialog objects that have been captured since the last call to this method or `clearDialogs`.

```typescript
async getDialogs(): Promise<Array<{ 
  type: 'alert' | 'confirm' | 'prompt';
  message: string;
  default?: string;
}>>
```

--------------------------------

### Constructor

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/browser-page-adapter.md

Initializes the BrowserPageAdapter with a Playwright Page object.

```APIDOC
## Constructor

### Description
Initializes the BrowserPageAdapter with a Playwright Page object.

### Signature
```typescript
constructor(page: Page)
```

### Parameters
#### Path Parameters
- **page** (Page) - Required - Playwright Page object

### Request Example
```typescript
import { test, expect } from '@playwright/test';
import { BrowserPageAdapter } from '@srsholmes/tauri-playwright';

const browser = await chromium.launch();
const page = await browser.newPage();
const adapter = new BrowserPageAdapter(page);

// Now use adapter like TauriPage
await adapter.click('[data-testid="button"]');
```
```

--------------------------------

### Get Element Attribute Value

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Retrieves the value of a specified attribute from an element. This method auto-waits for the element to exist.

```typescript
async getAttribute(
  selector: string,
  name: string,
  options?: TimeoutOption
): Promise<string | null>
```

--------------------------------

### Configure Tauri Playwright Plugin

Source: https://github.com/srsholmes/tauri-playwright/blob/main/packages/test/README.md

Initialize the Tauri Playwright plugin using `tauri_plugin_playwright::init()` for default settings or `tauri_plugin_playwright::init_with_config()` to specify a custom Unix socket path and TCP port.

```rust
use tauri_plugin_playwright::PluginConfig;

// Default: Unix socket at /tmp/tauri-playwright.sock
builder = builder.plugin(tauri_plugin_playwright::init());

// Custom socket path + TCP fallback
builder = builder.plugin(tauri_plugin_playwright::init_with_config(
    PluginConfig::new()
        .socket_path("/tmp/my-app-pw.sock")
        .tcp_port(6274)
));
```

--------------------------------

### List All Open Tauri Windows

Source: https://github.com/srsholmes/tauri-playwright/blob/main/_autodocs/api-reference/tauri-page.md

Asynchronously list all currently open webview windows. Returns an array of window info objects.

```typescript
async listWindows(): Promise<WindowInfo[]>
```
Tokens:
Raw