1---
2title: Mock External Services in Tests
3impact: HIGH
4impactDescription: Ensures fast, reliable, deterministic tests
5tags: testing, mocking, external-services, jest
6---
7 
8## Mock External Services in Tests
9 
10Never call real external services (APIs, databases, message queues) in unit tests. Mock them to ensure tests are fast, deterministic, and don't incur costs. Use realistic mock data and test edge cases like timeouts and errors.
11 
12**Incorrect (calling real APIs and databases):**
13 
14```typescript
15// Call real APIs in tests
16describe('PaymentService', () => {
17  it('should process payment', async () => {
18    const service = new PaymentService(new StripeClient(realApiKey));
19    // Hits real Stripe API!
20    const result = await service.charge('tok_visa', 1000);
21    // Slow, costs money, flaky
22  });
23});
24 
25// Use real database
26describe('UsersService', () => {
27  beforeEach(async () => {
28    await connection.query('DELETE FROM users'); // Modifies real DB
29  });
30 
31  it('should create user', async () => {
32    const user = await service.create({ email: '[email protected]' });
33    // Side effects on shared database
34  });
35});
36 
37// Incomplete mocks
38const mockHttpService = {
39  get: jest.fn().mockResolvedValue({ data: {} }),
40  // Missing error scenarios, missing other methods
41};
42```
43 
44**Correct (mock all external dependencies):**
45 
46```typescript
47// Mock HTTP service properly
48describe('WeatherService', () => {
49  let service: WeatherService;
50  let httpService: jest.Mocked<HttpService>;
51 
52  beforeEach(async () => {
53    const module = await Test.createTestingModule({
54      providers: [
55        WeatherService,
56        {
57          provide: HttpService,
58          useValue: {
59            get: jest.fn(),
60            post: jest.fn(),
61          },
62        },
63      ],
64    }).compile();
65 
66    service = module.get(WeatherService);
67    httpService = module.get(HttpService);
68  });
69 
70  it('should return weather data', async () => {
71    const mockResponse = {
72      data: { temperature: 72, humidity: 45 },
73      status: 200,
74      statusText: 'OK',
75      headers: {},
76      config: {},
77    };
78 
79    httpService.get.mockReturnValue(of(mockResponse));
80 
81    const result = await service.getWeather('NYC');
82 
83    expect(result).toEqual({ temperature: 72, humidity: 45 });
84  });
85 
86  it('should handle API timeout', async () => {
87    httpService.get.mockReturnValue(
88      throwError(() => new Error('ETIMEDOUT')),
89    );
90 
91    await expect(service.getWeather('NYC')).rejects.toThrow('Weather service unavailable');
92  });
93 
94  it('should handle rate limiting', async () => {
95    httpService.get.mockReturnValue(
96      throwError(() => ({
97        response: { status: 429, data: { message: 'Rate limited' } },
98      })),
99    );
100 
101    await expect(service.getWeather('NYC')).rejects.toThrow(TooManyRequestsException);
102  });
103});
104 
105// Mock repository instead of database
106describe('UsersService', () => {
107  let service: UsersService;
108  let repo: jest.Mocked<Repository<User>>;
109 
110  beforeEach(async () => {
111    const mockRepo = {
112      find: jest.fn(),
113      findOne: jest.fn(),
114      save: jest.fn(),
115      delete: jest.fn(),
116      createQueryBuilder: jest.fn(),
117    };
118 
119    const module = await Test.createTestingModule({
120      providers: [
121        UsersService,
122        { provide: getRepositoryToken(User), useValue: mockRepo },
123      ],
124    }).compile();
125 
126    service = module.get(UsersService);
127    repo = module.get(getRepositoryToken(User));
128  });
129 
130  it('should find user by id', async () => {
131    const mockUser = { id: '1', name: 'John', email: '[email protected]' };
132    repo.findOne.mockResolvedValue(mockUser);
133 
134    const result = await service.findById('1');
135 
136    expect(result).toEqual(mockUser);
137    expect(repo.findOne).toHaveBeenCalledWith({ where: { id: '1' } });
138  });
139});
140 
141// Create mock factory for complex SDKs
142function createMockStripe(): jest.Mocked<Stripe> {
143  return {
144    paymentIntents: {
145      create: jest.fn(),
146      retrieve: jest.fn(),
147      confirm: jest.fn(),
148      cancel: jest.fn(),
149    },
150    customers: {
151      create: jest.fn(),
152      retrieve: jest.fn(),
153    },
154  } as any;
155}
156 
157// Mock time for time-dependent tests
158describe('TokenService', () => {
159  beforeEach(() => {
160    jest.useFakeTimers();
161    jest.setSystemTime(new Date('2024-01-15'));
162  });
163 
164  afterEach(() => {
165    jest.useRealTimers();
166  });
167 
168  it('should expire token after 1 hour', async () => {
169    const token = await service.createToken();
170 
171    // Fast-forward time
172    jest.advanceTimersByTime(61 * 60 * 1000);
173 
174    expect(await service.isValid(token)).toBe(false);
175  });
176});
177```
178 
179Reference: [Jest Mocking](https://jestjs.io/docs/mock-functions)
180