home / skills / a5c-ai / babysitter / sdk-mock-generator

sdk-mock-generator skill

safe

/plugins/babysitter/skills/babysit/process/specializations/sdk-platform-development/skills/sdk-mock-generator

This skill generates mock servers and clients for SDK testing, enabling reliable integration testing without production API calls.

npx playbooks add skill a5c-ai/babysitter --skill sdk-mock-generator

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

1.9 KB

---
name: sdk-mock-generator
description: Generate mock servers and clients for SDK testing
allowed-tools:
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Bash
---

# SDK Mock Generator Skill

## Overview

This skill generates mock servers and clients for SDK testing, enabling developers to test integrations without hitting production APIs.

## Capabilities

- Generate mock servers from OpenAPI specifications
- Create SDK test fixtures with realistic data
- Implement response stubbing for various scenarios
- Support stateful mocking for complex workflows
- Generate error response mocks
- Configure latency simulation
- Support request recording and playback
- Create mock data factories

## Target Processes

- SDK Testing Strategy
- Developer Experience Optimization
- API Documentation System

## Integration Points

- Prism (OpenAPI mock server)
- WireMock (HTTP mock server)
- MSW (Mock Service Worker for browsers)
- Nock (Node.js HTTP mocking)
- VCR-style recording libraries

## Input Requirements

- OpenAPI specification
- Test scenario requirements
- Stateful behavior definitions
- Error scenarios to mock
- Performance simulation needs

## Output Artifacts

- Mock server implementation
- Test fixture data
- Response stub configurations
- Stateful scenario handlers
- Mock data factories
- Recording/playback setup

## Usage Example

```yaml
skill:
  name: sdk-mock-generator
  context:
    apiSpec: ./openapi.yaml
    mockTool: prism
    features:
      - responseStubbing
      - statefulMocking
      - errorSimulation
      - latencySimulation
    scenarios:
      - name: happyPath
        responses: ./fixtures/happy-path/
      - name: errorCases
        responses: ./fixtures/errors/
    recordMode: true
```

## Best Practices

1. Generate mocks from the same spec as production
2. Include realistic data in fixtures
3. Mock all error scenarios
4. Support stateful testing flows
5. Enable request recording for debugging
6. Simulate realistic latencies

Overview

This skill generates mock servers and client fixtures to streamline SDK testing and integration validation. It produces stateful and stateless mocks, error scenarios, and latency simulations so teams can run deterministic tests without hitting production APIs. The outputs include server implementations, fixture data, and recording/playback configurations for repeatable test runs.

How this skill works

Given an OpenAPI spec and scenario definitions, the skill scaffolds mock servers (Prism, WireMock, MSW) or Node.js stubs (Nock) and generates corresponding client fixtures. It supports response stubbing, error injection, and stateful handlers to emulate multi-step workflows. It can also record real traffic for playback and inject configurable latency to simulate performance conditions.

When to use it

During SDK development to validate client behavior without live APIs
When building CI tests that must be deterministic and fast
To exercise error handling and edge cases before production deployment
For end-to-end workflow testing requiring stateful API interactions
When simulating network conditions such as latency or intermittent failures

Best practices

Always generate mocks from the same OpenAPI spec used in production
Include realistic fixture data that matches production formats and constraints
Cover all error and edge-case responses in your scenarios
Use stateful mocks for multi-step flows to preserve context across requests
Enable request recording to reproduce bugs and refine mock behavior

Example use cases

Create a Prism-based mock server from an OpenAPI file for local developer testing
Generate MSW handlers and fixture factories for browser-based integration tests
Produce WireMock stubs for CI pipelines that run end-to-end SDK tests
Record real API interactions and generate VCR-style playback fixtures for flaky endpoints
Inject latency and error scenarios to validate retry and timeout logic in SDKs

FAQ

What inputs are required to generate mocks?

Supply an OpenAPI specification plus scenario definitions that list responses, stateful behaviors, and error cases.

Can this produce both server and client-side mocks?

Yes. It outputs server implementations (Prism, WireMock) and client-side stubs/factories (MSW, Nock) along with test fixtures and recording setups.