Swift Testing × Antigravity — Beyond XCTest to AI-Driven Test Design

// Production code
struct UserAuthService {
    private let minPasswordLength = 8
    private let maxUsernameLength = 20
 
    func validate(username: String, password: String) throws -> Bool {
        guard !username.isEmpty else { throw AuthError.emptyUsername }
        guard username.count <= maxUsernameLength else {
            throw AuthError.usernameTooLong(maxLength: maxUsernameLength)
        }
        guard password.count >= minPasswordLength else {
            throw AuthError.passwordTooShort(minLength: minPasswordLength)
        }
        guard password.contains(where: { $0.isNumber }) else {
            throw AuthError.passwordNeedsNumber
        }
        return true
    }
}
 
enum AuthError: Error, Equatable {
    case emptyUsername
    case usernameTooLong(maxLength: Int)
    case passwordTooShort(minLength: Int)
    case passwordNeedsNumber
}
 
// Test suite generated by Antigravity, refined by hand
@Suite("UserAuthService Validation")
struct UserAuthServiceTests {
 
    let service = UserAuthService()
 
    // MARK: - Happy Path
    @Test("Valid credentials pass validation")
    func validCredentials() throws {
        let result = try service.validate(username: "alice", password: "Secure123")
        #expect(result == true)
    }
 
    // MARK: - Username Validation
    @Test("Empty username is rejected")
    func emptyUsername() {
        #expect(throws: AuthError.emptyUsername) {
            try service.validate(username: "", password: "Secure123")
        }
    }
 
    @Test("Username exceeding 20 characters is rejected")
    func tooLongUsername() {
        let longName = String(repeating: "a", count: 21)
        #expect(throws: AuthError.usernameTooLong(maxLength: 20)) {
            try service.validate(username: longName, password: "Secure123")
        }
    }
 
    // MARK: - Parameterized Password Validation
    @Test(
        "Invalid passwords are rejected with the correct error",
        arguments: [
            ("short1",    AuthError.passwordTooShort(minLength: 8)),
            ("nonumbers", AuthError.passwordNeedsNumber),
            ("12345678",  AuthError.passwordNeedsNumber),  // all digits — no letters, still no letter+number mix
        ]
    )
    func invalidPasswords(password: String, expectedError: AuthError) {
        #expect(throws: expectedError) {
            try service.validate(username: "alice", password: password)
        }
    }
 
    // MARK: - Boundary Conditions
    @Test("Username at exactly 20 characters is accepted")
    func exactMaxLengthUsername() throws {
        let name = String(repeating: "a", count: 20)
        let result = try service.validate(username: name, password: "Secure123")
        #expect(result == true)
    }
 
    @Test("Password at exactly 8 characters is accepted")
    func exactMinLengthPassword() throws {
        let result = try service.validate(username: "alice", password: "Pass1234")
        #expect(result == true)
    }
}

// Dependency injection protocol for testability
protocol DataFetching: Sendable {
    func fetch(from url: String) async throws -> Data
}
 
// Mock that returns a controlled result
struct MockFetcher: DataFetching {
    let response: Result<Data, Error>
 
    func fetch(from url: String) async throws -> Data {
        // Simulate a network hop with a small delay
        try await Task.sleep(for: .milliseconds(1))
        return try response.get()
    }
}
 
enum FetchError: Error, Equatable {
    case badURL
    case serverError(statusCode: Int)
}
 
@Suite("DataFetching Tests")
struct DataFetchingTests {
 
    @Test("Successful fetch returns the expected data")
    func successfulFetch() async throws {
        let expected = Data("hello".utf8)
        let fetcher = MockFetcher(response: .success(expected))
 
        let result = try await fetcher.fetch(from: "https://example.com")
        #expect(result == expected)
    }
 
    @Test("Failed fetch throws the expected error")
    func failedFetch() async {
        let fetcher = MockFetcher(response: .failure(FetchError.badURL))
 
        // await goes before #expect(throws:) for async-throws functions
        await #expect(throws: FetchError.badURL) {
            try await fetcher.fetch(from: "bad-url")
        }
    }
 
    @Test("Five concurrent fetches all complete independently")
    func concurrentFetches() async throws {
        let fetcher = MockFetcher(response: .success(Data()))
 
        try await withThrowingTaskGroup(of: Data.self) { group in
            for i in 0..<5 {
                group.addTask {
                    try await fetcher.fetch(from: "https://example.com/\(i)")
                }
            }
            var count = 0
            for try await _ in group { count += 1 }
            #expect(count == 5)
        }
    }
}

