Implementing Mocks in Test-Driven Development with Swift and XCTest

In our journey through isolating dependencies with test doubles, we've explored dummies, stubs, and spies. This lesson focuses on mocks, a powerful type of test double used in Swift to simulate external dependencies in software tests. You may have noticed in the previous unit how spying on the real implementation can become cumbersome. Mocks can imitate the behavior of complex systems, allowing us to test code in isolation without relying on real, 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 example, when writing tests for a PricingService, you don't want the tests to fail due to external issues like a currency conversion API being down. Mocks provide a controlled environment where you can simulate various conditions and responses, as well as validate the calls.

Mocks differ from spies in that they fully simulate dependencies rather than just observing behavior. A mock creates a controlled substitute for a dependency, ensuring that 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 XCTest. We'll start with the basics: how to mock a class and its methods in Swift.

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 XCTest:

import XCTest

protocol ExchangeRateServiceProtocol {
    func getRate(fromCurrency: String, toCurrency: String) -> Double
}

class MockExchangeRateService: ExchangeRateServiceProtocol {
    var getRateCalled = false
    var returnValue: Double = 1.0

    func getRate(fromCurrency: String, toCurrency: String) -> Double {
        getRateCalled = true
        return returnValue
    }
}

class PricingService {
    private let exchangeRateService: ExchangeRateServiceProtocol

    init(exchangeRateService: ExchangeRateServiceProtocol) {
        self.exchangeRateService = exchangeRateService
    }

    func convertPrice(amount: Double, fromCurrency: String, toCurrency: String) -> Double {
        let rate = exchangeRateService.getRate(fromCurrency: fromCurrency, toCurrency: toCurrency)
        return amount * rate
    }
}

class PricingServiceTests: XCTestCase {
    func testConvertPricesUsingExchangeRate() {
        // Arrange
        let mockExchangeRateService = MockExchangeRateService()
        mockExchangeRateService.returnValue = 1.5
        let pricingService = PricingService(exchangeRateService: mockExchangeRateService)

        // Act
        let result = pricingService.convertPrice(amount: 100.0, fromCurrency: "USD", toCurrency: "EUR")

        // Assert
        XCTAssertTrue(mockExchangeRateService.getRateCalled)
        XCTAssertEqual(result, 150.0)
    }
}

In this setup:

• We define a protocol ExchangeRateServiceProtocol and a mock class MockExchangeRateService that conforms to it.
• The mock class allows us to control the return value and verify that the method was called.