As iOS developers, we know how important it is to create high-quality apps that work well, are stable, and provide a great user experience. One of the most effective ways to achieve this is by implementing unit testing.

The Secret: Start with Small Units

The secret to effective unit testing is to start with small units of code. This means breaking down your app into individual units that can be tested independently. Each unit should be tested in isolation to ensure that it works as expected. By testing each unit separately, you can identify and fix issues before they impact other parts of your app.

To understand this better, let's look at an example. Consider the following function:

func calculatePrice(quantity: Int, unitPrice: Double, taxRate: Double) -> Double {
    let subtotal = Double(quantity) * unitPrice
    let taxAmount = subtotal * taxRate
    return subtotal + taxAmount
}

This function calculates the total price of a product based on its quantity, unit price, and tax rate. To unit test this function, we need to break it down into smaller units. One way to do this is by testing each calculation separately. Here's an example of how this can be done:

func testCalculatePrice() {
    // Test the subtotal calculation
    XCTAssertEqual(calculateSubtotal(quantity: 2, unitPrice: 5.99), 11.98, accuracy: 0.001)

    // Test the tax amount calculation
    XCTAssertEqual(calculateTaxAmount(subtotal: 11.98, taxRate: 0.08), 0.96, accuracy: 0.001)

    // Test the total price calculation
    XCTAssertEqual(calculatePrice(quantity: 2, unitPrice: 5.99, taxRate: 0.08), 12.94, accuracy: 0.001)
}

func calculateSubtotal(quantity: Int, unitPrice: Double) -> Double {
    return Double(quantity) * unitPrice
}

func calculateTaxAmount(subtotal: Double, taxRate: Double) -> Double {
    return subtotal * taxRate
}

func calculatePrice(quantity: Int, unitPrice: Double, taxRate: Double) -> Double {
    let subtotal = calculateSubtotal(quantity: quantity, unitPrice: unitPrice)
    let taxAmount = calculateTaxAmount(subtotal: subtotal, taxRate: taxRate)
    return subtotal + taxAmount
}

In this example, we've broken down the calculatePrice function into three smaller units: calculateSubtotal, calculateTaxAmount, and calculatePrice itself. We can now test each of these units independently to ensure that they work as expected.

By breaking down your app into smaller units like this, you can test each unit independently and identify issues early on. This makes it easier to fix problems before they become bigger issues that impact your entire app.

Code Samples

To help you get started with unit testing in iOS, here are some code samples that demonstrate how to test various components of your app.

1. Testing a View Controller

class MyViewControllerTests: XCTestCase {
    var sut: MyViewController!

    override func setUp() {
        super.setUp()
        let storyboard = UIStoryboard(name: "Main", bundle: nil)
        sut = storyboard.instantiateViewController(withIdentifier: "MyViewController") as? MyViewController
        sut.loadViewIfNeeded()
    }

    func testMyButtonTapped() {
        sut.myButton.sendActions(for: .touchUpInside)
        XCTAssertTrue(sut.label.text == "Button tapped")
    }
}

In this example, we're testing a view controller that has a button and a label. We're verifying that when the button is tapped, the label text changes to "Button tapped". We're using the sendActions(for:) method to simulate a button tap and then checking the label's text property to ensure that it has been updated correctly.

2. Testing a Networking Layer

class NetworkServiceTests: XCTestCase {
    var sut: NetworkService!

    override func setUp() {
        super.setUp()
        sut = NetworkService()
    }

    func testFetchData() {
        let expectation = self.expectation(description: "Data fetch should succeed")

        sut.fetchData { result in
            switch result {
            case .success(let data):
                XCTAssertNotNil(data)
                expectation.fulfill()
            case .failure(_):
                XCTFail("Data fetch should not fail")
            }
        }

        waitForExpectations(timeout: 5, handler: nil)
    }
}

In this example, we're testing a networking layer that has a fetchData method. We're verifying that the method returns data successfully by using expectations. We're expecting the completion handler to be called with a success result that contains data. If the completion handler is called with a failure result, the test will fail.

3. Testing a Model Object

class ProductTests: XCTestCase {
    var sut: Product!

    override func setUp() {
        super.setUp()
        sut = Product(name: "iPhone", price: 999.99)
    }

    func testProductName() {
        XCTAssertEqual(sut.name, "iPhone")
    }

    func testProductPrice() {
        XCTAssertEqual(sut.price, 999.99, accuracy: 0.001)
    }
}

In this example, we're testing a model object that represents a product. We're verifying that the object's properties (name and price) have been set correctly. We're using the XCTAssertEqual method to compare the expected values with the actual values.

Conclusion

In conclusion, the one secret every successful iOS developer knows about unit testing is to start with small units of code. By breaking down your app into smaller units and testing each unit independently, you can identify and fix issues early on.

This makes it easier to create high-quality apps that work well, are stable, and provide a great user experience. Use the code samples provided in this post to get started with unit testing in iOS and take your app development to the next level.

I hope you enjoyed this article, and if you have any questions, comments, or feedback, then feel free to comment here or reach out via Twitter.

Thanks for reading!