Mocking Dependencies with Jest in TDD

In our journey through isolating dependencies with test doubles, we've explored dummies, stubs, and spies. This lesson focuses on mocks, which are powerful test doubles capable of simulating external dependencies in software tests. You may have noticed in the previous unit how spying on the real implementation can be messy (in the form of many console logs). Mocks can imitate the behavior of complex systems, allowing us to test code in isolation without relying on the real and sometimes unpredictable systems like databases or web services.

Now, let's review the TDD workflow:

• Red: Write a failing test.
• Green: Write the minimum code to pass the test.
• Refactor: Improve the code structure without changing its behavior.

We'll demonstrate these principles using mocks, helping you to effectively isolate and test your application logic.

Mocks are indispensable in TDD because they allow you to test your code independently of the parts of the system you don't control. For instance, when writing tests for a PricingService, you don't want tests to fail because an external currency conversion API goes down or changes unexpectedly. Mocks provide a controlled environment where you can simulate various conditions and responses as well as validate the calls.

Mocks, unlike spies, fully simulate the dependencies rather than simply observing their behavior. A mock creates a controlled substitute for a dependency, so the actual code or functionality isn’t executed. For instance, if a function interacts with an external API, a mock can simulate different responses from that API without making a network request.

Let's dive into mocking with Jest. We'll start with the basics: how to mock a module and its functions.

Consider the ExchangeRateService, which fetches exchange rates from an API. In testing the PricingService, we need to mock this service to ensure our tests don't rely on actual API responses.

Here's a simple way to mock with Jest:

// In pricing-service.test.ts
import { PricingService } from '../src/pricing-service';
import { ExchangeRateService } from '../src/exchange-rate-service';

// Mock the entire ExchangeRateService using Jest
jest.mock('../src/exchange-rate-service');

describe('PricingService', () => {
    let pricingService: PricingService;
    let mockExchangeRateService: jest.Mocked<ExchangeRateService>;

    beforeEach(() => {
        // Arrange
        jest.clearAllMocks();
        mockExchangeRateService = new ExchangeRateService() as jest.Mocked<ExchangeRateService>;
        pricingService = new PricingService(mockExchangeRateService);
    });

    it('should convert prices using exchange rate', async () => {
        // Arrange
        mockExchangeRateService.getRate = jest.fn().mockResolvedValue(1.5);
        
        // Act
        const result = await pricingService.convertPrice(100, 'USD', 'EUR');
        
        // Assert
        expect(mockExchangeRateService.getRate).toHaveBeenCalledWith('USD', 'EUR');
        expect(result).toBe(150.00);
    });
});

In this setup:

• We use jest.mock() to replace the ExchangeRateService with a mock version.
• mockExchangeRateService.getRate is transformed into a function that we can program to return controlled values using jest.fn().mockResolvedValue(1.5).

When using jest.mock('../src/exchange-rate-service'), Jest replaces all functions in ExchangeRateService with mocked versions. These versions do not contain any real logic but allow control over returned values and behavior. By typing mockExchangeRateService as jest.Mocked<ExchangeRateService>, we ensure Jest recognizes it as a mock with access to Jest’s mock methods. This typing is essential because it clarifies to TypeScript that our dependency has been mocked and includes methods like mockResolvedValue.