Asynchronen Code testen (XCTest)

Async-Tests: Grundlagen

Erfolgsfall eines Async-Tests

import XCTest
import Foundation

// System Under Test (SUT)
func fetchValue() async -> Int {
    try? await Task.sleep(nanoseconds: 50_000_000)
    return 42
}

final class AsyncBasicsTests: XCTestCase {
    func testFetchValue_returns42() async {
        let v = await fetchValue()
        XCTAssertEqual(v, 42)
    }
}

Async throws und Assertions

import XCTest

enum NetError: Error { case offline }

func loadNumber(online: Bool) async throws -> Int {
    try await Task.sleep(nanoseconds: 30_000_000)
    if !online { throw NetError.offline }
    return 7
}

final class AsyncThrowingTests: XCTestCase {
    func testLoadNumber_success() async throws {
        let n = try await loadNumber(online: true)
        XCTAssertEqual(n, 7)
    }

    func testLoadNumber_offline_throws() async {
        do {
            _ = try await loadNumber(online: false)
            XCTFail("Expected error")
        } catch NetError.offline {
            // expected
        } catch {
            XCTFail("Unexpected error: \\(error)")
        }
    }
}

Parallele Ergebnisse

import XCTest

func compute(_ x: Int) async -> Int {
    try? await Task.sleep(nanoseconds: 10_000_000)
    return x * x
}

final class ParallelTests: XCTestCase {
    func testParallel_asyncLet_sumsSquares() async {
        async let a = compute(2)
        async let b = compute(3)
        let sum = await (a + b)
        XCTAssertEqual(sum, 13) // 4 + 9
    }
}

Timeouts testen

import XCTest

enum TimeoutError: Error { case timedOut }

func withTimeout<T>(
    seconds: Double,
    operation: @escaping () async throws -> T
) async throws -> T {
    try await withThrowingTaskGroup(of: T.self) { group in
        group.addTask { try await operation() }
        group.addTask {
            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
            throw TimeoutError.timedOut
        }
        let first = try await group.next()!
        group.cancelAll()
        return first
    }
}

final class TimeoutTests: XCTestCase {
    func testTimeout_timesOutFast() async {
        do {
            _ = try await withTimeout(seconds: 0.01) {
                try await Task.sleep(nanoseconds: 50_000_000) // slower than timeout
                return "OK"
            }
            XCTFail("Expected timeout")
        } catch TimeoutError.timedOut {
            // expected
        } catch {
            XCTFail("Unexpected error: \\(error)")
        }
    }
}

Expectations (Legacy)

import XCTest

// Legacy API with a completion handler
func legacyFetch(_ completion: @escaping (String) -> Void) {
    Task { try? await Task.sleep(nanoseconds: 20_000_000); completion("done") }
}

final class ExpectationTests: XCTestCase {
    func testLegacy_withExpectation() {
        let exp = expectation(description: "legacy finishes")
        legacyFetch { value in
            XCTAssertEqual(value, "done")
            exp.fulfill()
        }
        wait(for: [exp], timeout: 1.0)
    }
}

Moderner Stil für Async-Tests

Zusammenfassung