Skip to main content
skill CX Codex

msw — Claude Code skill: MSW v2 rules for API mocking

A skill with 45 rules for Mock Service Worker v2: setup, handlers, test integration, GraphQL. Useful when your agent writes or fixes HTTP mocks.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pproenca/dot-skills --skill msw -a claude-code
Open on GitHub

What msw does

The skill covers Mock Service Worker v2 and splits its rules into 8 categories ranked by impact, from initialization and handler architecture down to debugging. There are 45 rules with prefixes setup-, handler-, test-, response-, match-, graphql-, advanced- and debug-. Your agent opens the matching file under references/ and applies it to your code.

The rules get specific: the right Node.js entrypoint msw/node, server lifecycle in test setup, resetting handlers after each test, MSW v2 response syntax, URL and method matching, GraphQL operation mocking. There is also server.boundary() for concurrent tests and fake timer config that keeps queueMicrotask intact.

MSW v2 requires Node.js 18+. The skill stays out of general test methodology and points to test-vitest and test-tdd for that, while OpenAPI mock generation belongs to the orval skill. If your project still runs MSW v1, the response syntax rules won't match — upgrade the library first.

What it helps with

  • set up MSW v2 in a test environment from scratch
  • split handlers by domain instead of one big file
  • reset handlers between tests so they stop leaking
  • mock error responses and delays, not just the happy path
  • wire up GraphQL operation mocks with variables

Example prompts for the agent

  • Set up MSW v2 for this project and add handlers for /api/users
  • My handler never matches — check the URL matching against the msw rules
  • Rewrite these tests so handlers reset after every case

How to install msw

1Skills CLI (Vercel)

npx skills add pproenca/dot-skills --skill msw -a claude-code

2Manually: put the files in place

~/.claude/skills/msw/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/msw/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about msw

How do I install msw in Claude?

Run npx skills add pproenca/dot-skills --skill msw -a claude-code. The skill lands in ~/.claude/skills/msw/SKILL.md.

What does the msw skill do?

It gives your agent 45 rules for Mock Service Worker v2: initialization, handler architecture, test integration, responses, request matching, GraphQL and debugging. The agent applies them while writing or editing API mocks.

Does it cover general testing patterns?

No. It is about MSW and points to the test-vitest and test-tdd skills for test methodology.

Source text

SKILL.md · MIT
---
name: msw
description: MSW (Mock Service Worker) best practices for API mocking in tests (formerly test-msw). This skill should be used when setting up MSW, writing request handlers, or mocking HTTP APIs. This skill does NOT cover general testing patterns (use test-vitest or test-tdd skills) or test methodology.
---

# MSW Best Practices

Comprehensive API mocking guide for MSW v2 applications, designed for AI agents and LLMs. Contains 45 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.

## When to Apply

Reference these guidelines when:
- Setting up MSW for testing or development
- Writing or organizing request handlers
- Configuring test environments with MSW
- Mocking REST or GraphQL APIs
- Debugging handler matching issues
- Testing error states and edge cases

## Rule Categories by Priority

| Priority | Category | Impact | Prefix |
|----------|----------|--------|--------|
| 1 | Setup & Initialization | CRITICAL | `setup-` |
| 2 | Handler Architecture | CRITICAL | `handler-` |
| 3 | Test Integration | HIGH | `test-` |
| 4 | Response Patterns | HIGH | `response-` |
| 5 | Request Matching | MEDIUM-HIGH | `match-` |
| 6 | GraphQL Mocking | MEDIUM | `graphql-` |
| 7 | Advanced Patterns | MEDIUM | `advanced-` |
| 8 | Debugging & Performance | LOW | `debug-` |

## Quick Reference

### 1. Setup & Initialization (CRITICAL)

- `setup-server-node-entrypoint` - Use correct entrypoint for Node.js (msw/node)
- `setup-lifecycle-hooks` - Configure server lifecycle in test setup
- `setup-worker-script-commit` - Commit worker script to version control
- `setup-node-version` - Require Node.js 18+ for MSW v2
- `setup-unhandled-requests` - Configure unhandled request behavior
- `setup-typescript-config` - Configure TypeScript for MSW v2

### 2. Handler Architecture (CRITICAL)

- `handler-happy-path-first` - Define happy path handlers as baseline
- `handler-domain-grouping` - Group handlers by domain
- `handler-absolute-urls` - Use absolute URLs in handlers
- `handler-shared-resolvers` - Extract shared response logic into resolvers
- `handler-v2-response-syntax` - Use MSW v2 response syntax
- `handler-request-body-parsing` - Explicitly parse request bodies
- `handler-resolver-argument` - Destructure resolver arguments correctly
- `handler-reusability-environments` - Share handlers across environments

