Mocking Dependencies in Swift: An Introduction to Unit Testing

By /

Mocking Dependencies in Swift: An Introduction to Unit Testing

Unit testing is an essential part of any software development process. It is the process of validating that a piece of code works as expected by writing tests against it. Writing tests can be especially challenging when the code you’re testing depends on other components, such as a database or a web service. In this article, we’ll take a look at how to mock dependencies in Swift and learn the basics of unit testing.

The first step in unit testing is to create a testable version of the code you want to test. This involves isolating the code from its dependencies, so that you can test it in a controlled environment. In Swift, this is done by using dependency injection. Dependency injection is a technique for providing a component with its dependencies. Instead of the component creating its own dependencies, they are passed in as parameters. This makes it easy to replace the dependencies with mock objects when writing tests.

To illustrate this, let’s look at a simple example. Suppose we have a class called `UserService` that fetches user data from a web service. The `UserService` class has two dependencies: a `NetworkManager` and a `UserParser`. The `NetworkManager` is responsible for making network requests, while the `UserParser` parses the response data into a `User` object. 

class UserService {
    private let networkManager: NetworkManager
    private let userParser: UserParser

    init(networkManager: NetworkManager, userParser: UserParser) {
        self.networkManager = networkManager
        self.userParser = userParser
    }

    func fetchUserData(completion: (Result<User, Error>) -> Void) {
        networkManager.makeRequest { (data, error) in
            guard let data = data else {
                completion(.failure(error!))
                return
            }

            do {
                let user = try self.userParser.parse(data: data)
                completion(.success(user))
            } catch {
                completion(.failure(error))
            }
        }
    }
}

In order to unit test the `UserService`, we need to mock its dependencies. To do this, we can use a mocking library like MockFive. MockFive allows us to create mock objects that we can use in place of the real objects when running our tests.

For example, we can create a mock `NetworkManager` that returns a pre-defined response when its `makeRequest` method is called. This allows us to control the input to the `UserService` and verify that it produces the expected output.

import MockFive

class MockNetworkManager: NetworkManager, Mock {
    let mock = MockFive()

    func makeRequest(completion: (Data?, Error?) -> Void) {
        mock.call(completion)
    }

    func stubMakeRequest(data: Data?, error: Error?, callMatcher: CallMatcher = CallMatcher(), file: StaticString = #file, line: UInt = #line) {
        mock.stub(makeRequest, data, error, callMatcher, file, line)
    }
}

We can also create a mock `UserParser` that returns a pre-defined `User` object when its `parse` method is called. This allows us to verify that the `UserService` is parsing the response data correctly.

class MockUserParser: UserParser, Mock {
    let mock = MockFive()

    func parse(data: Data) throws -> User {
        return try mock.callThrows(data)
    }

    func stubParse(user: User, callMatcher: CallMatcher = CallMatcher(), file: StaticString = #file, line: UInt = #line) {
        mock.stub(parse, user, callMatcher, file, line)
    }
}

Now that we have mock versions of the `NetworkManager` and `UserParser`, we can use them in our tests. We can create a `UserService` with the mock objects, call its `fetchUserData` method, and verify that it produces the expected result. 

import XCTest

class UserServiceTests: XCTestCase {
    func testFetchUserData() {
        // Create mocks
        let networkManager = MockNetworkManager()
        let userParser = MockUserParser()

        // Stub the mocks
        let user = User(name: "John Doe")
        userParser.stubParse(user: user)
        networkManager.stubMakeRequest(data: nil, error: nil)

        // Create the UserService with the mocks
        let userService = UserService(networkManager: networkManager, userParser: userParser)

        // Call fetchUserData and verify the result
        let expectation = XCTestExpectation(description: "User data fetched successfully")
        userService.fetchUserData { result in
            switch result {
            case .success(let user):
                XCTAssertEqual(user.name, "John Doe")
                expectation.fulfill()
            case .failure(_):
                XCTFail("Expected successful result")
            }
        }
        wait(for: [expectation], timeout: 1.0)
    }
}

By mocking the dependencies of the `UserService`, we can easily write unit tests to verify that it works as expected. Mocking is an essential part of unit testing, and it allows us to test our code in a controlled environment.

In this article, we looked at how to mock dependencies in Swift and learned the basics of unit testing. We saw how to use dependency injection to isolate our code from its dependencies, and how to use a mocking library like MockFive to create mock objects that we can use in our tests. By following these steps, we can easily write unit tests to verify that our code works as expected.

Scroll to Top