iOS Testing Suite Generator

Generate comprehensive, maintainable test suites for iOS applications following testing pyramid best practices.

Core Testing Principles

Testing Pyramid Distribution

• Unit Tests: 70% (fast, isolated, focused)
• Integration Tests: 20% (component interactions)
• UI Tests: 10% (critical user flows)

Test Quality Standards

• Fast: Unit tests < 100ms, Integration < 1s, UI < 5s
• Isolated: No shared state between tests
• Repeatable: Same result every time
• Descriptive naming: test_[unitOfWork]_[scenario]_[expectedBehavior]

Coverage Thresholds

• ViewModels: 90%+
• Services: 85%+
• Business Logic: 95%+
• Views: 60-70%
• Overall: 80%+

Quick Start

Generate tests based on component type:

Generate unit tests for my TipCalculator class

Create UI tests for the login flow using screen objects

Generate snapshot tests for ProductCard view across devices

Test Generation by Component Type

1. SwiftUI Views

Generate snapshot tests, state tests, interaction tests, and accessibility tests.

Pattern:

func test_view_initialState_matchesSnapshot() throws {
    let view = ContentView(viewModel: .mock())
    assertSnapshot(matching: view, as: .image(layout: .device(config: .iPhone13)))
}

func test_view_whenButtonTapped_callsViewModel() throws {
    let viewModel = ContentViewModelSpy()
    let view = ContentView(viewModel: viewModel)
    try view.inspect().find(button: "Refresh").tap()
    XCTAssertTrue(viewModel.refreshCalled)
}

Script: Use scripts/generate_view_tests.py for batch generation

2. ViewModels (MVVM)

Generate comprehensive tests for state management, data loading, user actions, and validation.

Pattern:

func test_loadData_success_updatesItems() async {
    // Given
    mockService.itemsToReturn = [Item.mock(), Item.mock()]
    
    // When
    await sut.loadData()
    
    // Then
    XCTAssertEqual(sut.items.count, 2)
    XCTAssertFalse(sut.isLoading)
    XCTAssertNil(sut.error)
}

3. Business Logic / Services

Generate calculation tests, validation tests, and edge case coverage.

Pattern:

func test_calculateTip_withValidAmount_returnsCorrectTip() {
    let result = sut.calculateTip(amount: 100.0, percentage: 0.15)
    XCTAssertEqual(result, 15.0, accuracy: 0.01)
}

4. Network Layer

Generate request building, response handling, error handling, and retry logic tests.

Pattern:

func test_fetch_withValidResponse_decodesData() async throws {
    mockSession.data = try JSONEncoder().encode(User.mock())
    mockSession.response = HTTPURLResponse(statusCode: 200)
    
    let result: User = try await sut.fetch(.getUser(id: 123))
    XCTAssertEqual(result.id, expectedUser.id)
}

5. Data Persistence

Generate CRUD operation tests with in-memory CoreData store.

Pattern:

func test_createItem_savesSuccessfully() throws {
    let item = try sut.createItem(name: "Test Item")
    XCTAssertNotNil(item)
    XCTAssertFalse(item.objectID.isTemporaryID)
}

Test Doubles Library

Mocks (Predefined Behavior)

final class MockDataService: DataServiceProtocol {
    var itemsToReturn: [Item] = []
    var errorToThrow: Error?
    
    func fetchItems() async throws -> [Item] {
        if let error = errorToThrow { throw error }
        return itemsToReturn
    }
}

Spies (Call Verification)

final class DataServiceSpy: DataServiceProtocol {
    var fetchItemsCalled = false
    var fetchItemsCallCount = 0
    var capturedItems: [Item] = []
}

Stubs (Minimal Implementation)

final class StubURLSession: URLSessionProtocol {
    var data: Data?
    var response: URLResponse?
    var error: Error?
}

Script: Use scripts/generate_test_doubles.py to create mocks/spies/stubs

Mock Data Factories

Generate reusable test data with sensible defaults:

extension User {
    static func mock(
        id: UUID = UUID(),
        name: String = "Test User",
        email: String = "test@example.com"
    ) -> User {
        User(id: id, name: name, email: email)
    }
}

Script: Use scripts/generate_mock_factories.py

UI Testing with Screen Objects

Generate page object pattern for maintainable UI tests:

class LoginScreen {
    let app: XCUIApplication
    
    var emailTextField: XCUIElement { app.textFields["email-field"] }
    var loginButton: XCUIElement { app.buttons["login-button"] }
    
