Network & API Testing

/**
 * Global API request client
 */
const request: APIRequest;

interface APIRequest {
  /** Create new API request context */
  newContext(options?: APIRequestNewContextOptions): Promise<APIRequestContext>;
}

interface APIRequestContext {
  /** Send GET request */
  get(url: string, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Send POST request */
  post(url: string, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Send PUT request */
  put(url: string, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Send PATCH request */
  patch(url: string, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Send DELETE request */
  delete(url: string, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Send HEAD request */
  head(url: string, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Send custom method request */
  fetch(urlOrRequest: string | Request, options?: APIRequestContextOptions): Promise<APIResponse>;
  /** Dispose context */
  dispose(): Promise<void>;
  /** Store auth state */
  setExtraHTTPHeaders(headers: { [key: string]: string }): Promise<void>;
  /** Set storage state */
  setStorageState(state: { cookies: Cookie[]; origins: any[] }): Promise<void>;
  /** Get storage state */
  storageState(options?: { path?: string }): Promise<{ cookies: Cookie[]; origins: any[] }>;
}

interface APIRequestContextOptions {
  /** Request parameters */
  params?: { [key: string]: string | number | boolean };
  /** Request headers */
  headers?: { [key: string]: string };
  /** Request body */
  data?: string | Buffer | object;
  /** Form data */
  form?: { [key: string]: string | number | boolean };
  /** Multipart form data */
  multipart?: { [key: string]: string | number | boolean | { name: string; mimeType: string; buffer: Buffer } };
  /** Request timeout */
  timeout?: number;
  /** Fail on HTTP error status */
  failOnStatusCode?: boolean;
  /** Ignore HTTPS errors */
  ignoreHTTPSErrors?: boolean;
}

import { request } from 'playwright';

// Create API context
const apiContext = await request.newContext({
  baseURL: 'https://api.example.com',
  extraHTTPHeaders: {
    'Authorization': 'Bearer token123',
    'Content-Type': 'application/json'
  }
});

// Make API requests
const response = await apiContext.get('/users');
const userData = await response.json();

const createResponse = await apiContext.post('/users', {
  data: {
    name: 'John Doe',
    email: 'john@example.com'
  }
});

// Form data
const formResponse = await apiContext.post('/upload', {
  multipart: {
    file: { name: 'document.pdf', mimeType: 'application/pdf', buffer: fileBuffer },
    description: 'Important document'
  }
});

await apiContext.dispose();

interface APIResponse {
  /** Get response status */
  status(): number;
  /** Get status text */
  statusText(): string;
  /** Get response URL */
  url(): string;
  /** Check if response is OK (200-299) */
  ok(): boolean;
  /** Get response headers */
  headers(): { [key: string]: string };
  /** Get response header array */
  headersArray(): { name: string; value: string }[];
  /** Get single header value */
  headerValue(name: string): Promise<string | null>;
  /** Get all values for header */
  headerValues(name: string): Promise<string[]>;
  
  /** Get response body as text */
  text(): Promise<string>;
  /** Get response body as JSON */
  json(): Promise<any>;
  /** Get response body as buffer */
  body(): Promise<Buffer>;
  /** Dispose response */
  dispose(): Promise<void>;
}

const response = await apiContext.get('/api/data');

// Check response status
if (response.ok()) {
  const data = await response.json();
  console.log('Success:', data);
} else {
  console.error('Error:', response.status(), response.statusText());
  const errorText = await response.text();
  console.error('Error body:', errorText);
}

// Inspect headers
const contentType = await response.headerValue('content-type');
const headers = response.headers();
console.log('Content-Type:', contentType);
console.log('All headers:', headers);

interface Page {
  /** Set route handler for URL pattern */
  route(url: string | RegExp | (url: URL) => boolean, handler: RouteHandler, options?: PageRouteOptions): Promise<void>;
  /** Remove route handlers */
  unroute(url: string | RegExp | (url: URL) => boolean, handler?: RouteHandler): Promise<void>;
  /** Remove all route handlers */
  unrouteAll(options?: PageUnrouteAllOptions): Promise<void>;
}

interface BrowserContext {
  /** Set route handler for context */
  route(url: string | RegExp | (url: URL) => boolean, handler: RouteHandler, options?: BrowserContextRouteOptions): Promise<void>;
  /** Remove route handlers */
  unroute(url: string | RegExp | (url: URL) => boolean, handler?: RouteHandler): Promise<void>;
  /** Remove all route handlers */
  unrouteAll(options?: BrowserContextUnrouteAllOptions): Promise<void>;
}

type RouteHandler = (route: Route, request: Request) => Promise<void> | void;

interface Route {
  /** Get the request being routed */
  request(): Request;
  /** Fulfill request with custom response */
  fulfill(response: RouteFulfillResponse): Promise<void>;
  /** Abort request with error */
  abort(errorCode?: string): Promise<void>;
  /** Continue request, optionally modified */
  continue(overrides?: RouteContinueOverrides): Promise<void>;
  /** Fetch original request */
  fetch(options?: RouteFetchOptions): Promise<APIResponse>;
}

interface RouteFulfillResponse {
  /** Response status */
  status?: number;
  /** Response headers */
  headers?: { [key: string]: string };
  /** Response body */
  body?: string | Buffer;
  /** Content type */
  contentType?: string;
  /** Response path (file) */
  path?: string;
}

interface RouteContinueOverrides {
  /** Override URL */
  url?: string;
  /** Override method */
  method?: string;
  /** Override headers */
  headers?: { [key: string]: string };
  /** Override post data */
  postData?: string | Buffer;
}

// Mock API responses
await page.route('/api/users', async (route) => {
  await route.fulfill({
    status: 200,
    contentType: 'application/json',
    body: JSON.stringify([
      { id: 1, name: 'John' },
      { id: 2, name: 'Jane' }
    ])
  });
});

// Block specific requests
await page.route('**/*.png', async (route) => {
  await route.abort();
});

// Modify requests
await page.route('/api/**', async (route, request) => {
  const headers = {
    ...request.headers(),
    'Authorization': 'Bearer test-token'
  };
  
  await route.continue({ headers });
});

// Conditional routing
await page.route('/api/data', async (route, request) => {
  if (request.method() === 'POST') {
    await route.fulfill({
      status: 201,
      body: '{"success": true}'
    });
  } else {
    await route.continue();
  }
});

interface Page {
  /** Listen for request events */
  on(event: 'request', listener: (request: Request) => void): void;
  /** Listen for response events */
  on(event: 'response', listener: (response: Response) => void): void;
  /** Listen for request finished events */
  on(event: 'requestfinished', listener: (request: Request) => void): void;
  /** Listen for request failed events */
  on(event: 'requestfailed', listener: (request: Request) => void): void;
}

interface Request {
  /** Get request URL */
  url(): string;
  /** Get request method */
  method(): string;
  /** Get request headers */
  headers(): { [key: string]: string };
  /** Get POST data */
  postData(): string | null;
  /** Get POST data as buffer */
  postDataBuffer(): Buffer | null;
  /** Get POST data as JSON */
  postDataJSON(): any | null;
  /** Get resource type */
  resourceType(): string;
  /** Get redirected from request */
  redirectedFrom(): Request | null;
  /** Get redirected to request */
  redirectedTo(): Request | null;
  /** Get request failure */
  failure(): { errorText: string } | null;
  /** Get request timing */
  timing(): ResourceTiming;
  /** Get response */
  response(): Promise<Response | null>;
  /** Check if request is navigation */
  isNavigationRequest(): boolean;
  /** Get request frame */
  frame(): Frame;
}

interface Response {
  /** Get response URL */
  url(): string;
  /** Get response status */
  status(): number;
  /** Get status text */
  statusText(): string;
  /** Check if response is OK */
  ok(): boolean;
  /** Get response headers */
  headers(): { [key: string]: string };
  /** Get response body */
  body(): Promise<Buffer>;
  /** Get response text */
  text(): Promise<string>;
  /** Get response JSON */
  json(): Promise<any>;
  /** Get request that produced this response */
  request(): Request;
  /** Get response frame */
  frame(): Frame;
  /** Get server address */
  serverAddr(): { ipAddress: string; port: number } | null;
  /** Get security details */
  securityDetails(): SecurityDetails | null;
}

interface ResourceTiming {
  startTime: number;
  domainLookupStart: number;
  domainLookupEnd: number;
  connectStart: number;
  secureConnectionStart: number;
  connectEnd: number;
  requestStart: number;
  responseStart: number;
  responseEnd: number;
}

interface SecurityDetails {
  issuer?: string;
  protocol?: string;
  subjectName?: string;
  validFrom?: number;
  validTo?: number;
}

// Monitor all requests
page.on('request', request => {
  console.log('Request:', request.method(), request.url());
});

// Monitor responses  
page.on('response', response => {
  console.log('Response:', response.status(), response.url());
});

// Monitor failed requests
page.on('requestfailed', request => {
  console.log('Failed:', request.url(), request.failure()?.errorText);
});

// Analyze network activity
const requests: Request[] = [];
page.on('request', request => requests.push(request));

await page.goto('https://example.com');

// Get all API requests
const apiRequests = requests.filter(req => 
  req.url().includes('/api/') && req.resourceType() === 'xhr'
);

console.log(`Made ${apiRequests.length} API requests`);

interface Page {
  /** Listen for WebSocket events */
  on(event: 'websocket', listener: (webSocket: WebSocket) => void): void;
}

interface WebSocket {
  /** Get WebSocket URL */
  url(): string;
  /** Check if WebSocket is closed */
  isClosed(): boolean;
  /** Wait for WebSocket event */
  waitForEvent(event: 'close' | 'framereceived' | 'framesent' | 'socketerror', options?: WaitForEventOptions): Promise<any>;
  
  /** Listen for frame received */
  on(event: 'framereceived', listener: (payload: WebSocketFrame) => void): void;
  /** Listen for frame sent */
  on(event: 'framesent', listener: (payload: WebSocketFrame) => void): void;
  /** Listen for close event */
  on(event: 'close', listener: () => void): void;
  /** Listen for socket error */
  on(event: 'socketerror', listener: (error: string) => void): void;
}

interface WebSocketFrame {
  /** Frame payload */
  payload: string | Buffer;
  /** Frame opcode */
  opcode: number;
}

interface WebSocketRoute {
  /** Get WebSocket URL */
  url(): string;
  /** Connect to WebSocket with handler */
  connectToServer(): Promise<void>;
  /** Close WebSocket */
  close(options?: { code?: number; reason?: string }): Promise<void>;
  /** Send frame to server */
  send(message: string | Buffer): void;
  
  /** Listen for messages from page */
  onMessage(handler: (message: string | Buffer) => void): void;
  /** Listen for close from page */
  onClose(handler: () => void): void;
}

// Monitor WebSocket connections
page.on('websocket', ws => {
  console.log('WebSocket created:', ws.url());
  
  ws.on('framereceived', frame => {
    console.log('Received:', frame.payload);
  });
  
  ws.on('framesent', frame => {
    console.log('Sent:', frame.payload);
  });
  
  ws.on('close', () => {
    console.log('WebSocket closed');
  });
});

// Route WebSocket connections
await page.routeWebSocket('/ws', ws => {
  ws.onMessage(message => {
    console.log('Message from page:', message);
    // Echo message back
    ws.send(`Echo: ${message}`);
  });
});

interface APIRequestNewContextOptions {
  /** Base URL for requests */
  baseURL?: string;
  /** Extra HTTP headers */
  extraHTTPHeaders?: { [key: string]: string };
  /** HTTP credentials */
  httpCredentials?: HTTPCredentials;
  /** Ignore HTTPS errors */
  ignoreHTTPSErrors?: boolean;
  /** Proxy settings */
  proxy?: ProxySettings;
  /** Client certificates */
  clientCertificates?: ClientCertificate[];
  /** User agent */
  userAgent?: string;
  /** Timeout for requests */
  timeout?: number;
}

interface PageRouteOptions {
  /** Times to handle route */
  times?: number;
}

interface RouteFetchOptions {
  /** Override URL */
  url?: string;
  /** Override method */
  method?: string;
  /** Override headers */
  headers?: { [key: string]: string };
  /** Override post data */
  postData?: string | Buffer;
  /** Request timeout */
  timeout?: number;
}

interface WaitForEventOptions {
  /** Event timeout */
  timeout?: number;
  /** Predicate function */
  predicate?: Function;
}