기록소 등록 화면에서 홈 화면으로 전환 간의 엔티티 설계 변경 & 테스트 코드 작성

MemorialHouse/MHApplication/MHApplication/Source/App/SceneDelegate.swift

@@ -17,23 +17,58 @@
         window = UIWindow(windowScene: windowScene)
         registerDependency()
 
-        var initialViewController: UIViewController = RegisterViewController(viewModel: RegisterViewModel())
-        if UserDefaults.standard.object(forKey: Constant.houseNameUserDefaultKey) != nil {
-            do {
-                let viewModelFactory = try DIContainer.shared.resolve(HomeViewModelFactory.self)
-                let viewModel = viewModelFactory.make()
-                initialViewController = HomeViewController(viewModel: viewModel)
-            } catch {
-                MHLogger.error(error.localizedDescription)
-            }
-        }
-
-        let navigationController = UINavigationController(rootViewController: initialViewController)
-        window?.rootViewController = navigationController
+        let initialViewController = createInitialViewController()
+        window?.rootViewController = UINavigationController(rootViewController: initialViewController)
         window?.makeKeyAndVisible()
     }
 
-    func registerDependency() {
+    private func createInitialViewController() -> UIViewController {
+        if isUserRegistered() {
+            return createHomeViewController()
+        } else {
+            return createRegisterViewController()
+        }
+    }
+
+    private func isUserRegistered() -> Bool {
+        return UserDefaults.standard.object(forKey: Constant.houseNameUserDefaultKey) != nil
+    }
+
+    private func createHomeViewController() -> UIViewController {
+        do {
+            let homeViewModelFactory = try DIContainer.shared.resolve(HomeViewModelFactory.self)
+            let homeViewModel = homeViewModelFactory.make()
+            return HomeViewController(viewModel: homeViewModel)
+        } catch {
+            MHLogger.error("HomeViewModelFactory 해제 실패: \(error.localizedDescription)")
+            return createErrorViewController()
+        }
+    }
+
+    private func createRegisterViewController() -> UIViewController {
+        do {
+            let registerViewModelFactory = try DIContainer.shared.resolve(RegisterViewModelFactory.self)
+            let registerViewModel = registerViewModelFactory.make()
+            return RegisterViewController(viewModel: registerViewModel)
+        } catch {
+            MHLogger.error("CreateMemorialHouseNameUseCase 해제 실패: \(error.localizedDescription)")
+            return createErrorViewController()
+        }
+    }
+
+    private func createErrorViewController() -> UIViewController {
+        let errorViewController = UIViewController()
+        errorViewController.view.backgroundColor = .systemRed
+        let label = UILabel()
+        label.text = "오류가 발생했습니다."
+        label.textColor = .white
+        label.textAlignment = .center
+        label.frame = errorViewController.view.bounds
+        errorViewController.view.addSubview(label)
+        return errorViewController
+    }
+
+    private func registerDependency() {
         do {
             try registerStorageDepedency()
             try registerRepositoryDependency()
@@ -48,7 +83,7 @@
 
     private func registerStorageDepedency() throws {
         DIContainer.shared.register(CoreDataStorage.self, object: CoreDataStorage())
-                
+
         let coreDataStorage = try DIContainer.shared.resolve(CoreDataStorage.self)
         DIContainer.shared.register(
             BookCategoryStorage.self,
@@ -62,12 +97,17 @@
             BookStorage.self,
             object: CoreDataBookStorage(coreDataStorage: coreDataStorage)
         )
+        DIContainer.shared.register(
+            MemorialHouseNameStorage.self,
+            object: UserDefaultsMemorialHouseNameStorage()
+        )
     }
 
     private func registerRepositoryDependency() throws {
+        let memorialHouseNameStorage = try DIContainer.shared.resolve(MemorialHouseNameStorage.self)
         DIContainer.shared.register(
-            MemorialHouseRepository.self,
-            object: DefaultMemorialHouseRepository()
+            MemorialHouseNameRepository.self,
+            object: LocalMemorialHouseNameRepository(storage: memorialHouseNameStorage)
         )
 
         let bookCategoryStorage = try DIContainer.shared.resolve(BookCategoryStorage.self)
@@ -87,12 +127,16 @@
         )
     }
 
     private func registerUseCaseDependency() throws {
         // MARK: MemorialHouse UseCase
-        let memorialHouseRepository = try DIContainer.shared.resolve(MemorialHouseRepository.self)
+        let memorialHouseNameRepository = try DIContainer.shared.resolve(MemorialHouseNameRepository.self)
         DIContainer.shared.register(
-            FetchMemorialHouseUseCase.self,
-            object: DefaultFetchMemorialHouseUseCase(repository: memorialHouseRepository)
+            CreateMemorialHouseNameUseCase.self,
+            object: DefaultCreateMemorialHouseNameUseCase(repository: memorialHouseNameRepository)
+        )
+        DIContainer.shared.register(
+            FetchMemorialHouseNameUseCase.self,
+            object: DefaultFetchMemorialHouseNameUseCase(repository: memorialHouseNameRepository)
         )
 
         // MARK: Category UseCase
@@ -135,20 +179,33 @@
 
         // MARK: - BookCover UseCase
         let bookCoverRepository = try DIContainer.shared.resolve(BookCoverRepository.self)
+        DIContainer.shared.register(
+            FetchAllBookCoverUseCase.self,
+            object: DefaultFetchAllBookCoverUseCase(repository: bookCoverRepository)
+        )
         DIContainer.shared.register(
             UpdateBookCoverUseCase.self,
             object: DefaultUpdateBookCoverUseCase(repository: bookCoverRepository)
         )
     }
 
     private func registerViewModelFactoryDependency() throws {
-        // MARK: MemorialHouse ViewModel
-        let fetchMemorialHouseUseCase = try DIContainer.shared.resolve(FetchMemorialHouseUseCase.self)
+        // MARK: Register ViewModel
+        let createMemorialHouseNameUseCase = try DIContainer.shared.resolve(CreateMemorialHouseNameUseCase.self)
+        DIContainer.shared.register(
+            RegisterViewModelFactory.self,
+            object: RegisterViewModelFactory(createMemorialHouseNameUseCase: createMemorialHouseNameUseCase)
+        )
+
+        // MARK: Home ViewModel
+        let fetchMemorialHouseNameUseCase = try DIContainer.shared.resolve(FetchMemorialHouseNameUseCase.self)
+        let fetchAllBookCoverUseCase = try DIContainer.shared.resolve(FetchAllBookCoverUseCase.self)
         let updateBookCoverUseCase = try DIContainer.shared.resolve(UpdateBookCoverUseCase.self)
         DIContainer.shared.register(
             HomeViewModelFactory.self,
             object: HomeViewModelFactory(
-                fetchMemorialHouseUseCase: fetchMemorialHouseUseCase,
+                fetchMemorialHouseNameUseCase: fetchMemorialHouseNameUseCase,
+                fetchAllBookCoverUseCase: fetchAllBookCoverUseCase,
                 updateBookCoverUseCase: updateBookCoverUseCase
             )
         )

MemorialHouse/MHCore/MHCore/MHDataError.swift

@@ -16,6 +16,7 @@ public enum MHDataError: Error, CustomStringConvertible, Equatable {
     case fileMovingFailure
     case fileNotExists
     case generalFailure
+    case setUserDefaultFailure
 
     public var description: String {
         switch self {
@@ -49,6 +50,8 @@ public enum MHDataError: Error, CustomStringConvertible, Equatable {
             "파일이 존재하지 않습니다"
         case .generalFailure:
             "알 수 없는 에러입니다."
+        case .setUserDefaultFailure:
+            "UserDefault 설정 실패"
         }
     }
 }

MemorialHouse/MHData/MHData/LocalStorage/MemorialHouseNameStorage.swift

@@ -0,0 +1,8 @@
+import MHFoundation
+import MHCore
+
+// TODO: 기록소 이름 변경
+public protocol MemorialHouseNameStorage: Sendable {
+    func create(with memorialHouseName: String) async -> Result<Void, MHDataError>
+    func fetch() async -> Result<String, MHDataError>
+}

MemorialHouse/MHData/MHData/LocalStorage/UserDefaults/UserDefaultsMemorialHouseNameStorage.swift

@@ -0,0 +1,28 @@
+import MHCore
+import MHFoundation
+
+public struct UserDefaultsMemorialHouseNameStorage: MemorialHouseNameStorage {
+    private nonisolated(unsafe) let userDefaults: UserDefaults
+
+    public init(userDefaults: UserDefaults = .standard) {
+        self.userDefaults = userDefaults
+    }
+
+    public func create(with memorialHouseName: String) async -> Result<Void, MHDataError> {
+        userDefaults.set(memorialHouseName, forKey: Constant.houseNameUserDefaultKey)
+
+        if userDefaults.string(forKey: Constant.houseNameUserDefaultKey) == memorialHouseName {
+            return .success(())
+        } else {
+            return .failure(.setUserDefaultFailure)
+        }
+    }
+
+    public func fetch() async -> Result<String, MHDataError> {
+        guard let memorialHouseName = userDefaults.string(forKey: Constant.houseNameUserDefaultKey) else {
+            MHLogger.error("MemorialHouseName을 찾을 수 없습니다: \(Constant.houseNameUserDefaultKey)")
+            return .failure(.noSuchEntity(key: Constant.houseNameUserDefaultKey))
+        }
+        return .success(memorialHouseName)
+    }
+}

MemorialHouse/MHData/MHData/Repository/LocalMemorialHouseNameRepository.swift

@@ -0,0 +1,18 @@
+import MHCore
+import MHDomain
+
+public struct LocalMemorialHouseNameRepository: MemorialHouseNameRepository {
+    private let storage: MemorialHouseNameStorage
+
+    public init(storage: MemorialHouseNameStorage) {
+        self.storage = storage
+    }
+
+    public func createMemorialHouseName(with name: String) async -> Result<Void, MHDataError> {
+        return await storage.create(with: name)
+    }
+
+    public func fetchMemorialHouseName() async -> Result<String, MHDataError> {
+        return await storage.fetch()
+    }
+}

MemorialHouse/MHData/MHDataTests/UserDefaultsMemorialHouseNameStorageTests.swift

@@ -0,0 +1,72 @@
+import Testing
+@testable import MHData
+@testable import MHCore
+@testable import MHFoundation
+
+struct UserDefaultsMemorialHouseNameStorageTest {
+    @Test func test저장소에_기록소_이름을_저장한다() async throws {
+        // Arrange
+        let suiteName = UUID().uuidString
+        let userDefaults = UserDefaults(suiteName: suiteName)!
+        let storage = UserDefaultsMemorialHouseNameStorage(userDefaults: userDefaults)
+        let testName = "테스트 기록소"
+
+        // Act
+        let result = await storage.create(with: testName)
+
+        // Assert
+        switch result {
+        case .success:
+            // 비동기 작업 후 일정 시간 대기 (필요 시)
+            let savedName = userDefaults.string(forKey: Constant.houseNameUserDefaultKey)
+            #expect(savedName == testName)
+        case .failure:
+            throw MHDataError.noSuchEntity(key: suiteName)
+        }
+
+        userDefaults.removePersistentDomain(forName: suiteName)
+    }
+
+    @Test func test_fetch_저장소에서_기록소_이름을_불러온다() async throws {
+        // Arrange
+        let suiteName = UUID().uuidString
+        let userDefaults = UserDefaults(suiteName: suiteName)!
+        let storage = UserDefaultsMemorialHouseNameStorage(userDefaults: userDefaults)
+        let testName = "테스트 기록소"
+        userDefaults.set(testName, forKey: Constant.houseNameUserDefaultKey)
+
+        // Act
+        let result = await storage.fetch()
+
+        // Assert
+        switch result {
+        case .success(let fetchedName):
+            #expect(fetchedName == testName)
+        case .failure:
+            throw MHDataError.noSuchEntity(key: suiteName)
+        }
+
+        userDefaults.removePersistentDomain(forName: suiteName)
+    }
+
+    @Test func test_fetch_기록소_이름이_없을때_에러를_반환한다() async throws {
+        // Arrange
+        let suiteName = UUID().uuidString
+        let userDefaults = UserDefaults(suiteName: suiteName)!
+        userDefaults.removePersistentDomain(forName: suiteName)
+        let storage = UserDefaultsMemorialHouseNameStorage(userDefaults: userDefaults)
+
+        // Act
+        let result = await storage.fetch()
+
+        // Assert
+        switch result {
+        case .success:
+            throw MHDataError.noSuchEntity(key: suiteName)
+        case .failure(let error):
+            #expect(error == .noSuchEntity(key: Constant.houseNameUserDefaultKey))
+        }
+
+        userDefaults.removePersistentDomain(forName: suiteName)
+    }
+}

MemorialHouse/MHDomain/MHDomain/Repository/MemorialHouseNameRepository.swift

@@ -0,0 +1,6 @@
+import MHCore
+
+public protocol MemorialHouseNameRepository: Sendable {
+    func createMemorialHouseName(with name: String) async -> Result<Void, MHDataError>
+    func fetchMemorialHouseName() async -> Result<String, MHDataError>
+}

MemorialHouse/MHDomain/MHDomain/UseCase/DefaultBookCoverUseCase.swift

@@ -24,7 +24,7 @@ public struct DefaultFetchBookCoverUseCase: FetchBookCoverUseCase {
     }
 }
 
-public struct DefaultFetchAllBookCoversUseCase: FetchAllBookCoverUseCase {
+public struct DefaultFetchAllBookCoverUseCase: FetchAllBookCoverUseCase {
     private let repository: BookCoverRepository
 
     public init(repository: BookCoverRepository) {