Merge pull request #11 from ra1028/feat/testing-tool

feat: Testing support library

Author: ra1028

.github/workflows/test.yml

@@ -29,13 +29,13 @@ jobs:
           swift --version
           xcodebuild -version
       - name: Test for macOS
-        run: xcodebuild test -scheme Hooks -destination "platform=macOS"
+        run: xcodebuild test -scheme Hooks-Package -destination "platform=macOS"
       - name: Test for iOS
-        run: xcodebuild test -scheme Hooks -destination "platform=iOS Simulator,name=iPhone 12 Pro"
+        run: xcodebuild test -scheme Hooks-Package -destination "platform=iOS Simulator,name=iPhone 12 Pro"
       - name: Test for tvOS
-        run: xcodebuild test -scheme Hooks -destination "platform=tvOS Simulator,name=Apple TV"
+        run: xcodebuild test -scheme Hooks-Package -destination "platform=tvOS Simulator,name=Apple TV"
       - name: Build for watchOS
-        run: WATCHOS=true xcodebuild build -scheme Hooks -destination "platform=watchOS Simulator,name=Apple Watch Series 6 - 44mm"
+        run: WATCHOS=true xcodebuild build -scheme Hooks-Package -destination "platform=watchOS Simulator,name=Apple Watch Series 6 - 44mm"
 
   build-examples:
     name: Build examples

Package.swift

@@ -13,12 +13,23 @@ let package = Package(
     ],
     products: [
         .library(name: "Hooks", targets: ["Hooks"]),
+        .library(name: "HooksTesting", targets: ["HooksTesting"]),
     ],
     targets: [
-        .target(name: "Hooks"),
+        .target(
+            name: "Hooks"
+        ),
+        .target(
+            name: "HooksTesting",
+            dependencies: ["Hooks"]
+        ),
         .testTarget(
             name: "HooksTests",
-            dependencies: ["Hooks"]
+            dependencies: ["HooksTesting"]
+        ),
+        .testTarget(
+            name: "HooksTestingTests",
+            dependencies: ["HooksTesting"]
         ),
     ],
     swiftLanguageVersions: [.v5]

README.md

@@ -403,24 +403,39 @@ See also: [Building Your Own React Hooks](https://reactjs.org/docs/hooks-custom.
 ## How to Test Your Custom Hooks
 
 So far, we have explained that hooks should be called within `HookScope` or `HookView`. Then, how can the custom hook you have created be tested?  
-For such purposes, there is an API to create a temporary hook scope independent of SwiftUI view.  
+To making unit testing of your custom hooks easy, SwiftUI-Hooks provides a simple and complete test utility library `HooksTesting`.  
 
-Within the `withTemporaryHookScope` function, you can launch the hook scope multiple times to test state transitions in cases such as when the SwiftUI view is evaluated multiple times.
+`HookTester` enables unit testing independent of UI of custom hooks by simulating the behavior on the view of a given hook and managing the result values.  
 
-For example:
+Example:  
 
 ```swift
-withTemporaryHookScope { scope in
-    scope {
-        let count = useState(0)
-        count.wrappedValue = 1
-    }
+// Your custom hook.
+func useCounter() -> (count: Int, increment: () -> Void) {
+    let count = useState(0)
 
-    scope {
-        let count = useState(0)
-        XCTAssertEqual(count.wrappedValue, 1)  // The previous state is preserved.
+    let increment = {
+        count.wrappedValue += 1
     }
+
+    return (count: count.wrappedValue, increment: increment)
+}
+```
+
+```swift
+let tester = HookTester {
+    useCounter()
 }
+
+XCTAssertEqual(tester.value.count, 0)
+
+tester.value.increment()
+
+XCTAssertEqual(tester.value.count, 1)
+
+tester.update()  // Simulates view's update.
+
+XCTAssertEqual(tester.value.count, 1)
 ```
 
 ---

Sources/Hooks/Hook/UseContext.swift

@@ -11,7 +11,7 @@ public func useContext<T>(_ context: Context<T>.Type) -> T {
     useHook(ContextHook(context: context))
 }
 
-internal struct ContextHook<T>: Hook {
+private struct ContextHook<T>: Hook {
     let context: Context<T>.Type
     let computation = HookComputation.once
 

Sources/Hooks/Hook/UseEffect.swift

@@ -27,7 +27,33 @@ public func useEffect(
     )
 }
 
-internal struct EffectHook: Hook {
+/// A hook to use a side effect function that is called the number of times according to the strategy specified by `computation`.
+/// Optionally the function can be cancelled when this hook is unmount from the view tree or when the side-effect function is called again.
+/// The signature is identical to `useEffect`, but this fires synchronously when the hook is called.
+///
+///     useLayoutEffect(.always) {
+///         print("View is being evaluated")
+///         return nil
+///     }
+///
+/// - Parameters:
+///   - computation: A computation strategy that to determine when to call the effect function again.
+///   - effect: A closure that typically represents a side-effect.
+///             It is able to return a closure that to do something when this hook is unmount from the view or when the side-effect function is called again.
+public func useLayoutEffect(
+    _ computation: HookComputation,
+    _ effect: @escaping () -> (() -> Void)?
+) {
+    useHook(
+        EffectHook(
+            computation: computation,
+            shouldDeferredCompute: false,
+            effect: effect
+        )
+    )
+}
+
+private struct EffectHook: Hook {
     let computation: HookComputation
     let shouldDeferredCompute: Bool
     let effect: () -> (() -> Void)?
@@ -45,7 +71,7 @@ internal struct EffectHook: Hook {
     }
 }
 
-internal extension EffectHook {
+private extension EffectHook {
     final class State {
         var cleanup: (() -> Void)? {
             didSet { oldValue?() }

Sources/Hooks/Hook/UseEnvironment.swift

@@ -10,7 +10,7 @@ public func useEnvironment<Value>(_ keyPath: KeyPath<EnvironmentValues, Value>)
     useHook(EnvironmentHook(keyPath: keyPath))
 }
 
-internal struct EnvironmentHook<Value>: Hook {
+private struct EnvironmentHook<Value>: Hook {
     let keyPath: KeyPath<EnvironmentValues, Value>
     let computation = HookComputation.once
 

Sources/Hooks/Hook/UseLayoutEffect.swift

@@ -15,7 +15,7 @@ public func useMemo<Value>(
     useHook(MemoHook(computation: computation, makeValue: makeValue))
 }
 
-internal struct MemoHook<Value>: Hook {
+private struct MemoHook<Value>: Hook {
     let computation: HookComputation
     let makeValue: () -> Value
 
@@ -32,7 +32,7 @@ internal struct MemoHook<Value>: Hook {
     }
 }
 
-internal extension MemoHook {
+private extension MemoHook {
     final class State {
         var value: Value?
     }

Sources/Hooks/Hook/UseMemo.swift

@@ -25,7 +25,7 @@ public func usePublisher<P: Publisher>(
     )
 }
 
-internal struct PublisherHook<P: Publisher>: Hook {
+private struct PublisherHook<P: Publisher>: Hook {
     let computation: HookComputation
     let shouldDeferredCompute = true
     let makePublisher: () -> P
@@ -40,12 +40,6 @@ internal struct PublisherHook<P: Publisher>: Hook {
 
     func compute(coordinator: Coordinator) {
         coordinator.state.cancellable = makePublisher()
-            .handleEvents(
-                receiveSubscription: { _ in
-                    coordinator.state.phase = .running
-                    coordinator.updateView()
-                }
-            )
             .sink(
                 receiveCompletion: { completion in
                     switch completion {
@@ -69,9 +63,9 @@ internal struct PublisherHook<P: Publisher>: Hook {
     }
 }
 
-internal extension PublisherHook {
+private extension PublisherHook {
     final class State {
-        var phase = AsyncPhase<P.Output, P.Failure>.pending
+        var phase = AsyncPhase<P.Output, P.Failure>.running
         var cancellable: AnyCancellable?
     }
 }

Sources/Hooks/Hook/UsePublisher.swift

@@ -19,7 +19,7 @@ public func usePublisherSubscribe<P: Publisher>(
     useHook(PublisherSubscribeHook(makePublisher: makePublisher))
 }
 
-internal struct PublisherSubscribeHook<P: Publisher>: Hook {
+private struct PublisherSubscribeHook<P: Publisher>: Hook {
     let makePublisher: () -> P
     let computation = HookComputation.once
 
@@ -73,7 +73,7 @@ internal struct PublisherSubscribeHook<P: Publisher>: Hook {
     }
 }
 
-internal extension PublisherSubscribeHook {
+private extension PublisherSubscribeHook {
     final class State {
         var phase = AsyncPhase<P.Output, P.Failure>.pending
         var isDisposed = false