test(frigate-health-checker): update tests for simplified FPS-based health check

Remove tests for legacy checks (slow inference, stuck detection, backlog)
Add tests for new camera FPS check:
- test_check_health_no_frames: fails when camera_fps < 1
- test_check_health_skipped_camera_no_frames: passes when skipped camera has no frames
- test_no_frames_triggers_restart: integration test for restart workflow
- test_healthy_with_all_cameras_working: integration test for healthy state

Update fixtures to use camera_fps field (not fps)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: web-flow

apps/frigate-health-checker/tests/conftest.py

@@ -101,25 +101,28 @@ def frigate_stats_healthy() -> dict:
     return {
         "detectors": {
             "coral": {
-                "inference_speed": 45.5,
+                "inference_speed": 15.0,
                 "pid": 123,
             }
         },
         "cameras": {
-            "front_door": {"fps": 30, "detection_fps": 5},
+            "front_door": {"camera_fps": 5.0, "detection_fps": 0.2},
+            "back_yard": {"camera_fps": 5.0, "detection_fps": 0.1},
         },
     }
 
 
 @pytest.fixture
-def frigate_stats_slow_inference() -> dict:
-    """Create Frigate stats with slow inference."""
+def frigate_stats_no_frames() -> dict:
+    """Create Frigate stats with camera having no frames."""
     return {
         "detectors": {
             "coral": {
-                "inference_speed": 250.0,
+                "inference_speed": 15.0,
                 "pid": 123,
             }
         },
-        "cameras": {},
+        "cameras": {
+            "front_door": {"camera_fps": 0.0, "detection_fps": 0.0},
+        },
     }

apps/frigate-health-checker/tests/test_health_checker.py

