Skip to content

JordanCoin/ios-skills-collection / skills/bocato--swift-testing

swift-testing

Verified

Expert guidance on Swift Testing best practices, patterns, and implementation. Use when developers mention: (1) Swift Testing, @Test, #expect, #require, or @Suite, (2) "use Swift Testing" or "modern testing patterns", (3) test doubles, mocks, stubs, spies, or fixtures, (4) unit tests, integration tests, or snapshot tests, (5) migrating from XCTest to Swift Testing, (6) TDD, Arrange-Act-Assert, or F.I.R.S.T. principles, (7) parameterized tests or test organization.

references/migration-xctest.md

View on GitHub
# Migration from XCTest to Swift Testing

How to migrate existing XCTest tests to Swift Testing.

## Quick Reference

| XCTest | Swift Testing |
|--------|---------------|
| `class FooTests: XCTestCase` | `@Suite struct FooTests` |
| `func testFoo()` | `@Test func foo()` |
| `XCTAssertEqual(a, b)` | `#expect(a == b)` |
| `XCTAssertTrue(x)` | `#expect(x)` |
| `XCTAssertFalse(x)` | `#expect(!x)` |
| `XCTAssertNil(x)` | `#expect(x == nil)` |
| `XCTAssertNotNil(x)` | `#expect(x != nil)` or `try #require(x)` |
| `XCTAssertThrowsError` | `#expect(throws:)` |
| `XCTFail("message")` | `Issue.record("message")` |
| `XCTSkip("reason")` | Test trait `.disabled("reason")` |
| `setUp()` | `init()` |
| `tearDown()` | `deinit` |

## Basic Test Migration

### Before (XCTest)

```swift
import XCTest

class UserTests: XCTestCase {
    func testUserCreation() {
        let user = User(name: "Alice")
        XCTAssertEqual(user.name, "Alice")
        XCTAssertNotNil(user.id)
    }
}
```

### After (Swift Testing)

```swift
import Testing

@Suite struct UserTests {
    @Test func userCreation() throws {
        let user = User(name: "Alice")
        #expect(user.name == "Alice")
        let id = try #require(user.id)
        #expect(!id.isEmpty)
    }
}
```

## Assertion Migration

### Equality

```swift
// XCTest
XCTAssertEqual(result, expected)
XCTAssertEqual(result, expected, "Custom message")

// Swift Testing
#expect(result == expected)
#expect(result == expected, "Custom message")
```

### Boolean

```swift
// XCTest
XCTAssertTrue(condition)
XCTAssertFalse(condition)

// Swift Testing
#expect(condition)
#expect(!condition)
```

### Nil Checks

```swift
// XCTest
XCTAssertNil(optional)
XCTAssertNotNil(optional)

// Swift Testing
#expect(optional == nil)
#expect(optional != nil)

// Or use #require for unwrapping
let value = try #require(optional)
```

### Error Testing

```swift
// XCTest
XCTAssertThrowsError(try riskyOperation()) { error in
    XCTAssertEqual(error as? MyError, .specific)
}

XCTAssertNoThrow(try safeOperation())

// Swift Testing
#expect(throws: MyError.specific) {
    try riskyOperation()
}

#expect(throws: Never.self) {
    try safeOperation()
}
```

## Setup and Teardown

### Before (XCTest)

```swift
class DatabaseTests: XCTestCase {
    var database: Database!

    override func setUp() {
        super.setUp()
        database = Database.inMemory()
    }

    override func tearDown() {
        database.close()
        database = nil
        super.tearDown()
    }

    func testInsert() {
        database.insert(record)
    }
}
```

### After (Swift Testing)

```swift
@Suite struct DatabaseTests {
    let database: Database

    init() throws {
        database = try Database.inMemory()
    }

    @Test func insert() {
        database.insert(record)
    }
}
```

## Async Tests

### Before (XCTest)

```swift
func testAsyncFetch() async throws {
    let result = try await service.fetch()
    XCTAssertFalse(result.isEmpty)
}

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

    service.fetch { result in
        XCTAssertNotNil(result)
        expectation.fulfill()
    }

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

### After (Swift Testing)

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

// For callbacks, use confirmation
@Test func asyncWithConfirmation() async {
    await confirmation { confirm in
        service.fetch { result in
            #expect(result != nil)
            confirm()
        }
    }
}
```

## Parameterized Tests

### Before (XCTest)

```swift
func testValidEmails() {
    let validEmails = ["a@b.com", "test@example.org"]
    for email in validEmails {
        XCTAssertTrue(EmailValidator.isValid(email), "\(email) should be valid")
    }
}
```

### After (Swift Testing)

```swift
@Test(arguments: ["a@b.com", "test@example.org"])
func validEmail(email: String) {
    #expect(EmailValidator.isValid(email))
}
```

## Skipping Tests

### Before (XCTest)

```swift
func testPlatformSpecific() throws {
    #if !os(iOS)
    throw XCTSkip("iOS only")
    #endif
    // Test code
}
```

### After (Swift Testing)

```swift
@Test(.enabled(if: Platform.isIOS, "iOS only"))
func platformSpecific() {
    // Test code
}

// Or
@Test(.disabled("Not implemented yet"))
func futureFeature() { }
```

## Test Organization

### Before (XCTest)

```swift
class CartTests: XCTestCase {
    // Tests grouped by comments
    // MARK: - Adding Items
    func testAddSingleItem() { }
    func testAddMultipleItems() { }

    // MARK: - Removing Items
    func testRemoveItem() { }
}
```

### After (Swift Testing)

```swift
@Suite("Cart")
struct CartTests {
    @Suite("Adding Items")
    struct AddingTests {
        @Test func singleItem() { }
        @Test func multipleItems() { }
    }

    @Suite("Removing Items")
    struct RemovingTests {
        @Test func removeItem() { }
    }
}
```

## Migration Strategy

1. **Start with leaf tests**: Tests that don't depend on XCTest infrastructure
2. **Migrate one file at a time**: Keep changes reviewable
3. **Run both simultaneously**: XCTest and Swift Testing can coexist
4. **Update CI configuration**: Ensure both are run during migration
5. **Remove XCTest after full migration**: Clean up imports and dependencies

## Coexistence

You can have both frameworks in the same project:

```swift
// XCTest (existing)
import XCTest
class OldTests: XCTestCase { }

// Swift Testing (new)
import Testing
@Suite struct NewTests { }
```

Both will be discovered and run by `swift test`.
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall