Add binding tests

Sources/RecombinePackage/Middleware.swift

@@ -9,7 +9,7 @@ public struct Middleware<State, Input, Output> {
     public typealias Transform<Result> = (StatePublisher, Output) -> Result
     internal let transform: Function
 
-    /// Create a blank slate Middleware.
+    /// Create a passthrough Middleware.
     public init() where Input == Output {
         self.transform = { Just($1).eraseToAnyPublisher() }
     }

Sources/RecombinePackage/Store/StoreProtocol.swift

@@ -79,17 +79,17 @@ public extension StoreProtocol {
 }
 
 public extension StoreProtocol {
-    /// Create a SwiftUI Binding from a `KeyPath` and a `SubRefinedAction`.
+    /// Create a SwiftUI Binding from a lensing function and a `SubRefinedAction`.
     /// - Parameters:
-    ///   - keyPath: A keypath to the state property.
+    ///   - lens: A lens to the state property.
     ///   - action: The refined action which will be called when the value is changed.
     /// - Returns: A `Binding` whose getter is the property and whose setter dispatches the refined action.
     func binding<Value>(
-        state keyPath: KeyPath<SubState, Value>,
+        state lens: @escaping (SubState) -> Value,
         actions transform: @escaping (Value) -> SubRefinedAction
     ) -> Binding<Value> {
         .init(
-            get: { self.state[keyPath: keyPath] },
+            get: { lens(self.state) },
             set: { self.dispatch(refined: transform($0)) }
         )
     }
@@ -107,15 +107,15 @@ public extension StoreProtocol {
         )
     }
 
-    /// Create a SwiftUI Binding from a `KeyPath` when the value of that path is equivalent to `SubRefinedAction`.
+    /// Create a SwiftUI Binding from a lensing function when the value of that function is equivalent to `SubRefinedAction`.
     /// - Parameters:
-    ///   - keyPath: A keypath to the state property.
+    ///   - lens: A lens to the state property.
     /// - Returns: A `Binding` whose getter is the property and whose setter dispatches the store's refined action.
     func binding<Value>(
-        state keyPath: KeyPath<SubState, Value>
+        state lens: @escaping (SubState) -> Value
     ) -> Binding<Value> where SubRefinedAction == Value {
         .init(
-            get: { self.state[keyPath: keyPath] },
+            get: { lens(self.state) },
             set: { self.dispatch(refined: $0) }
         )
     }

Tests/RecombineTests/StoreTests.swift

@@ -30,7 +30,10 @@ class StoreTests: XCTestCase {
             middleware: .init(),
             publishOn: ImmediateScheduler.shared
         )
-        let subStore = store.lensing(state: \.subState.value, actions: TestFakes.NestedTest.Action.sub)
+        let subStore = store.lensing(
+            state: \.subState.value,
+            actions: TestFakes.NestedTest.Action.sub
+        )
         let stateRecorder = subStore.$state.dropFirst().record()
         let actionsRecorder = subStore.actions.record()
 
@@ -43,6 +46,43 @@ class StoreTests: XCTestCase {
         let actions = try wait(for: actionsRecorder.prefix(1), timeout: 1)
         XCTAssertEqual(actions, [.set(string)])
     }
+
+    func testBinding() throws {
+        let store = BaseStore(
+            state: TestFakes.NestedTest.State(),
+            reducer: TestFakes.NestedTest.reducer,
+            middleware: .init(),
+            publishOn: ImmediateScheduler.shared
+        )
+        let binding1 = store.binding(
+            state: \.subState.value,
+            actions: { .sub(.set("\($0)1")) }
+        )
+        let binding2 = store.lensing(
+            state: \.subState.value
+        ).binding(
+            actions: { .sub(.set("\($0)2")) }
+        )
+        let binding3 = store.lensing(
+            state: \.subState,
+            actions: { .sub(.set("\($0)3")) }
+        ).binding(
+            state: \.value
+        )
+        let stateRecorder = store.$state.dropFirst().record()
+
+        let string = "Oh Yeah!"
+
+        binding1.wrappedValue = string
+        binding2.wrappedValue = string
+        binding3.wrappedValue = string
+
+        let state = try wait(for: stateRecorder.prefix(3), timeout: 1)
+        XCTAssertEqual(
+            state.map(\.subState.value),
+            zip(repeatElement(string, count: 3), 1...).map { "\($0)\($1)" }
+        )
+    }
 }
 
 // Used for deinitialization test