Self-Hosted Swift Testing Frameworks: XCTest vs Quick/Nimble vs SnapshotTesting

1
2
3
4

# XCTest is bundled — no installation needed
# Create a test target in Xcode or via SPM:
swift package init --type library
# Tests go in Tests/YourPackageTests/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

import XCTest
@testable import MyApp

final class UserServiceTests: XCTestCase {
    var sut: UserService!
    var mockAPIClient: MockAPIClient!

    override func setUp() async throws {
        try await super.setUp()
        mockAPIClient = MockAPIClient()
        sut = UserService(apiClient: mockAPIClient)
    }

    override func tearDown() async throws {
        sut = nil
        mockAPIClient = nil
        try await super.tearDown()
    }

    func testFetchUserReturnsDecodedUser() async throws {
        // Given
        let expectedUser = User(id: 1, name: "Alice", email: "alice@test.com")
        mockAPIClient.stubResponse = expectedUser

        // When
        let user = try await sut.fetchUser(id: 1)

        // Then
        XCTAssertEqual(user.name, "Alice")
        XCTAssertEqual(user.email, "alice@test.com")
    }

    func testFetchUserThrowsOnNetworkError() async {
        mockAPIClient.shouldThrow = true
        do {
            _ = try await sut.fetchUser(id: 1)
            XCTFail("Expected error not thrown")
        } catch {
            XCTAssertTrue(error is NetworkError)
        }
    }

    func testUserValidationPerformance() throws {
        let users = (1...1000).map { User(id: $0, name: "User \($0)", email: "u\($0)@test.com") }
        measure {
            for user in users {
                _ = sut.validate(user)
            }
        }
    }
}

// UI Testing with XCUITest
final class LoginUITests: XCTestCase {
    let app = XCUIApplication()

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