@@ -48,104 +48,90 @@ def test_check_health_api_unresponsive(
         assert result.status == HealthStatus.UNHEALTHY
         assert result.reason == UnhealthyReason.API_UNRESPONSIVE
 
-    def test_check_health_slow_inference(
+    def test_check_health_no_frames(
         self,
         settings: Settings,
         mock_k8s_client: MagicMock,
         mock_pod: MagicMock,
-        frigate_stats_slow_inference: dict,
     ) -> None:
-        """Test health check with slow Coral inference."""
+        """Test health check when camera has no frames (fps=0)."""
+        stats_no_frames = {
+            "detectors": {"coral": {"inference_speed": 15.0}},
+            "cameras": {
+                "front_door": {"camera_fps": 0.0, "detection_fps": 0.0},
+                "back_yard": {"camera_fps": 5.0, "detection_fps": 0.1},
+            },
+        }
         mock_k8s_client.get_frigate_pod.return_value = mock_pod
         mock_k8s_client.get_pod_node_name.return_value = "still-fawn"
         mock_k8s_client.exec_in_pod.return_value = (
-            json.dumps(frigate_stats_slow_inference),
+            json.dumps(stats_no_frames),
             True,
         )
         checker = HealthChecker(settings, mock_k8s_client)
 
         result = checker.check_health()
 
         assert result.status == HealthStatus.UNHEALTHY
-        assert result.reason == UnhealthyReason.INFERENCE_SLOW
-        assert result.metrics.inference_speed_ms == 250.0
+        assert result.reason == UnhealthyReason.NO_FRAMES
+        assert "front_door" in result.message
 
-    def test_check_health_detection_stuck(
+    def test_check_health_skipped_camera_no_frames(
         self,
         settings: Settings,
         mock_k8s_client: MagicMock,
         mock_pod: MagicMock,
-        frigate_stats_healthy: dict,
     ) -> None:
-        """Test health check with stuck detection."""
+        """Test that skipped cameras (e.g., doorbell) don't fail health check."""
+        stats_doorbell_down = {
+            "detectors": {"coral": {"inference_speed": 15.0}},
+            "cameras": {
+                "reolink_doorbell": {"camera_fps": 0.0, "detection_fps": 0.0},
+                "back_yard": {"camera_fps": 5.0, "detection_fps": 0.1},
+            },
+        }
         mock_k8s_client.get_frigate_pod.return_value = mock_pod
         mock_k8s_client.get_pod_node_name.return_value = "still-fawn"
         mock_k8s_client.exec_in_pod.return_value = (
-            json.dumps(frigate_stats_healthy),
+            json.dumps(stats_doorbell_down),
             True,
         )
-        # Simulate logs with stuck detection messages
-        mock_k8s_client.get_pod_logs.return_value = """
-2024-01-15 10:00:00 Detection appears to be stuck
-2024-01-15 10:01:00 Detection appears to be stuck
-2024-01-15 10:02:00 Detection appears to be stuck
-"""
         checker = HealthChecker(settings, mock_k8s_client)
 
         result = checker.check_health()
 
-        assert result.status == HealthStatus.UNHEALTHY
-        assert result.reason == UnhealthyReason.DETECTION_STUCK
-        assert result.metrics.stuck_detection_count == 3
-
-    def test_check_health_recording_backlog(
-        self,
-        settings: Settings,
-        mock_k8s_client: MagicMock,
-        mock_pod: MagicMock,
-        frigate_stats_healthy: dict,
-    ) -> None:
-        """Test health check with recording backlog."""
-        mock_k8s_client.get_frigate_pod.return_value = mock_pod
-        mock_k8s_client.get_pod_node_name.return_value = "still-fawn"
-        mock_k8s_client.exec_in_pod.return_value = (
-            json.dumps(frigate_stats_healthy),
-            True,
-        )
-        # Simulate logs with backlog messages (more than threshold)
-        backlog_msg = "Too many unprocessed recording segments\n"
-        mock_k8s_client.get_pod_logs.return_value = backlog_msg * 6
-        checker = HealthChecker(settings, mock_k8s_client)
-
-        result = checker.check_health()
-
-        assert result.status == HealthStatus.UNHEALTHY
-        assert result.reason == UnhealthyReason.RECORDING_BACKLOG
-        assert result.metrics.recording_backlog_count == 6
+        # Should be healthy because reolink_doorbell is in skip list
+        assert result.status == HealthStatus.HEALTHY
+        assert result.reason is None
 
     def test_check_health_all_healthy(
         self,
         settings: Settings,
         mock_k8s_client: MagicMock,
         mock_pod: MagicMock,
-        frigate_stats_healthy: dict,
     ) -> None:
         """Test health check when everything is healthy."""
+        stats_healthy = {
+            "detectors": {"coral": {"inference_speed": 15.0}},
+            "cameras": {
+                "front_door": {"camera_fps": 5.0, "detection_fps": 0.2},
+                "back_yard": {"camera_fps": 5.0, "detection_fps": 0.1},
+            },
+        }
         mock_k8s_client.get_frigate_pod.return_value = mock_pod
         mock_k8s_client.get_pod_node_name.return_value = "still-fawn"
         mock_k8s_client.exec_in_pod.return_value = (
-            json.dumps(frigate_stats_healthy),
+            json.dumps(stats_healthy),
             True,
         )
-        mock_k8s_client.get_pod_logs.return_value = "Normal log output"
         checker = HealthChecker(settings, mock_k8s_client)
 
         result = checker.check_health()
 
         assert result.status == HealthStatus.HEALTHY
         assert result.reason is None
         assert result.metrics.api_responsive is True
-        assert result.metrics.inference_speed_ms == 45.5
+        assert result.metrics.inference_speed_ms == 15.0
 
 
 class TestRestartManager:

apps/frigate-health-checker/tests/test_integration.py

@@ -237,19 +237,20 @@ def test_alert_sent_only_once_per_incident(
         assert decision2.should_restart is True
         assert decision2.should_alert is False
 
-    def test_slow_inference_triggers_correct_workflow(
+    def test_no_frames_triggers_restart(
         self,
         settings: Settings,
         mock_k8s: MagicMock,
     ) -> None:
-        """Test workflow with slow Coral inference detection."""
-        # Setup: Slow inference
-        slow_stats = {
-            "detectors": {"coral": {"inference_speed": 250.0}},
-            "cameras": {},
+        """Test workflow when camera has no frames."""
+        # Setup: Camera with 0 FPS
+        no_frames_stats = {
+            "detectors": {"coral": {"inference_speed": 15.0}},
+            "cameras": {
+                "front_door": {"camera_fps": 0.0, "detection_fps": 0.0},
+            },
         }
-        mock_k8s.exec_in_pod.return_value = (json.dumps(slow_stats), True)
-        mock_k8s.get_pod_logs.return_value = "Normal logs"
+        mock_k8s.exec_in_pod.return_value = (json.dumps(no_frames_stats), True)
         mock_k8s.get_configmap_data.return_value = {
             "consecutive_failures": "1",
             "alert_sent_for_incident": "false",
@@ -267,33 +268,29 @@ def test_slow_inference_triggers_correct_workflow(
 
         # Verify
         assert result.is_healthy is False
-        assert "inference" in result.message.lower()
-        assert result.metrics.inference_speed_ms == 250.0
+        assert "front_door" in result.message
         assert decision.should_restart is True
 
-    def test_stuck_detection_triggers_restart(
+    def test_healthy_with_all_cameras_working(
         self,
         settings: Settings,
         mock_k8s: MagicMock,
     ) -> None:
-        """Test that stuck detection messages trigger restart."""
-        # Setup: Normal stats but stuck detection in logs
+        """Test healthy status when all cameras have frames."""
+        # Setup: All cameras working
         healthy_stats = {
-            "detectors": {"coral": {"inference_speed": 50.0}},
-            "cameras": {},
+            "detectors": {"coral": {"inference_speed": 15.0}},
+            "cameras": {
+                "front_door": {"camera_fps": 5.0, "detection_fps": 0.2},
+                "back_yard": {"camera_fps": 5.0, "detection_fps": 0.1},
+            },
         }
         mock_k8s.exec_in_pod.return_value = (json.dumps(healthy_stats), True)
-        mock_k8s.get_pod_logs.return_value = """
-        Detection appears to be stuck
-        Detection appears to be stuck
-        Detection appears to be stuck
-        """
         mock_k8s.get_configmap_data.return_value = {
-            "consecutive_failures": "1",
+            "consecutive_failures": "0",
             "alert_sent_for_incident": "false",
             "last_restart_times": "",
         }
-        mock_k8s.is_node_ready.return_value = True
 
         # Execute
         checker = HealthChecker(settings, mock_k8s)
@@ -304,10 +301,8 @@ def test_stuck_detection_triggers_restart(
         decision = manager.evaluate_restart(result, state)
 
         # Verify
-        assert result.is_healthy is False
-        assert result.metrics.stuck_detection_count == 3
-        assert "stuck" in result.message.lower()
-        assert decision.should_restart is True
+        assert result.is_healthy is True
+        assert decision.should_restart is False
 
 
 class TestEmailIntegration: