Day 9 · 테스트 ② — 실전

@DependencyClient
struct AuthClient {
  var login: @Sendable (_ email: String) async throws -> Void
}
extension AuthClient: DependencyKey {
  static let liveValue = AuthClient(login: { _ in
    try await Task.sleep(for: .seconds(1))     // 실제로는 서버 호출
  })
  static let testValue = AuthClient()          // 모든 엔드포인트가 unimplemented
}
extension DependencyValues {
  var authClient: AuthClient {
    get { self[AuthClient.self] }
    set { self[AuthClient.self] = newValue }
  }
}

@Reducer
struct Login {
  @ObservableState
  struct State: Equatable {
    var email = ""
    var isLoading = false
    var errorMessage: String?
    var canSubmit: Bool { email.contains("@") && !isLoading }
  }
  enum Action {
    case delegate(Delegate)
    case loginFailed
    case loginSucceeded
    case submitButtonTapped
    @CasePathable                    // 중첩 enum은 직접 붙여야 \.delegate.didLogin이 된다
    enum Delegate { case didLogin }
  }
  @Dependency(\.authClient) var authClient

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .delegate:
        return .none
      case .loginFailed:
        state.isLoading = false
        state.errorMessage = "로그인에 실패했다"
        return .none
      case .loginSucceeded:
        state.isLoading = false
        return .send(.delegate(.didLogin))
      case .submitButtonTapped:
        state.isLoading = true
        state.errorMessage = nil
        return .run { [email = state.email] send in
          try await authClient.login(email)
          await send(.loginSucceeded)
        } catch: { _, send in
          await send(.loginFailed)
        }
      }
    }
  }
}

@Reducer
struct AppFeature {
  enum Tab: Equatable { case activity, profile }
  @ObservableState
  struct State: Equatable {
    var isLoggedIn = false
    var login = Login.State()
    var selectedTab = Tab.profile
  }
  enum Action {
    case login(Login.Action)
  }
  var body: some ReducerOf<Self> {
    Scope(\.login, action: \.login) { Login() }   // 자식이 읽는 DependencyValues 값도 그대로 물려받는다
    Reduce { state, action in
      switch action {
      case .login(.delegate(.didLogin)):
        state.isLoggedIn = true
        state.selectedTab = .activity
        return .none
      case .login:
        return .none
      }
    }
  }
}

import Testing

@MainActor
@Test func loginExhaustive() async {
  let store = TestStore(initialState: AppFeature.State(login: Login.State(email: "blob@example.com"))) {
    AppFeature()
  } withDependencies: {                    // DependencyValues의 authClient를 성공으로
    $0.authClient.login = { _ in }
  }
  await store.send(\.login.submitButtonTapped) {
    $0.login.isLoading = true              // 자식 내부 상태
  }
  await store.receive(\.login.loginSucceeded) {
    $0.login.isLoading = false             // 자식 내부 액션
  }
  await store.receive(\.login.delegate.didLogin) {
    $0.isLoggedIn = true
    $0.selectedTab = .activity             // 정작 확인하고 싶은 것
  }
}

import Testing

@MainActor
@Test func loginSwitchesTab() async {
  let store = TestStore(initialState: AppFeature.State(login: Login.State(email: "blob@example.com"))) {
    AppFeature()
  } withDependencies: {                    // DependencyValues의 authClient를 성공으로
    $0.authClient.login = { _ in }
  }
  store.exhaustivity = .off
  await store.send(\.login.submitButtonTapped)          // 상태 단언 생략
  await store.receive(\.login.delegate.didLogin) {      // 사이의 loginSucceeded는 건너뛴다
    $0.selectedTab = .activity
  }
}

import Testing

@Reducer
struct Recents {
  @ObservableState
  struct State: Equatable {
    var values: [String] = []
  }
  enum Action { case removeButtonTapped }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      state.values.removeLast()
      return .none
    }
  }
}

@MainActor
@Test func removeNonExhaustive() async {
  let store = TestStore(initialState: Recents.State(values: ["a", "b"])) { Recents() }
  store.exhaustivity = .off
  await store.send(.removeButtonTapped) {
    $0.values = ["a"]                       // 또는 #expect($0.values.count == 1)
  }
}

store.exhaustivity = .off
await store.send(.removeButtonTapped) {
  $0.values.removeLast()     // 실행 결과: "A state change does not match expectation"
}

import Testing

struct LoginFailure: Error {}

