oof

2026-01-29 08:47:23 -05:00
parent b89a6c3ac4
commit a61d73753e
38 changed files with 1020 additions and 783 deletions
--- a/GazeTests/AppDelegateTestabilityTests.swift
+++ b/GazeTests/AppDelegateTestabilityTests.swift
@@ -53,12 +53,12 @@ final class AppDelegateTestabilityTests: XCTestCase {
        let appDelegate = testEnv.createAppDelegate()

        // Change a setting
-        testEnv.settingsManager.settings.lookAwayTimer.enabled = false
+        testEnv.settingsManager.settings.lookAwayEnabled = false

        try await Task.sleep(for: .milliseconds(50))

        // Verify the change propagated
-        XCTAssertFalse(testEnv.settingsManager.settings.lookAwayTimer.enabled)
+        XCTAssertFalse(testEnv.settingsManager.settings.lookAwayEnabled)
    }

    func testOpenSettingsUsesWindowManager() {
--- a/GazeTests/OnboardingNavigationTests.swift
+++ b/GazeTests/OnboardingNavigationTests.swift
@@ -79,30 +79,22 @@ final class OnboardingNavigationTests: XCTestCase {

    func testSettingsPersistDuringNavigation() {
        // Configure lookaway timer
-        var config = testEnv.settingsManager.settings.lookAwayTimer
-        config.enabled = true
-        config.intervalSeconds = 1200
-        testEnv.settingsManager.updateTimerConfiguration(for: .lookAway, configuration: config)
+        testEnv.settingsManager.settings.lookAwayEnabled = true
+        testEnv.settingsManager.settings.lookAwayIntervalMinutes = 20

        // Verify settings persisted
-        let retrieved = testEnv.settingsManager.timerConfiguration(for: .lookAway)
-        XCTAssertTrue(retrieved.enabled)
-        XCTAssertEqual(retrieved.intervalSeconds, 1200)
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.lookAwayIntervalMinutes, 20)

        // Configure blink timer
-        var blinkConfig = testEnv.settingsManager.settings.blinkTimer
-        blinkConfig.enabled = false
-        blinkConfig.intervalSeconds = 300
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: blinkConfig)
+        testEnv.settingsManager.settings.blinkEnabled = false
+        testEnv.settingsManager.settings.blinkIntervalMinutes = 5

        // Verify both settings persist
-        let lookAway = testEnv.settingsManager.timerConfiguration(for: .lookAway)
-        let blink = testEnv.settingsManager.timerConfiguration(for: .blink)
-
-        XCTAssertTrue(lookAway.enabled)
-        XCTAssertEqual(lookAway.intervalSeconds, 1200)
-        XCTAssertFalse(blink.enabled)
-        XCTAssertEqual(blink.intervalSeconds, 300)
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.lookAwayIntervalMinutes, 20)
+        XCTAssertFalse(testEnv.settingsManager.settings.blinkEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.blinkIntervalMinutes, 5)
    }

    func testOnboardingCompletion() {
@@ -118,45 +110,26 @@ final class OnboardingNavigationTests: XCTestCase {

    func testAllTimersConfiguredDuringOnboarding() {
        // Configure all three built-in timers
-        var lookAwayConfig = testEnv.settingsManager.settings.lookAwayTimer
-        lookAwayConfig.enabled = true
-        lookAwayConfig.intervalSeconds = 1200
-        testEnv.settingsManager.updateTimerConfiguration(
-            for: .lookAway, configuration: lookAwayConfig)
-
-        var blinkConfig = testEnv.settingsManager.settings.blinkTimer
-        blinkConfig.enabled = true
-        blinkConfig.intervalSeconds = 300
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: blinkConfig)
-
-        var postureConfig = testEnv.settingsManager.settings.postureTimer
-        postureConfig.enabled = true
-        postureConfig.intervalSeconds = 1800
-        testEnv.settingsManager.updateTimerConfiguration(
-            for: .posture, configuration: postureConfig)
+        testEnv.settingsManager.settings.lookAwayEnabled = true
+        testEnv.settingsManager.settings.lookAwayIntervalMinutes = 20
+        testEnv.settingsManager.settings.blinkEnabled = true
+        testEnv.settingsManager.settings.blinkIntervalMinutes = 5
+        testEnv.settingsManager.settings.postureEnabled = true
+        testEnv.settingsManager.settings.postureIntervalMinutes = 30

        // Verify all configurations
-        let allConfigs = testEnv.settingsManager.allTimerConfigurations()
-
-        XCTAssertEqual(allConfigs[.lookAway]?.intervalSeconds, 1200)
-        XCTAssertEqual(allConfigs[.blink]?.intervalSeconds, 300)
-        XCTAssertEqual(allConfigs[.posture]?.intervalSeconds, 1800)
-
-        XCTAssertTrue(allConfigs[.lookAway]?.enabled ?? false)
-        XCTAssertTrue(allConfigs[.blink]?.enabled ?? false)
-        XCTAssertTrue(allConfigs[.posture]?.enabled ?? false)
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.lookAwayIntervalMinutes, 20)
+        XCTAssertTrue(testEnv.settingsManager.settings.blinkEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.blinkIntervalMinutes, 5)
+        XCTAssertTrue(testEnv.settingsManager.settings.postureEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.postureIntervalMinutes, 30)
    }

    func testNavigationWithPartialConfiguration() {
        // Configure only some timers
-        var lookAwayConfig = testEnv.settingsManager.settings.lookAwayTimer
-        lookAwayConfig.enabled = true
-        testEnv.settingsManager.updateTimerConfiguration(
-            for: .lookAway, configuration: lookAwayConfig)
-
-        var blinkConfig = testEnv.settingsManager.settings.blinkTimer
-        blinkConfig.enabled = false
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: blinkConfig)
+        testEnv.settingsManager.settings.lookAwayEnabled = true
+        testEnv.settingsManager.settings.blinkEnabled = false

        // Should still be able to complete onboarding
        testEnv.settingsManager.settings.hasCompletedOnboarding = true
