Non-Exhaustive Tests do not allow to observe State-Changes triggered by indirect actions

[andtie]

Description

Consider the following simple feature:

struct CounterFeature: ReducerProtocol {

    struct State: Equatable {
        var count = 0
    }

    enum Action {
        case direct
        case indirect
    }

    var body: some ReducerProtocol<State, Action> {
        Reduce { state, action in
            switch action {
            case .direct:
                return EffectTask(value: .indirect)
            case .indirect:
                state.count += 1
            }
            return .none
        }
    }
}

When using non-exhaustive tests, it seems not to be possible to observe the state-change that gets indirectly triggered by just sending the .direct-action. See this example-test:

@MainActor
final class NonExhaustiveTest: XCTestCase {
    func testNonExhaustive() async {
        let store = TestStore(initialState: CounterFeature.State()) {
            CounterFeature()
        }
        store.exhaustivity = .off

        await store.send(.direct) {
            $0.count = 1
        }
        // 1️⃣ ❌ testNonExhaustive(): A state change does not match expectation: …
        //
        //      − CounterFeature.State(count: 1)
        //      + CounterFeature.State(count: 0)
        //
        //  (Expected: −, Actual: +)

        XCTAssertEqual(store.state.count, 1)
        // 2️⃣ ❌ testNonExhaustive(): XCTAssertEqual failed: ("0") is not equal to ("1")

        await store.finish(timeout: .seconds(1))
        XCTAssertEqual(store.state.count, 1)
        // 3️⃣ ❌ testNonExhaustive(): XCTAssertEqual failed: ("0") is not equal to ("1")

        await store.receive(.indirect) {
            $0.count = 1
        }
        // 4️⃣ ✅ This one passes.
    }
}

I understand that 1️⃣ and 2️⃣ fail, because the state is not yet updated. But I would expect that 3️⃣ would reflect the updated state.

The documentation of store.finish(timeout:) states:

Suspends until all in-flight effects have finished, or until it times out.

I definitely expected this to work and spent a long time debugging this in a more complex scenario.

If the .indirect-action is explicitly expected (4️⃣) the state-change is observed. But, imho, this defeats the purpose of non-exhaustive testing.

Checklist

• I have determined whether this bug is also reproducible in a vanilla SwiftUI project.
• If possible, I've reproduced the issue using the main branch of this package.
• This issue hasn't been addressed in an existing GitHub issue or discussion.

Expected behavior

The state-change should be observed in 3️⃣.

Actual behavior

The assertions at 1️⃣, 2️⃣ and 3️⃣ fail.

Steps to reproduce

See the above sample-code.

The Composable Architecture version information

0.55.0

Destination operating system

iOS 16.4

Xcode version information

Version 14.3.1 (14E300c)

Swift Compiler version information

swift-driver version: 1.75.2 Apple Swift version 5.8.1 (swiftlang-5.8.0.124.5 clang-1403.0.22.11.100)
Target: arm64-apple-macosx13.0

[mbrandonw]

Hi @andtie, the finish method on TestStore is specifically for waiting for inflight effects to finish, and really is just a kludge due to the flakiness of async tests in Swift in general. In your test, you don't have any inflight effects. The synchronous effect that delivers indirect was processed right away.

It seems what you are looking for is the skipReceivedActions, which does accomplish what you want:

await store.send(.direct)
await store.skipReceivedActions()
XCTAssertEqual(store.state.count, 1)  // ✅

Since this is not an issue with the library I am going to convert it to a discussion, and feel free to follow up with any questions.

[andtie]

Thanks a lot @mbrandonw! skipReceivedActions is exactly the tool that I need.