@MainActor
@Test func retryAfterFailure() async {
  let store = TestStore(initialState: Login.State(email: "blob@example.com")) {
    Login()
  } withDependencies: {                    // DependencyValues: 처음엔 실패하는 서버
    $0.authClient.login = { _ in throw LoginFailure() }
  }
  await store.send(.submitButtonTapped) { $0.isLoading = true }
  await store.receive(\.loginFailed) {
    $0.isLoading = false
    $0.errorMessage = "로그인에 실패했다"
  }

  store.dependencies.authClient.login = { _ in }   // 이제 성공
  await store.send(.submitButtonTapped) {
    $0.isLoading = true
    $0.errorMessage = nil
  }
  await store.receive(\.loginSucceeded) { $0.isLoading = false }
  await store.receive(\.delegate.didLogin)
}

let store = TestStore(initialState: Login.State(email: "blob@example.com")) { Login() }
await store.send(.submitButtonTapped) { $0.isLoading = true }
// 실행 결과: Unimplemented: 'AuthClient.login'   ← 테스트 실패로 기록
// (unimplemented 엔드포인트는 에러를 던지므로 이어서 loginFailed가 들어온다)

import Testing

@Observable @MainActor
final class LoginModel {
  var email = ""
  var errorMessage: String?
  @ObservationIgnored @Dependency(\.authClient) var authClient

  func loginButtonTapped() async {
    do {
      try await authClient.login(email)
      errorMessage = nil
    } catch {
      errorMessage = "로그인에 실패했다"
    }
  }
}

@MainActor
@Test func modelRetry() async {
  let model = withDependencies {           // DependencyValues를 이 블록 안에서만 교체
    $0.authClient.login = { _ in throw LoginFailure() }
  } operation: {
    LoginModel()
  }
  await model.loginButtonTapped()
  #expect(model.errorMessage == "로그인에 실패했다")

  await withDependencies {
    $0.authClient.login = { _ in }
  } operation: {
    await model.loginButtonTapped()
  }
  #expect(model.errorMessage == nil)
}

import Testing

@MainActor
@Suite struct LoginTests {
  @Test(arguments: ["", "blob", "blob@example.com"])
  func canSubmit(email: String) {
    let store = TestStore(initialState: Login.State(email: email)) { Login() }
    #expect(store.state.canSubmit == email.contains("@"))
  }

  @Test func submitLeadsToDelegate() async {
    let store = TestStore(initialState: Login.State(email: "blob@example.com")) {
      Login()
    } withDependencies: {                  // DependencyValues의 authClient를 성공으로
      $0.authClient.login = { _ in }
    }
    store.exhaustivity = .off
    await store.send(.submitButtonTapped) { $0.isLoading = true }   // .off: $0은 액션 후 상태
    await store.receive(\.delegate.didLogin)
  }
}

import Testing

@Reducer
struct LaunchCounter {
  @ObservableState
  struct State: Equatable {
    @Shared var count: Int
  }
  enum Action {
    case appLaunched
    case resetButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .appLaunched:
        state.$count.withLock { $0 += 1 }
        return .none
      case .resetButtonTapped:
        return .run { [count = state.$count] _ in
          count.withLock { $0 = 0 }            // 액션 없이 이펙트가 직접 바꾼다
        }
      }
    }
  }
}

@MainActor
@Test func launchAndReset() async {
  let store = TestStore(initialState: LaunchCounter.State(count: Shared(value: 0))) {
    LaunchCounter()
  }
  await store.send(.appLaunched) {
    $0.$count.withLock { $0 = 1 }
  }
  await store.send(.resetButtonTapped)
  store.assert {
    $0.$count.withLock { $0 = 0 }
  }
}

@main
struct MyApp: App {
  var body: some Scene {
    WindowGroup {
      if !isTesting {            // IssueReporting(TCA가 함께 가져옴)의 전역 값
        RootView()
      }
    }
  }
}

struct RootView: View {
  var body: some View { Text("홈") }
}

struct Todo: Equatable, Identifiable {
  let id: UUID
  var title: String
}

@Reducer
struct TodoList {
  @ObservableState
  struct State: Equatable {
    var todos: IdentifiedArrayOf<Todo> = []
  }
  enum Action {
    case addButtonTapped(String)
  }
  @Dependency(\.uuid) var uuid

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case let .addButtonTapped(title):
        state.todos.append(Todo(id: uuid(), title: title))
        return .none
      }
    }
  }
}