When exhaustivity is off receive now waits for the expected action rather than the first action (#2100)

* Tests passing

* cleanup

* Add tests

* cleanup

* rollback package resolved

* Clean up

* wip

* Bump up timeouts in tests from hundredths to tenths of a second

* bump timeouts

* fix test

---------

Co-authored-by: Brandon Williams <[email protected]>
Co-authored-by: Brandon Williams <[email protected]>

Author: alex-reilly-pronto

Sources/ComposableArchitecture/TestStore.swift

@@ -1428,7 +1428,12 @@ extension TestStore where ScopedState: Equatable, Action: Equatable {
       }()
       return
     }
-    await self.receiveAction(timeout: nanoseconds, file: file, line: line)
+    await self.receiveAction(
+      matching: { expectedAction == $0 },
+      timeout: nanoseconds,
+      file: file,
+      line: line
+    )
     _ = {
       self.receive(expectedAction, assert: updateStateToExpectedResult, file: file, line: line)
     }()
@@ -1445,7 +1450,6 @@ extension TestStore where ScopedState: Equatable {
   /// - Parameters:
   ///   - isMatching: A closure that attempts to match an action. If it returns `false`, a test
   ///     failure is reported.
-  ///   - nanoseconds: The amount of time to wait for the expected action.
   ///   - updateStateToExpectedResult: A closure that asserts state changed by sending the action to
   ///     the store. The mutable state sent to this closure must be modified to match the state of
   ///     the store after processing the given action. Do not provide a closure if no change is
@@ -1612,7 +1616,7 @@ extension TestStore where ScopedState: Equatable {
       }()
       return
     }
-    await self.receiveAction(timeout: nanoseconds, file: file, line: line)
+    await self.receiveAction(matching: isMatching, timeout: nanoseconds, file: file, line: line)
     _ = {
       self.receive(isMatching, assert: updateStateToExpectedResult, file: file, line: line)
     }()
@@ -1666,7 +1670,12 @@ extension TestStore where ScopedState: Equatable {
       }()
       return
     }
-    await self.receiveAction(timeout: nanoseconds, file: file, line: line)
+    await self.receiveAction(
+      matching: { actionCase.extract(from: $0) != nil },
+      timeout: nanoseconds,
+      file: file,
+      line: line
+    )
     _ = {
       self.receive(actionCase, assert: updateStateToExpectedResult, file: file, line: line)
     }()
@@ -1722,7 +1731,12 @@ extension TestStore where ScopedState: Equatable {
         }()
         return
       }
-      await self.receiveAction(timeout: duration.nanoseconds, file: file, line: line)
+      await self.receiveAction(
+        matching: { actionCase.extract(from: $0) != nil },
+        timeout: duration.nanoseconds,
+        file: file,
+        line: line
+      )
       _ = {
         self.receive(actionCase, assert: updateStateToExpectedResult, file: file, line: line)
       }()
@@ -1821,6 +1835,7 @@ extension TestStore where ScopedState: Equatable {
   }
 
   private func receiveAction(
+    matching predicate: (Action) -> Bool,
     timeout nanoseconds: UInt64?,
     file: StaticString,
     line: UInt
@@ -1832,8 +1847,14 @@ extension TestStore where ScopedState: Equatable {
     while !Task.isCancelled {
       await Task.detached(priority: .background) { await Task.yield() }.value
 
-      guard self.reducer.receivedActions.isEmpty
-      else { break }
+      switch self.exhaustivity {
+      case .on:
+        guard self.reducer.receivedActions.isEmpty
+        else { return }
+      case .off:
+        guard !self.reducer.receivedActions.contains(where: { predicate($0.action) })
+        else { return }
+      }
 
       guard start.distance(to: DispatchTime.now().uptimeNanoseconds) < nanoseconds
       else {
@@ -1861,7 +1882,7 @@ extension TestStore where ScopedState: Equatable {
         }
         XCTFail(
           """
-          Expected to receive an action, but received none\
+          Expected to receive \(self.exhaustivity == .on ? "an action" : "a matching action"), but received none\
           \(nanoseconds > 0 ? " after \(Double(nanoseconds)/Double(NSEC_PER_SEC)) seconds" : "").
 
           \(suggestion)
@@ -1872,9 +1893,6 @@ extension TestStore where ScopedState: Equatable {
         return
       }
     }
-
-    guard !Task.isCancelled
-    else { return }
   }
 }
 

Tests/ComposableArchitectureTests/TestStoreNonExhaustiveTests.swift

@@ -716,6 +716,99 @@
       }
     }
 
+    func testReceiveNonExhuastiveWithTimeout() async {
+      struct Feature: ReducerProtocol {
+        struct State: Equatable {}
+        enum Action: Equatable { case tap, response1, response2 }
+        func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
+          switch action {
+
+          case .tap:
+            return .run { send in
+              try await Task.sleep(nanoseconds: 10_000_000)
+              await send(.response1)
+              try await Task.sleep(nanoseconds: 10_000_000)
+              await send(.response2)
+            }
+          case .response1, .response2:
+            return .none
+          }
+        }
+      }
+
+      let store = TestStore(initialState: Feature.State(), reducer: Feature())
+      store.exhaustivity = .off
+
+      await store.send(.tap)
+      await store.receive(.response2, timeout: 1_000_000_000)
+    }
+
+    func testReceiveNonExhuastiveWithTimeoutMultipleNonMatching() async {
+      struct Feature: ReducerProtocol {
+        struct State: Equatable {}
+        enum Action: Equatable { case tap, response1, response2 }
+        func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
+          switch action {
+
+          case .tap:
+            return .run { send in
+              try await Task.sleep(nanoseconds: 10_000_000)
+              await send(.response1)
+              try await Task.sleep(nanoseconds: 10_000_000)
+              await send(.response1)
+            }
+          case .response1:
+            return .none
+          case .response2:
+            return .none
+          }
+        }
+      }
+
+      let store = TestStore(initialState: Feature.State(), reducer: Feature())
+      store.exhaustivity = .off
+
+      await store.send(.tap)
+      XCTExpectFailure { issue in
+        issue.compactDescription.contains(
+          """
+          Expected to receive a matching action, but received none after 1.0 seconds.
+          """)
+          || (issue.compactDescription.contains(
+            "Expected to receive the following action, but didn't")
+            && issue.compactDescription.contains("Action.response2"))
+      }
+      await store.receive(.response2, timeout: 1_000_000_000)
+    }
+
+    func testReceiveNonExhuastiveWithTimeoutMultipleMatching() async {
+      struct Feature: ReducerProtocol {
+        struct State: Equatable {}
+        enum Action: Equatable { case tap, response1, response2 }
+        func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
+          switch action {
+
+          case .tap:
+            return .run { send in
+              try await Task.sleep(nanoseconds: 10_000_000)
+              await send(.response2)
+              try await Task.sleep(nanoseconds: 10_000_000)
+              await send(.response2)
+            }
+          case .response1, .response2:
+            return .none
+          }
+        }
+      }
+
+      let store = TestStore(initialState: Feature.State(), reducer: Feature())
+      store.exhaustivity = .off
+
+      await store.send(.tap)
+      await store.receive(.response2, timeout: 1_000_000_000)
+      await store.receive(.response2, timeout: 1_000_000_000)
+    }
+
     // This example comes from Krzysztof Zabłocki's blog post:
     // https://www.merowing.info/exhaustive-testing-in-tca/
     func testKrzysztofExample1() {