Unconstrain TestStore action for predicate/case path receive (#1856)

* Unconstrain TestStore action for predicate/case path `receive`

These methods are currently defined in a constrained extension, but it's
not necessary, so let's loosen the constraint.

* added some tests

* Update Sources/ComposableArchitecture/TestStore.swift

* flakey test

Co-authored-by: Brandon Williams <mbrandonw@hey.com>
(cherry picked from commit b524b01be3dd7aa0220a4184cc1500ee7cb62ece)

Author: 2 people

Sources/ComposableArchitecture/TestStore.swift

@@ -1337,6 +1337,111 @@ extension TestStore where ScopedState: Equatable, Action: Equatable {
     )
   }
 
+  // NB: Only needed until Xcode ships a macOS SDK that uses the 5.7 standard library.
+  // See: https://forums.swift.org/t/xcode-14-rc-cannot-specialize-protocol-type/60171/15
+  #if swift(>=5.7) && !os(macOS) && !targetEnvironment(macCatalyst)
+    /// Asserts an action was received from an effect and asserts how the state changes.
+    ///
+    /// When an effect is executed in your feature and sends an action back into the system, you can
+    /// use this method to assert that fact, and further assert how state changes after the effect
+    /// action is received:
+    ///
+    /// ```swift
+    /// await store.send(.buttonTapped)
+    /// await store.receive(.response(.success(42)) {
+    ///   $0.count = 42
+    /// }
+    /// ```
+    ///
+    /// Due to the variability of concurrency in Swift, sometimes a small amount of time needs to
+    /// pass before effects execute and send actions, and that is why this method suspends. The
+    /// default time waited is very small, and typically it is enough so you should be controlling
+    /// your dependencies so that they do not wait for real world time to pass (see
+    /// <doc:DependencyManagement> for more information on how to do that).
+    ///
+    /// To change the amount of time this method waits for an action, pass an explicit `timeout`
+    /// argument, or set the ``timeout`` on the ``TestStore``.
+    ///
+    /// - Parameters:
+    ///   - expectedAction: An action expected from an effect.
+    ///   - duration: 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 expected.
+    @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
+    @MainActor
+    public func receive(
+      _ expectedAction: Action,
+      timeout duration: Duration,
+      assert updateStateToExpectedResult: ((inout ScopedState) throws -> Void)? = nil,
+      file: StaticString = #file,
+      line: UInt = #line
+    ) async {
+      await self.receive(
+        expectedAction,
+        timeout: duration.nanoseconds,
+        assert: updateStateToExpectedResult,
+        file: file,
+        line: line
+      )
+    }
+  #endif
+
+  /// Asserts an action was received from an effect and asserts how the state changes.
+  ///
+  /// When an effect is executed in your feature and sends an action back into the system, you can
+  /// use this method to assert that fact, and further assert how state changes after the effect
+  /// action is received:
+  ///
+  /// ```swift
+  /// await store.send(.buttonTapped)
+  /// await store.receive(.response(.success(42)) {
+  ///   $0.count = 42
+  /// }
+  /// ```
+  ///
+  /// Due to the variability of concurrency in Swift, sometimes a small amount of time needs to pass
+  /// before effects execute and send actions, and that is why this method suspends. The default
+  /// time waited is very small, and typically it is enough so you should be controlling your
+  /// dependencies so that they do not wait for real world time to pass (see
+  /// <doc:DependencyManagement> for more information on how to do that).
+  ///
+  /// To change the amount of time this method waits for an action, pass an explicit `timeout`
+  /// argument, or set the ``timeout`` on the ``TestStore``.
+  ///
+  /// - Parameters:
+  ///   - expectedAction: An action expected from an effect.
+  ///   - 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
+  ///     expected.
+  @MainActor
+  @_disfavoredOverload
+  public func receive(
+    _ expectedAction: Action,
+    timeout nanoseconds: UInt64? = nil,
+    assert updateStateToExpectedResult: ((inout ScopedState) throws -> Void)? = nil,
+    file: StaticString = #file,
+    line: UInt = #line
+  ) async {
+    guard !self.reducer.inFlightEffects.isEmpty
+    else {
+      _ = {
+        self.receive(expectedAction, assert: updateStateToExpectedResult, file: file, line: line)
+      }()
+      return
+    }
+    await self.receiveAction(timeout: nanoseconds, file: file, line: line)
+    _ = {
+      self.receive(expectedAction, assert: updateStateToExpectedResult, file: file, line: line)
+    }()
+    await Task.megaYield()
+  }
+}
+
+extension TestStore where ScopedState: Equatable {
   /// Asserts a matching action was received from an effect and asserts how the state changes.
   ///
   /// See ``receive(_:timeout:assert:file:line:)-3myco`` for more information of how to use this
@@ -1412,53 +1517,6 @@ extension TestStore where ScopedState: Equatable, Action: Equatable {
   // NB: Only needed until Xcode ships a macOS SDK that uses the 5.7 standard library.
   // See: https://forums.swift.org/t/xcode-14-rc-cannot-specialize-protocol-type/60171/15
   #if swift(>=5.7) && !os(macOS) && !targetEnvironment(macCatalyst)
-    /// Asserts an action was received from an effect and asserts how the state changes.
-    ///
-    /// When an effect is executed in your feature and sends an action back into the system, you can
-    /// use this method to assert that fact, and further assert how state changes after the effect
-    /// action is received:
-    ///
-    /// ```swift
-    /// await store.send(.buttonTapped)
-    /// await store.receive(.response(.success(42)) {
-    ///   $0.count = 42
-    /// }
-    /// ```
-    ///
-    /// Due to the variability of concurrency in Swift, sometimes a small amount of time needs to
-    /// pass before effects execute and send actions, and that is why this method suspends. The
-    /// default time waited is very small, and typically it is enough so you should be controlling
-    /// your dependencies so that they do not wait for real world time to pass (see
-    /// <doc:DependencyManagement> for more information on how to do that).
-    ///
-    /// To change the amount of time this method waits for an action, pass an explicit `timeout`
-    /// argument, or set the ``timeout`` on the ``TestStore``.
-    ///
-    /// - Parameters:
-    ///   - expectedAction: An action expected from an effect.
-    ///   - duration: 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 expected.
-    @available(iOS 16, macOS 13, tvOS 16, watchOS 9, *)
-    @MainActor
-    public func receive(
-      _ expectedAction: Action,
-      timeout duration: Duration,
-      assert updateStateToExpectedResult: ((inout ScopedState) throws -> Void)? = nil,
-      file: StaticString = #file,
-      line: UInt = #line
-    ) async {
-      await self.receive(
-        expectedAction,
-        timeout: duration.nanoseconds,
-        assert: updateStateToExpectedResult,
-        file: file,
-        line: line
-      )
-    }
-
     /// Asserts an action was received from an effect that matches a predicate, and asserts how the
     /// state changes.
     ///
@@ -1511,58 +1569,6 @@ extension TestStore where ScopedState: Equatable, Action: Equatable {
     }
   #endif
 
-  /// Asserts an action was received from an effect and asserts how the state changes.
-  ///
-  /// When an effect is executed in your feature and sends an action back into the system, you can
-  /// use this method to assert that fact, and further assert how state changes after the effect
-  /// action is received:
-  ///
-  /// ```swift
-  /// await store.send(.buttonTapped)
-  /// await store.receive(.response(.success(42)) {
-  ///   $0.count = 42
-  /// }
-  /// ```
-  ///
-  /// Due to the variability of concurrency in Swift, sometimes a small amount of time needs to pass
-  /// before effects execute and send actions, and that is why this method suspends. The default
-  /// time waited is very small, and typically it is enough so you should be controlling your
-  /// dependencies so that they do not wait for real world time to pass (see
-  /// <doc:DependencyManagement> for more information on how to do that).
-  ///
-  /// To change the amount of time this method waits for an action, pass an explicit `timeout`
-  /// argument, or set the ``timeout`` on the ``TestStore``.
-  ///
-  /// - Parameters:
-  ///   - expectedAction: An action expected from an effect.
-  ///   - 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
-  ///     expected.
-  @MainActor
-  @_disfavoredOverload
-  public func receive(
-    _ expectedAction: Action,
-    timeout nanoseconds: UInt64? = nil,
-    assert updateStateToExpectedResult: ((inout ScopedState) throws -> Void)? = nil,
-    file: StaticString = #file,
-    line: UInt = #line
-  ) async {
-    guard !self.reducer.inFlightEffects.isEmpty
-    else {
-      _ = {
-        self.receive(expectedAction, assert: updateStateToExpectedResult, file: file, line: line)
-      }()
-      return
-    }
-    await self.receiveAction(timeout: nanoseconds, file: file, line: line)
-    _ = {
-      self.receive(expectedAction, assert: updateStateToExpectedResult, file: file, line: line)
-    }()
-    await Task.megaYield()
-  }
-
   /// Asserts an action was received from an effect that matches a predicate, and asserts how the
   /// state changes.
   ///
@@ -1760,10 +1766,9 @@ extension TestStore where ScopedState: Equatable, Action: Equatable {
       while let receivedAction = self.reducer.receivedActions.first,
         !predicate(receivedAction.action)
       {
+        self.reducer.receivedActions.removeFirst()
         actions.append(receivedAction.action)
-        self.withExhaustivity(.off) {
-          self.receive(receivedAction.action, file: file, line: line)
-        }
+        self.reducer.state = receivedAction.state
       }
 
       if !actions.isEmpty {

Sources/ComposableArchitecture/ViewStore.swift

@@ -395,7 +395,7 @@ public final class ViewStore<ViewState, ViewAction> {
   /// - Parameters:
   ///   - action: An action.
   ///   - predicate: A predicate on `ViewState` that determines for how long this method should
-  ///                suspend.
+  ///     suspend.
   @MainActor
   public func send(_ action: ViewAction, while predicate: @escaping (ViewState) -> Bool) async {
     let task = self.send(action)
@@ -415,7 +415,7 @@ public final class ViewStore<ViewState, ViewAction> {
   ///   - action: An action.
   ///   - animation: The animation to perform when the action is sent.
   ///   - predicate: A predicate on `ViewState` that determines for how long this method should
-  ///                suspend.
+  ///     suspend.
   @MainActor
   public func send(
     _ action: ViewAction,
@@ -437,7 +437,7 @@ public final class ViewStore<ViewState, ViewAction> {
   /// ``send(_:while:)``.
   ///
   /// - Parameter predicate: A predicate on `ViewState` that determines for how long this method
-  ///                        should suspend.
+  ///   should suspend.
   @MainActor
   public func yield(while predicate: @escaping (ViewState) -> Bool) async {
     if #available(iOS 15, macOS 12, tvOS 15, watchOS 8, *) {

Tests/ComposableArchitectureTests/EffectTests.swift

@@ -291,33 +291,35 @@ final class EffectTests: XCTestCase {
   }
 
   func testDependenciesTransferredToEffects_Run() async {
-    struct Feature: ReducerProtocol {
-      enum Action: Equatable {
-        case tap
-        case response(Int)
-      }
-      @Dependency(\.date) var date
-      func reduce(into state: inout Int, action: Action) -> EffectTask<Action> {
-        switch action {
-        case .tap:
-          return .run { send in
-            await send(.response(Int(self.date.now.timeIntervalSinceReferenceDate)))
+    await _withMainSerialExecutor {
+      struct Feature: ReducerProtocol {
+        enum Action: Equatable {
+          case tap
+          case response(Int)
+        }
+        @Dependency(\.date) var date
+        func reduce(into state: inout Int, action: Action) -> EffectTask<Action> {
+          switch action {
+          case .tap:
+            return .run { send in
+              await send(.response(Int(self.date.now.timeIntervalSinceReferenceDate)))
+            }
+          case let .response(value):
+            state = value
+            return .none
           }
-        case let .response(value):
-          state = value
-          return .none
         }
       }
-    }
-    let store = TestStore(
-      initialState: 0,
-      reducer: Feature()
-        .dependency(\.date, .constant(.init(timeIntervalSinceReferenceDate: 1_234_567_890)))
-    )
+      let store = TestStore(
+        initialState: 0,
+        reducer: Feature()
+          .dependency(\.date, .constant(.init(timeIntervalSinceReferenceDate: 1_234_567_890)))
+      )
 
-    await store.send(.tap).finish(timeout: NSEC_PER_SEC)
-    await store.receive(.response(1_234_567_890)) {
-      $0 = 1_234_567_890
+      await store.send(.tap).finish(timeout: NSEC_PER_SEC)
+      await store.receive(.response(1_234_567_890)) {
+        $0 = 1_234_567_890
+      }
     }
   }
 

Tests/ComposableArchitectureTests/TestStoreNonExhaustiveTests.swift

@@ -584,6 +584,46 @@
       }
     }
 
+    func testCasePathReceive_Exhaustive_NonEquatable() async {
+      struct NonEquatable {}
+      enum Action { case tap, response(NonEquatable) }
+
+      let store = TestStore(
+        initialState: 0,
+        reducer: Reduce<Int, Action> { state, action in
+          switch action {
+          case .tap:
+            return EffectTask(value: .response(NonEquatable()))
+          case .response:
+            return .none
+          }
+        }
+      )
+
+      await store.send(.tap)
+      await store.receive(/Action.response)
+    }
+
+    func testPredicateReceive_Exhaustive_NonEquatable() async {
+      struct NonEquatable {}
+      enum Action { case tap, response(NonEquatable) }
+
+      let store = TestStore(
+        initialState: 0,
+        reducer: Reduce<Int, Action> { state, action in
+          switch action {
+          case .tap:
+            return EffectTask(value: .response(NonEquatable()))
+          case .response:
+            return .none
+          }
+        }
+      )
+
+      await store.send(.tap)
+      await store.receive({ (/Action.response) ~= $0 })
+    }
+
     func testCasePathReceive_SkipReceivedAction() async {
       let store = TestStore(
         initialState: NonExhaustiveReceive.State(),