chkpt

2026-01-29 13:15:52 -05:00
parent dbe6923f99
commit 6e3730849b
7 changed files with 352 additions and 445 deletions
--- a/GazeTests/Services/EnforcePolicyEvaluatorTests.swift
+++ b/GazeTests/Services/EnforcePolicyEvaluatorTests.swift
@@ -0,0 +1,217 @@
+//
+//  EnforcePolicyEvaluatorTests.swift
+//  GazeTests
+//
+//  Unit tests for EnforcePolicyEvaluator (now nested in EnforceModeService).
+//
+
+import XCTest
+@testable import Gaze
+
+@MainActor
+final class EnforcePolicyEvaluatorTests: XCTestCase {
+    
+    var evaluator: EnforcePolicyEvaluator!
+    var mockSettings: EnhancedMockSettingsManager!
+    
+    override func setUp() async throws {
+        mockSettings = EnhancedMockSettingsManager(settings: .defaults)
+        evaluator = EnforcePolicyEvaluator(settingsProvider: mockSettings)
+    }
+    
+    override func tearDown() async throws {
+        evaluator = nil
+        mockSettings = nil
+    }
+    
+    // MARK: - Initialization Tests
+    
+    func testInitialization() {
+        XCTAssertNotNil(evaluator)
+    }
+    
+    func testInitializationWithSettingsProvider() {
+        let newSettings = EnhancedMockSettingsManager(settings: AppSettings.defaults)
+        let newEvaluator = EnforcePolicyEvaluator(settingsProvider: newSettings)
+        XCTAssertNotNil(newEvaluator)
+    }
+    
+    // MARK: - Enforcement Enabled Tests
+    
+    func testIsEnforcementEnabledWhenLookAwayDisabled() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: false)
+        
+        let isEnabled = evaluator.isEnforcementEnabled
+        
+        XCTAssertFalse(isEnabled)
+    }
+    
+    func testIsEnforcementEnabledWhenLookAwayEnabled() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let isEnabled = evaluator.isEnforcementEnabled
+        
+        XCTAssertTrue(isEnabled)
+    }
+    
+    // MARK: - Should Enforce Tests
+    
+    func testShouldEnforceWhenLookAwayEnabled() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldEnforce = evaluator.shouldEnforce(timerIdentifier: .builtIn(.lookAway))
+        
+        XCTAssertTrue(shouldEnforce)
+    }
+    
+    func testShouldEnforceWhenLookAwayDisabled() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: false)
+        
+        let shouldEnforce = evaluator.shouldEnforce(timerIdentifier: .builtIn(.lookAway))
+        
+        XCTAssertFalse(shouldEnforce)
+    }
+    
+    func testShouldEnforceUserTimerNever() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldEnforce = evaluator.shouldEnforce(timerIdentifier: .user)
+        
+        XCTAssertFalse(shouldEnforce)
+    }
+    
+    func testShouldEnforceBuiltInPostureTimerNever() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldEnforce = evaluator.shouldEnforce(timerIdentifier: .builtIn(.posture))
+        
+        XCTAssertFalse(shouldEnforce)
+    }
+    
+    func testShouldEnforceBuiltInBlinkTimerNever() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldEnforce = evaluator.shouldEnforce(timerIdentifier: .builtIn(.blink))
+        
+        XCTAssertFalse(shouldEnforce)
+    }
+    
+    // MARK: - Pre-activate Camera Tests
+    
+    func testShouldPreActivateCameraWhenTimerDisabled() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: false)
+        
+        let shouldPreActivate = evaluator.shouldPreActivateCamera(
+            timerIdentifier: .builtIn(.lookAway),
+            secondsRemaining: 3
+        )
+        
+        XCTAssertFalse(shouldPreActivate)
+    }
+    
+    func testShouldPreActivateCameraWhenSecondsRemainingTooHigh() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldPreActivate = evaluator.shouldPreActivateCamera(
+            timerIdentifier: .builtIn(.lookAway),
+            secondsRemaining: 5
+        )
+        
+        XCTAssertFalse(shouldPreActivate)
+    }
+    
+    func testShouldPreActivateCameraWhenAllConditionsMet() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldPreActivate = evaluator.shouldPreActivateCamera(
+            timerIdentifier: .builtIn(.lookAway),
+            secondsRemaining: 2
+        )
+        
+        XCTAssertTrue(shouldPreActivate)
+    }
+    
+    func testShouldPreActivateCameraForUserTimerNever() {
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        let shouldPreActivate = evaluator.shouldPreActivateCamera(
+            timerIdentifier: .user,
+            secondsRemaining: 1
+        )
+        
+        XCTAssertFalse(shouldPreActivate)
+    }
+    
+    // MARK: - Compliance Evaluation Tests
+    
+    func testEvaluateComplianceWhenLookingAtScreenAndFaceDetected() {
+        let result = evaluator.evaluateCompliance(
+            isLookingAtScreen: true,
+            faceDetected: true
+        )
+        
+        XCTAssertEqual(result, .notCompliant)
+    }
+    
+    func testEvaluateComplianceWhenNotLookingAtScreenAndFaceDetected() {
+        let result = evaluator.evaluateCompliance(
+            isLookingAtScreen: false,
+            faceDetected: true
+        )
+        
+        XCTAssertEqual(result, .compliant)
+    }
+    
+    func testEvaluateComplianceWhenFaceNotDetected() {
+        let result = evaluator.evaluateCompliance(
+            isLookingAtScreen: true,
+            faceDetected: false
+        )
+        
+        XCTAssertEqual(result, .faceNotDetected)
+    }
+    
+    func testEvaluateComplianceWhenFaceNotDetectedAndNotLookingAtScreen() {
+        let result = evaluator.evaluateCompliance(
+            isLookingAtScreen: false,
+            faceDetected: false
+        )
+        
+        XCTAssertEqual(result, .faceNotDetected)
+    }
+    
+    func testEvaluateComplianceWhenFaceNotDetectedAndNotLookingAtScreen() {
+        // Test edge case - should still return face not detected
+        let result = evaluator.evaluateCompliance(
+            isLookingAtScreen: false,
+            faceDetected: false
+        )
+        
+        XCTAssertEqual(result, .faceNotDetected)
+    }
+    
+    // MARK: - Integration Tests
+    
+    func testFullEnforcementFlow() {
+        // Setup: Look away timer enabled
+        mockSettings.updateTimerEnabled(for: .lookAway, enabled: true)
+        
+        // Test 1: Check enforcement
+        let shouldEnforce = evaluator.shouldEnforce(timerIdentifier: .builtIn(.lookAway))
+        XCTAssertTrue(shouldEnforce)
+        
+        // Test 2: Check pre-activation at 3 seconds
+        let shouldPreActivate = evaluator.shouldPreActivateCamera(
+            timerIdentifier: .builtIn(.lookAway),
+            secondsRemaining: 3
+        )
+        XCTAssertTrue(shouldPreActivate)
+        
+        // Test 3: Check compliance when looking at screen
+        let compliance = evaluator.evaluateCompliance(
+            isLookingAtScreen: true,
+            faceDetected: true
+        )
+        XCTAssertEqual(compliance, .notCompliant)
+    }
+}
--- a/GazeTests/Services/TimerEngineTests.swift
+++ b/GazeTests/Services/TimerEngineTests.swift
@@ -265,8 +265,8 @@ final class TimerEngineTests: XCTestCase {

        systemSleepManager.handleSystemWillSleep()

-        // States should still exist
-        XCTAssertEqual(timerEngine.timerStates.count, statesBefore)
+        // States should be cleared
+        XCTAssertEqual(timerEngine.timerStates.count, 0)
    }

    func testSystemSleepManagerHandlesWake() {