TCA で UserDefaults をテスタブルにしつつ ActorIsolated を使ってテストを行う方法

public struct UserDefaultsClient {
  public var boolForKey: @Sendable (String) -> Bool
  public var dataForKey: @Sendable (String) -> Data?
  public var doubleForKey: @Sendable (String) -> Double
  public var integerForKey: @Sendable (String) -> Int
  public var remove: @Sendable (String) async -> Void
  public var setBool: @Sendable (Bool, String) async -> Void
  public var setData: @Sendable (Data?, String) async -> Void
  public var setDouble: @Sendable (Double, String) async -> Void
  public var setInteger: @Sendable (Int, String) async -> Void
  
  // ...
}

public struct UserDefaultsClient {
  // ...

  // 外部からは key を気にせず、特定の key で格納されている Bool を取得できる
  public var hasShownFirstLaunchOnboarding: Bool {
    self.boolForKey(hasShownFirstLaunchOnboardingKey)
  }
  // 外部からは key を気にせず、特定の key で Bool をセットできる
  public func setHasShownFirstLaunchOnboarding(_ bool: Bool) async {
    await self.setBool(bool, hasShownFirstLaunchOnboardingKey)
  }

  public var installationTime: Double {
    self.doubleForKey(installationTimeKey)
  }

  public func setInstallationTime(_ double: Double) async {
    await self.setDouble(double, installationTimeKey)
  }

  public func incrementMultiplayerOpensCount() async -> Int {
    let incremented = self.integerForKey(multiplayerOpensCount) + 1
    await self.setInteger(incremented, multiplayerOpensCount)
    return incremented
  }
}

// UserDefaults で利用する key を　internal で定義しモジュールに閉じ込める
let hasShownFirstLaunchOnboardingKey = "hasShownFirstLaunchOnboardingKey"
let installationTimeKey = "installationTimeKey"
let multiplayerOpensCount = "multiplayerOpensCount"

extension UserDefaultsClient: DependencyKey {
  public static let liveValue: Self = {
    let defaults = { UserDefaults(suiteName: "group.isowords")! }
    return Self(
      boolForKey: { defaults().bool(forKey: $0) },
      dataForKey: { defaults().data(forKey: $0) },
      doubleForKey: { defaults().double(forKey: $0) },
      integerForKey: { defaults().integer(forKey: $0) },
      remove: { defaults().removeObject(forKey: $0) },
      setBool: { defaults().set($0, forKey: $1) },
      setData: { defaults().set($0, forKey: $1) },
      setDouble: { defaults().set($0, forKey: $1) },
      setInteger: { defaults().set($0, forKey: $1) }
    )
  }()
}

extension UserDefaultsClient: TestDependencyKey {
  public static let previewValue = Self.noop

  public static let testValue = Self(
    boolForKey: XCTUnimplemented("\(Self.self).boolForKey", placeholder: false),
    dataForKey: XCTUnimplemented("\(Self.self).dataForKey", placeholder: nil),
    doubleForKey: XCTUnimplemented("\(Self.self).doubleForKey", placeholder: 0),
    integerForKey: XCTUnimplemented("\(Self.self).integerForKey", placeholder: 0),
    remove: XCTUnimplemented("\(Self.self).remove"),
    setBool: XCTUnimplemented("\(Self.self).setBool"),
    setData: XCTUnimplemented("\(Self.self).setData"),
    setDouble: XCTUnimplemented("\(Self.self).setDouble"),
    setInteger: XCTUnimplemented("\(Self.self).setInteger")
  )
}

public struct Onboarding: ReducerProtocol {
  // ...
  @Dependency(\.userDefaults) var userDefaults
  
  public var body: some ReducerProtocol<State, Action> {
    // ...
    case .delegate(.getStarted):
      return .fireAndForget {
        await self.userDefaults.setHasShownFirstLaunchOnboarding(true)
	// ...
      }
    case .skipButtonTapped:
      guard !self.userDefaults.hasShownFirstLaunchOnboarding else {
        return .run { send in
	  await send(.delegate(.getStarted), animation: .default)
	  // ...
	}
	// ...
      }
  }
}

