Writing tests using the withExhaustivity() function does not work on TestStore using the ReducerProtocol

[LudvigIversen]

When writing tests in our project we have found that we would like to use the withExhaustivity() function documented here; https://pointfreeco.github.io/swift-composable-architecture/main/documentation/composablearchitecture/teststore/withexhaustivity(_:operation:)-9psu7

We want to do this because we don't want to turn off exhaustivity for our whole TestStore when doing tests, instead only for specific actions. Consider the following example:

   func test_ {
        let store = TestStore(
            initialState: ListFeature.State(),
            reducer: ListFeature()
        ) {
            ....
        }

        store.send(.updateFilterBy([])) {
            $0.filterBy = []
        }

        store.receive(.refresh)
    }

Here I would like to be able to use the withExhaustivity() operation on the receive like this;

   func test_() {
        let store = TestStore(
            initialState: ListFeature.State(),
            reducer: ListFeature()
        ) {
            ....
        }

        store.send(.updateFilterBy([])) {
            $0.filterBy = []
        }

        store.withExhaustivity(.off(showSkippedAssertions: true)) {
            store.receive(.refresh)
        }
    }

The .refresh action received in this case calls further to other actions but they are not of interest for this specific tests since this focuses only on the .updateFilterBy() action.
However, this does not seem to work as of right now. To use exhaustivity in this test we would need to turn of exhaustivity for the entire test using store.exhaustivity = .off this is not ideal.
What if we change how the .updateFilterBy() action works, making it do additional state-changes? Using store.exhaustivity = .off will make it so that the test won't fail, just giving us an additional warning messages that there are changes that we have not asserted. This is something easily missed.

What we can see is that this functionality works on a TestStore that tests a feature that uses the reducer function, instead of the ReducerProtocol. This would work fine for example;

    func test_() {
        let store = TestStore(
            initialState: DetailFeature.State(),
            reducer: DetailFeature.reducer,
            environment: .unimplemented.with {
                .....
            }
        )

        store.send(.didPressButton) {
               .....
        }

        store.withExhaustivity(.off(showSkippedAssertions: true)) {
            store.receive(.load)
        }
    }

As you can see, this test uses both the reducer as a function, as well as an environment.

My point is, or what I am asking, is that if there are any plans to make the withExhaustivity() function work on TestStore that tests on features using the ReducerProtocol ? And if it should work, what are the things that we might be doing wrong/missing?

[mbrandonw]

Hi @LudvigIversen, there definitely is a chance that we have overlooked something in our implementation of exhaustivity checking in the TestStore, but can you provide a minimal reproducible test that shows the behavior you are seeing? Ideally a failing test that you think should pass.

[LudvigIversen]

Hello @mbrandonw and thank you for answering! Here is an example of something very simple, that as to my understanding is something that should be working

struct TestFeature: ReducerProtocol {
    struct State: Equatable {
        var count: Int

        public init(count: Int) {
            self.count = count
        }
    }

    enum Action: Equatable {
        case increaseCount
        case indirectOne
        case indirectTwo
    }

    func reduce(into state: inout State, action: Action) -> ComposableArchitecture.EffectTask<Action> {
        switch action {
        case .increaseCount:
            state.count += 1
            return EffectPublisher(value: .indirectOne)

        case .indirectOne:
            return EffectPublisher(value: .indirectTwo)

        case .indirectTwo:
            return .none
        }
    }
}

class TestFeatureTests: XCTestCase {
    func test() {
        let store = TestStore(initialState: TestFeature.State(count: 0), reducer: TestFeature())

        store.send(.increaseCount) {
            $0.count = 1
        }

        store.withExhaustivity(.off(showSkippedAssertions: true)) {
            store.receive(.indirectOne)
        }
    }
}

Written as the test is now it fails on my end, it says that the store receives another action after the last one.

[mbrandonw]

Hi @LudvigIversen, thank you for that example, that helps to see what you are trying to achieve.

In my opinion, the current behavior is correct and it's also kinda all we can hope to accomplish. The withExhaustivity helper can only control exhaustivity for a well-defined lexical scope, and the check to make sure you handled all received actions doesn't happen until the deinit of the TestStore, and so well outside that lexical scope.

And I'm not sure there is much we can do about that. We could technically flush all received actions at the end of a withExhaustivity scope, but that doesn't seem right.

There is an alternative to make your example work. You can skipReceivedActions at the end of withExhaustivity to force all actions to be flushed from the system:

await store.withExhaustivity(.off(showSkippedAssertions: true)) {
  await store.receive(.indirectOne)
  await store.skipReceivedActions()
}

I guess you could even cook up your own helper that does this too if this is the behavior you always expect. But I'm not sure it's correct to be the default behavior.

[LudvigIversen]

I understand, thank you for your answer @mbrandonw !