Merge pull request #33 from Ryu0118/feature/teststore-waitforall

Add `TestStore.waitForAll`

Author: Ryu0118

Sources/SimplexArchitecture/TestStore.swift

@@ -11,6 +11,9 @@ public final class TestStore<Reducer: ReducerProtocol> where Reducer.Action: Equ
     /// The running state container.
     var runningContainer: StateContainer<Reducer.Target>?
 
+    /// The running tasks
+    var runningTasks: [SendTask] = []
+
     /// An array of tested actions.
     var testedActions: [ActionTransition<Reducer>] = []
 
@@ -62,6 +65,18 @@ public final class TestStore<Reducer: ReducerProtocol> where Reducer.Action: Equ
         }
     }
 
+    /// Wait for all of the TestStore's remaining SendTasks to complete.
+    public func waitForAll() async {
+        await withTaskGroup(of: Void.self) { group in
+            for task in runningTasks {
+                group.addTask {
+                    await task.wait()
+                }
+            }
+            await group.waitForAll()
+        }
+    }
+
     /// Asserts an action was received from an effect and asserts how the state changes.
     ///
     /// - Parameters:
@@ -210,6 +225,7 @@ public final class TestStore<Reducer: ReducerProtocol> where Reducer.Action: Equ
         let actualContainer = expectedContainer.copy()
 
         let sendTask = target.store.sendIfNeeded(action)
+        runningTasks.append(sendTask)
 
         expected?(actualContainer)
 
@@ -241,6 +257,7 @@ public final class TestStore<Reducer: ReducerProtocol> where Reducer.Action: Equ
         let actualContainer = expectedContainer.copy()
 
         let sendTask = target.store.sendIfNeeded(action)
+        runningTasks.append(sendTask)
 
         expected?(actualContainer)
 
@@ -273,6 +290,7 @@ public final class TestStore<Reducer: ReducerProtocol> where Reducer.Action: Equ
         let actualContainer = expectedContainer.copy()
 
         let sendTask = target.store.sendIfNeeded(action)
+        runningTasks.append(sendTask)
 
         expected?(actualContainer)
 
@@ -304,6 +322,7 @@ public final class TestStore<Reducer: ReducerProtocol> where Reducer.Action: Equ
         let actualContainer = expectedContainer.copy()
 
         let sendTask = target.store.sendIfNeeded(action)
+        runningTasks.append(sendTask)
 
         expected?(actualContainer)
 

Tests/SimplexArchitectureTests/CollectionTests.swift

@@ -0,0 +1,10 @@
+@testable import SimplexArchitecture
+import XCTest
+
+final class CollectionTests: XCTestCase {
+    func testSafe() throws {
+        let array = ["a", "b"]
+        XCTAssertNotNil(array[safe: 1])
+        XCTAssertNil(array[safe: 2])
+    }
+}

Tests/SimplexArchitectureTests/ReducerTests.swift

@@ -1,6 +1,7 @@
 @testable import SimplexArchitecture
 import SwiftUI
 import XCTest
+import Dependencies
 
 @MainActor
 final class ReducerTests: XCTestCase {
@@ -94,6 +95,43 @@ final class ReducerTests: XCTestCase {
             $0.count = 0
         }
     }
+
+    func testDependencies() async {
+        let testStore = TestView(
+            store: Store(
+                reducer: withDependencies {
+                    $0.continuousClock = ImmediateClock()
+                } operation: {
+                    TestReducer()
+                },
+                initialReducerState: .init()
+            )
+        ).testStore(states: .init())
+
+        await testStore.send(.runEffectWithDependencies)
+        await testStore.receive(.increment) {
+            $0.count = 1
+        }
+    }
+
+    func testWaitForAll() async {
+        let testStore = TestView(
+            store: Store(
+                reducer: withDependencies {
+                    $0.continuousClock = ImmediateClock()
+                } operation: {
+                    TestReducer()
+                },
+                initialReducerState: .init()
+            )
+        ).testStore(states: .init())
+
+        await testStore.send(.runEffectWithDependencies)
+        await testStore.waitForAll()
+        await testStore.receive(.increment) {
+            $0.count = 1
+        }
+    }
 }
 
 private struct TestReducer: ReducerProtocol {
@@ -118,8 +156,11 @@ private struct TestReducer: ReducerProtocol {
         case invokeIncrement
         case invokeDecrement
         case send
+        case runEffectWithDependencies
     }
 
+    @Dependency(\.continuousClock) private var clock
+
     func reduce(into state: StateContainer<TestView>, action: ReducerAction) -> SideEffect<Self> {
         switch action {
         case .incrementFromReducerAction:
@@ -171,6 +212,12 @@ private struct TestReducer: ReducerProtocol {
 
         case .send:
             return .send(.increment)
+
+        case .runEffectWithDependencies:
+            return .run { send in
+                try await clock.sleep(for: .seconds(1))
+                await send(.increment)
+            }
         }
     }
 }

Tests/SimplexArchitectureTests/TaskResultTests.swift

@@ -0,0 +1,24 @@
+@testable import SimplexArchitecture
+import XCTest
+
+final class TaskResultTests: XCTestCase {
+    func testCatching() {
+        let result1 = TaskResult {
+            throw CancellationError()
+        }
+        switch result1 {
+        case .success:
+            XCTFail()
+        case .failure(let error):
+            XCTAssertTrue(error is CancellationError)
+        }
+
+        let result2 = TaskResult {}
+        switch result2 {
+        case .success:
+            break
+        case .failure:
+            XCTFail()
+        }
+    }
+}

Tests/SimplexArchitectureTests/TestStoreTests.swift

@@ -6,21 +6,27 @@ final class TestStoreTests: XCTestCase {
     func testSend() async throws {
         let store = TestView().testStore(states: .init())
         XCTAssertNil(store.runningContainer)
-        await store.send(.increment) {
+        XCTAssertTrue(store.runningTasks.isEmpty)
+        let sendTask = await store.send(.increment) {
             $0.count = 1
         }
+        XCTAssertEqual(store.runningTasks, [sendTask])
         XCTAssertNotNil(store.runningContainer)
     }
 
     @MainActor
     func testReceive() async throws {
         let store = TestView().testStore(states: .init())
-        await store.send(.receiveTest)
+        XCTAssertTrue(store.runningTasks.isEmpty)
+
+        let sendTask = await store.send(.receiveTest)
         XCTAssertTrue(store.testedActions.isEmpty)
+        XCTAssertEqual(store.runningTasks, [sendTask])
+
         await store.receive(.increment) {
             $0.count = 1
         }
-        XCTAssertTrue(store.testedActions.count == 1)
+        XCTAssertEqual(store.testedActions.count, 1)
     }
 }