Testing run effect using WithTaskGroup/async let

[PorterHoskins]

What is the best way to test receiving actions when the reducer uses WithTaskGroup inside a run effect? The order the actions can come back can be in any order. This also happens with using async let to execute asynchronous work.

I have tried putting in delays in each of the dependency functions used in the run but that still isn't consistent based on the resources the test runner has.

I've tried using a timeout and while that works, the state assertions come back wrong because another effect can change the state in a different order.

I was looking for examples from isowords but not finding anything. Anyone have any suggestions?

[mbrandonw]

Hi @PorterHoskins, this is definitely a bit of a blind spot in the library right now, and this exact use case was one of the motivating reasons we started a forum discussion that sadly didn't really go anywhere.

Stephen and I have discussed potentially adding a receive method on TestStore that allows you to receive multiple actions in any order. It might look like this:

await store.send(.buttonTapped)
await store.receive(inAnyOrder: [.responseA, .responseB]) {
  // state assertion
}

This could help with testing parallel effects that can emit in any order. It still wouldn't be a 100% solution because if the mutations that happen in .responseA and .responseB overlap at all, then the order of receiving actions will definitely matter and it will be impossible to get a passing test. But, it could still help in the non-overlapping situation.

Even before we add that tool, there is a way to force the order in your test right now. You can use a test scheduler directly in the test to force one affect to take 1 second and the other effect to take 2 seconds. That gives you a deterministic way to sequence the effects:

let testScheduler = DispatchQueue.test
let store = TestStore(...)

store.dependencies.fetchA = { 
  try await testScheduler.sleep(for: .seconds(1))
  return // mock data
}
store.dependencies.fetchB = { 
  try await testScheduler.sleep(for: .seconds(2))
  return // mock data
}

await store.send(.buttonTapped)

await testScheduler.advance(by: .seconds(1))
await store.receive(.responseA)
await testScheduler.advance(by: .seconds(2))
await store.receive(.responseB)

Hopefully that helps.

[PorterHoskins]

I think the scheduler workaround will work. That forum discussion is really interesting and it looks like there isn’t really any good option for testing async-await yet.

I think your suggestion for a receive function that took in actions in any order probably would cover most use cases but yeah I see the potential issue with it.