Swift Testing × Antigravity — XCTest の限界を超えて AI 駆動テスト設計へ

// テスト対象
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
}
 
// Antigravity が生成したテストをベースに手を加えたもの
@Suite("UserAuthService Validation Tests")
struct UserAuthServiceTests {
 
    let service = UserAuthService()
 
    // MARK: - 正常系
    @Test("有効な認証情報はバリデーションを通過する")
    func validCredentials() throws {
        let result = try service.validate(username: "masaki", password: "Password123")
        #expect(result == true)
    }
 
    // MARK: - ユーザー名バリデーション
    @Test("空のユーザー名は拒否される")
    func emptyUsername() {
        #expect(throws: AuthError.emptyUsername) {
            try service.validate(username: "", password: "Password123")
        }
    }
 
    @Test("20文字を超えるユーザー名は拒否される")
    func tooLongUsername() {
        let longName = String(repeating: "a", count: 21)
        #expect(throws: AuthError.usernameTooLong(maxLength: 20)) {
            try service.validate(username: longName, password: "Password123")
        }
    }
 
    // MARK: - パスワードバリデーション（パラメータ化テスト）
    @Test(
        "無効なパスワードは拒否される",
        arguments: [
            ("short1",   AuthError.passwordTooShort(minLength: 8)),
            ("nonnumber", AuthError.passwordNeedsNumber),
            ("12345678", AuthError.passwordNeedsNumber), // 数字のみも失敗
        ]
    )
    func invalidPasswords(password: String, expectedError: AuthError) {
        #expect(throws: expectedError) {
            try service.validate(username: "validuser", password: password)
        }
    }
 
    // MARK: - 境界値テスト
    @Test("ユーザー名 20 文字はちょうど通過する")
    func exactMaxLengthUsername() throws {
        let exactName = String(repeating: "a", count: 20)
        let result = try service.validate(username: exactName, password: "Password123")
        #expect(result == true)
    }
 
    @Test("パスワード 8 文字はちょうど通過する")
    func exactMinLengthPassword() throws {
        let result = try service.validate(username: "user", password: "Pass1234")
        #expect(result == true)
    }
}

// テスト対象: 非同期のデータ取得サービス
actor NetworkDataService {
    private var cache: [String: Data] = [:]
 
    func fetchData(from url: String) async throws -> Data {
        // キャッシュヒット
        if let cached = cache[url] {
            return cached
        }
 
        // 実際のネットワーク処理（テストではモックに差し替える）
        guard let validURL = URL(string: url) else {
            throw NetworkError.invalidURL(url)
        }
        let (data, response) = try await URLSession.shared.data(from: validURL)
        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw NetworkError.badResponse
        }
        cache[url] = data
        return data
    }
}
 
enum NetworkError: Error, Equatable {
    case invalidURL(String)
    case badResponse
}
 
// テスト用プロトコルを用意してモックに差し替える（依存性注入パターン）
protocol DataFetching: Sendable {
    func fetchData(from url: String) async throws -> Data
}
 
struct MockDataFetcher: DataFetching {
    let result: Result<Data, Error>
 
    func fetchData(from url: String) async throws -> Data {
        try result.get()
    }
}
 
// Antigravity が生成したテストをベースにしたもの
@Suite("Non-blocking Data Fetch Tests")
struct DataFetchTests {
 
    @Test("有効な URL からデータを取得できる")
    func fetchValidData() async throws {
        let expectedData = "hello".data(using: .utf8)!
        let fetcher = MockDataFetcher(result: .success(expectedData))
 
        let result = try await fetcher.fetchData(from: "https://example.com")
        #expect(result == expectedData)
    }
 
    @Test("無効な URL はエラーをスローする")
    func fetchInvalidURL() async {
        let fetcher = MockDataFetcher(result: .failure(NetworkError.invalidURL("not-a-url")))
 
        await #expect(throws: NetworkError.invalidURL("not-a-url")) {
            try await fetcher.fetchData(from: "not-a-url")
        }
    }
 
    @Test("複数の並行フェッチが独立して実行される")
    func concurrentFetch() async throws {
        let fetcher = MockDataFetcher(result: .success(Data()))
 
        // withTaskGroup で並行テスト
        try await withThrowingTaskGroup(of: Data.self) { group in
            for i in 0..<5 {
                group.addTask {
                    try await fetcher.fetchData(from: "https://example.com/\(i)")
                }
            }
            var results: [Data] = []
            for try await data in group {
                results.append(data)
            }
            #expect(results.count == 5)
        }
    }
}

// 既存の XCTest（触らない）
class LegacyTests: XCTestCase {
    func testLegacyFeature() {
        XCTAssertEqual(1 + 1, 2)
    }
}
 
// 新しい Swift Testing（これから書くテスト）
@Test("新機能のテスト")
func newFeatureTest() {
    #expect(1 + 1 == 2)
}

// XCTest → Swift Testing の対応表
 
