Merge pull request #27 from Ryu0118/feature/test-store

[WIP] Add `TestStore<Reducer>`

Author: Ryu0118

Package.resolved

@@ -22,6 +22,8 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/apple/swift-syntax.git", exact: "509.0.0"),
         .package(url: "https://github.com/pointfreeco/swift-case-paths.git", exact: "1.0.0"),
+        .package(url: "https://github.com/pointfreeco/swift-custom-dump.git", exact: "1.0.0"),
+        .package(url: "https://github.com/pointfreeco/swift-dependencies.git", exact: "1.0.0"),
     ],
     targets: [
         // Targets are the basic building blocks of a package, defining a module or a test suite.
@@ -31,6 +33,8 @@ let package = Package(
             dependencies: [
                 "SimplexArchitectureMacrosPlugin",
                 .product(name: "CasePaths", package: "swift-case-paths"),
+                .product(name: "CustomDump", package: "swift-custom-dump"),
+                .product(name: "Dependencies", package: "swift-dependencies"),
             ]
         ),
         .macro(

Package.swift

@@ -14,12 +14,30 @@ public extension ActionSendable {
     /// Send an action to the store
     @discardableResult
     func send(_ action: consuming Reducer.Action) -> SendTask {
-        if store.container == nil {
+        threadCheck()
+        return if store.container == nil {
             store.sendAction(action, target: self)
         } else {
             store.sendIfNeeded(action)
         }
     }
+
+    @inline(__always)
+    func threadCheck() {
+        #if DEBUG
+            guard !Thread.isMainThread else {
+                return
+            }
+            runtimeWarning(
+                """
+                "ActionSendable.send" was called on a non-main thread.
+
+                The "Store" class is not thread-safe, and so all interactions with an instance of \
+                "Store" must be done on the main thread.
+                """
+            )
+        #endif
+    }
 }
 
 public extension ActionSendable where Reducer.Action: Pullbackable {

Sources/SimplexArchitecture/ActionSendable.swift

@@ -1,6 +1,7 @@
 import Foundation
 
-public struct CombineAction<Reducer: ReducerProtocol> {
+public struct CombineAction<Reducer: ReducerProtocol>: @unchecked Sendable {
+    @usableFromInline
     enum ActionKind {
         case viewAction(
             action: Reducer.Action
@@ -10,23 +11,32 @@ public struct CombineAction<Reducer: ReducerProtocol> {
         )
     }
 
+    @usableFromInline
     let kind: ActionKind
 
+    @usableFromInline
     init(kind: ActionKind) {
         self.kind = kind
     }
 }
 
 public extension CombineAction {
+    @inlinable
     static func action(
         _ action: Reducer.Action
     ) -> Self {
         .init(kind: .viewAction(action: action))
     }
 
+    @inlinable
     static func action(
         _ action: Reducer.ReducerAction
     ) -> Self {
         .init(kind: .reducerAction(action: action))
     }
 }
+
+extension CombineAction: Equatable where CombineAction.ActionKind: Equatable {}
+extension CombineAction.ActionKind: Equatable where Reducer.Action: Equatable, Reducer.ReducerAction: Equatable {}
+extension CombineAction: Hashable where CombineAction.ActionKind: Hashable {}
+extension CombineAction.ActionKind: Hashable where Reducer.Action: Hashable, Reducer.ReducerAction: Hashable {}

Sources/SimplexArchitecture/Effect/CombineAction.swift

@@ -62,21 +62,25 @@ public extension SideEffect {
         .init(effectKind: .serialAction(actions))
     }
 
+    @_disfavoredOverload
     @inlinable
     static func concurrent(_ actions: Reducer.ReducerAction...) -> Self {
         .init(effectKind: .concurrentReducerAction(actions))
     }
 
+    @_disfavoredOverload
     @inlinable
     static func serial(_ actions: Reducer.ReducerAction...) -> Self {
         .init(effectKind: .serialReducerAction(actions))
     }
 
+    @_disfavoredOverload
     @inlinable
     static func concurrent(_ actions: CombineAction<Reducer>...) -> Self {
         .init(effectKind: .concurrentCombineAction(actions))
     }
 
+    @_disfavoredOverload
     @inlinable
     static func serial(_ actions: CombineAction<Reducer>...) -> Self {
         .init(effectKind: .serialCombineAction(actions))

Sources/SimplexArchitecture/Effect/EffectTask.swift renamed to Sources/SimplexArchitecture/Effect/SideEffect.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+/// ``ActionTransition`` represents a transition between states in a reducer. It captures the previous and next states, the associated side effect,effect context, and the action triggering the transition.
+struct ActionTransition<Reducer: ReducerProtocol> {
+    /// Represents a state. It includes the target state and the reducer state.
+    struct State {
+        let state: Reducer.Target.States?
+        let reducerState: Reducer.ReducerState?
+    }
+    /// The previous state.
+    let previous: Self.State
+    /// The next state.
+    let next: Self.State
+    /// The associated side effect.
+    let effect: SideEffect<Reducer>
+    /// The unique effect context that represents parent effect.
+    let effectContext: UUID
+    /// The Action that cause a change of state
+    let action: CombineAction<Reducer>
+
+    /// - Parameters:
+    ///   - previous: The previous state.
+    ///   - next: The next state.
+    ///   - effect: The unique effect context that represents parent effect.
+    ///   - effectContext: The unique effect context that represents parent effect.
+    ///   - action: The action responsible for the transition.
+    init(
+        previous: Self.State,
+        next: Self.State,
+        effect: SideEffect<Reducer>,
+        effectContext: UUID,
+        for action: CombineAction<Reducer>
+    ) {
+        self.previous = previous
+        self.next = next
+        self.effect = effect
+        self.effectContext = effectContext
+        self.action = action
+    }
+
+    /// Converts the `ActionTransition` to a `StateContainer` representing the next state.
+    ///
+    /// - Parameter target: The target reducer.
+    /// - Returns: A `StateContainer` representing the next state.
+    func asNextStateContainer(from target: Reducer.Target) -> StateContainer<Reducer.Target> {
+        asStateContainer(from: target, state: next)
+    }
+
+    /// Converts the `ActionTransition` to a `StateContainer` representing the previous state.
+    ///
+    /// - Parameter target: The target reducer.
+    /// - Returns: A `StateContainer` representing the previous state.
+    func asPreviousStateContainer(from target: Reducer.Target) -> StateContainer<Reducer.Target> {
+        asStateContainer(from: target, state: previous)
+    }
+
+    private func asStateContainer(
+        from target: Reducer.Target,
+        state: Self.State
+    ) -> StateContainer<Reducer.Target> {
+        .init(
+            target,
+            states: state.state,
+            reducerState: state.reducerState
+        )
+    }
+}

Sources/SimplexArchitecture/Internal/ActionTransition.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+extension Collection {
+    subscript(safe index: Index) -> Element? {
+        indices.contains(index) ? self[index] : nil
+    }
+}

Sources/SimplexArchitecture/Internal/Collection+safe.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+/// Enum to determine parent's Effect
+enum EffectContext {
+    @TaskLocal static var id: UUID?
+}

Sources/SimplexArchitecture/Internal/EffectContext.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+extension Task where Failure == any Error {
+    // Granted when there is no EffectContext in the Task.
+    @discardableResult
+    static func withEffectContext(
+        priority: TaskPriority? = nil,
+        @_inheritActorContext @_implicitSelfCapture operation: @Sendable @escaping () async throws -> Success
+    ) -> Self {
+        if let _ = EffectContext.id {
+            Self(priority: priority, operation: operation)
+        } else {
+            Self(priority: priority) {
+                try await EffectContext.$id.withValue(UUID()) {
+                    try await operation()
+                }
+            }
+        }
+    }
+}
+
+extension Task where Failure == Never {
+    // Granted when there is no EffectContext in the Task.
+    @discardableResult
+    static func withEffectContext(
+        priority: TaskPriority? = nil,
+        @_inheritActorContext @_implicitSelfCapture operation: @Sendable @escaping () async -> Success
+    ) -> Self {
+        if let _ = EffectContext.id {
+            Self(priority: priority, operation: operation)
+        } else {
+            Self(priority: priority) {
+                await EffectContext.$id.withValue(UUID()) {
+                    await operation()
+                }
+            }
+        }
+    }
+}

Sources/SimplexArchitecture/Internal/Task+withEffectContext.swift

@@ -0,0 +1,25 @@
+import Foundation
+import XCTestDynamicOverlay
+
+@propertyWrapper
+struct TestOnly<T> {
+    private var _value: T
+
+    var wrappedValue: T {
+        _read {
+            if !_XCTIsTesting {
+                runtimeWarning("\(Self.self) is accessible only during Unit tests")
+            }
+            yield _value
+        }
+        set {
+            if _XCTIsTesting {
+                _value = newValue
+            }
+        }
+    }
+
+    init(wrappedValue: T) {
+        _value = wrappedValue
+    }
+}