マイクロサービスモック戦略: MSW対WireMockガイド

// Example: Setting up MSW 2.0 network handlers in a Node.js microservice test
import { setupServer } from 'msw/node';
import { http, HttpResponse } from 'msw';
import { fetchPaymentStatus } from '../src/payment-client';

const handlers = [
  http.get('https://api.payments.example.com/v1/charges/:chargeId', ({ params }) => {
    const { chargeId } = params;
    
    if (chargeId === 'ch_invalid') {
      return HttpResponse.json({ error: 'Charge not found' }, { status: 404 });
    }
    
    return HttpResponse.json({
      id: chargeId,
      amount: 4999,
      currency: 'usd',
      status: 'succeeded',
    }, { status: 200 });
  }),
];

const server = setupServer(...handlers);

describe('Payment Service Client', () => {
  beforeAll(() => server.listen({ onUnhandledRequest: 'error' }));
  afterEach(() => server.resetHandlers());
  afterAll(() => server.close());

  it('fetches payment status successfully for valid charge ID', async () => {
    const status = await fetchPaymentStatus('ch_9901');
    expect(status.amount).toEqual(4999);
    expect(status.status).toEqual('succeeded');
  });
});

// Client code verified by MSW network interception
import axios from 'axios';

export async function fetchPaymentStatus(chargeId: string) {
  const response = await axios.get(`https://api.payments.example.com/v1/charges/${chargeId}`);
  return response.data;
}

// Stateful WireMock scenario mapping: Tracking state transition from UNPAID to PAID
{
  "scenarioName": "Order Payment Process",
  "requiredScenarioState": "Started",
  "newScenarioState": "Order Placed",
  "request": {
    "method": "POST",
    "url": "/api/v1/orders"
  },
  "response": {
    "status": 201,
    "jsonBody": { "orderId": "ord_505", "status": "PENDING" }
  }
}

// Advanced MSW 2.0 GraphQL and REST handler composition
import { http, graphql, HttpResponse } from 'msw';

export const microserviceHandlers = [
  // Intercept REST endpoint
  http.post('https://api.inventory.example.com/v1/stock/reserve', async ({ request }) => {
    const body = await request.json() as { sku: string; quantity: number };
    
    if (body.quantity > 100) {
      return HttpResponse.json({ error: 'Insufficient inventory' }, { status: 422 });
    }
    
    return HttpResponse.json({ reserved: true, reservationId: 'res_8812' });
  }),

  // Intercept GraphQL query
  graphql.query('GetCustomerDetails', ({ variables }) => {
    const { id } = variables;
    return HttpResponse.json({
      data: {
        customer: {
          id,
          name: 'Alex Mercer',
          email: 'alex.mercer@example.com',
        },
      },
    });
  }),
];

// Reusing MSW handlers between Node.js Vitest unit tests and Storybook UI components
import { http, HttpResponse } from 'msw';

export const commonUserHandlers = [
  http.get('/api/user', () => {
    return HttpResponse.json({ name: 'Jane Doe', role: 'admin' });
  }),
];

// MSW 2.0 WebSocket event mocking example
import { ws } from 'msw';

const chatService = ws.link('wss://chat.example.com/socket');

export const websocketHandlers = [
  chatService.addEventListener('connection', ({ client }) => {
    client.send(JSON.stringify({ type: 'WELCOME', message: 'Connected to mock server' }));

    client.addEventListener('message', (event) => {
      const data = JSON.parse(event.data as string);
      if (data.type === 'PING') {
        client.send(JSON.stringify({ type: 'PONG' }));
      }
    });
  }),
];

// WireMock JSON mapping file: mappings/get-user-profile.json
{
  "request": {
    "method": "GET",
    "urlPattern": "/api/v1/users/[0-9]+"
  },
  "response": {
    "status": 200,
    "headers": {
      "Content-Type": "application/json"
    },
    "jsonBody": {
      "id": 101,
      "username": "developer_user",
      "tier": "enterprise",
      "status": "active"
    },
    "fixedDelayMilliseconds": 50
  }
}

# Docker Compose stack integrating WireMock for polyglot microservice integration tests
version: '3.8'

services:
  wiremock:
    image: wiremock/wiremock:3.5.0
    container_name: integration-wiremock
    ports:
      - "8080:8080"
    volumes:
      - ./wiremock/mappings:/home/wiremock/mappings
      - ./wiremock/__files:/home/wiremock/__files
    command: --verbose --enable-stub-cors

  order-service:
    build: .
    environment:
      USER_SERVICE_URL: "http://wiremock:8080"
    depends_on:
      - wiremock