// XCTAssertEqual → #expect(a == b)
XCTAssertEqual(result, expected)          // Before
#expect(result == expected)               // After
 
// XCTAssertNil → #expect(x == nil)
XCTAssertNil(optionalValue)              // Before
#expect(optionalValue == nil)            // After
 
// XCTAssertTrue / XCTAssertFalse
XCTAssertTrue(isReady)                   // Before
#expect(isReady)                         // After
 
// XCTUnwrap → #require
let value = try XCTUnwrap(optional)      // Before
let value = try #require(optional)       // After
 
// XCTAssertThrowsError → #expect(throws:)
XCTAssertThrowsError(try failingOp()) { error in
    XCTAssertEqual(error as? MyError, .expected)
}
// ↓
#expect(throws: MyError.expected) {
    try failingOp()
}
 
// setUp / tearDown → init / deinit (struct) or @Suite の init
class MyTests: XCTestCase {
    var sut: MyService!
    override func setUp() { sut = MyService() }
    // ↓ struct で書ける
}
struct MyTests {
    let sut = MyService()  // テストごとに新しいインスタンス
}

// ❌ これは Xcode 16 時点でコンパイルエラーまたは実行時クラッシュになる場合がある
@Test("メインアクターのテスト")
func mainActorTest() async {
    await MainActor.run {
        // UI コードのテスト
    }
}
 
// ✅ テスト関数自体に @MainActor を付ける
@Test("メインアクターのテスト")
@MainActor
func mainActorTest() async {
    let viewModel = MyViewModel()  // @MainActor なクラスを直接操作できる
    viewModel.updateTitle("Test")
    #expect(viewModel.title == "Test")
}

// ❌ Sendable でないクラスをテストで使うと警告・エラーになる
class NonSendableService {  // @unchecked Sendable でない
    var state = ""
}
 
// ✅ 解決策 1: struct に変更する（推奨）
struct SendableService {
    var state = ""
}
 
// ✅ 解決策 2: Actor に変更する（状態を持つ場合）
actor StatefulService {
    var state = ""
    func updateState(_ value: String) { state = value }
}
 
// ✅ 解決策 3: @unchecked Sendable（既存コードを変えられない場合の暫定対応）
class LegacyService: @unchecked Sendable {
    var state = ""  // ロックが必要だが、既存コードとの互換性を保てる
}

// ❌ グローバル状態に依存したテスト（並行実行で問題が起きる）
var sharedCounter = 0  // グローバル変数
 
@Test("カウンターをインクリメント")
func incrementTest() {
    sharedCounter += 1
    #expect(sharedCounter == 1)  // 並行実行だと失敗する
}
 
// ✅ 各テストで独立した状態を持つ
struct CounterTests {
    var counter = Counter()  // structなので各テストで独立して初期化
 
    @Test("カウンターをインクリメント")
    mutating func incrementTest() {
        counter.increment()
        #expect(counter.value == 1)  // 常に安定
    }
}

# .xcode/workflows/RunTests.xcodeworkflow の概念的な設定
# 実際は Xcode Cloud UI から設定する
 
start_conditions:
  - pull_request_changes:
      target_branches: ["main", "develop"]
 
actions:
  - action: Test
    scheme: MyApp
    destination:
      platform: iOS Simulator
      version: latest
    test_plans:
      - name: AllTests  # Swift Testing と XCTest が混在していても OK

<!-- agents.md の該当箇所 -->
## テスト生成ルール
 
新しい public 関数やメソッドが追加された場合:
1. Swift Testing 形式でテストを生成する
2. 正常系・異常系・境界値の3カテゴリをカバーする
3. @Test(arguments:) が使えるパラメータ化テストを優先する
4. テストファイルは [TargetName]Tests/ 以下に配置する

// テストヘルパー: 非同期タイムアウト付きのアサーション
extension Testing {
    // カスタムアサーションヘルパー（再利用可能）
}
 
// ファイルやディレクトリのテスト用ヘルパー
struct TestFileHelper {
    let directory: URL
 
    init() throws {
        directory = FileManager.default.temporaryDirectory
            .appendingPathComponent(UUID().uuidString)
        try FileManager.default.createDirectory(
            at: directory,
            withIntermediateDirectories: true
        )
    }
 
    // Swift Testing では deinit でクリーンアップを行える
    // ただし struct は deinit を持てないため、class または actor を使う
 
    func write(_ content: String, to filename: String) throws -> URL {
        let url = directory.appendingPathComponent(filename)
        try content.write(to: url, atomically: true, encoding: .utf8)
        return url
    }
}
 
// テスト内での使用例
@Test("ファイルの読み書きが正しく機能する")
func fileReadWrite() throws {
    let helper = try TestFileHelper()
    let url = try helper.write("Swift Testing is great", to: "test.txt")
 
    let content = try String(contentsOf: url, encoding: .utf8)
    #expect(content == "Swift Testing is great")
}