    func login(email: String, password: String) {
        emailTextField.tap()
        emailTextField.typeText(email)
        // ...
        loginButton.tap()
    }
}

Script: Use scripts/generate_screen_objects.py

Snapshot Testing

Generate snapshot tests across devices and states:

func test_productCard_allStates() {
    let states: [(name: String, product: Product)] = [
        ("available", .mock(stock: 10)),
        ("out-of-stock", .mock(stock: 0)),
        ("on-sale", .mock(onSale: true))
    ]
    
    for (name, product) in states {
        assertSnapshot(matching: ProductCard(product: product),
                      as: .image(layout: .device(config: .iPhone13)),
                      named: name)
    }
}

Performance Testing

Generate performance benchmarks:

func test_sortLargeDataSet_performance() {
    let items = (0..<10000).map { _ in Item.mock() }
    measure {
        let _ = items.sorted { $0.price < $1.price }
    }
}

Accessibility Testing

Generate VoiceOver, Dynamic Type, and keyboard navigation tests:

func test_allInteractiveElements_haveAccessibilityLabels() {
    let buttons = app.buttons.allElementsBoundByIndex
    for button in buttons {
        XCTAssertFalse(button.label.isEmpty, "Button missing accessibility label")
    }
}

Integration Testing

Generate end-to-end flow tests:

func test_completeCheckout_fromCartToConfirmation() async throws {
    // Given: Items in cart
    try await cartService.addItem(Item.mock(price: 29.99))
    
    // When: Process payment
    let paymentResult = try await paymentService.processPayment(...)
    let order = try await orderService.createOrder(...)
    
    // Then: Verify order created and cart cleared
    XCTAssertEqual(order.status, .confirmed)
    let clearedCart = try await cartService.getCart()
    XCTAssertTrue(clearedCart.items.isEmpty)
}

Test Organization Structure

YourAppTests/
├── UnitTests/
│   ├── ViewModels/
│   ├── Services/
│   ├── BusinessLogic/
│   └── Models/
├── IntegrationTests/
├── SnapshotTests/
│   └── __Snapshots__/
├── PerformanceTests/
├── Helpers/
│   ├── Mocks/
│   └── Builders/
└── UITests/
    └── ScreenObjects/

Workflow

1. Analyze: Identify components needing tests and existing coverage
2. Generate: Create unit, integration, and UI tests with appropriate scripts
3. Create Infrastructure: Generate mocks, factories, and helpers
4. Validate: Ensure tests pass and meet coverage thresholds
5. Document: Provide coverage report and maintenance guide

Common Testing Patterns

Combine Publishers

func test_publisher_emitsExpectedValues() {
    var values: [String] = []
    let expectation = expectation(description: "Publisher")
    
    viewModel.$text
        .dropFirst()
        .sink { values.append($0); expectation.fulfill() }
        .store(in: &cancellables)
    
    wait(for: [expectation], timeout: 1.0)
    XCTAssertEqual(values, ["First", "Second"])
}

Async/Await

func test_asyncFunction_throwsError() async {
    do {
        try await sut.fetchData()
        XCTFail("Expected error")
    } catch {
        XCTAssertEqual(error as? DataError, .networkFailure)
    }
}

Memory Management

func test_closure_doesNotCauseCycle() {
    weak var weakViewModel: ContentViewModel?
    autoreleasepool {
        let viewModel = ContentViewModel()
        weakViewModel = viewModel
        viewModel.onComplete = { [weak viewModel] in
            viewModel?.handleCompletion()
        }
    }
    XCTAssertNil(weakViewModel)
}

Best Practices

• Tests are independent (no shared state)
• Descriptive names following convention
• Each test verifies one behavior
• Use Arrange-Act-Assert pattern
• Mock external dependencies
• No hardcoded values
• Tests run quickly
• Update tests with code changes
• Fix flaky tests immediately

Output Format

When generating tests, provide:

1. Summary: Overview of generated test suite
2. Test Files: Complete implementations
3. Test Doubles: Required mocks/spies/stubs
4. Test Data: Factories and builders
5. Coverage Report: Expected coverage by component
6. Setup Instructions: How to run tests
7. Maintenance Notes: How to keep tests updated

References

For detailed patterns and examples, see:

• references/testing-patterns.md - Comprehensive pattern library
• references/test-doubles-guide.md - Mock/Spy/Stub implementations
• references/snapshot-testing-guide.md - Visual regression testing