// Existing XCTest — leave it alone
class LegacyServiceTests: XCTestCase {
    func testLegacyBehavior() {
        XCTAssertEqual(1 + 1, 2)
    }
}
 
// New Swift Testing — write all new tests here
@Test("New feature behaves correctly")
func newFeatureTest() {
    #expect(1 + 1 == 2)
}

// Equality
XCTAssertEqual(a, b)          → #expect(a == b)
XCTAssertNotEqual(a, b)       → #expect(a != b)
 
// Boolean
XCTAssertTrue(condition)      → #expect(condition)
XCTAssertFalse(condition)     → #expect(!condition)
 
// Nil/optional
XCTAssertNil(x)               → #expect(x == nil)
XCTAssertNotNil(x)            → #expect(x != nil)
let v = try XCTUnwrap(x)      → let v = try #require(x)
 
// Error throwing
XCTAssertThrowsError(try f()) → #expect(throws: ...) { try f() }
XCTAssertNoThrow(try f())     → #expect(throws: Never.self) { try f() }
 
// Lifecycle
setUp() in XCTestCase         → init() in struct (automatic reset per test)
tearDown() in XCTestCase      → deinit in class/actor, or addTeardownBlock workaround

// ❌ Potential runtime issue without @MainActor
@Test("ViewModel title updates correctly")
func titleUpdate() async {
    let vm = MyViewModel()  // @MainActor class
    await MainActor.run { vm.title = "Test" }
    await MainActor.run { #expect(vm.title == "Test") }
}
 
// ✅ Annotate the test function itself
@Test("ViewModel title updates correctly")
@MainActor
func titleUpdate() {
    let vm = MyViewModel()
    vm.title = "Test"
    #expect(vm.title == "Test")  // All on MainActor, no await needed
}

// ❌ Global state causes test pollution under concurrent execution
var globalCounter = 0
 
@Test("Counter increments")
func increment() {
    globalCounter += 1
    #expect(globalCounter == 1)  // Fails non-deterministically
}
 
// ✅ Each test gets its own isolated state via struct properties
struct CounterTests {
    var counter = Counter()  // Fresh instance per test invocation
 
    @Test("Counter increments from zero")
    mutating func increment() {
        counter.increment()
        #expect(counter.value == 1)  // Always deterministic
    }
}
 
// ✅ Use @Suite(.serialized) only when external state is unavoidable
@Suite(.serialized)
struct DatabaseIntegrationTests {
    // Tests that write to a shared test database run sequentially
}

// ❌ Non-Equatable error can't be compared directly
enum LegacyError: Error {  // No Equatable conformance
    case networkFailure
}
 
// ✅ Option 1: Add Equatable conformance (preferred for new code)
enum ModernError: Error, Equatable {
    case networkFailure
}
 
// ✅ Option 2: Use a closure to inspect the error
#expect {
    try operationThatThrows()
} throws: { error in
    guard let legacyError = error as? LegacyError else { return false }
    return legacyError == .networkFailure  // Manual comparison
}
 
// ✅ Option 3: Verify the error type without equality
#expect(throws: LegacyError.self) {
    try operationThatThrows()
}

## Test Generation Rules
 
When a new public function, method, or type is added to the production target:
1. Generate a Swift Testing test suite covering happy path, errors, and boundaries.
2. Prefer @Test(arguments:) for any validation logic with multiple input cases.
3. Place the test file in the corresponding Tests target under the same directory structure.
4. Do not add XCTestCase — use Swift Testing exclusively.

// Define tags in one place
extension Tag {
    @Tag static var networking: Self
    @Tag static var authentication: Self
}
 
// Apply tags to tests
@Test("Login API returns token on valid credentials", .tags(.networking, .authentication))
func loginAPISuccess() async throws {
    let token = try await AuthAPI.shared.login(username: "alice", password: "Secure123")
    // Verify the token is non-empty and has reasonable length
    #expect(!token.isEmpty)
    #expect(token.count > 10)
}
 
@Test("Logout clears the session", .tags(.authentication))
func logoutClearsSession() {
    SessionManager.shared.logout()
    #expect(SessionManager.shared.currentUser == nil)
    #expect(SessionManager.shared.token == nil)
}

