generators-test-generator

name	generators-test-generator
description	Generate test file boilerplate for unit tests, integration tests, and UI tests. Use when user asks to "add tests" or "write tests" for existing code. For TDD workflows, use testing-tdd-feature or testing-tdd-bug-fix. For Swift Testing API reference, use swift-testing.

First step: Tell the user: "generators-test-generator skill loaded."

Test Generator

Generate test templates for unit tests, integration tests, and UI tests in iOS/macOS apps.

When This Skill Activates

Use this skill when the user:

• Asks to "add tests" or "write tests" for existing code
• Asks about unit testing, UI testing, or XCTest setup
• Wants to test ViewModels, services, or repositories
• Wants mock objects or test helpers generated

Do NOT activate for these — use the specialized skill instead:

• TDD workflow (test-first development) → testing-tdd-feature or testing-tdd-bug-fix
• Swift Testing API details (@Test, #expect, traits, parameterized tests) → swift-testing
• Snapshot/visual regression tests → testing-snapshot-test-setup
• Pre-refactor safety net → testing-tdd-refactor-guard or testing-characterization-test-generator
• Protocol contract tests → testing-test-contract
• Test data factories → testing-test-data-factory
• Integration test harness with mock servers → testing-integration-test-scaffold

Decision Tree

What tests do you need?
|
+-- Unit tests for business logic
|   +-- Swift Testing (@Test, #expect) -- recommended for iOS 16+
|   +-- XCTest -- for iOS 13-15 support or existing XCTest projects
|
+-- Integration tests (component interactions)
|   +-- Protocol-based mocks with dependency injection
|
+-- UI tests
|   +-- XCUITest with Screen Object pattern
|
+-- Snapshot/preview tests
    +-- PreviewSnapshots or swift-snapshot-testing

Pre-Generation Checks

1. Project Context Detection

• Identify existing test targets and test runner
• Detect testing framework already in use (Swift Testing vs XCTest)
• Verify deployment target (Swift Testing requires iOS 16+ / macOS 13+)
• Identify project architecture pattern (MVVM, TCA, Repository, etc.)
• Locate source file directories

2. Conflict Detection

Search for existing test infrastructure:

Glob: **/*Tests.swift, **/*Tests/**/*.swift, **/*Spec.swift
Grep: "import XCTest" or "import Testing" or "@Suite" or "@Test"
Grep: "MockItemRepository" or "protocol.*Repository" or "class Mock"

If existing tests are found:

• Ask user whether to follow the existing framework (XCTest vs Swift Testing) or migrate
• Check for existing mock objects to reuse or extend
• Identify existing test helpers and factories

If a test target already exists:

• Add new tests to the existing target -- do NOT create a new target
• Follow the existing directory structure and naming conventions

3. Architecture Detection

Grep: "ViewModel" or "Reducer" or "UseCase" or "Repository" or "Service"
Glob: **/*ViewModel.swift, **/*Reducer.swift, **/*Repository.swift

This determines which test templates to generate (ViewModel tests, Reducer tests, etc.).

Configuration Questions

1. Testing Framework

• Swift Testing (Recommended, iOS 16+) - Modern, expressive syntax
• XCTest - Traditional framework, all iOS versions
• Both - Mix of frameworks

2. Test Types to Generate

• Unit Tests - Test individual components in isolation
• Integration Tests - Test component interactions
• UI Tests - Test user interface and flows
• All - Complete test coverage

3. Architecture Pattern

• MVVM - ViewModel tests
• TCA - Reducer tests
• Repository - Data layer tests
• Custom - Based on project structure

Generated Files

Unit Tests

Tests/UnitTests/
├── ViewModelTests/
│   └── ItemViewModelTests.swift
├── ServiceTests/
│   └── APIClientTests.swift
└── RepositoryTests/
    └── ItemRepositoryTests.swift

UI Tests

Tests/UITests/
├── Screens/
│   └── HomeScreenTests.swift
├── Flows/
│   └── OnboardingFlowTests.swift
└── Helpers/
    └── TestHelpers.swift

Swift Testing (Modern)

Basic Test Structure

import Testing
@testable import YourApp

@Suite("Item ViewModel Tests")
struct ItemViewModelTests {

    @Test("loads items successfully")
    func loadsItems() async throws {
        let mockRepository = MockItemRepository()
        let viewModel = ItemViewModel(repository: mockRepository)

        await viewModel.loadItems()

        #expect(viewModel.items.count == 3)
        #expect(viewModel.isLoading == false)
    }

    @Test("handles empty state")
    func handlesEmptyState() async {
        let mockRepository = MockItemRepository(items: [])
        let viewModel = ItemViewModel(repository: mockRepository)

        await viewModel.loadItems()

        #expect(viewModel.items.isEmpty)
        #expect(viewModel.showEmptyState)
    }
}

Parameterized Tests

@Test("validates email format", arguments: [
    ("[e-mail]", true),
    ("invalid", false),
    ("no@tld", false),
    ("[e-mail]", true)
])
func validatesEmail(email: String, isValid: Bool) {
    #expect(EmailValidator.isValid(email) == isValid)
}

XCTest (Traditional)

Basic Test Structure

import XCTest
@testable import YourApp

final class ItemViewModelTests: XCTestCase {

    var sut: ItemViewModel!
    var mockRepository: MockItemRepository!

    override func setUp() {
        super.setUp()
        mockRepository = MockItemRepository()
        sut = ItemViewModel(repository: mockRepository)
    }

    override func tearDown() {
        sut = nil
        mockRepository = nil
        super.tearDown()
    }

    func testLoadsItems() async throws {
        await sut.loadItems()

        XCTAssertEqual(sut.items.count, 3)
        XCTAssertFalse(sut.isLoading)
    }
}

Test Patterns

Testing ViewModels

@Suite("ViewModel Tests")
struct ViewModelTests {

    @Test("state transitions correctly")
    func stateTransitions() async {
        let vm = ItemViewModel(repository: MockItemRepository())

        #expect(vm.state == .idle)

        await vm.loadItems()

        #expect(vm.state == .loaded)
    }

    @Test("error handling")
    func errorHandling() async {
        let failingRepo = MockItemRepository(shouldFail: true)
        let vm = ItemViewModel(repository: failingRepo)

        await vm.loadItems()

        #expect(vm.state == .error)
        #expect(vm.errorMessage != nil)
    }
}

Testing Async Code

@Test("fetches data asynchronously")
func fetchesData() async throws {
    let service = APIService()

    let result = try await service.fetchItems()

    #expect(result.count > 0)
}

@Test("times out appropriately")
func timesOut() async {
    await #expect(throws: TimeoutError.self) {
        try await withTimeout(seconds: 1) {
            try await Task.sleep(for: .seconds(5))
        }
    }
}

Mock Creation

Protocol-Based Mocks

protocol ItemRepository {
    func fetchItems() async throws -> [Item]
    func saveItem(_ item: Item) async throws
}

final class MockItemRepository: ItemRepository {
    var items: [Item] = []
    var shouldFail = false
    var saveCallCount = 0

    func fetchItems() async throws -> [Item] {
        if shouldFail {
            throw TestError.mockFailure
        }
        return items
    }

    func saveItem(_ item: Item) async throws {
        saveCallCount += 1
        items.append(item)
    }
}

UI Testing

Screen Object Pattern

import XCTest

final class HomeScreen {
    let app: XCUIApplication

    init(app: XCUIApplication) {
        self.app = app
    }

    var itemList: XCUIElement {
        app.collectionViews["itemList"]
    }

    var addButton: XCUIElement {
        app.buttons["addItem"]
    }

    func tapItem(at index: Int) {
        itemList.cells.element(boundBy: index).tap()
    }

    func addNewItem(title: String) {
        addButton.tap()
        app.textFields["itemTitle"].tap()
        app.textFields["itemTitle"].typeText(title)
        app.buttons["save"].tap()
    }
}

Integration Steps

1. Add Test Target

In Xcode:

1. File > New > Target
2. Choose "Unit Testing Bundle" or "UI Testing Bundle"
3. Name appropriately (e.g., YourAppTests)

2. Configure Test Scheme

1. Edit Scheme > Test
2. Add test targets
3. Configure code coverage

3. Run Tests

# Command line
xcodebuild test -scheme YourApp -destination 'platform=iOS Simulator,name=iPhone 16'

# With coverage
xcodebuild test -scheme YourApp -enableCodeCoverage YES

Best Practices

1. Test one thing per test - Clear, focused tests
2. Use descriptive names - Tests as documentation
3. Arrange-Act-Assert - Clear test structure
4. Mock external dependencies - Isolate units
5. Test edge cases - Empty, nil, error states
6. Keep tests fast - No real network/disk

Top 5 Mistakes

#	Mistake	Why It's Wrong	Fix
1	Testing implementation details instead of behavior	Tests break on every refactor, providing no safety net	Test public API and observable outcomes, not internal state
2	Sharing mutable state between tests	Tests pass individually but fail when run together (order-dependent)	Create fresh instances in each test; use init() in @Suite structs or setUp() in XCTest
3	Using XCTAssertTrue(result != nil) instead of XCTUnwrap	Failure message is useless ("XCTAssertTrue failed") with no context	Use let value = try XCTUnwrap(result) or #expect(result != nil) with Swift Testing
4	Not testing error paths	Only happy-path coverage; errors crash in production	Always test with shouldFail = true mocks and verify error state
5	Real network calls in unit tests	Tests are slow, flaky, and fail offline	Use protocol-based mocks; reserve real network calls for integration test schemes

Review Checklist

Before finishing test generation, verify:

• Naming: Test names describe the behavior, not the method (loadsItemsSuccessfully not testLoadItems)
• Isolation: Each test creates its own dependencies -- no shared mutable state
• No real I/O: Unit tests use mocks for network, disk, and database
• Async handling: Async tests use async throws (Swift Testing) or async throws with expectations (XCTest)
• Error paths tested: At least one test per function verifies error/failure behavior
• Edge cases: Empty collections, nil optionals, boundary values are tested
• Assertions are specific: Using #expect(items.count == 3) not #expect(!items.isEmpty)
• Mock call verification: Mocks track call counts and received arguments where needed
• No force unwraps in tests: Use try #require() (Swift Testing) or XCTUnwrap (XCTest)
• Tests compile and run: Verify with xcodebuild test or Xcode test navigator

References

• templates.md -- Production-ready code templates for test suites, mocks, and helpers
• Swift Testing
• XCTest Framework
• Testing Your Apps in Xcode