refactor: LoadingFeature 적용

Author: opficdev

Application/DevLogPresentation/Sources/Search/SearchFeature.swift

@@ -16,7 +16,7 @@ struct SearchFeature {
     @ObservableState
     struct State: Equatable {
         @Presents var alert: AlertState<Never>?
-        var isLoading = false
+        var loading = LoadingFeature.State()
         var isSearching = false
         var searchQuery = ""
         var webPages: [WebPageItem] = []
@@ -30,6 +30,10 @@ struct SearchFeature {
             self.recentQueries = OrderedSet(recentQueries)
         }
 
+        var isLoading: Bool {
+            loading.isLoading
+        }
+
         var visibleTodos: [TodoListItem] {
             if showAllTodos {
                 return todos
@@ -65,9 +69,9 @@ struct SearchFeature {
         case clearRecentQueries
         case applySearchQuery(String)
         case setAlert(Bool)
-        case setLoading(Bool)
         case setShowAllTodos(Bool)
         case setShowAllWebPages(Bool)
+        case loading(LoadingFeature.Action)
     }
 
     private enum CancelID: Hashable {
@@ -84,14 +88,17 @@ struct SearchFeature {
     private let searchDebounceDelay = Duration.seconds(0.4)
 
     var body: some ReducerOf<Self> {
+        Scope(state: \.loading, action: \.loading) {
+            LoadingFeature()
+        }
         BindingReducer()
         Reduce { state, action in
             switch action {
             case .alert:
                 break
             case .binding(\.isSearching):
                 if !state.isSearching {
-                    return cancelSearchEffect()
+                    return cancelSearchEffect(isLoading: state.isLoading)
                 }
             case .binding(\.searchQuery):
                 state.showAllTodos = false
@@ -100,10 +107,10 @@ struct SearchFeature {
                 if trimmed.isEmpty {
                     state.webPages = []
                     state.todos = []
-                    return cancelSearchEffect()
+                    return cancelSearchEffect(isLoading: state.isLoading)
                 } else {
                     return .concatenate(
-                        cancelSearchEffect(),
+                        cancelSearchEffect(isLoading: state.isLoading),
                         debounceFetchEffect(trimmed)
                     )
                 }
@@ -133,18 +140,18 @@ struct SearchFeature {
                 if trimmed.isEmpty {
                     state.webPages = []
                     state.todos = []
-                    return cancelSearchEffect()
+                    return cancelSearchEffect(isLoading: state.isLoading)
                 } else {
-                    return fetchEffect(trimmed)
+                    return fetchEffect(trimmed, isLoading: state.isLoading)
                 }
             case .setAlert(let isPresented):
                 state.alert = isPresented ? alertState() : nil
-            case .setLoading(let isLoading):
-                state.isLoading = isLoading
             case .setShowAllTodos(let shouldShowAll):
                 state.showAllTodos = shouldShowAll
             case .setShowAllWebPages(let shouldShowAll):
                 state.showAllWebPages = shouldShowAll
+            case .loading:
+                break
             }
 
             return .none
@@ -201,17 +208,17 @@ private enum SearchUpdateRecentQueriesUseCaseKey: DependencyKey {
 }
 
 private extension SearchFeature {
-    func cancelSearchEffect() -> Effect<Action> {
+    func cancelSearchEffect(isLoading: Bool) -> Effect<Action> {
         .merge(
             .cancel(id: CancelID.debounce),
             .cancel(id: CancelID.request),
-            .send(.setLoading(false))
+            endLoadingEffect(isLoading: isLoading)
         )
     }
 
     func debounceFetchEffect(_ query: String) -> Effect<Action> {
         .concatenate(
-            .send(.setLoading(true)),
+            .send(.loading(.begin(target: .default, mode: .immediate))),
             .run { [clock, searchDebounceDelay] send in
                 try await clock.sleep(for: searchDebounceDelay)
                 await send(.applySearchQuery(query))
@@ -220,7 +227,7 @@ private extension SearchFeature {
         )
     }
 
-    func fetchEffect(_ query: String) -> Effect<Action> {
+    func fetchEffect(_ query: String, isLoading: Bool) -> Effect<Action> {
         let searchesTodoOnly = searchesTodoOnly(query)
 
         return .run { [fetchTodosUseCase, fetchWebPagesUseCase] send in
@@ -235,17 +242,26 @@ private extension SearchFeature {
                 let resolvedWebPageItems = try await webPageItems
                 await send(.fetchTodos(todoItems))
                 await send(.fetchWebPage(resolvedWebPageItems))
-                await send(.setLoading(false))
+                if isLoading {
+                    await send(.loading(.end(target: .default, mode: .immediate)))
+                }
             } catch is CancellationError {
                 return
             } catch {
-                await send(.setLoading(false))
+                if isLoading {
+                    await send(.loading(.end(target: .default, mode: .immediate)))
+                }
                 await send(.setAlert(true))
             }
         }
         .cancellable(id: CancelID.request, cancelInFlight: true)
     }
 
+    func endLoadingEffect(isLoading: Bool) -> Effect<Action> {
+        guard isLoading else { return .none }
+        return .send(.loading(.end(target: .default, mode: .immediate)))
+    }
+
     func saveRecentQueriesEffect(_ queries: OrderedSet<String>) -> Effect<Action> {
         let values = Array(queries)
         return .run { [updateRecentSearchQueriesUseCase] _ in

Application/DevLogPresentation/Tests/Search/SearchFeatureTestDoubles.swift

@@ -41,7 +41,9 @@ struct SearchStoreTestAdapter {
         state.todos = initialTodos
         state.webPages = initialWebPages
         state.isSearching = isSearching
-        state.isLoading = isLoading
+        if isLoading {
+            state.loading.setImmediateLoading()
+        }
         store = TestStore(initialState: state) {
             SearchFeature()
         } withDependencies: {
@@ -93,6 +95,7 @@ struct SearchStoreTestAdapter {
 
     func setSearchQuery(_ query: String) async {
         let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines)
+        let wasLoading = store.state.isLoading
         await store.send(.binding(.set(\.searchQuery, query))) {
             $0.searchQuery = query
             $0.showAllTodos = false
@@ -102,13 +105,11 @@ struct SearchStoreTestAdapter {
                 $0.webPages = []
             }
         }
-        await store.receive(.setLoading(false)) {
-            $0.isLoading = false
+        if wasLoading {
+            await receiveEndLoading()
         }
         if !trimmed.isEmpty {
-            await store.receive(.setLoading(true)) {
-                $0.isLoading = true
-            }
+            await receiveBeginLoading()
         }
     }
 
@@ -117,13 +118,12 @@ struct SearchStoreTestAdapter {
     }
 
     func setSearching(_ value: Bool) async {
+        let wasLoading = store.state.isLoading
         await store.send(.binding(.set(\.isSearching, value))) {
             $0.isSearching = value
         }
-        if !value {
-            await store.receive(.setLoading(false)) {
-                $0.isLoading = false
-            }
+        if !value, wasLoading {
+            await receiveEndLoading()
         }
     }
 
@@ -135,25 +135,55 @@ struct SearchStoreTestAdapter {
         todos: [TodoListItem],
         webPages: [WebPageItem]
     ) async {
+        let wasLoading = store.state.isLoading
         await store.receive(.fetchTodos(todos)) {
             $0.todos = todos
         }
         await store.receive(.fetchWebPage(webPages)) {
             $0.webPages = webPages
         }
-        await store.receive(.setLoading(false)) {
-            $0.isLoading = false
+        if wasLoading {
+            await receiveEndLoading()
         }
     }
 
     func receiveSearchFailure() async {
-        await store.receive(.setLoading(false)) {
-            $0.isLoading = false
+        let wasLoading = store.state.isLoading
+        if wasLoading {
+            await receiveEndLoading()
         }
         await store.receive(.setAlert(true)) {
             $0.alert = expectedSearchErrorAlert()
         }
     }
+
+    private func receiveBeginLoading() async {
+        await store.receive(.loading(.begin(target: .default, mode: .immediate))) {
+            $0.loading.setImmediateLoading()
+        }
+    }
+
+    private func receiveEndLoading() async {
+        await store.receive(.loading(.end(target: .default, mode: .immediate))) {
+            $0.loading.setImmediateLoadingFinished()
+        }
+    }
+}
+
+private extension LoadingFeature.State {
+    mutating func setImmediateLoading() {
+        let target = LoadingFeature.Target.default
+        immediateCountByTarget[target] = 1
+        visibleTargets.insert(target)
+        isLoading = !visibleTargets.isEmpty
+    }
+
+    mutating func setImmediateLoadingFinished() {
+        let target = LoadingFeature.Target.default
+        immediateCountByTarget[target] = 0
+        visibleTargets.remove(target)
+        isLoading = !visibleTargets.isEmpty
+    }
 }
 
 final class SearchFetchTodosUseCaseSpy: FetchTodosUseCase {