swift-testing

What this skill does

# Swift Testing

## Overview

This skill provides expert guidance on Swift Testing, covering the modern Swift Testing framework, test doubles (mocks, stubs, spies), fixtures, integration testing, snapshot testing, and migration from XCTest. Use this skill to help developers write reliable, maintainable tests following F.I.R.S.T. principles and Arrange-Act-Assert patterns.

## Agent Behavior Contract (Follow These Rules)

1. Use Swift Testing framework (`@Test`, `#expect`, `#require`, `@Suite`) for all new tests, not XCTest.
2. Always structure tests with clear Arrange-Act-Assert phases.
3. Follow F.I.R.S.T. principles: Fast, Isolated, Repeatable, Self-Validating, Timely.
4. Use proper test double terminology per Martin Fowler's taxonomy (Dummy, Fake, Stub, Spy, SpyingStub, Mock).
5. Place fixtures close to models with `#if DEBUG`, not in test targets.
6. Place test doubles close to interfaces with `#if DEBUG`, not in test targets.
7. Prefer state verification over behavior verification - simpler, less brittle tests.
8. Use `#expect` for soft assertions (continue on failure) and `#require` for hard assertions (stop on failure).

## Quick Decision Tree

When a developer needs testing guidance, follow this decision tree:

1. **Starting fresh with Swift Testing?**
   - Read `references/test-organization.md` for suites, tags, traits
   - Read `references/async-testing.md` for async test patterns

2. **Need to create test data?**
   - Read `references/fixtures.md` for fixture patterns and placement
   - Read `references/test-doubles.md` for mock/stub/spy patterns

3. **Testing multiple inputs?**
   - Read `references/parameterized-tests.md` for parameterized testing

4. **Testing module interactions?**
   - Read `references/integration-testing.md` for integration test patterns

5. **Testing UI for regressions?**
   - Read `references/snapshot-testing.md` for snapshot testing setup

6. **Testing data structures or state?**
   - Read `references/dump-snapshot-testing.md` for text-based snapshot testing

7. **Migrating from XCTest?**
   - Read `references/migration-xctest.md` for migration guide

## Triage-First Playbook (Common Errors -> Next Best Move)

- "XCTAssertEqual is unavailable" / need to modernize tests
  - Use `references/migration-xctest.md` for XCTest to Swift Testing migration
- Need to test async code
  - Use `references/async-testing.md` for async patterns, confirmation, timeouts
- Tests are slow or flaky
  - Check F.I.R.S.T. principles, use proper mocking per `references/test-doubles.md`
- Need deterministic test data
  - Use `references/fixtures.md` for fixture patterns with fixed dates
- Need to test multiple scenarios efficiently
  - Use `references/parameterized-tests.md` for parameterized testing
- Need to verify component interactions
  - Use `references/integration-testing.md` for integration test patterns

## Core Syntax

### Basic Test

```swift
import Testing

@Test func basicTest() {
    #expect(1 + 1 == 2)
}
```

### Test with Description

```swift
@Test("Adding items increases cart count")
func addItem() {
    let cart = Cart()
    cart.add(item)
    #expect(cart.count == 1)
}
```

### Async Test

```swift
@Test func asyncOperation() async throws {
    let result = try await service.fetch()
    #expect(result.isValid)
}
```

## Arrange-Act-Assert Pattern

Structure every test with clear phases:

```swift
@Test func calculateTotal() {
    // Given
    let cart = ShoppingCart()
    cart.add(Item(price: 10))
    cart.add(Item(price: 20))

    // When
    let total = cart.calculateTotal()

    // Then
    #expect(total == 30)
}
```

## Assertions

### #expect - Soft Assertion

Continues test execution after failure:

```swift
@Test func multipleExpectations() {
    let user = User(name: "Alice", age: 30)
    #expect(user.name == "Alice")  // If fails, test continues
    #expect(user.age == 30)        // This still runs
}
```

### #require - Hard Assertion

Stops test execution on failure:

