feat: AlertState 적용

Author: opficdev

Application/DevLogPresentation/Sources/Login/LoginFeature.swift

@@ -13,15 +13,12 @@ import Foundation
 struct LoginFeature {
     @ObservableState
     struct State: Equatable {
+        @Presents var alert: AlertState<Never>?
         var isLoading = false
-        var showAlert = false
-        var alertType: AlertType?
-        var alertTitle = ""
-        var alertMessage = ""
     }
 
-    enum Action: BindableAction {
-        case binding(BindingAction<State>)
+    enum Action {
+        case alert(PresentationAction<Never>)
         case tapSignInButton(AuthProvider)
         case signInFailed(AlertType)
         case signInCancelled
@@ -35,15 +32,10 @@ struct LoginFeature {
     @Dependency(SignInUseCaseDependency.self) var signInUseCase
 
     var body: some ReducerOf<Self> {
-        BindingReducer()
         Reduce { state, action in
             switch action {
-            case .binding(\.showAlert):
-                if !state.showAlert {
-                    setAlert(&state, isPresented: false, alertType: nil)
-                }
-            case .binding:  // 다른 binding 액션들은 이쪽으로 처리됨
-                break       // 작성 필수
+            case .alert:
+                break
             case .tapSignInButton(let provider):
                 state.isLoading = true
                 return .run { [signInUseCase] send in
@@ -61,10 +53,11 @@ struct LoginFeature {
                 state.isLoading = false
             case .signInFailed(let alertType):
                 state.isLoading = false
-                setAlert(&state, isPresented: true, alertType: alertType)
+                state.alert = alertState(for: alertType)
             }
             return .none
         }
+        .ifLet(\.$alert, action: \.alert)
     }
 }
 
@@ -98,24 +91,28 @@ extension DependencyValues {
 }
 
 private extension LoginFeature {
-    func setAlert(
-        _ state: inout State,
-        isPresented: Bool,
-        alertType: AlertType?
-    ) {
+    func alertState(for alertType: AlertType) -> AlertState<Never> {
+        let title: String
+        let message: String
+
         switch alertType {
         case .emailUnavailable:
-            state.alertTitle = String(localized: "login_alert_email_unavailable_title")
-            state.alertMessage = String(localized: "login_alert_email_unavailable_message")
+            title = String(localized: "login_alert_email_unavailable_title")
+            message = String(localized: "login_alert_email_unavailable_message")
         case .error:
-            state.alertTitle = String(localized: "common_error_title")
-            state.alertMessage = String(localized: "common_error_message")
-        case .none:
-            state.alertTitle = ""
-            state.alertMessage = ""
+            title = String(localized: "common_error_title")
+            message = String(localized: "common_error_message")
+        }
+
+        return AlertState {
+            TextState(title)
+        } actions: {
+            ButtonState(role: .cancel) {
+                TextState(String(localized: "common_close"))
+            }
+        } message: {
+            TextState(message)
         }
-        state.showAlert = isPresented
-        state.alertType = alertType
     }
 
     func alertType(for error: Error) -> AlertType {

Application/DevLogPresentation/Sources/Login/LoginView.swift

@@ -57,10 +57,6 @@ struct LoginView: View {
                 LoadingView()
             }
         }
-        .alert(store.alertTitle, isPresented: $store.showAlert) {
-            Button(String(localized: "common_close"), role: .cancel) { }
-        } message: {
-            Text(store.alertMessage)
-        }
+        .alert($store.scope(state: \.alert, action: \.alert))
     }
 }

Application/DevLogPresentation/Tests/Login/LoginFeatureTests.swift

@@ -68,7 +68,7 @@ struct LoginFeatureTests {
         spy.resume()
 
         await waitUntil {
-            !driver.isLoading && driver.showAlert
+            !driver.isLoading && driver.hasAlert
         }
 
         #expect(!driver.isLoading)
@@ -83,12 +83,13 @@ struct LoginFeatureTests {
         driver.tapSignInButton(.google)
 
         await waitUntil {
-            driver.showAlert
+            driver.hasAlert
         }
 
-        #expect(driver.alertKind == .emailUnavailable)
-        #expect(driver.alertTitle == String(localized: "login_alert_email_unavailable_title"))
-        #expect(driver.alertMessage == String(localized: "login_alert_email_unavailable_message"))
+        #expect(driver.alert == expectedAlert(
+            title: String(localized: "login_alert_email_unavailable_title"),
+            message: String(localized: "login_alert_email_unavailable_message")
+        ))
     }
 
     @Test("일반 로그인 에러가 발생하면 공통 에러 알림을 표시한다")
@@ -100,12 +101,13 @@ struct LoginFeatureTests {
         driver.tapSignInButton(.apple)
 
         await waitUntil {
-            driver.showAlert
+            driver.hasAlert
         }
 
-        #expect(driver.alertKind == .error)
-        #expect(driver.alertTitle == String(localized: "common_error_title"))
-        #expect(driver.alertMessage == String(localized: "common_error_message"))
+        #expect(driver.alert == expectedAlert(
+            title: String(localized: "common_error_title"),
+            message: String(localized: "common_error_message")
+        ))
     }
 
     @Test("소셜 로그인 취소 에러가 발생하면 알림을 표시하지 않는다")
@@ -121,9 +123,7 @@ struct LoginFeatureTests {
         }
 
         #expect(!driver.showAlert)
-        #expect(driver.alertKind == nil)
-        #expect(driver.alertTitle.isEmpty)
-        #expect(driver.alertMessage.isEmpty)
+        #expect(driver.alert == nil)
     }
 
     @Test("알림을 닫으면 알림 상태와 문구가 초기화된다")
@@ -135,23 +135,16 @@ struct LoginFeatureTests {
         driver.tapSignInButton(.google)
 
         await waitUntil {
-            driver.showAlert
+            driver.hasAlert
         }
 
-        driver.setAlert(false)
+        driver.dismissAlert()
 
         #expect(!driver.showAlert)
-        #expect(driver.alertKind == nil)
-        #expect(driver.alertTitle.isEmpty)
-        #expect(driver.alertMessage.isEmpty)
+        #expect(driver.alert == nil)
     }
 }
 