@Test("Image cache evicts entries correctly under memory pressure")
func cachePressureEviction() {
    let cache = ImageCache(maxEntries: 3)
 
    // Add four images — the fourth should evict the oldest
    for i in 0..<4 {
        cache.store(image: UIImage(), forKey: "img_\(i)")
    }
 
    // BUG: Eviction not yet implemented (filed in JIRA-1234)
    // withKnownIssue marks this as an expected failure.
    // If it unexpectedly passes, Xcode reports that too — so we don't forget to remove this.
    withKnownIssue("Eviction not yet implemented — JIRA-1234") {
        #expect(cache.count == 3)
        #expect(cache.contains(key: "img_0") == false)
    }
}

struct LoginScenario: CustomStringConvertible {
    let username: String
    let password: String
    let shouldSucceed: Bool
 
    var description: String {
        "user='\(username)' pass_len=\(password.count) expected=\(shouldSucceed ? "success" : "failure")"
    }
}
 
@Test(
    "Credential validation covers all edge cases",
    arguments: [
        LoginScenario(username: "",      password: "Secure123", shouldSucceed: false),
        LoginScenario(username: "alice", password: "short",     shouldSucceed: false),
        LoginScenario(username: "alice", password: "Secure123", shouldSucceed: true),
    ]
)
func credentialEdgeCases(scenario: LoginScenario) throws {
    let service = AuthService()
    if scenario.shouldSucceed {
        let result = try service.validate(username: scenario.username,
                                          password: scenario.password)
        #expect(result == true)
    } else {
        #expect(throws: (any Error).self) {
            try service.validate(username: scenario.username,
                                 password: scenario.password)
        }
    }
}

// A function with branching that is easy to miss in tests
struct FileProcessor {
    enum ProcessingError: Error, Equatable {
        case emptyFile
        case fileTooLarge(sizeMB: Int)
    }
 
    static let maxFileSizeMB = 100
 
    func process(contents: String, fileSizeBytes: Int) throws -> String {
        let sizeMB = fileSizeBytes / (1024 * 1024)
 
        // Branch 1: file too large
        guard sizeMB <= Self.maxFileSizeMB else {
            throw ProcessingError.fileTooLarge(sizeMB: sizeMB)
        }
 
        // Branch 2: empty content
        guard !contents.isEmpty else {
            throw ProcessingError.emptyFile
        }
 
        return contents.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}
 
// Coverage-driven tests for each branch
@Suite("FileProcessor Branch Coverage")
struct FileProcessorTests {
 
    let processor = FileProcessor()
    let oneMB = 1024 * 1024
 
    @Test("Content below size limit is processed correctly")
    func normalProcessing() throws {
        let result = try processor.process(contents: "  hello  ", fileSizeBytes: oneMB)
        #expect(result == "hello")
    }
 
    @Test("Empty content triggers emptyFile error")
    func emptyContent() {
        #expect(throws: FileProcessor.ProcessingError.emptyFile) {
            try processor.process(contents: "", fileSizeBytes: 1024)
        }
    }
 
    @Test("File exceeding 100 MB triggers fileTooLarge error")
    func oversizedFile() {
        let oversizedBytes = 101 * oneMB
        #expect(throws: FileProcessor.ProcessingError.fileTooLarge(sizeMB: 101)) {
            try processor.process(contents: "data", fileSizeBytes: oversizedBytes)
        }
    }
}

// Step 1: Write the test first — EmailValidator doesn't exist yet
@Test("Valid email addresses pass validation")
func validEmails() {
    // Writing this test before the implementation forces you to design
    // the API from the caller's perspective, not the implementation's perspective
    let validator = EmailValidator()
    #expect(validator.isValid("user@example.com"))
    #expect(validator.isValid("first.last+tag@subdomain.example.org"))
    #expect(!validator.isValid("not-an-email"))
    #expect(!validator.isValid("@missing-local.com"))
    #expect(!validator.isValid("missing-domain.com"))
}
 
// Step 2: Ask Antigravity: "Implement EmailValidator so this test passes"
// Antigravity sees your expected inputs and outputs, then generates
// an implementation that satisfies them.
 
// Step 3: Run the tests — iterate until green
 
// Step 4 (Optional): Ask Antigravity: "What edge cases is this test missing?"
// Common additions: punycode domains, Unicode local parts, trailing dots