```swift
@Test func requireExample() throws {
    let user = try #require(fetchUser())  // Stops if nil
    #expect(user.name == "Alice")
}
```

### Error Testing

```swift
@Test func throwsError() {
    #expect(throws: ValidationError.self) {
        try validate(invalidInput)
    }
}

@Test func throwsSpecificError() {
    #expect(throws: ValidationError.emptyField) {
        try validate("")
    }
}
```

## F.I.R.S.T. Principles

| Principle | Description | Application |
|-----------|-------------|-------------|
| **Fast** | Tests execute in milliseconds | Mock expensive operations |
| **Isolated** | Tests don't depend on each other | Fresh instance per test |
| **Repeatable** | Same result every time | Mock dates, network, external deps |
| **Self-Validating** | Auto-report pass/fail | Use `#expect`, never rely on `print()` |
| **Timely** | Write tests alongside code | Use parameterized tests for edge cases |

## Test Double Quick Reference

Per [Martin Fowler's definition](https://martinfowler.com/articles/mocksArentStubs.html):

| Type | Purpose | Verification |
|------|---------|--------------|
| **Dummy** | Fill parameters, never used | N/A |
| **Fake** | Working implementation with shortcuts | State |
| **Stub** | Provides canned answers | State |
| **Spy** | Records calls for verification | State |
| **SpyingStub** | Stub + Spy combined (most common) | State |
| **Mock** | Pre-programmed expectations, self-verifies | Behavior |

**Important**: What Swift community calls "Mock" is usually a **SpyingStub**.

For detailed patterns, see `references/test-doubles.md`.

## Test Double Placement

Place test doubles **close to the interface**, not in test targets:

```swift
// In PersonalRecordsCore-Interface/Sources/...

public protocol PersonalRecordsRepositoryProtocol: Sendable {
    func getAll() async throws -> [PersonalRecord]
    func save(_ record: PersonalRecord) async throws
}

#if DEBUG
public final class PersonalRecordsRepositorySpyingStub: PersonalRecordsRepositoryProtocol {
    // Spy: Captured calls
    public private(set) var savedRecords: [PersonalRecord] = []

    // Stub: Configurable responses
    public var recordsToReturn: [PersonalRecord] = []
    public var errorToThrow: Error?

    public func getAll() async throws -> [PersonalRecord] {
        if let error = errorToThrow { throw error }
        return recordsToReturn
    }

    public func save(_ record: PersonalRecord) async throws {
        if let error = errorToThrow { throw error }
        savedRecords.append(record)
    }
}
#endif
```

## Fixtures

Place fixtures **close to the model**:

```swift
// In Sources/Models/PersonalRecord.swift

public struct PersonalRecord: Equatable, Sendable {
    public let id: UUID
    public let weight: Double
    // ...
}

#if DEBUG
extension PersonalRecord {
    public static func fixture(
        id: UUID = UUID(),
        weight: Double = 100.0
        // ... defaults for all properties
    ) -> PersonalRecord {
        PersonalRecord(id: id, weight: weight)
    }
}
#endif
```

For detailed patterns, see `references/fixtures.md`.

## Test Pyramid

```
        +-------------+
        |   UI Tests  |  5%  - End-to-end flows
        |   (E2E)     |
        +-------------+
        | Integration |  15% - Module interactions
        |    Tests    |
        +-------------+
        |    Unit     |  80% - Individual components
        |    Tests    |
        +-------------+
```

## Reference Files

Load these files as needed for specific topics:

- **`test-organization.md`** - Suites, tags, traits, parallel execution
- **`parameterized-tests.md`** - Testing multiple inputs efficiently
- **`async-testing.md`** - Async patterns, confirmation, timeouts, cancellation
- **`migration-xctest.md`** - Complete XCTest to Swift Testing migration guide
- **`test-doubles.md`** - Complete taxonomy with examples (Dummy, Fake, Stub, Spy, SpyingStub, Mock)
- **`fixtures.md`** - Fixture patterns, placement, and best practices
- **`integration-testing.md`