Effect dispatching multiple actions (#59)

* Testable ActionRecorder

* Rename

* Effect dispatching multiple

* Add test

* Update README.md

* Add coverage fixing test

Author: MortenGregersen

README.md

@@ -51,7 +51,7 @@ Fluxor can be installed as a dependency to your project using [Swift Package Man
 
 ### Requirements
 
-- iOS 13.0+ / Mac OS X 10.15+ / tvOS 13.0+
+- iOS 13.0+ / macOS 10.15+ / tvOS 13.0+
 - Xcode 11.0+
 - Swift 5.2+
 
@@ -106,7 +106,7 @@ import Fluxor
 import Foundation
 
 class TodosEffects: Effects {
-    let fetchTodos = Effect.dispatching {
+    let fetchTodos = Effect.dispatchingOne {
         $0.ofType(FetchTodosAction.self)
             .flatMap { _ in
                 Current.todoService.fetchTodos()

Sources/Fluxor/Effects.swift

@@ -13,7 +13,9 @@ import Combine
  */
 public enum Effect {
     /// An `Effect` that publishes an `Action` to dispatch.
-    case dispatching(_ publisher: (AnyPublisher<Action, Never>) -> AnyPublisher<Action, Never>)
+    case dispatchingOne(_ publisher: (AnyPublisher<Action, Never>) -> AnyPublisher<Action, Never>)
+    /// An `Effect` that publishes multiple`Action`s to dispatch.
+    case dispatchingMultiple(_ publisher: (AnyPublisher<Action, Never>) -> AnyPublisher<[Action], Never>)
     /// An `Effect` that handles the action but doesn't publish a new `Action`.
     case nonDispatching(_ cancellable: (AnyPublisher<Action, Never>) -> AnyCancellable)
 }

Sources/Fluxor/Store.swift

@@ -78,16 +78,20 @@ open class Store<State: Encodable>: ObservableObject {
      */
     public func register(effects: Effects) {
         effects.enabledEffects.forEach { effect in
+            let cancellable: AnyCancellable
             switch effect {
-            case .dispatching(let effectCreator):
-                effectCreator(action.eraseToAnyPublisher())
+            case .dispatchingOne(let effectCreator):
+                cancellable = effectCreator(action.eraseToAnyPublisher())
                     .receive(on: DispatchQueue.main)
                     .sink(receiveValue: self.dispatch(action:))
-                    .store(in: &effectCancellables)
+            case .dispatchingMultiple(let effectCreator):
+                cancellable = effectCreator(action.eraseToAnyPublisher())
+                    .receive(on: DispatchQueue.main)
+                    .sink { $0.forEach(self.dispatch(action:)) }
             case .nonDispatching(let effectCreator):
-                effectCreator(action.eraseToAnyPublisher())
-                    .store(in: &effectCancellables)
+                cancellable = effectCreator(action.eraseToAnyPublisher())
             }
+            cancellable.store(in: &effectCancellables)
         }
     }
 

Sources/FluxorTestSupport/Effect+Run.swift

@@ -10,23 +10,33 @@ import Fluxor
 import XCTest
 
 public extension Effect {
+    enum RunError: Error {
+        case wrongType
+    }
+
     /**
      Run the `Effect` with the specified `Action` and return the published `Action`s.
 
      The `expectedCount` defines how many `Action`s the `Publisher` should publish before they are returned.
 
      - Parameter action: The `Action` to send to the `Effect`
      - Parameter expectedCount: The count of `Action`s to wait for
-     - Parameter file: The calling file (used in log if failing)
-     - Parameter line: The calling line (used in log if failing)
      */
-    func run(with action: Action, expectedCount: Int = 1, file: StaticString = #file, line: UInt = #line) -> [Action] {
+    func run(with action: Action, expectedCount: Int = 1) throws -> [Action] {
         let actions = PassthroughSubject<Action, Never>()
-        guard case .dispatching(let effectCreator) = self else { return [] }
         let recorder = ActionRecorder(numberOfActions: expectedCount)
-        effectCreator(actions.eraseToAnyPublisher()).subscribe(recorder)
+        let publisher: AnyPublisher<[Action], Never>
+        switch self {
+        case .dispatchingOne(let effectCreator):
+            publisher = effectCreator(actions.eraseToAnyPublisher()).map { [$0] }.eraseToAnyPublisher()
+        case .dispatchingMultiple(let effectCreator):
+            publisher = effectCreator(actions.eraseToAnyPublisher())
+        case .nonDispatching:
+            throw RunError.wrongType
+        }
+        publisher.subscribe(recorder)
         actions.send(action)
-        recorder.waitForAllActions()
+        try recorder.waitForAllActions()
         return recorder.actions
     }
 
@@ -50,9 +60,13 @@ public extension Effect {
  Inspired by: https://vojtastavik.com/2019/12/11/combine-publisher-blocking-recorder/
  */
 private class ActionRecorder {
-    typealias Input = Action
+    typealias Input = [Action]
     typealias Failure = Never
 
+    enum RecordingError: Error {
+        case expectedCountNotReached(message: String)
+    }
+
     private let expectation = XCTestExpectation()
     private let waiter = XCTWaiter()
     private(set) var actions = [Action]() { didSet { expectation.fulfill() } }
@@ -65,10 +79,8 @@ private class ActionRecorder {
      Wait for all the expected `Action`s to be published.
 
      - Parameter timeout: The time waiting for the `Action`s
-     - Parameter file: The calling file (used in log if failing)
-     - Parameter line: The calling line (used in log if failing)
      */
-    func waitForAllActions(timeout: TimeInterval = 1, file: StaticString = #file, line: UInt = #line) {
+    func waitForAllActions(timeout: TimeInterval = 1) throws {
         guard actions.count < expectation.expectedFulfillmentCount else { return }
         let waitResult = waiter.wait(for: [expectation], timeout: timeout)
         if waitResult != .completed {
@@ -78,8 +90,8 @@ private class ActionRecorder {
             let formattedNumberOfActions = valueFormatter(expectation.expectedFulfillmentCount)
             let formattedActions = valueFormatter(actions.count)
 
-            XCTFail("Waiting for \(formattedNumberOfActions) timed out. Received only \(formattedActions).",
-                    file: file, line: line)
+            let errorMessage = "Waiting for \(formattedNumberOfActions) timed out. Received only \(formattedActions)."
+            throw RecordingError.expectedCountNotReached(message: errorMessage)
         }
     }
 }
@@ -91,7 +103,7 @@ extension ActionRecorder: Subscriber {
 
     func receive(_ input: Input) -> Subscribers.Demand {
         DispatchQueue.main.async {
-            self.actions.append(input)
+            input.forEach { self.actions.append($0) }
         }
         return .unlimited
     }

Tests/FluxorTests/EffectsTests.swift

@@ -13,6 +13,7 @@ import XCTest
 class EffectsTests: XCTestCase {
     var action = PassthroughSubject<Action, Never>()
 
+    /// Can we lookup `Effect`s?
     func testEffectsLookup() {
         // Given
         struct TestEffects: Effects {
@@ -25,12 +26,13 @@ class EffectsTests: XCTestCase {
         XCTAssertEqual(testEffects.enabledEffects.count, 1)
     }
 
-    func testEffectRunDispatching() {
+    /// Can we run a single dispatching `Effect`?
+    func testEffectRunDispatchingOne() throws {
         // Given
         let action2 = Test2Action()
         let expectation = XCTestExpectation(description: debugDescription)
         expectation.expectedFulfillmentCount = 1
-        let effect = Effect.dispatching {
+        let effect = Effect.dispatchingOne {
             $0.ofType(Test1Action.self)
                 .map { _ in
                     expectation.fulfill()
@@ -40,14 +42,41 @@ class EffectsTests: XCTestCase {
         }
         // When
         let action = Test1Action()
-        let actions: [Action] = effect.run(with: action)
+        let actions: [Action] = try effect.run(with: action)
         effect.run(with: action) // Returns early because of wrong type
         // Then
         wait(for: [expectation], timeout: 1)
         XCTAssertEqual(actions[0] as! Test2Action, action2)
+        XCTAssertThrowsError(try effect.run(with: action, expectedCount: 2))
     }
 
-    func testEffectRunNonDispatching() {
+    /// Can we run a multi dispatching `Effect`?
+    func testEffectRunDispatchingMultiple() throws {
+        // Given
+        let action2 = Test2Action()
+        let action3 = Test3Action()
+        let expectation = XCTestExpectation(description: debugDescription)
+        expectation.expectedFulfillmentCount = 1
+        let effect = Effect.dispatchingMultiple {
+            $0.ofType(Test1Action.self)
+                .map { _ in
+                    expectation.fulfill()
+                    return [action2, action3]
+                }
+                .eraseToAnyPublisher()
+        }
+        // When
+        let action = Test1Action()
+        let actions: [Action] = try effect.run(with: action, expectedCount: 2)
+        effect.run(with: action) // Returns early because of wrong type
+        // Then
+        wait(for: [expectation], timeout: 1)
+        XCTAssertEqual(actions[0] as! Test2Action, action2)
+        XCTAssertEqual(actions[1] as! Test3Action, action3)
+    }
+
+    /// Can we run a non dispatching `Effect`?
+    func testEffectRunNonDispatching() throws {
         // Given
         let expectation = XCTestExpectation(description: debugDescription)
         expectation.expectedFulfillmentCount = 1
@@ -57,13 +86,33 @@ class EffectsTests: XCTestCase {
         // When
         let action = Test1Action()
         effect.run(with: action)
-        _ = effect.run(with: action) // Returns early because of wrong type
+        XCTAssertThrowsError(try effect.run(with: action, expectedCount: 1)) // Returns early because of wrong type
         // Then
         wait(for: [expectation], timeout: 1)
     }
+
+    /// Only here for test coverage of ActionRecorder's empty completion function.
+    func testActionRecorderCompletion() throws {
+        var cancellable: AnyCancellable!
+        let effect = Effect.dispatchingOne {
+            let publisher = PassthroughSubject<Action, Never>()
+            cancellable = $0.sink {
+                publisher.send($0)
+                publisher.send(completion: .finished)
+            }
+            return publisher.eraseToAnyPublisher()
+        }
+        _ = try effect.run(with: Test1Action(), expectedCount: 1)
+        XCTAssertNotNil(cancellable)
+    }
 }
 
 private struct Test1Action: Action {}
+
 private struct Test2Action: Action, Equatable {
     let id = UUID()
 }
+
+private struct Test3Action: Action, Equatable {
+    let id = UUID()
+}

Tests/FluxorTests/StoreTests.swift

@@ -51,10 +51,11 @@ class StoreTests: XCTestCase {
         // Then
         wait(for: [TestEffects.expectation], timeout: 1)
         let dispatchedActions = interceptor.stateChanges.map(\.action)
-        XCTAssertEqual(dispatchedActions.count, 3)
+        XCTAssertEqual(dispatchedActions.count, 4)
         XCTAssertEqual(dispatchedActions[0] as! TestAction, firstAction)
         XCTAssertEqual(dispatchedActions[1] as! AnonymousAction<Void>, TestEffects.responseAction)
         XCTAssertEqual(dispatchedActions[2] as! AnonymousAction<Int>, TestEffects.generateAction)
+        XCTAssertEqual(dispatchedActions[3] as! AnonymousAction<Void>, TestEffects.unrelatedAction)
         XCTAssertEqual(TestEffects.lastAction, TestEffects.generateAction)
     }
 
@@ -179,21 +180,23 @@ class StoreTests: XCTestCase {
         static let responseAction = TestEffects.responseActionTemplate.createAction()
         static let generateActionTemplate = ActionTemplate(id: "TestGenerateAction", payloadType: Int.self)
         static let generateAction = TestEffects.generateActionTemplate.createAction(payload: 42)
+        static let unrelatedActionTemplate = ActionTemplate(id: "UnrelatedAction")
+        static let unrelatedAction = TestEffects.unrelatedActionTemplate.createAction()
         static let expectation = XCTestExpectation()
         static var lastAction: AnonymousAction<Int>?
         static var threadCheck: (() -> Void)!
 
-        let testEffect = Effect.dispatching {
+        let testEffect = Effect.dispatchingOne {
             $0.ofType(TestAction.self)
                 .receive(on: DispatchQueue.global(qos: .background))
                 .map { _ in TestEffects.responseAction }
                 .eraseToAnyPublisher()
         }
 
-        let anotherTestEffect = Effect.dispatching {
+        let anotherTestEffect = Effect.dispatchingMultiple {
             $0.withIdentifier(TestEffects.responseActionIdentifier)
                 .handleEvents(receiveOutput: { _ in TestEffects.threadCheck() })
-                .map { _ in TestEffects.generateAction }
+                .map { _ in [TestEffects.generateAction, TestEffects.unrelatedAction] }
                 .eraseToAnyPublisher()
         }