@MainActor
class OnboardingFeatureTests: XCTestCase {
  func testSkip_HasSeenOnboardingBefore() async {
    // `ActorIsolated` というものを使って Bool 値を定義。
    // UserDefaults の set が正しく動作しているか確認するために利用される。
    // `ActorIsolated` については後ほど説明します。
    let isFirstLaunchOnboardingKeySet = ActorIsolated(false)

    let store = TestStore(
      initialState: Onboarding.State(presentationStyle: .help),
      reducer: Onboarding()
    )

    // ...
    
    // `boolForKey` が呼び出されたら `key` に関わらず `true` を返すように override する。
    // `XCTAssertNoDifference` を利用して、`key` が意図したものになっているかどうかもチェック。
    // `XCTAssertNoDifference` については後ほど説明します。
    store.dependencies.userDefaults.boolForKey = { key in
      XCTAssertNoDifference(key, "hasShownFirstLaunchOnboardingKey")
      return true
    }
    
    // `setBool` が呼び出されたら、用意しておいた Bool の変数に `true` をセットするような動作で override する。
    // `XCTAssertNoDifference` を利用しつつ、`key` と `value` が意図したものになっているかもチェック。
    store.dependencies.userDefaults.setBool = { value, key in
      XCTAssertNoDifference(key, "hasShownFirstLaunchOnboardingKey")
      XCTAssertNoDifference(value, true)
      await isFirstLaunchOnboardingKeySet.setValue(true)
    }

    // ...

    // `.skipButtonTapped` Action が発火すると `userDefaults.hasShownFirstLaunchOnboarding` が呼ばれる。
    // その Bool 値は `true` になるように override しているため、
    // `.delegate(.getStarted)` Action が引き続いて発火する
    await store.send(.skipButtonTapped)
    await store.receive(.delegate(.getStarted))

    // `.delegate(.getStarted)` Action が発火した結果、
    // `userDefaults.setHasShownFirstLaunchOnboarding(true)`　が呼ばれる。
    // その結果、`isFirstLaunchOnboardingKeySet` が正しい状態になっていることをチェック。
    await isFirstLaunchOnboardingKeySet.withValue { XCTAssert($0) }
  }
}

@Dependency(\.analytics) var analytics

func reduce(into state: inout State, action: Action) -> Effect<Action, Never> {
  switch action {
  case .buttonTapped:
    return .fireAndForget { try await self.analytics.track("Button Tapped") }
  }
}

@MainActor
func testAnalytics() async {
  let store = TestStore(…)

  var events: [String] = []
  store.dependencies.analytics = AnalyticsClient(
    track: { event in // この closure は @Sendable
      events.append(event) // ここでコンパイルエラーが発生する
    }
  )

  await store.send(.buttonTapped)

  XCTAssertEqual(events, ["Button Tapped"])
}

@MainActor
func testAnalytics() async {
  let store = TestStore(…)

  let events = ActorIsolated<[String]>([])
  store.dependencies.analytics = AnalyticsClient(
    track: { event in
      await events.withValue { $0.append(event) }
    }
  )

  await store.send(.buttonTapped)

  await events.withValue { XCTAssertEqual($0, ["Button Tapped"]) }
}

@dynamicMemberLookup
public final actor ActorIsolated<Value: Sendable> {
  public var value: Value
  
  public init(_ value: Value) {
    self.value = value
  }

  public subscript<Subject>(dynamicMember keyPath: KeyPath<Value, Subject>) -> Subject {
    self.value[keyPath: keyPath]
  }

  public func withValue<T: Sendable>(
    _ operation: @Sendable (inout Value) async throws -> T
  ) async rethrows -> T {
    var value = self.value
    defer { self.value = value }
    return try await operation(&value)
  }

  public func setValue(_ newValue: Value) {
    self.value = newValue
  }
}