[Xcode/Swift] Quick/NimbleではじめるSwiftの快適ユニットテスト入門

describe("ログイン機能") {
    context("正しい入力のとき") {
        it("成功すべき") {
            // テスト処理をここに書く
        }
    }
}

describe("ある機能") {
    context("ある状況") {
        it("こうなるべき") {
            // 検証
        }
    }
}

import Foundation
import Combine

class GitHubAPIClient {
    func searchRepositories(query: String) -> AnyPublisher<[Repository], Error> {
        guard let encodedQuery = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
              let url = URL(string: "https://api.github.com/search/repositories?q=\(encodedQuery)") else {
            return Fail(error: URLError(.badURL)).eraseToAnyPublisher()
        }
        return URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: SearchResponse.self, decoder: JSONDecoder())
            .map(\.items)
            .receive(on: DispatchQueue.main)
            .eraseToAnyPublisher()
    }
}

import Quick
import Nimble
import Combine
@testable import GitHubSearchApp

class MockGitHubAPIClient: GitHubAPIClient {
    var mockResult: Result<[Repository], Error> = .success([]) // テストケース用のMockデータの役割

    override func searchRepositories(query: String) -> AnyPublisher<[Repository], any Error> {
        switch mockResult {
        case .success(let repos):
            return Just(repos)
                .setFailureType(to: Error.self)
                .eraseToAnyPublisher()
        case .failure(let error):
            return Fail(error: error)
                .eraseToAnyPublisher()
        }
    }
}

import SwiftUI
import Combine

final class SearchViewModel: ObservableObject {
    @Published var query: String = ""
    @Published var results: [Repository] = []
    @Published var isLoading = false
    @Published var errorMessage: String?

    private let apiClient: GitHubAPIClient
    private var cancellables = Set<AnyCancellable>()

    init(apiClient: GitHubAPIClient = GitHubAPIClient()) {
        self.apiClient = apiClient
    }

    func search() {
        guard !query.isEmpty else { return }
        isLoading = true
        errorMessage = nil

        apiClient.searchRepositories(query: query)
            .sink(receiveCompletion: { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    self?.errorMessage = error.localizedDescription
                }
            }, receiveValue: { [weak self] repos in
                self?.results = repos
            })
            .store(in: &cancellables)
    }
}

import SwiftUI

struct SearchView: View {
    @StateObject private var viewModel = SearchViewModel()

    var body: some View {
        NavigationView {
            VStack {
                TextField("Search GitHub repos", text: $viewModel.query)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .padding()

                Button("Search") {
                    viewModel.search()
                }

                if viewModel.isLoading {
                    ProgressView()
                }
                List(viewModel.results) { repo in
                    VStack(alignment: .leading) {
                        Text(repo.name).font(.headline)
                        if let desc = repo.description {
                            Text(desc).font(.subheadline)
                        }
                    }
                }
            }
        }
        .navigationTitle("GitHub Search")
    }
}

#Preview {
    SearchView()
}

import Quick
import Nimble
@testable import GitHubSearchApp

final class SearchViewModelSpec: QuickSpec {
    override class func spec() {
        // 各テスト前に使い回す変数（mockとViewModel）
        var mockApiClient: MockGitHubAPIClient!
        var viewModel: SearchViewModel!

        // 初期状態のテスト（テスト対象が正しく初期化されるか）
        describe("SearchViewModel") {
            it("can be initialized") {
                let viewModel = SearchViewModel()
                expect(viewModel.query).to(equal(""))
                expect(viewModel.results).to(beEmpty())
            }
        }

        describe("SearchViewModel Execute Search") {
            // 各テストごとに ViewModel と モックAPI を毎回初期化
            beforeEach {
                mockApiClient = MockGitHubAPIClient()
                viewModel = SearchViewModel(apiClient: mockApiClient)
            }

            context("When search succeeds") {
                it("Updates the results array") {
                    let expectedRepo = Repository(id: 1, name: "swift", description: "Swift language", html_url: "https://github.com/apple/swift")
                    mockApiClient.mockResult = .success([expectedRepo])
                    viewModel.query = "swift"
                    viewModel.search()
                    expect(viewModel.results).toEventually(haveCount(1))
                    expect(viewModel.results.first?.name).toEventually(equal("swift"))
                }
            }

            context("When search fails") {
                it("sets errorMessage") {
                    mockApiClient.mockResult = .failure(NSError(domain: "", code: 0, userInfo: [NSLocalizedDescriptionKey: "Mock Error"]))
                    viewModel.query = "fail"
                    viewModel.search()
                    expect(viewModel.errorMessage).toEventually(equal("Mock Error"))
                }
            }

            context("When query is empty") {
                it("Does not perform search") {
                    mockApiClient.mockResult = .success([Repository(id: 1, name: "test", description: nil, html_url: "")])
                    viewModel.query = ""
                    viewModel.search()
                    expect(viewModel.results).toEventually(beEmpty())
                }
            }
        }
    }
}