@@ -181,23 +154,15 @@ final class OnboardingNavigationTests: XCTestCase {
        // Page 1: MenuBar Welcome - no configuration needed

        // Page 2: LookAway Setup
-        var lookAwayConfig = testEnv.settingsManager.settings.lookAwayTimer
-        lookAwayConfig.enabled = true
-        lookAwayConfig.intervalSeconds = 1200
-        testEnv.settingsManager.updateTimerConfiguration(
-            for: .lookAway, configuration: lookAwayConfig)
+        testEnv.settingsManager.settings.lookAwayEnabled = true
+        testEnv.settingsManager.settings.lookAwayIntervalMinutes = 20

        // Page 2: Blink Setup
-        var blinkConfig = testEnv.settingsManager.settings.blinkTimer
-        blinkConfig.enabled = true
-        blinkConfig.intervalSeconds = 300
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: blinkConfig)
+        testEnv.settingsManager.settings.blinkEnabled = true
+        testEnv.settingsManager.settings.blinkIntervalMinutes = 5

        // Page 3: Posture Setup
-        var postureConfig = testEnv.settingsManager.settings.postureTimer
-        postureConfig.enabled = false  // User chooses to disable this one
-        testEnv.settingsManager.updateTimerConfiguration(
-            for: .posture, configuration: postureConfig)
+        testEnv.settingsManager.settings.postureEnabled = false  // User chooses to disable this one

        // Page 4: General Settings
        testEnv.settingsManager.settings.playSounds = true