-private enum LoginAlertKind: Equatable {
-    case emailUnavailable
-    case error
-}
-
 @MainActor
 private struct LoginTestDriver {
     private let feature: StoreOf<LoginFeature>
@@ -161,26 +154,15 @@ private struct LoginTestDriver {
     }
 
     var showAlert: Bool {
-        feature.state.showAlert
-    }
-
-    var alertKind: LoginAlertKind? {
-        switch feature.state.alertType {
-        case .emailUnavailable:
-            return .emailUnavailable
-        case .error:
-            return .error
-        case .none:
-            return nil
-        }
+        hasAlert
     }
 
-    var alertTitle: String {
-        feature.state.alertTitle
+    var hasAlert: Bool {
+        alert != nil
     }
 
-    var alertMessage: String {
-        feature.state.alertMessage
+    var alert: AlertState<Never>? {
+        feature.state.alert
     }
 
     init(useCase: SignInUseCase) {
@@ -197,7 +179,22 @@ private struct LoginTestDriver {
         feature.send(.tapSignInButton(provider))
     }
 
-    func setAlert(_ isPresented: Bool) {
-        feature.send(.binding(.set(\.showAlert, isPresented)))
+    func dismissAlert() {
+        feature.send(.alert(.dismiss))
+    }
+}
+
+private func expectedAlert(
+    title: String,
+    message: String
+) -> AlertState<Never> {
+    AlertState {
+        TextState(title)
+    } actions: {
+        ButtonState(role: .cancel) {
+            TextState(String(localized: "common_close"))
+        }
+    } message: {
+        TextState(message)
     }
 }