general: test redux

GazeTests/TimerEngineTestabilityTests.swift

@@ -0,0 +1,112 @@
+//
+//  TimerEngineTestabilityTests.swift
+//  GazeTests
+//
+//  Tests demonstrating TimerEngine testability with dependency injection.
+//
+
+import Combine
+import XCTest
+@testable import Gaze
+
+@MainActor
+final class TimerEngineTestabilityTests: XCTestCase {
+    
+    var testEnv: TestEnvironment!
+    var cancellables: Set<AnyCancellable>!
+    
+    override func setUp() async throws {
+        testEnv = TestEnvironment(settings: .shortIntervals)
+        cancellables = []
+    }
+    
+    override func tearDown() async throws {
+        cancellables = nil
+        testEnv = nil
+    }
+    
+    func testTimerEngineCreationWithMocks() {
+        let timeProvider = MockTimeProvider()
+        let timerEngine = TimerEngine(
+            settingsManager: testEnv.settingsManager,
+            timeProvider: timeProvider
+        )
+        
+        XCTAssertNotNil(timerEngine)
+        XCTAssertEqual(timerEngine.timerStates.count, 0)
+    }
+    
+    func testTimerEngineUsesInjectedSettings() {
+        var settings = AppSettings.defaults
+        settings.lookAwayTimer.enabled = true
+        settings.blinkTimer.enabled = false
+        settings.postureTimer.enabled = false
+        
+        testEnv.settingsManager.settings = settings
+        let timerEngine = testEnv.container.timerEngine
+        
+        timerEngine.start()
+        
+        // Only lookAway should be active
+        let lookAwayTimer = timerEngine.timerStates.first { $0.key == .builtIn(.lookAway) }
+        let blinkTimer = timerEngine.timerStates.first { $0.key == .builtIn(.blink) }
+        
+        XCTAssertNotNil(lookAwayTimer)
+        XCTAssertNil(blinkTimer)
+    }
+    
+    func testTimerEngineWithMockTimeProvider() {
+        let timeProvider = MockTimeProvider(startTime: Date())
+        let timerEngine = TimerEngine(
+            settingsManager: testEnv.settingsManager,
+            timeProvider: timeProvider
+        )
+        
+        // Start timers
+        timerEngine.start()
+        
+        // Advance time
+        timeProvider.advance(by: 10)
+        
+        // Timer engine should use the mocked time
+        XCTAssertNotNil(timerEngine.timerStates)
+    }
+    
+    func testPauseAndResumeWithMocks() {
+        let timerEngine = testEnv.container.timerEngine
+        timerEngine.start()
+        
+        timerEngine.pause()
+        
+        // Verify all timers are paused
+        for (_, state) in timerEngine.timerStates {
+            XCTAssertTrue(state.isPaused)
+        }
+        
+        timerEngine.resume()
+        
+        // Verify all timers are resumed
+        for (_, state) in timerEngine.timerStates {
+            XCTAssertFalse(state.isPaused)
+        }
+    }
+    
+    func testReminderEventPublishing() async throws {
+        let timerEngine = testEnv.container.timerEngine
+        
+        var receivedReminder: ReminderEvent?
+        timerEngine.$activeReminder
+            .sink { reminder in
+                receivedReminder = reminder
+            }
+            .store(in: &cancellables)
+        
+        let timerId = TimerIdentifier.builtIn(.lookAway)
+        timerEngine.triggerReminder(for: timerId)
+        
+        // Give time for publisher to fire
+        try await Task.sleep(nanoseconds: 10_000_000)
+        
+        XCTAssertNotNil(receivedReminder)
+    }
+}