@@ -209,10 +174,9 @@ final class OnboardingNavigationTests: XCTestCase {
        // Verify final state
        XCTAssertTrue(testEnv.settingsManager.settings.hasCompletedOnboarding)

-        let finalConfigs = testEnv.settingsManager.allTimerConfigurations()
-        XCTAssertTrue(finalConfigs[.lookAway]?.enabled ?? false)
-        XCTAssertTrue(finalConfigs[.blink]?.enabled ?? false)
-        XCTAssertFalse(finalConfigs[.posture]?.enabled ?? true)
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
+        XCTAssertTrue(testEnv.settingsManager.settings.blinkEnabled)
+        XCTAssertFalse(testEnv.settingsManager.settings.postureEnabled)

        XCTAssertTrue(testEnv.settingsManager.settings.playSounds)
        XCTAssertFalse(testEnv.settingsManager.settings.launchAtLogin)
@@ -220,24 +184,17 @@ final class OnboardingNavigationTests: XCTestCase {

    func testNavigatingBackPreservesSettings() {
        // Configure on page 1
-        var lookAwayConfig = testEnv.settingsManager.settings.lookAwayTimer
-        lookAwayConfig.intervalSeconds = 1500
-        testEnv.settingsManager.updateTimerConfiguration(
-            for: .lookAway, configuration: lookAwayConfig)
+        testEnv.settingsManager.settings.lookAwayIntervalMinutes = 25

        // Move forward to page 2
-        var blinkConfig = testEnv.settingsManager.settings.blinkTimer
-        blinkConfig.intervalSeconds = 250
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: blinkConfig)
+        testEnv.settingsManager.settings.blinkIntervalMinutes = 4

        // Navigate back to page 1
        // Verify lookaway settings still exist
-        let lookAway = testEnv.settingsManager.timerConfiguration(for: .lookAway)
-        XCTAssertEqual(lookAway.intervalSeconds, 1500)
+        XCTAssertEqual(testEnv.settingsManager.settings.lookAwayIntervalMinutes, 25)

        // Navigate forward again to page 2
        // Verify blink settings still exist
-        let blink = testEnv.settingsManager.timerConfiguration(for: .blink)
-        XCTAssertEqual(blink.intervalSeconds, 250)
+        XCTAssertEqual(testEnv.settingsManager.settings.blinkIntervalMinutes, 4)
    }
 }