    func testSuccessfulLoginNavigatesToDashboard() {
        let emailField = app.textFields["email"]
        let passwordField = app.secureTextFields["password"]
        let loginButton = app.buttons["Sign In"]

        emailField.tap()
        emailField.typeText("alice@example.com")
        passwordField.tap()
        passwordField.typeText("password123")
        loginButton.tap()

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

1
2
3
4
5

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import Quick
import Nimble
@testable import MyApp

final class ShoppingCartSpec: QuickSpec {
    override class func spec() {
        var cart: ShoppingCart!
        var inventory: MockInventoryService!

        describe("ShoppingCart") {
            beforeEach {
                inventory = MockInventoryService()
                cart = ShoppingCart(inventory: inventory)
            }

            // MARK: - Adding Items
            describe("addItem") {
                context("when the item is in stock") {
                    beforeEach {
                        inventory.stubAvailability(sku: "BOOK-001", available: true)
                        cart.addItem(sku: "BOOK-001", quantity: 2)
                    }

                    it("adds the item to the cart") {
                        expect(cart.items).to(haveCount(1))
                    }

                    it("calculates the correct subtotal") {
                        expect(cart.items.first?.quantity).to(equal(2))
                    }
                }

                context("when the item is out of stock") {
                    beforeEach {
                        inventory.stubAvailability(sku: "BOOK-999", available: false)
                    }

                    it("throws an OutOfStock error") {
                        expect { try cart.addItemWithValidation(sku: "BOOK-999", quantity: 1) }
                            .to(throwError(OutOfStockError.self))
                    }
                }

                context("when quantity exceeds available stock") {
                    it("throws an InsufficientStock error") {
                        inventory.stubAvailability(sku: "LIMITED", available: true)
                        inventory.stubStockLevel(sku: "LIMITED", available: 5)
                        expect { try cart.addItemWithValidation(sku: "LIMITED", quantity: 10) }
                            .to(throwError(InsufficientStockError.self))
                    }
                }
            }

            // MARK: - Async Operations
            describe("checkout") {
                it("eventually completes the order", skip: {
                    // Skip this test on CI runners without network access
                    #if os(Linux)
                    return true
                    #else
                    return false
                    #endif
                }()) {
                    cart.addItem(sku: "BOOK-001", quantity: 1)
                    let order = try await cart.checkout()
                    await expect(order.status).toEventually(equal(.confirmed), timeout: .seconds(5))
                }
            }
        }
    }
}

1
2
3
4

// Package.swift
dependencies: [
    .package(url: "https://github.com/pointfreeco/swift-snapshot-testing.git", from: "1.17.0"),
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

import SnapshotTesting
import SwiftUI
import XCTest

final class ProfileViewSnapshotTests: XCTestCase {

    func testDefaultProfileView() {
        let view = ProfileView(user: .preview)
        let host = UIHostingController(rootView: view)

        // Snapshot the view as a PNG image
        assertSnapshot(
            of: host,
            as: .image(
                on: .iPhone14,
                perceptualPrecision: 0.98,
                traits: .init(userInterfaceStyle: .light)
            )
        )
    }

    func testDarkModeProfileView() {
        let view = ProfileView(user: .preview)
        let host = UIHostingController(rootView: view)

        assertSnapshot(
            of: host,
            as: .image(
                on: .iPhone14,
                traits: .init(userInterfaceStyle: .dark)
            ),
            named: "dark"
        )
    }

    func testProfileViewWithLongName() {
        let user = User(name: "Alexandria Bartholomew Cunningham-Smythe",
                        bio: String(repeating: "A very long biography. ", count: 20))
        let view = ProfileView(user: user)
        let host = UIHostingController(rootView: view)

        assertSnapshot(of: host, as: .image(on: .iPhone14))
    }

    // Snapshot JSON API responses
    func testUserAPIResponseDecoding() {
        let json = """
        {
            "id": 42,
            "name": "Snap Shot",
            "email": "snap@test.com",
            "roles": ["admin", "editor"]
        }
        """.data(using: .utf8)!

        let user = try! JSONDecoder().decode(User.self, from: json)

        assertSnapshot(of: user, as: .json)
    }

    // Snapshot attributed strings
    func testWelcomeAttributedString() {
        let string = WelcomeBuilder.buildAttributedWelcome(for: .preview)
        assertSnapshot(of: string, as: .lines)
    }
}

// Custom strategy: snapshot a SwiftUI View directly
extension Snapshotting where Value: SwiftUI.View, Format == UIImage {
    static func image(
        on device: ViewImageConfig = .iPhone14,
        perceptualPrecision: Float = 0.98
    ) -> Snapshotting {
        Snapshotting<UIViewController, UIImage>.image(
            on: device,
            perceptualPrecision: perceptualPrecision
        ).pullback { view in
            UIHostingController(rootView: view)
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// Testing a Vapor endpoint response
import XCTVapor
import SnapshotTesting

final class APITests: XCTestCase {
    func testGetUsersEndpoint() throws {
        let app = Application(.testing)
        defer { app.shutdown() }
        try configure(app)

        try app.test(.GET, "/api/users") { response in
            XCTAssertEqual(response.status, .ok)
            // Snapshot the full response body for contract testing
            assertSnapshot(of: response.body.string, as: .lines)
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# .github/workflows/swift-tests.yml
name: Swift Tests
on: [push, pull_request]

jobs:
  test:
    runs-on: macos-14
    strategy:
      matrix:
        xcode: ['15.4', '16.0']
    steps:
      - uses: actions/checkout@v4

      - name: Select Xcode
        run: sudo xcode-select -s /Applications/Xcode_${{ matrix.xcode }}.app

      - name: Run XCTest + Quick/Nimble
        run: |
          xcodebuild test \
            -scheme MyApp \
            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=latest' \
            -resultBundlePath TestResults.xcresult

      - name: Run snapshot tests (record new baselines on failure)
        run: |
          xcodebuild test \
            -scheme MyApp \
            -destination 'platform=iOS Simulator,name=iPhone 15 Pro,OS=latest' \
            -only-testing:MyAppTests/ProfileViewSnapshotTests
        continue-on-error: true

      - name: Upload test results
        uses: kishikawakatsumi/xcresulttool@v1
        if: always()
        with:
          path: TestResults.xcresult