Day 8 · 테스트 ① — TestStore

@Reducer
struct Counter {
  @ObservableState
  struct State: Equatable {          // TestStore는 State: Equatable을 요구한다
    var count = 0
    var isEven: Bool { count % 2 == 0 }
  }
  enum Action {
    case decrementButtonTapped
    case incrementButtonTapped
  }
  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .decrementButtonTapped:
        state.count -= 1
        return .none
      case .incrementButtonTapped:
        state.count += 1
        return .none
      }
    }
  }
}

import Testing

@Observable @MainActor
final class CounterModel {
  var count = 0
  func incrementButtonTapped() { count += 1 }
}

@MainActor
struct CounterModelTests {
  @Test func increment() {
    let model = CounterModel()
    model.incrementButtonTapped()
    #expect(model.count == 1)        // 확인하지 않은 프로퍼티는 검사하지 않는다
  }
}

import Testing

@MainActor                           // TestStore는 main actor에 묶여 있다
struct CounterTests {
  @Test func increment() async {     // send가 await라서 async
    let store = TestStore(initialState: Counter.State()) {
      Counter()
    }
    await store.send(.incrementButtonTapped) {
      $0.count = 1                   // $0 = 액션 "전" 상태. 바뀐 뒤 모습으로 고친다
    }
    await store.send(.incrementButtonTapped) {
      $0.count = 2
    }
    #expect(store.state.isEven)      // 계산 프로퍼티는 store.state로 확인
    await store.send(\.decrementButtonTapped) {   // 연관값 없는 케이스는 키패스로도 보낸다
      $0.count = 1
    }
  }
}

await store.send(.incrementButtonTapped) {
  $0.count += 1          // 통과는 하지만 "지금 몇인지"는 증명하지 못한다
}
await store.send(.incrementButtonTapped) {
  $0 = store.state       // 클로저 안의 store.state는 "액션 전" 상태 → 실패한다
}

struct NumberFactClient: Sendable {
  var fetch: @Sendable (Int) async throws -> String
}
extension NumberFactClient: DependencyKey {
  static let liveValue = NumberFactClient { number in
    let url = URL(string: "https://example.com/fact/\(number)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return String(decoding: data, as: UTF8.self)
  }
}
extension DependencyValues {
  var numberFact: NumberFactClient {
    get { self[NumberFactClient.self] }
    set { self[NumberFactClient.self] = newValue }
  }
}

@Reducer
struct NumberFact {
  @ObservableState
  struct State: Equatable {
    var count = 0
    var fact: String?
    var isLoading = false
  }
  enum Action {
    case factButtonTapped
    case factFailed
    case factResponse(String)
    case incrementButtonTapped
  }
  @Dependency(\.numberFact) var numberFact

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .factButtonTapped:
        state.isLoading = true
        state.fact = nil
        return .run { [count = state.count] send in
          let fact = try await numberFact.fetch(count)
          await send(.factResponse(fact))
        } catch: { _, send in
          await send(.factFailed)
        }
      case .factFailed:
        state.isLoading = false
        return .none
      case let .factResponse(fact):
        state.isLoading = false
        state.fact = fact
        return .none
      case .incrementButtonTapped:
        state.count += 1
        return .none
      }
    }
  }
}

import Testing

@MainActor
struct NumberFactTests {
  @Test func factButtonTapped() async {
    let store = TestStore(initialState: NumberFact.State()) {
      NumberFact()
    } withDependencies: {                  // $0 = DependencyValues 복사본
      $0.numberFact = NumberFactClient { "\($0) is a good number" }
    }
    await store.send(.incrementButtonTapped) {
      $0.count = 1
    }
    await store.send(.factButtonTapped) {
      $0.isLoading = true            // 중간 상태도 증명한다
    }
    await store.receive(\.factResponse) {   // 케이스 키패스로 "어떤 액션"인지
      $0.isLoading = false
      $0.fact = "1 is a good number"
    }
  }
}

import Testing

@Observable @MainActor
final class NumberFactModel {
  var count = 0
  var fact: String?
  var isLoading = false
  private let fetch: @Sendable (Int) async throws -> String
  init(fetch: @escaping @Sendable (Int) async throws -> String) { self.fetch = fetch }

  func factButtonTapped() async {
    isLoading = true
    defer { isLoading = false }
    fact = try? await fetch(count)
  }
}

@MainActor
@Test func modelFact() async {
  let model = NumberFactModel { "\($0) is a good number" }
  await model.factButtonTapped()
  #expect(model.fact == "0 is a good number")
  #expect(model.isLoading == false)   // 중간에 true였는지는 이 테스트로 알 수 없다
}

return .run { send in
  for _ in 1...5 {
    try await Task.sleep(for: .seconds(1))   // 테스트에서 바꿀 방법이 없다
    await send(.timerTick)
  }
}

@Reducer
struct Stopwatch {
  @ObservableState
  struct State: Equatable {
    var isRunning = false
    var secondsElapsed = 0
  }
  enum Action {
    case startButtonTapped
    case stopButtonTapped
    case timerTicked
  }
  enum CancelID { case timer }
  @Dependency(\.continuousClock) var clock

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .startButtonTapped:
        state.isRunning = true
        return .run { send in
          for await _ in clock.timer(interval: .seconds(1)) {
            await send(.timerTicked)
          }
        }
        .cancellable(id: CancelID.timer)
      case .stopButtonTapped:
        state.isRunning = false
        return .cancel(id: CancelID.timer)
      case .timerTicked:
        state.secondsElapsed += 1
        return .none
      }
    }
  }
}

import Testing

@MainActor
@Test func stopwatchTicks() async {
  let clock = TestClock()
  let store = TestStore(initialState: Stopwatch.State()) {
    Stopwatch()
  } withDependencies: {
    $0.continuousClock = clock
  }
  await store.send(.startButtonTapped) {
    $0.isRunning = true
  }
  await clock.advance(by: .seconds(1))         // 1초가 "즉시" 흐른다
  await store.receive(\.timerTicked) { $0.secondsElapsed = 1 }

  await clock.advance(by: .seconds(2))         // tick 두 번
  await store.receive(\.timerTicked) { $0.secondsElapsed = 2 }
  await store.receive(\.timerTicked) { $0.secondsElapsed = 3 }

  await store.send(.stopButtonTapped) {        // 타이머를 끄지 않으면 ③ 위반
    $0.isRunning = false
  }
}

@MainActor
struct FeatureTests {
  let store = TestStore(initialState: Counter.State()) { Counter() }   // 공유
  @Test func basics() async {
    await store.send(.incrementButtonTapped) { $0.count = 1 }
  }
}

import Testing

@MainActor
struct FeatureTests {
  @Test func basics() async {
    let store = TestStore(initialState: Counter.State()) { Counter() }
    await store.send(.incrementButtonTapped) { $0.count = 1 }
    await store.finish()     // 해제가 보장되지 않는 구조라면 끝에 명시적으로
  }
}

@Reducer
struct Countdown {
  @ObservableState
  struct State: Equatable {
    var remaining = 3
    var isFinished = false
  }
  enum Action {
    case startButtonTapped
    case ticked
  }
  @Dependency(\.continuousClock) var clock

  var body: some ReducerOf<Self> {
    Reduce { state, action in
      switch action {
      case .startButtonTapped:
        return .run { send in
          for _ in 1...3 {
            try await clock.sleep(for: .seconds(1))
            await send(.ticked)
          }
        }
      case .ticked:
        state.remaining -= 1
        if state.remaining == 0 { state.isFinished = true }
        return .none
      }
    }
  }
}