--- a/GazeTests/ServiceContainerTests.swift
+++ b/GazeTests/ServiceContainerTests.swift
@@ -22,8 +22,8 @@ final class ServiceContainerTests: XCTestCase {
        let settings = AppSettings.onlyLookAwayEnabled
        let container = TestServiceContainer(settings: settings)
        
-        XCTAssertEqual(container.settingsManager.settings.lookAwayTimer.enabled, true)
-        XCTAssertEqual(container.settingsManager.settings.blinkTimer.enabled, false)
+        XCTAssertEqual(container.settingsManager.settings.lookAwayEnabled, true)
+        XCTAssertEqual(container.settingsManager.settings.blinkEnabled, false)
    }
    
    func testTimerEngineCreation() {
--- a/GazeTests/Services/SettingsManagerTests.swift
+++ b/GazeTests/Services/SettingsManagerTests.swift
@@ -38,52 +38,42 @@ final class SettingsManagerTests: XCTestCase {
    func testDefaultSettingsValues() {
        let defaults = AppSettings.defaults
        
-        XCTAssertTrue(defaults.lookAwayTimer.enabled)
-        XCTAssertFalse(defaults.blinkTimer.enabled)  // Blink timer is disabled by default
-        XCTAssertTrue(defaults.postureTimer.enabled)
+        XCTAssertTrue(defaults.lookAwayEnabled)
+        XCTAssertFalse(defaults.blinkEnabled)  // Blink timer is disabled by default
+        XCTAssertTrue(defaults.postureEnabled)
        XCTAssertFalse(defaults.hasCompletedOnboarding)
    }
    
    // MARK: - Timer Configuration Tests
    
    func testGetTimerConfiguration() {
-        let lookAwayConfig = settingsManager.timerConfiguration(for: .lookAway)
-        XCTAssertNotNil(lookAwayConfig)
-        XCTAssertTrue(lookAwayConfig.enabled)
+        XCTAssertTrue(settingsManager.settings.lookAwayEnabled)
    }
    
    func testUpdateTimerConfiguration() {
-        var config = settingsManager.timerConfiguration(for: .lookAway)
-        config.intervalSeconds = 1500
-        config.enabled = false
+        settingsManager.settings.lookAwayEnabled = false
+        settingsManager.settings.lookAwayIntervalMinutes = 25
        
-        settingsManager.updateTimerConfiguration(for: .lookAway, configuration: config)
-        
-        let updated = settingsManager.timerConfiguration(for: .lookAway)
-        XCTAssertEqual(updated.intervalSeconds, 1500)
-        XCTAssertFalse(updated.enabled)
+        XCTAssertFalse(settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(settingsManager.settings.lookAwayIntervalMinutes, 25)
    }
    
    func testAllTimerConfigurations() {
-        let allConfigs = settingsManager.allTimerConfigurations()
-        
-        XCTAssertEqual(allConfigs.count, 3)
-        XCTAssertNotNil(allConfigs[.lookAway])
-        XCTAssertNotNil(allConfigs[.blink])
-        XCTAssertNotNil(allConfigs[.posture])
+        XCTAssertEqual(settingsManager.settings.lookAwayEnabled, true)
+        XCTAssertEqual(settingsManager.settings.blinkEnabled, false)
+        XCTAssertEqual(settingsManager.settings.postureEnabled, true)
    }
    
    func testUpdateMultipleTimerConfigurations() {
-        var lookAway = settingsManager.timerConfiguration(for: .lookAway)
-        lookAway.intervalSeconds = 1000
-        settingsManager.updateTimerConfiguration(for: .lookAway, configuration: lookAway)
+        settingsManager.settings.lookAwayEnabled = true
+        settingsManager.settings.lookAwayIntervalMinutes = 16
+        settingsManager.settings.blinkEnabled = true
+        settingsManager.settings.blinkIntervalMinutes = 4
        
-        var blink = settingsManager.timerConfiguration(for: .blink)
-        blink.intervalSeconds = 250
-        settingsManager.updateTimerConfiguration(for: .blink, configuration: blink)
-        
-        XCTAssertEqual(settingsManager.timerConfiguration(for: .lookAway).intervalSeconds, 1000)
-        XCTAssertEqual(settingsManager.timerConfiguration(for: .blink).intervalSeconds, 250)
+        XCTAssertTrue(settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(settingsManager.settings.lookAwayIntervalMinutes, 16)
+        XCTAssertTrue(settingsManager.settings.blinkEnabled)
+        XCTAssertEqual(settingsManager.settings.blinkIntervalMinutes, 4)
    }
    
    // MARK: - Settings Publisher Tests
@@ -138,9 +128,8 @@ final class SettingsManagerTests: XCTestCase {
        // Modify settings
        settingsManager.settings.playSounds = false
        settingsManager.settings.launchAtLogin = true
-        var config = settingsManager.timerConfiguration(for: .lookAway)
-        config.intervalSeconds = 5000
-        settingsManager.updateTimerConfiguration(for: .lookAway, configuration: config)
+        settingsManager.settings.lookAwayEnabled = false
+        settingsManager.settings.lookAwayIntervalMinutes = 10
        
        // Reset
        settingsManager.resetToDefaults()
@@ -149,6 +138,8 @@ final class SettingsManagerTests: XCTestCase {
        let defaults = AppSettings.defaults
        XCTAssertEqual(settingsManager.settings.playSounds, defaults.playSounds)
        XCTAssertEqual(settingsManager.settings.launchAtLogin, defaults.launchAtLogin)
+        XCTAssertEqual(settingsManager.settings.lookAwayEnabled, defaults.lookAwayEnabled)
+        XCTAssertEqual(settingsManager.settings.lookAwayIntervalMinutes, defaults.lookAwayIntervalMinutes)
    }
    
    // MARK: - Onboarding Tests
--- a/GazeTests/Services/TimerEngineTests.swift
+++ b/GazeTests/Services/TimerEngineTests.swift
@@ -282,9 +282,9 @@ final class TimerEngineTests: XCTestCase {

    func testDisabledTimersNotInitialized() {
        var settings = AppSettings.defaults
-        settings.lookAwayTimer.enabled = false
-        settings.blinkTimer.enabled = false
-        settings.postureTimer.enabled = false
+        settings.lookAwayEnabled = false
+        settings.blinkEnabled = false
+        settings.postureEnabled = false

        let settingsManager = EnhancedMockSettingsManager(settings: settings)
        let engine = TimerEngine(settingsManager: settingsManager)
@@ -296,9 +296,9 @@ final class TimerEngineTests: XCTestCase {

    func testPartiallyEnabledTimers() {
        var settings = AppSettings.defaults
-        settings.lookAwayTimer.enabled = true
-        settings.blinkTimer.enabled = false
-        settings.postureTimer.enabled = false
+        settings.lookAwayEnabled = true
+        settings.blinkEnabled = false
+        settings.postureEnabled = false

        let settingsManager = EnhancedMockSettingsManager(settings: settings)
        let engine = TimerEngine(settingsManager: settingsManager)
--- a/GazeTests/TestHelpers.swift
+++ b/GazeTests/TestHelpers.swift
@@ -28,11 +28,19 @@ final class EnhancedMockSettingsManager: SettingsProviding {
    }

    @ObservationIgnored
-    private let timerConfigKeyPaths: [TimerType: WritableKeyPath<AppSettings, TimerConfiguration>] =
+    private let intervalKeyPaths: [TimerType: WritableKeyPath<AppSettings, Int>] =
        [
-            .lookAway: \.lookAwayTimer,
-            .blink: \.blinkTimer,
-            .posture: \.postureTimer,
+            .lookAway: \.lookAwayIntervalMinutes,
+            .blink: \.blinkIntervalMinutes,
+            .posture: \.postureIntervalMinutes,
+        ]
+
+    @ObservationIgnored
+    private let enabledKeyPaths: [TimerType: WritableKeyPath<AppSettings, Bool>] =
+        [
+            .lookAway: \.lookAwayEnabled,
+            .blink: \.blinkEnabled,
+            .posture: \.postureEnabled,
        ]

    // Track method calls for verification
@@ -50,27 +58,42 @@ final class EnhancedMockSettingsManager: SettingsProviding {
        self._settingsSubject = CurrentValueSubject(settings)
    }

-    func timerConfiguration(for type: TimerType) -> TimerConfiguration {
-        guard let keyPath = timerConfigKeyPaths[type] else {
+    func timerIntervalMinutes(for type: TimerType) -> Int {
+        guard let keyPath = intervalKeyPaths[type] else {
            preconditionFailure("Unknown timer type: \(type)")
        }
        return settings[keyPath: keyPath]
    }

-    func updateTimerConfiguration(for type: TimerType, configuration: TimerConfiguration) {
-        guard let keyPath = timerConfigKeyPaths[type] else {
+    func isTimerEnabled(for type: TimerType) -> Bool {
+        guard let keyPath = enabledKeyPaths[type] else {
            preconditionFailure("Unknown timer type: \(type)")
        }
-        settings[keyPath: keyPath] = configuration
+        return settings[keyPath: keyPath]
+    }
+
+    func updateTimerInterval(for type: TimerType, minutes: Int) {
+        guard let keyPath = intervalKeyPaths[type] else {
+            preconditionFailure("Unknown timer type: \(type)")
+        }
+        settings[keyPath: keyPath] = minutes
        _settingsSubject.send(settings)
    }

-    func allTimerConfigurations() -> [TimerType: TimerConfiguration] {
-        var configs: [TimerType: TimerConfiguration] = [:]
-        for (type, keyPath) in timerConfigKeyPaths {
-            configs[type] = settings[keyPath: keyPath]
+    func updateTimerEnabled(for type: TimerType, enabled: Bool) {
+        guard let keyPath = enabledKeyPaths[type] else {
+            preconditionFailure("Unknown timer type: \(type)")
        }
-        return configs
+        settings[keyPath: keyPath] = enabled
+        _settingsSubject.send(settings)
+    }
+
+    func allTimerSettings() -> [TimerType: (enabled: Bool, intervalMinutes: Int)] {
+        var settingsMap: [TimerType: (enabled: Bool, intervalMinutes: Int)] = [:]
+        for (type, enabledKey) in enabledKeyPaths {
+            settingsMap[type] = (enabled: settings[keyPath: enabledKey], intervalMinutes: settings[keyPath: intervalKeyPaths[type]!])
+        }
+        return settingsMap
    }

    func save() {
@@ -155,27 +178,27 @@ extension AppSettings {
    /// Settings with all timers disabled
    static var allTimersDisabled: AppSettings {
        var settings = AppSettings.defaults
-        settings.lookAwayTimer.enabled = false
-        settings.blinkTimer.enabled = false
-        settings.postureTimer.enabled = false
+        settings.lookAwayEnabled = false
+        settings.blinkEnabled = false
+        settings.postureEnabled = false
        return settings
    }

    /// Settings with only lookAway timer enabled
    static var onlyLookAwayEnabled: AppSettings {
        var settings = AppSettings.defaults
-        settings.lookAwayTimer.enabled = true
-        settings.blinkTimer.enabled = false
-        settings.postureTimer.enabled = false
+        settings.lookAwayEnabled = true
+        settings.blinkEnabled = false
+        settings.postureEnabled = false
        return settings
    }

    /// Settings with short intervals for testing
    static var shortIntervals: AppSettings {
        var settings = AppSettings.defaults
-        settings.lookAwayTimer.intervalSeconds = 5
-        settings.blinkTimer.intervalSeconds = 3
-        settings.postureTimer.intervalSeconds = 7
+        settings.lookAwayIntervalMinutes = 5
+        settings.blinkIntervalMinutes = 3
+        settings.postureIntervalMinutes = 7
        return settings
    }

--- a/GazeTests/TimerEngineTestabilityTests.swift
+++ b/GazeTests/TimerEngineTestabilityTests.swift
@@ -40,9 +40,9 @@ final class TimerEngineTestabilityTests: XCTestCase {

    func testTimerEngineUsesInjectedSettings() {
        var settings = AppSettings.defaults
-        settings.lookAwayTimer.enabled = true
-        settings.blinkTimer.enabled = false
-        settings.postureTimer.enabled = false
+        settings.lookAwayEnabled = true
+        settings.blinkEnabled = false
+        settings.postureEnabled = false

        testEnv.settingsManager.settings = settings
        let timerEngine = testEnv.container.timerEngine
--- a/GazeTests/Views/BlinkSetupViewTests.swift
+++ b/GazeTests/Views/BlinkSetupViewTests.swift
@@ -29,40 +29,41 @@ final class BlinkSetupViewTests: XCTestCase {
    }
    
    func testBlinkTimerConfigurationChanges() {
-        let initial = testEnv.settingsManager.timerConfiguration(for: .blink)
+        XCTAssertFalse(testEnv.settingsManager.settings.blinkEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.blinkIntervalMinutes, 7)
        
-        var modified = initial
-        modified.enabled = true
-        modified.intervalSeconds = 300
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: modified)
+        testEnv.settingsManager.settings.blinkEnabled = true
+        testEnv.settingsManager.settings.blinkIntervalMinutes = 5
        
-        let updated = testEnv.settingsManager.timerConfiguration(for: .blink)
-        XCTAssertTrue(updated.enabled)
-        XCTAssertEqual(updated.intervalSeconds, 300)
+        XCTAssertTrue(testEnv.settingsManager.settings.blinkEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.blinkIntervalMinutes, 5)
    }
    
    func testBlinkTimerEnableDisable() {
-        var config = testEnv.settingsManager.timerConfiguration(for: .blink)
+        var config = testEnv.settingsManager.settings
        
-        config.enabled = true
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: config)
-        XCTAssertTrue(testEnv.settingsManager.timerConfiguration(for: .blink).enabled)
+        config.blinkEnabled = true
+        config.blinkIntervalMinutes = 4
+        testEnv.settingsManager.settings = config
+        XCTAssertTrue(testEnv.settingsManager.settings.blinkEnabled)
        
-        config.enabled = false
-        testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: config)
-        XCTAssertFalse(testEnv.settingsManager.timerConfiguration(for: .blink).enabled)
+        config.blinkEnabled = false
+        config.blinkIntervalMinutes = 3
+        testEnv.settingsManager.settings = config
+        XCTAssertFalse(testEnv.settingsManager.settings.blinkEnabled)
    }
    
    func testBlinkIntervalValidation() {
-        var config = testEnv.settingsManager.timerConfiguration(for: .blink)
+        var config = testEnv.settingsManager.settings
        
-        let intervals = [180, 240, 300, 360, 600]
-        for interval in intervals {
-            config.intervalSeconds = interval
-            testEnv.settingsManager.updateTimerConfiguration(for: .blink, configuration: config)
+        let intervals = [3, 4, 5, 6, 10]
+        for minutes in intervals {
+            config.blinkEnabled = true
+            config.blinkIntervalMinutes = minutes
+            testEnv.settingsManager.settings = config
            
-            let retrieved = testEnv.settingsManager.timerConfiguration(for: .blink)
-            XCTAssertEqual(retrieved.intervalSeconds, interval)
+            let retrieved = testEnv.settingsManager.settings
+            XCTAssertEqual(retrieved.blinkIntervalMinutes, minutes)
        }
    }
    
--- a/GazeTests/Views/LookAwaySetupViewTests.swift
+++ b/GazeTests/Views/LookAwaySetupViewTests.swift
@@ -30,45 +30,46 @@ final class LookAwaySetupViewTests: XCTestCase {
    
    func testLookAwayTimerConfigurationChanges() {
        // Start with default
-        let initial = testEnv.settingsManager.timerConfiguration(for: .lookAway)
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.lookAwayIntervalMinutes, 20)
        
        // Modify configuration
-        var modified = initial
-        modified.enabled = true
-        modified.intervalSeconds = 1500
-        testEnv.settingsManager.updateTimerConfiguration(for: .lookAway, configuration: modified)
+        testEnv.settingsManager.settings.lookAwayEnabled = true
+        testEnv.settingsManager.settings.lookAwayIntervalMinutes = 25
        
        // Verify changes
-        let updated = testEnv.settingsManager.timerConfiguration(for: .lookAway)
-        XCTAssertTrue(updated.enabled)
-        XCTAssertEqual(updated.intervalSeconds, 1500)
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.lookAwayIntervalMinutes, 25)
    }
    
    func testLookAwayTimerEnableDisable() {
-        var config = testEnv.settingsManager.timerConfiguration(for: .lookAway)
+        var config = testEnv.settingsManager.settings
        
        // Enable
-        config.enabled = true
-        testEnv.settingsManager.updateTimerConfiguration(for: .lookAway, configuration: config)
-        XCTAssertTrue(testEnv.settingsManager.timerConfiguration(for: .lookAway).enabled)
+        config.lookAwayEnabled = true
+        config.lookAwayIntervalMinutes = 15
+        testEnv.settingsManager.settings = config
+        XCTAssertTrue(testEnv.settingsManager.settings.lookAwayEnabled)
        
        // Disable
-        config.enabled = false
-        testEnv.settingsManager.updateTimerConfiguration(for: .lookAway, configuration: config)
-        XCTAssertFalse(testEnv.settingsManager.timerConfiguration(for: .lookAway).enabled)
+        config.lookAwayEnabled = false
+        config.lookAwayIntervalMinutes = 10
+        testEnv.settingsManager.settings = config
+        XCTAssertFalse(testEnv.settingsManager.settings.lookAwayEnabled)
    }
    
    func testLookAwayIntervalValidation() {
-        var config = testEnv.settingsManager.timerConfiguration(for: .lookAway)
+        var config = testEnv.settingsManager.settings
        
-        // Test various intervals
-        let intervals = [300, 600, 1200, 1800, 3600]
-        for interval in intervals {
-            config.intervalSeconds = interval
-            testEnv.settingsManager.updateTimerConfiguration(for: .lookAway, configuration: config)
+        // Test various intervals (in minutes)
+        let intervals = [5, 10, 20, 30, 60]
+        for minutes in intervals {
+            config.lookAwayEnabled = true
+            config.lookAwayIntervalMinutes = minutes
+            testEnv.settingsManager.settings = config
            
-            let retrieved = testEnv.settingsManager.timerConfiguration(for: .lookAway)
-            XCTAssertEqual(retrieved.intervalSeconds, interval)
+            let retrieved = testEnv.settingsManager.settings
+            XCTAssertEqual(retrieved.lookAwayIntervalMinutes, minutes)
        }
    }
    
--- a/GazeTests/Views/PostureSetupViewTests.swift
+++ b/GazeTests/Views/PostureSetupViewTests.swift
@@ -29,40 +29,47 @@ final class PostureSetupViewTests: XCTestCase {
    }
    
    func testPostureTimerConfigurationChanges() {
-        let initial = testEnv.settingsManager.timerConfiguration(for: .posture)
+        // Start with default
+        XCTAssertTrue(testEnv.settingsManager.settings.postureEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.postureIntervalMinutes, 30)
        
-        var modified = initial
-        modified.enabled = true
-        modified.intervalSeconds = 1800
-        testEnv.settingsManager.updateTimerConfiguration(for: .posture, configuration: modified)
+        // Modify configuration
+        testEnv.settingsManager.settings.postureEnabled = true
+        testEnv.settingsManager.settings.postureIntervalMinutes = 45
        
-        let updated = testEnv.settingsManager.timerConfiguration(for: .posture)
-        XCTAssertTrue(updated.enabled)
-        XCTAssertEqual(updated.intervalSeconds, 1800)
+        // Verify changes
+        XCTAssertTrue(testEnv.settingsManager.settings.postureEnabled)
+        XCTAssertEqual(testEnv.settingsManager.settings.postureIntervalMinutes, 45)
    }
    
    func testPostureTimerEnableDisable() {
-        var config = testEnv.settingsManager.timerConfiguration(for: .posture)
+        var config = testEnv.settingsManager.settings
        
-        config.enabled = true
-        testEnv.settingsManager.updateTimerConfiguration(for: .posture, configuration: config)
-        XCTAssertTrue(testEnv.settingsManager.timerConfiguration(for: .posture).enabled)
+        // Enable
+        config.postureEnabled = true
+        config.postureIntervalMinutes = 25
+        testEnv.settingsManager.settings = config
+        XCTAssertTrue(testEnv.settingsManager.settings.postureEnabled)
        
-        config.enabled = false
-        testEnv.settingsManager.updateTimerConfiguration(for: .posture, configuration: config)
-        XCTAssertFalse(testEnv.settingsManager.timerConfiguration(for: .posture).enabled)
+        // Disable
+        config.postureEnabled = false
+        config.postureIntervalMinutes = 20
+        testEnv.settingsManager.settings = config
+        XCTAssertFalse(testEnv.settingsManager.settings.postureEnabled)
    }
    
    func testPostureIntervalValidation() {
-        var config = testEnv.settingsManager.timerConfiguration(for: .posture)
+        var config = testEnv.settingsManager.settings
        
-        let intervals = [900, 1200, 1800, 2400, 3600]
-        for interval in intervals {
-            config.intervalSeconds = interval
-            testEnv.settingsManager.updateTimerConfiguration(for: .posture, configuration: config)
+        // Test various intervals (in minutes)
+        let intervals = [15, 20, 30, 45, 60]
+        for minutes in intervals {
+            config.postureEnabled = true
+            config.postureIntervalMinutes = minutes
+            testEnv.settingsManager.settings = config
            
-            let retrieved = testEnv.settingsManager.timerConfiguration(for: .posture)
-            XCTAssertEqual(retrieved.intervalSeconds, interval)
+            let retrieved = testEnv.settingsManager.settings
+            XCTAssertEqual(retrieved.postureIntervalMinutes, minutes)
        }
    }