// Programmatic WireMock stubbing via Node.js administrative REST API
import axios from 'axios';

export async function registerWireMockStub(wiremockUrl: string) {
  await axios.post(`${wiremockUrl}/__admin/mappings`, {
    request: {
      method: 'POST',
      url: '/api/v1/payments',
      bodyPatterns: [
        { matchesJsonPath: '$.amount' }
      ]
    },
    response: {
      status: 201,
      jsonBody: { transactionRef: 'tx_772199', status: 'approved' },
    },
  });
}

export async function resetWireMockMappings(wiremockUrl: string) {
  await axios.post(`${wiremockUrl}/__admin/mappings/reset`);
}

// WireMock Handlebars response templating mapping
{
  "request": {
    "method": "POST",
    "url": "/api/v1/echo"
  },
  "response": {
    "status": 200,
    "jsonBody": {
      "receivedAt": "{{now}}",
      "requestId": "{{randomValue type='UUID'}}",
      "clientName": "{{jsonPath request.body '$.name'}}"
    },
    "transformers": ["response-template"]
  }
}

// Example: MSW runtime fault injection simulating 503 service unavailable and network delays
import { setupServer } from 'msw/node';
import { http, HttpResponse, delay } from 'msw';
import { microserviceHandlers } from './handlers';
import { fetchBillingDetails } from '../src/billing-client';

const server = setupServer(...microserviceHandlers);

describe('Billing Service Fault Resilience', () => {
  beforeAll(() => server.listen());
  afterEach(() => server.resetHandlers());
  afterAll(() => server.close());

  it('handles 503 Service Unavailable gracefully with exponential backoff', async () => {
    // Inject temporary 503 error for billing endpoint
    server.use(
      http.get('https://api.billing.example.com/v1/invoices', () => {
        return new HttpResponse(null, { status: 503, statusText: 'Service Unavailable' });
      })
    );

    await expect(fetchBillingDetails()).rejects.toThrow('Billing service unavailable');
  });

  it('handles high network latency timeout scenarios', async () => {
    // Inject 3000ms delay to trigger client HTTP timeout threshold
    server.use(
      http.get('https://api.billing.example.com/v1/invoices', async () => {
        await delay(3000);
        return HttpResponse.json({ invoices: [] });
      })
    );

    await expect(fetchBillingDetails({ timeoutMs: 1000 })).rejects.toThrow('Request timed out');
  });
});

// WireMock fault injection mapping: Connection reset simulation
{
  "request": {
    "method": "POST",
    "url": "/api/v1/orders"
  },
  "response": {
    "fault": "CONNECTION_RESET_BY_PEER"
  }
}

// Custom circuit breaker implementation verified against MSW fault injection
import axios from 'axios';

export class ResilientApiClient {
  private failureCount = 0;
  private readonly threshold = 3;

  async executeRequest(url: string) {
    if (this.failureCount >= this.threshold) {
      throw new Error('Circuit breaker open: requests blocked');
    }

    try {
      const response = await axios.get(url);
      this.failureCount = 0;
      return response.data;
    } catch (error) {
      this.failureCount++;
      throw error;
    }
  }
}

// Randomized chaos injection middleware in MSW
export function createChaosHandler(targetUrl: string, errorProbability = 0.1) {
  return http.get(targetUrl, () => {
    if (Math.random() < errorProbability) {
      return new HttpResponse(null, { status: 500, statusText: 'Internal Chaos Error' });
    }
    return HttpResponse.json({ status: 'ok' });
  });
}

// Calculation helper for evaluating mock execution latency overhead
function estimateSuiteRunTime(
  totalSpecs: number,
  avgNetworkLatencyMs: number,
  parallelWorkers: number
): number {
  const totalLatencyMs = (totalSpecs * avgNetworkLatencyMs) / parallelWorkers;
  return Math.round(totalLatencyMs / 1000);
}

// MSW in-memory vs WireMock socket latency comparison
const mswSuiteTime = estimateSuiteRunTime(500, 0.5, 4);   // ~1 second
const wiremockSuiteTime = estimateSuiteRunTime(500, 12, 4); // ~15 seconds

console.log(`Estimated 500-spec run time with MSW: ${mswSuiteTime}s`);
console.log(`Estimated 500-spec run time with WireMock: ${wiremockSuiteTime}s`);