refactor: now 시점을 최대한 상위 위치로 옮겨 시간을 일차화

Author: opficdev

Application/DevLogPresentation/Sources/Today/TodayFeature+State.swift

@@ -12,7 +12,8 @@ extension TodayFeature {
     static func summaryValue(
         for scope: SectionScope,
         todos: [TodayTodoItem],
-        displayOptions: TodayDisplayOptions
+        displayOptions: TodayDisplayOptions,
+        now: Date
     ) -> Int {
         let displayedTodos = displayedTodos(
             todos: todos,
@@ -25,9 +26,9 @@ extension TodayFeature {
         case .focused:
             return displayedTodos.filter(\.isPinned).count
         case .overdue:
-            return displayedTodos.filter(isOverdue).count
+            return displayedTodos.filter { isOverdue($0, now: now) }.count
         case .dueSoon:
-            return displayedTodos.filter(isDueSoon).count
+            return displayedTodos.filter { isDueSoon($0, now: now) }.count
         }
     }
 
@@ -54,10 +55,11 @@ extension TodayFeature {
     }
 
     static func groupedSectionItems(
-        from items: [TodayTodoItem]
+        from items: [TodayTodoItem],
+        now: Date
     ) -> TodayFeature.SectionCollection {
         let calendar = Calendar.current
-        let startOfToday = calendar.startOfDay(for: Date())
+        let startOfToday = calendar.startOfDay(for: now)
         guard let windowEnd = calendar.date(
             byAdding: .day,
             value: TodayFeature.upcomingWindowDays,
@@ -95,16 +97,16 @@ extension TodayFeature {
         return collection
     }
 
-    static func isOverdue(_ item: TodayTodoItem) -> Bool {
+    static func isOverdue(_ item: TodayTodoItem, now: Date) -> Bool {
         guard let dueDate = item.dueDate else { return false }
         let calendar = Calendar.current
-        return calendar.startOfDay(for: dueDate) < calendar.startOfDay(for: Date())
+        return calendar.startOfDay(for: dueDate) < calendar.startOfDay(for: now)
     }
 
-    static func isDueSoon(_ item: TodayTodoItem) -> Bool {
+    static func isDueSoon(_ item: TodayTodoItem, now: Date) -> Bool {
         guard let dueDate = item.dueDate else { return false }
         let calendar = Calendar.current
-        let startOfToday = calendar.startOfDay(for: Date())
+        let startOfToday = calendar.startOfDay(for: now)
         guard let windowEnd = calendar.date(
             byAdding: .day,
             value: TodayFeature.upcomingWindowDays,

Application/DevLogPresentation/Sources/Today/TodayFeature.swift

@@ -59,11 +59,13 @@ struct TodayFeature {
         }
 
         var sections: [SectionContent] {
+            let now = Date()
             let items = TodayFeature.groupedSectionItems(
                 from: TodayFeature.displayedTodos(
                     todos: todos,
                     displayOptions: displayOptions
-                )
+                ),
+                now: now
             )
 
             switch selectedSectionScope {
@@ -122,14 +124,16 @@ struct TodayFeature {
         }
 
         var summaryCounts: [SectionScope: Int] {
-            Dictionary(
+            let now = Date()
+            return Dictionary(
                 uniqueKeysWithValues: SectionScope.allCases.map { scope in
                     (
                         scope,
                         TodayFeature.summaryValue(
                             for: scope,
                             todos: todos,
-                            displayOptions: displayOptions
+                            displayOptions: displayOptions,
+                            now: now
                         )
                     )
                 }

Application/DevLogPresentation/Tests/Today/TodayFeatureTests.swift

@@ -6,10 +6,65 @@
 //
 
 import Testing
+import Foundation
+import DevLogCore
 @testable import DevLogPresentation
 
 @MainActor
 struct TodayFeatureTests {
+    @Test("TodayFeature groupedSectionItems는 주입된 now 기준으로 섹션을 분류한다")
+    func TodayFeature_groupedSectionItems는_주입된_now_기준으로_섹션을_분류한다() throws {
+        let now = try #require(makeFixedTodayNow())
+        let items = makeFixedTodayTodoItems(now: now)
+
+        let sections = TodayFeature.groupedSectionItems(from: items, now: now)
+
+        #expect(sections.focused.map(\.id) == ["focused"])
+        #expect(sections.overdue.map(\.id) == ["overdue"])
+        #expect(sections.dueSoon.map(\.id) == ["due-soon"])
+        #expect(sections.later.map(\.id) == ["later"])
+        #expect(sections.unscheduled.map(\.id) == ["unscheduled"])
+    }
+
+    @Test("TodayFeature summaryValue는 주입된 now 기준으로 요약 값을 계산한다")
+    func TodayFeature_summaryValue는_주입된_now_기준으로_요약_값을_계산한다() throws {
+        let now = try #require(makeFixedTodayNow())
+        let todos = makeFixedTodayTodoItems(now: now)
+
+        #expect(
+            TodayFeature.summaryValue(
+                for: .all,
+                todos: todos,
+                displayOptions: .default,
+                now: now
+            ) == 5
+        )
+        #expect(
+            TodayFeature.summaryValue(
+                for: .focused,
+                todos: todos,
+                displayOptions: .default,
+                now: now
+            ) == 1
+        )
+        #expect(
+            TodayFeature.summaryValue(
+                for: .overdue,
+                todos: todos,
+                displayOptions: .default,
+                now: now
+            ) == 1
+        )
+        #expect(
+            TodayFeature.summaryValue(
+                for: .dueSoon,
+                todos: todos,
+                displayOptions: .default,
+                now: now
+            ) == 2
+        )
+    }
+
     @Test("현재 TodayViewModel fetchData는 요약과 섹션 상태를 갱신한다")
     func 현재_TodayViewModel_fetchData는_요약과_섹션_상태를_갱신한다() async throws {
         let todos = makeTodaySectionTodos()
@@ -234,3 +289,30 @@ struct TodayFeatureTests {
         await verifyTodayFetchFailureShowsAlert(adapter: adapter)
     }
 }
+
+private func makeFixedTodayNow() -> Date? {
+    Calendar.current.date(
+        from: DateComponents(
+            year: 2026,
+            month: 6,
+            day: 14,
+            hour: 12
+        )
+    )
+}
+
+private func makeFixedTodayTodoItems(now: Date) -> [TodayTodoItem] {
+    let calendar = Calendar.current
+
+    func dueDate(_ dayOffset: Int) -> Date {
+        calendar.date(byAdding: .day, value: dayOffset, to: now) ?? now
+    }
+
+    return [
+        TodayTodoItem(from: makeTodayTodo(id: "focused", isPinned: true, dueDate: dueDate(1)))!,
+        TodayTodoItem(from: makeTodayTodo(id: "overdue", dueDate: dueDate(-1)))!,
+        TodayTodoItem(from: makeTodayTodo(id: "due-soon", dueDate: dueDate(2)))!,
+        TodayTodoItem(from: makeTodayTodo(id: "later", dueDate: dueDate(10)))!,
+        TodayTodoItem(from: makeTodayTodo(id: "unscheduled", dueDate: nil))!
+    ]
+}