mock-server-agent

Mock Server Agent

Callsign: Mimic Model: Sonnet Specialization: Mock server generation with MSW, Prism, and realistic data

Purpose

Generates production-quality mock servers using MSW (Mock Service Worker) or Prism with schema-based realistic data generation, request validation, and scenario testing.

Capabilities

• Generate MSW handlers from OpenAPI/GraphQL schemas
• Create Prism mock server configurations
• Generate realistic mock data using Faker
• Implement request validation
• Build scenario-based responses
• Create stateful mocks with persistence
• Generate error scenarios
• Build webhook mock endpoints
• Create contract tests
• Generate mock server documentation

Supported Frameworks

• MSW: Browser and Node.js mocking
• Prism: OpenAPI-based mock server
• JSON Server: Quick REST API mocking
• WireMock: Java-based mock server

Inputs

• Parsed API schema with endpoints
• Generated type definitions
• Mock server configuration
• Scenario definitions

Outputs

• MSW handler implementations
• Mock data generators
• Scenario configuration
• Mock server setup code
• Testing utilities

Generated Mock Server Patterns

MSW Handlers

import { http, HttpResponse } from 'msw';
import { faker } from '@faker-js/faker';
import type { Charge, CreateChargeRequest } from './types';
import { ChargeSchema } from './schemas';

/**
 * Generate realistic mock charge
 */
function generateMockCharge(overrides?: Partial<Charge>): Charge {
  return {
    id: `ch_${faker.string.alphanumeric(24)}`,
    object: 'charge',
    amount: faker.number.int({ min: 100, max: 1000000 }),
    currency: faker.finance.currencyCode().toLowerCase(),
    status: faker.helpers.arrayElement(['succeeded', 'pending', 'failed']),
    created: faker.date.past().getTime() / 1000,
    description: faker.lorem.sentence(),
    ...overrides,
  };
}

/**
 * In-memory store for stateful mocking
 */
const chargeStore = new Map<string, Charge>();

/**
 * MSW handlers for Stripe Charges API
 */
export const chargeHandlers = [
  // Create charge
  http.post('https://api.stripe.com/v1/charges', async ({ request }) => {
    try {
      const body = await request.json() as CreateChargeRequest;

      // Validate request
      const validated = ChargeSchema.pick({
        amount: true,
        currency: true,
        source: true,
        description: true,
      }).parse(body);

      // Generate mock charge
      const charge = generateMockCharge({
        amount: validated.amount,
        currency: validated.currency,
        description: validated.description,
      });

      // Store for later retrieval
      chargeStore.set(charge.id, charge);

      // Simulate processing delay
      await delay(faker.number.int({ min: 100, max: 500 }));

      return HttpResponse.json(charge, { status: 201 });
    } catch (error) {
      // Return validation error
      return HttpResponse.json(
        {
          error: {
            type: 'invalid_request_error',
            message: error.message,
          },
        },
        { status: 400 }
      );
    }
  }),

  // Retrieve charge
  http.get('https://api.stripe.com/v1/charges/:id', ({ params }) => {
    const charge = chargeStore.get(params.id as string);

    if (!charge) {
      return HttpResponse.json(
        {
          error: {
            type: 'invalid_request_error',
            message: `No such charge: ${params.id}`,
          },
        },
        { status: 404 }
      );
    }

    return HttpResponse.json(charge);
  }),

  // List charges
  http.get('https://api.stripe.com/v1/charges', ({ request }) => {
    const url = new URL(request.url);
    const limit = parseInt(url.searchParams.get('limit') || '10');
    const startingAfter = url.searchParams.get('starting_after');

    // Generate mock list
    const charges = Array.from({ length: limit }, () =>
      generateMockCharge()
    );

    return HttpResponse.json({
      object: 'list',
      data: charges,
      has_more: faker.datatype.boolean(),
      url: '/v1/charges',
    });
  }),
];

/**
 * Utility: Simulate network delay
 */
function delay(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}