Separate Recucer’s logic without scoping a new feature

[Pomanks]

Hi! 👋🏻

I’m struggling a bit with tests and dependencies override in a peculiar context:

I have some MainFeature reducer which implements a separate reducer called OperationLogic to separate some actions/state from it, without having to create a brand new feature for that.

The implementation looks a bit like that: (I took inspiration from isowords’s game and isowords’s turn based by the way)

// MARK: - Main

@Reducer
struct MainFeature: Sendable {

    @ObservableState
    struct State: Equatable, Sendable {
        var text: String = ""
    }

    enum Action: Sendable {
        case operation(OperationAction)

        case endpointResult(String)

        enum OperationAction: Sendable {
            case someAction
        }
    }

    @Dependency(\.apiClient)
    var apiClient

    var body: some ReducerOf<Self> {
        Reduce<State, Action> { state, action in
            switch action {
            case .operation:
                break

            case let .endpointResult(string):
                state.text = string
            }

            return .none
        }

        OperationLogic()
    }
}

// MARK: - Logic

@Reducer
struct OperationLogic: Sendable {

    @Dependency(\.apiClient)
    var apiClient

    var body: some ReducerOf<MainFeature> {
        Reduce<State, Action> { _, action in
            guard case let .operation(operationAction) = action else {
                return .none
            }

            switch operationAction {
            case .someAction:
                return .run { send in
                    let response = await apiClient.someEndpointCalled()

                    await send(.endpointResult(response))
                }
            }

            return .none
        }
    }
}

As you can see, I’m not using Scope(state:action:) inside the MainFeature’s body since it relies on the same Action/State.

The problem is, in my tests, when I override the apiClient’s someEndpointCall() to return something else than it’s default result, using store.dependencies the result only seem to be overridden on the second call, like so:

@Suite
struct TestSuite {

    @Test
    func someTest() async throws {
        let store = TestStore(initialState: .init()) {
            MainFeature()
        }

        // default result
        await store.send(\.operation.someAction)
        await store.receive(\.endpointResult) {
            $0.text = "foo bar"
        }

        store.dependencies.someEndpointCalled = {
            "foo"
        }

        // first call
        await store.send(\.operation.someAction)
        await store.receive(\.endpointResult) {
            $0.text = "foo bar"
        }
        // second call
        await store.send(\.operation.someAction)
        await store.receive(\.endpointResult) {
            $0.text = "foo"
        }
    }
}

I’m really wondering if it's because of my current implementation (and not using Scope)

I’m setting up an example project to but until then if you have any idea that comes to mind, I’m all ears 😄

[mbrandonw]

Hi @Pomanks, I'm not able to reproduce this behavior with your code. I copied-pasted it into a project and added the missing pieces necessary to get it compiling, and the test behaves as I would expect:

import ComposableArchitecture
import Testing

@Suite
struct TestSuite {

  @Test
  @MainActor
  func someTest() async throws {
    let store = TestStore(initialState: .init()) {
      MainFeature()
    }

    // default result
    await store.send(\.operation.someAction)
    await store.receive(\.endpointResult) {
      $0.text = "foo bar"
    }

    store.dependencies[APIClient.self].someEndpointCalled = { @Sendable in
      "foo"
    }

    // first call
    await store.send(\.operation.someAction)
    await store.receive(\.endpointResult) {
      $0.text = "foo"  //👈 This is "foo", not "foo bar" 
    }
    // second call
    await store.send(\.operation.someAction)
    await store.receive(\.endpointResult)  // 👈 No assertion necessary because state didn't change
  }
}

@Reducer
struct MainFeature: Sendable {

  @ObservableState
  struct State: Equatable, Sendable {
    var text: String = ""
  }

  enum Action: Sendable {
    case operation(OperationAction)

    case endpointResult(String)

    @CasePathable
    enum OperationAction: Sendable {
      case someAction
    }
  }

  @Dependency(APIClient.self)
  var apiClient

  var body: some ReducerOf<Self> {
    Reduce<State, Action> { state, action in
      switch action {
      case .operation:
        break

      case let .endpointResult(string):
        state.text = string
      }

      return .none
    }

    OperationLogic()
  }
}

@Reducer
struct OperationLogic: Sendable {

  @Dependency(APIClient.self)
  var apiClient

  var body: some ReducerOf<MainFeature> {
    Reduce<State, Action> { _, action in
      guard case let .operation(operationAction) = action else {
        return .none
      }

      switch operationAction {
      case .someAction:
        return .run { send in
          let response = await apiClient.someEndpointCalled()

          await send(.endpointResult(response))
        }
      }

    }
  }
}

struct APIClient: TestDependencyKey {
  var someEndpointCalled: @Sendable () async -> String
  static let testValue = APIClient { "foo bar" }
}

There must be something else happening in your project.

[Pomanks]

Hi @mbrandonw, thank you for that!

My first guess would be I’m not linking to the DependenciesTestSupport correctly for the Tests target since I haven’t found another solution than how I’m currently doing (to be honest, those parts are still a bit obscure for me…).

Right now, the app depends on ComposableArchitecture (under Frameworks, Libraries and Embedded Content) and other packages that themselves depend either on TCA or Dependencies.

Though in the Tests target I directly added DependenciesTestSupport like so:

I’m thinking it’s something related to what’s listed under Statically linking your tests target to Dependencies, even though I’m not seeing any of those logs…

[mbrandonw]

Hi @Pomanks, the DependenciesTestSupport library only contains a .dependency(…) test trait that can be used with Swift Testing, and so should not have an affect on this. Can you try reproducing this in a minimal project that you can share?

[Pomanks]

Ah well… I did some sample project and I cannot reproduce the issue either… (it uses a simple String result right now)
Perhaps it’s too simple and can't trigger the underlying issue yet 🤔

I’ll check back on Monday to add a bit more complexity to the sample project and try to make it behave like our real one.

Anyway, thanks a lot for your help, I’ll share more details as soon as possible!

[Pomanks]

Hi @mbrandonw, after a much deeper debugging I found out my test suite was not correctly set up as well as my feature was a bit too complex and was kind of malfunctioning. I did some rewrite and updated my tests and now everything is working the way it should!

I’m really sorry for bothering you when the problem was on my side… and I’m really thankful you took the time to help!
I’ll close this discussion since it’s not relevant anymore.