iOS Testing Expert

Comprehensive testing patterns for iOS apps.

Testing Pyramid for iOS

 /\        E2E (XCUITest) - 10%
/  \       UI Tests, full flows

/----
/ \ Integration - 20% / \ ViewModels + Services /----------
/ \ Unit - 70% \ Models, Utils, Pure Logic

XCTest Basics

Unit Test

import XCTest @testable import App

final class UserTests: XCTestCase {

func testUserFullName() {
    let user = User(firstName: "John", lastName: "Doe")
    XCTAssertEqual(user.fullName, "John Doe")
}

func testUserValidation() throws {
    let user = User(email: "invalid")
    XCTAssertThrowsError(try user.validate())
}

}

Async Testing

func testAsyncFetch() async throws { let service = UserService() let user = try await service.fetch(id: "123") XCTAssertEqual(user.id, "123") }

// Or with expectations func testAsyncWithExpectation() { let expectation = expectation(description: "fetch")

service.fetch(id: "123") { result in
    XCTAssertNotNil(result)
    expectation.fulfill()
}

wait(for: [expectation], timeout: 5)

}

XCUITest (UI Tests)

Basic UI Test

import XCUITest

final class LoginUITests: XCTestCase { let app = XCUIApplication()

override func setUpWithError() throws {
    continueAfterFailure = false
    app.launch()
}

func testLogin() throws {
    app.textFields["email"].tap()
    app.textFields["email"].typeText("test@example.com")

    app.secureTextFields["password"].tap()
    app.secureTextFields["password"].typeText("password123")

    app.buttons["Login"].tap()

    XCTAssertTrue(app.staticTexts["Welcome"].waitForExistence(timeout: 5))
}

}

Accessibility Identifiers

// In your SwiftUI View TextField("Email", text: $email) .accessibilityIdentifier("email")

// In UI Test app.textFields["email"].tap()

Quick/Nimble (BDD Style)

Setup

// Package.swift .package(url: "https://github.com/Quick/Quick.git", from: "7.0.0"), .package(url: "https://github.com/Quick/Nimble.git", from: "13.0.0"),

BDD Test

import Quick import Nimble @testable import App

final class UserSpec: QuickSpec { override class func spec() { describe("User") { var user: User!

        beforeEach {
            user = User(firstName: "John", lastName: "Doe")
        }

        context("when valid") {
            it("has a full name") {
                expect(user.fullName).to(equal("John Doe"))
            }

            it("can be validated") {
                expect { try user.validate() }.toNot(throwError())
            }
        }

        context("when email is invalid") {
            beforeEach {
                user.email = "invalid"
            }

            it("throws validation error") {
                expect { try user.validate() }.to(throwError())
            }
        }
    }
}

}

Mocking with Protocols

Protocol-Based DI

protocol UserServiceProtocol { func fetch(id: String) async throws -> User }

// Real implementation class UserService: UserServiceProtocol { func fetch(id: String) async throws -> User { // Network call } }

// Mock for testing class MockUserService: UserServiceProtocol { var mockUser: User? var shouldFail = false

func fetch(id: String) async throws -> User {
    if shouldFail { throw APIError.failed }
    return mockUser ?? User(id: id)
}

}

Testing with Mock

func testViewModelLoadsUser() async { let mockService = MockUserService() mockService.mockUser = User(id: "1", name: "Test")

let viewModel = UserViewModel(service: mockService)
await viewModel.load()

XCTAssertEqual(viewModel.user?.name, "Test")

}

Snapshot Testing

swift-snapshot-testing

import SnapshotTesting import SwiftUI

func testUserProfileView() { let view = UserProfileView(user: .mock)

assertSnapshot(
    of: view,
    as: .image(layout: .device(config: .iPhone13))
)

}

Test Coverage

Enable Coverage

xcodebuild test
-scheme App
-enableCodeCoverage YES
-resultBundlePath TestResults.xcresult

View Report

xcrun xccov view --report TestResults.xcresult

Use when: Writing iOS tests, setting up testing infrastructure, mocking