Test Doubles Generator
Overview
Generate mocks, stubs, spies, and fakes to isolate units under test from external dependencies. Supports Jest mocks, Sinon.js stubs, Python unittest.mock, Go interfaces, and testdouble.js patterns.
Prerequisites
- Testing framework installed (Jest, Vitest, Mocha, pytest, JUnit 5, or Go testing)
- Mocking library available (Sinon.js, testdouble.js, unittest.mock, Mockito, or gomock)
- TypeScript
strict mode enabled for type-safe mocks (if applicable)
- Source code with clear interface or class boundaries for dependency injection
Instructions
- Scan the codebase with Glob and Grep to identify modules with external dependencies (database clients, HTTP clients, file system access, third-party SDKs).
- Read each module under test and catalog its dependency interfaces -- list every method signature, return type, and side effect.
- Determine the appropriate test double type for each dependency:
- Stub: Returns canned data, no behavior verification (use for database queries returning fixed datasets).
- Mock: Verifies interactions -- call count, argument matching, call order (use for email senders, event emitters).
- Spy: Wraps real implementation while recording calls (use when partial behavior is needed).
- Fake: Lightweight working implementation (use for in-memory repositories replacing real databases).
- Generate test double files following the project's existing test directory structure (e.g.,
__mocks__/, test/doubles/, testutil/).
- For each test double, implement:
- Factory function or class matching the dependency interface exactly.
- Configurable return values via builder pattern or method chaining.
- Call recording for assertion (arguments, call count, call order).
- Reset/restore mechanism for cleanup between tests.
- Wire test doubles into existing test files using the framework's dependency injection pattern (
jest.mock(), @patch, constructor injection, or Go interface substitution).
- Validate all test doubles compile and pass type checks by running
tsc --noEmit or equivalent.
Output
- Test double source files (one per dependency) placed in the project's mock directory
- Factory functions with TypeScript generics or equivalent type safety
- Jest
__mocks__ auto-mock modules where applicable
- Updated test files wired to use generated doubles instead of real dependencies
- Summary listing each double, its type (mock/stub/spy/fake), and the interface it replaces
Error Handling
| Error |
Cause |
Solution |
TypeError: X is not a function |
Mock missing a method from the real interface |
Regenerate the double from the current interface definition; add the missing method |
| Mock leaking between tests |
Shared mock state not reset in afterEach |
Add jest.restoreAllMocks() or sinon.restore() in teardown hooks |
| Type mismatch on mock return value |
Return type does not match interface contract |
Use as ReturnType<typeof fn> or update the mock factory to return the correct type |
| Spy not recording calls |
Spy created after the function was already bound |
Create spies before the module under test imports the dependency |
| Over-mocking hides real bugs |
Too many layers replaced with fakes |
Limit mocks to true external boundaries (I/O, network); let pure logic run unmocked |
Examples
Jest mock factory for a UserRepository:
// __mocks__/userRepository.ts
export const createMockUserRepo = () => ({
findById: jest.fn().mockResolvedValue({ id: '1', name: 'Test User' }),
save: jest.fn().mockResolvedValue(undefined),
delete: jest.fn().mockResolvedValue(true),
});
Python unittest.mock patch for an HTTP client:
from unittest.mock import patch, MagicMock
@patch('myapp.client.requests.get')
def test_fetch_data(mock_get):
mock_get.return_value = MagicMock(status_code=200, json=lambda: {"key": "value"}) # HTTP 200 OK
result = fetch_data("https://api.example.com/data")
assert result == {"key": "value"}
mock_get.assert_called_once()
Go interface-based fake:
type FakeStore struct {
data map[string]string
}
func (f *FakeStore) Get(key string) (string, error) {
v, ok := f.data[key]
if !ok { return "", ErrNotFound }
return v, nil
}
Resources
1---2name: generating-test-doubles3description: Generate mocks, stubs, spies, and fakes for dependency isolation. Use when creating mocks, stubs, or test isolation fixtures. Trigger with phrases like "generate mocks", "create test doubles", or "setup stubs".4license: MIT5---6# Test Doubles Generator
7
8## Overview
9
10Generate mocks, stubs, spies, and fakes to isolate units under test from external dependencies. Supports Jest mocks, Sinon.js stubs, Python unittest.mock, Go interfaces, and testdouble.js patterns.
11
12## Prerequisites
13
14- Testing framework installed (Jest, Vitest, Mocha, pytest, JUnit 5, or Go testing)
15- Mocking library available (Sinon.js, testdouble.js, unittest.mock, Mockito, or gomock)
16- TypeScript `strict` mode enabled for type-safe mocks (if applicable)
17- Source code with clear interface or class boundaries for dependency injection
18
19## Instructions
20
211. Scan the codebase with Glob and Grep to identify modules with external dependencies (database clients, HTTP clients, file system access, third-party SDKs).
222. Read each module under test and catalog its dependency interfaces -- list every method signature, return type, and side effect.
233. Determine the appropriate test double type for each dependency:
24 - **Stub**: Returns canned data, no behavior verification (use for database queries returning fixed datasets).
25 - **Mock**: Verifies interactions -- call count, argument matching, call order (use for email senders, event emitters).
26 - **Spy**: Wraps real implementation while recording calls (use when partial behavior is needed).
27 - **Fake**: Lightweight working implementation (use for in-memory repositories replacing real databases).
284. Generate test double files following the project's existing test directory structure (e.g., `__mocks__/`, `test/doubles/`, `testutil/`).
295. For each test double, implement:
30 - Factory function or class matching the dependency interface exactly.
31 - Configurable return values via builder pattern or method chaining.
32 - Call recording for assertion (arguments, call count, call order).
33 - Reset/restore mechanism for cleanup between tests.
346. Wire test doubles into existing test files using the framework's dependency injection pattern (`jest.mock()`, `@patch`, constructor injection, or Go interface substitution).
357. Validate all test doubles compile and pass type checks by running `tsc --noEmit` or equivalent.
36
37## Output
38
39- Test double source files (one per dependency) placed in the project's mock directory
40- Factory functions with TypeScript generics or equivalent type safety
41- Jest `__mocks__` auto-mock modules where applicable
42- Updated test files wired to use generated doubles instead of real dependencies
43- Summary listing each double, its type (mock/stub/spy/fake), and the interface it replaces
44
45## Error Handling
46
47| Error | Cause | Solution |
48|-------|-------|---------|
49| `TypeError: X is not a function` | Mock missing a method from the real interface | Regenerate the double from the current interface definition; add the missing method |
50| Mock leaking between tests | Shared mock state not reset in `afterEach` | Add `jest.restoreAllMocks()` or `sinon.restore()` in teardown hooks |
51| Type mismatch on mock return value | Return type does not match interface contract | Use `as ReturnType<typeof fn>` or update the mock factory to return the correct type |
52| Spy not recording calls | Spy created after the function was already bound | Create spies before the module under test imports the dependency |
53| Over-mocking hides real bugs | Too many layers replaced with fakes | Limit mocks to true external boundaries (I/O, network); let pure logic run unmocked |
54
55## Examples
56
57**Jest mock factory for a UserRepository:**
58
59```typescript
60// __mocks__/userRepository.ts
61export const createMockUserRepo = () => ({
62 findById: jest.fn().mockResolvedValue({ id: '1', name: 'Test User' }),
63 save: jest.fn().mockResolvedValue(undefined),
64 delete: jest.fn().mockResolvedValue(true),
65});
66```
67
68**Python unittest.mock patch for an HTTP client:**
69
70```python
71from unittest.mock import patch, MagicMock
72
73@patch('myapp.client.requests.get')
74def test_fetch_data(mock_get):
75 mock_get.return_value = MagicMock(status_code=200, json=lambda: {"key": "value"}) # HTTP 200 OK
76 result = fetch_data("https://api.example.com/data")
77 assert result == {"key": "value"}
78 mock_get.assert_called_once()
79```
80
81**Go interface-based fake:**
82
83```go
84type FakeStore struct {
85 data map[string]string
86}
87func (f *FakeStore) Get(key string) (string, error) {
88 v, ok := f.data[key]
89 if !ok { return "", ErrNotFound }
90 return v, nil
91}
92```
93
94## Resources
95
96- Jest Manual Mocks: https://jestjs.io/docs/manual-mocks
97- Sinon.js Stubs, Mocks, Spies: https://sinonjs.org/
98- Python unittest.mock: https://docs.python.org/3/library/unittest.mock.html
99- Mockito (Java): https://site.mockito.org/
100- gomock (Go): https://github.com/uber-go/mock
101- Martin Fowler, "Mocks Aren't Stubs": https://martinfowler.com/articles/mocksArentStubs.html
gabrielmoreira