Buffer actions when sent recursively (#287)

* wip

* wip

* explicit test store

* test

* test

* clean up

Co-authored-by: Stephen Celis <[email protected]>

Author: 2 people

Sources/ComposableArchitecture/Store.swift

@@ -11,6 +11,7 @@ public final class Store<State, Action> {
   private var isSending = false
   private let reducer: (inout State, Action) -> Effect<Action, Never>
   private var synchronousActionsToSend: [Action] = []
+  private var bufferedActions: [Action] = []
 
   /// Initializes a store from an initial state, a reducer, and an environment.
   ///
@@ -131,32 +132,18 @@ public final class Store<State, Action> {
   }
 
   func send(_ action: Action) {
-    self.synchronousActionsToSend.append(action)
-
-    while !self.synchronousActionsToSend.isEmpty {
-      let action = self.synchronousActionsToSend.removeFirst()
-
-      if self.isSending {
-        assertionFailure(
-          """
-          The store was sent the action \(debugCaseOutput(action)) while it was already 
-          processing another action.
-
-          This can happen for a few reasons:
-
-          * The store was sent an action recursively. This can occur when you run an effect \
-          directly in the reducer, rather than returning it from the reducer. Check the stack (⌘7) \
-          to find frames corresponding to one of your reducers. That code should be refactored to \
-          not invoke the effect directly.
-
-          * The store has been sent actions from multiple threads. The `send` method is not \
-          thread-safe, and should only ever be used from a single thread (typically the main \
-          thread). Instead of calling `send` from multiple threads you should use effects to \
-          process expensive computations on background threads so that it can be fed back into the \
-          store.
-          """
-        )
-      }
+    if !self.isSending {
+      self.synchronousActionsToSend.append(action)
+    } else {
+      self.bufferedActions.append(action)
+      return
+    }
+
+    while !self.synchronousActionsToSend.isEmpty || !self.bufferedActions.isEmpty {
+      let action = !self.synchronousActionsToSend.isEmpty
+        ? self.synchronousActionsToSend.removeFirst()
+        : self.bufferedActions.removeFirst()
+
       self.isSending = true
       let effect = self.reducer(&self.state, action)
       self.isSending = false

Tests/ComposableArchitectureTests/StoreTests.swift

@@ -296,4 +296,46 @@ final class StoreTests: XCTestCase {
       XCTAssertEqual(vs.state, 3)
     }
   }
+
+  func testActionQueuing() {
+    let subject = PassthroughSubject<Void, Never>()
+
+    enum Action: Equatable {
+      case incrementTapped
+      case `init`
+      case doIncrement
+    }
+
+    let store = TestStore(
+      initialState: 0,
+      reducer: Reducer<Int, Action, Void> { state, action, _ in
+        switch action {
+        case .incrementTapped:
+          subject.send()
+          return .none
+
+        case .`init`:
+          return subject.map { .doIncrement }.eraseToEffect()
+
+        case .doIncrement:
+          state += 1
+          return .none
+        }
+      },
+      environment: ()
+    )
+
+    store.assert(
+      .send(.`init`),
+      .send(.incrementTapped),
+      .receive(.doIncrement) {
+        $0 = 1
+      },
+      .send(.incrementTapped),
+      .receive(.doIncrement) {
+        $0 = 2
+      },
+      .do { subject.send(completion: .finished) }
+    )
+  }
 }