### 3. Test Integration (HIGH)

- `test-reset-handlers` - Reset handlers after each test
- `test-avoid-request-assertions` - Avoid direct request assertions
- `test-concurrent-boundary` - Use server.boundary() for concurrent tests
- `test-fake-timers-config` - Configure fake timers to preserve queueMicrotask
- `test-async-utilities` - Use async testing utilities for mock responses
- `test-clear-request-cache` - Clear request library caches between tests
- `test-jsdom-environment` - Use correct JSDOM environment for Jest

### 4. Response Patterns (HIGH)

- `response-http-response-helpers` - Use HttpResponse static methods
- `response-delay-realistic` - Add realistic response delays
- `response-error-simulation` - Simulate error responses correctly
- `response-one-time-handlers` - Use one-time handlers for sequential scenarios
- `response-custom-headers` - Set response headers correctly
- `response-streaming` - Mock streaming responses with ReadableStream

### 5. Request Matching (MEDIUM-HIGH)

- `match-url-patterns` - Use URL path parameters correctly
- `match-query-params` - Access query parameters from request URL
- `match-custom-predicate` - Use custom predicates for complex matching
- `match-http-methods` - Match HTTP methods explicitly
- `match-handler-order` - Order handlers from specific to general

### 6. GraphQL Mocking (MEDIUM)

- `graphql-operation-handlers` - Use operation name for GraphQL matching
- `graphql-error-responses` - Return GraphQL errors in correct format
- `graphql-batched-queries` - Handle batched GraphQL queries
- `graphql-variables-access` - Access GraphQL variables correctly

### 7. Advanced Patterns (MEDIUM)

- `advanced-bypass-requests` - Use bypass() for passthrough requests
- `advanced-cookies-auth` - Handle cookies and authentication
- `advanced-dynamic-scenarios` - Implement dynamic mock scenarios
- `advanced-vitest-browser` - Configure MSW for Vitest browser mode
- `advanced-file-uploads` - Mock file upload endpoints

### 8. Debugging & Performance (LOW)

- `debug-lifecycle-events` - Use lifecycle events for debugging
- `debug-verify-interception` - Verify request interception is working
- `debug-common-issues` - Know common MSW issues and fixes
- `debug-request-logging` - Log request details for debugging

## How to Use

Read individual reference files for detailed explanations and code examples:

- [Section definitions](references/_sections.md) - Category structure and impact levels
- [Rule template](assets/templates/_template.md) - Template for adding new rules
- Individual rules: `references/{prefix}-{slug}.md`

## Related Skills

- For generating MSW mocks from OpenAPI, see `orval` skill
- For consuming mocked APIs, see `tanstack-query` skill
- For test methodology, see `test-vitest` or `test-tdd` skills

## Full Compiled Document

For the complete guide with all rules expanded: `AGENTS.md`

© pproenca · MIT · pproenca/dot-skills

Similar skills

Everything for Testing and QA →

From the same set45

clean-architecture A skill with 42 rules from Robert C. Martin's book: it tells the agent which way dependencies should point and where layer boundaries belong. CX Codex +1 2,000installs code-simplifier A skill that gives AI agents 47 rules for cleaning up recently changed code without altering what it does. CX Codex +1 1,600installs expo-react-native-performance Performance guidelines with 42 prioritized rules for Expo React Native apps. Helps agents refactor startup bottlenecks, list virtualization, re-renders, and animations. CX Codex +1 1,500installs framer-motion Optimizes React animations using Framer Motion guidelines: slashes bundle size, eliminates unnecessary re-renders, and polishes gesture or scroll transitions. CX Codex +1 1,100installs clean-code A skill that feeds the agent 48 rules on naming, functions, errors and tests, drawn from Robert C. Martin's book with modern fixes. Useful during reviews and refactors. CX Codex +1 842installs terminal-ui A skill with 42 rules for TypeScript terminal interfaces: rendering, keyboard input, prompts. Useful when you build a CLI on Ink or Clack. CX Codex +1 836installs typescript-refactor A skill with 47 rules for refactoring TypeScript and React/TSX: type architecture, narrowing, generics, and modern TS 6.0 / React 19 features. CX Codex +1 788installs react-refactor Architectural refactoring skill with 40 rules for React codebases. Guides component decomposition, custom hook design, and module boundaries. CX Codex +1 776installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor