Non-exhaustive testing and stale TestStore state

[RandomActsOfCode]

I have been experimenting with non-exhaustive testing to see if it be can
leveraged to create end-to-end tests with fully live dependencies and features.
The idea would be to create "user journey" based workflows in tests where view
actions are feed into the system and the mutated state asserted on at
various checkpoints. Similar to a UI automation test but without the GUI
clicking:

func testSomeWorkflow() async {
  let testStore = TestStore(initialState: App.State(), reducer: App)
  testStore.exhaustivity = .off

  // Send view only actions to simulate user interactions
  await testStore.send(.loggedIn(.someFeature(.someButtonPressed)))
  await testStore.send(.loggedIn(.someFeature(.someOtherButtonPressed)))

  // Checkpoint
  XCTAssertNotNil(testStore.state.loggedIn.someFeature.someProperty)

  // Continue testing the user journey ...
  await testStore.send(.loggedIn(.someOtherFeature(.checkBoxToggled)))
  await testStore.send(.loggedIn(.someOtherFeature(.someOtherButtonPressed)))
  
  // Another Checkpoint
  XCTAssertEqual(testStore.state.loggedIn.someOtherFeature.someProperty, somevalue)

  // etc.
}

I thought non-exhaustive testing would be a good fit since the intermediate
internal effects don't need to be explicitly captured. However, I am
experiencing stale state on the TestStore as illustrated by the two tests in
this trivial example:

struct AuthenticationFeature: ReducerProtocol {
  struct State: Equatable {}

  enum Action: Equatable {
    case doAuth
    case authSuccessful
  }

  var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
      switch action {
      case .doAuth:
        // pretend credentials were entered, auth succeeded
        return .init(value: .authSuccessful)
      case .authSuccessful:
        return .none
      }
    }
  }
}

struct AppFeature: ReducerProtocol {
  enum State: Equatable {
    case loggedOut(AuthenticationFeature.State)
    case loggedIn /* (LoggedInState) */

    init() {
      self = .loggedOut(.init())
    }

    var isLoggedIn: Bool {
      guard case .loggedIn = self else { return false }
      return true
    }

    var isLoggedOut: Bool {
      guard case .loggedOut = self else { return false }
      return true
    }
  }

  enum Action: Equatable {
    case authentication(action: AuthenticationFeature.Action)
  }

  var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
      switch action {
      case .authentication(.authSuccessful):
        state = .loggedIn
        return .none
      case .authentication:
        return .none
      }
    }
    .ifCaseLet(/State.loggedOut, action: /Action.authentication) {
      AuthenticationFeature()
    }
  }
}

@MainActor
final class MyFeatureTests: XCTestCase {
  func testExhaustive() async {
    let testStore = TestStore(initialState: AppFeature.State(), reducer: AppFeature())
    await testStore.send(.authentication(action: .doAuth))
    await testStore.receive(.authentication(action: .authSuccessful)) {
      $0 = .loggedIn
    }

    // Passes
    XCTAssert(testStore.state.isLoggedIn)
  }

  func testNonExhaustiveStaleState() async {
    let testStore = TestStore(initialState: AppFeature.State(), reducer: AppFeature())
    testStore.exhaustivity = .off

    XCTAssert(testStore.state.isLoggedOut)

    await testStore.send(.authentication(action: .doAuth))
    await testStore.finish()

    // Fails even though .doAuth was processed and AppState was changed to loggedIn
    // TestStore state is updated only if we receive the authSuccessful effect
    XCTAssert(testStore.state.isLoggedIn)
  }
}

The problem is an Action needs to be received to flush the latest state but
there isn't an Action at the same abstraction level that can be received
easily (in the real app). For example, the real authSuccessful action has
associated types:

// The action which needs to be received to update state
case authSuccessful(User, UserSession)

// What to use for associated values? Capturing the values to use would require
// receiving other internal events and would muddy the tests
await testStore.receive(.authentication(action: .authSuccessful(???, ???))) {
 $0 = .loggedIn(???)
}

I am wondering if there way to manually update the TestStore's state without
an explicit action? I was hoping for something like testStore.receive() but could
not find this or something similar.

[mbrandonw]

Hi @RandomActsOfCode, you are correct that state is not updated in the test store until actions are received. We do, however, provide a tool to force receiving all pending actions:

await store.skipReceivedActions()

And we have a test that demonstrates how to use the tool.

Does that help with your situation?

[RandomActsOfCode]

Exactly what I was looking for, thanks for the pointer!

[lukeredpath]

I'm having the same trouble - the skipReceivedActions() function recommended above isn't helping me.

I suspect this might be because I'm sending multiple effects from a single action and using one of my dependencies to control when those actions get sent - the effect actually uses a dependency that returns an AsyncStream and I'm using streamWithContinuation() in my test to trigger client events that will in turn lead to actions being sent to the store from the effect. This continues until the stream finishes and then the effect completes.

So in effect I have:

await store.send(.startsComplexEffect)

continuation.yield(.firstEvent) // will trigger a single action
await store.skipReceivedActions()

continuation.yield(.lastEvent) // will trigger multiple actions
continuation.finish()
await store.skipReceivedActions() // I expect this to skip the actions sent after the effect receives `.lastEvent`
await store.finish() // wait for the effect to finish

Unfortunately this fails with an error on the original .send(.startsComplexEffect) line with the error The store received 5 unexpected actions after this one. Why aren't these being skipped?

[lukeredpath]

Figured this out myself in the end - I needed to await store.finish() to wait for the effect to complete before I called skipReceivedActions(). 🤦🏻