feat: enhance telemetry metrics with target FPS tracking and logging

tests/test_telemetry_collector.py

@@ -10,7 +10,7 @@ from unittest.mock import MagicMock, patch
 class TestTelemetryCollector:
     """Test telemetry calculations in isolation (no Qt event loop required)."""
 
-    def _make_collector(self):
+    def _make_collector(self, cpu_count: int = 8):
         """Construct a TelemetryCollector bypassing Qt machinery."""
         from app.telemetry.telemetry_collector import TelemetryCollector
 
@@ -23,8 +23,11 @@ class TestTelemetryCollector:
         col._dropped_frames = 0
         col._fps_window = deque()
         col._fps_window_size_s = 1.0
+        col._target_fps = None
+        col._cpu_count = cpu_count
+
         col._process = MagicMock()
-        # Simulate Windows: wset is present and takes priority over rss
+        # Simulate Windows: wset takes priority over rss
         mem_info = MagicMock()
         mem_info.wset = 50 * 1024 * 1024   # 50 MB private working set
         mem_info.rss = 70 * 1024 * 1024    # RSS (larger, includes shared)
@@ -40,7 +43,6 @@ class TestTelemetryCollector:
     def test_fps_counts_frames_in_window(self):
         col = self._make_collector()
         now = time.perf_counter()
-        # Simulate 30 frames within the last second
         for i in range(30):
             col._fps_window.append(now - 0.9 + i * 0.03)
         snap = col._compute_snapshot()
@@ -60,7 +62,6 @@ class TestTelemetryCollector:
 
     def test_frame_time_average(self):
         col = self._make_collector()
-        # 10 frames at 33.3 ms each
         interval = 0.0333
         for _ in range(10):
             col._frame_times.append(interval)
@@ -69,7 +70,6 @@ class TestTelemetryCollector:
 
     def test_drop_detection(self):
         col = self._make_collector()
-        # Seed with 10 normal frames at ~16 ms
         normal_interval = 0.016
         now = time.perf_counter()
         col._last_frame_time = now - normal_interval * 10
@@ -77,15 +77,11 @@ class TestTelemetryCollector:
             col._last_frame_time += normal_interval
             col._frame_times.append(normal_interval)
 
-        # Simulate a big gap (3× normal) — should trigger drop detection
-        col._last_frame_time = now - normal_interval * 10  # reset base
-        # Manually call on_frame-like logic
+        col._last_frame_time = now
         with patch("app.telemetry.telemetry_collector.time") as mock_time:
-            # Set last_frame_time to something reasonable
             col._last_frame_time = now
             big_delta = normal_interval * 5  # 5× average → drop
             mock_time.perf_counter.return_value = now + big_delta
-            # Replicate the drop detection logic
             delta = big_delta
             col._frame_times.append(delta)
             avg = sum(col._frame_times) / len(col._frame_times)
@@ -110,3 +106,34 @@ class TestTelemetryCollector:
         col = self._make_collector()
         snap = col._compute_snapshot()
         assert snap.memory_mb == 50.0
+
+    def test_cpu_sys_is_core_divided_by_cpu_count(self):
+        col = self._make_collector(cpu_count=8)
+        col._process.cpu_percent.return_value = 80.0  # 80% of one core
+        snap = col._compute_snapshot()
+        assert snap.cpu_percent_core == 80.0
+        assert snap.cpu_percent_sys == round(80.0 / 8, 1)
+
+    def test_cpu_sys_never_exceeds_100_on_single_core_machine(self):
+        col = self._make_collector(cpu_count=1)
+        col._process.cpu_percent.return_value = 95.0
+        snap = col._compute_snapshot()
+        assert snap.cpu_percent_sys == snap.cpu_percent_core == 95.0
+
+    def test_cpu_sys_le_cpu_core(self):
+        """cpu_percent_sys must always be <= cpu_percent_core."""
+        col = self._make_collector(cpu_count=4)
+        col._process.cpu_percent.return_value = 150.0
+        snap = col._compute_snapshot()
+        assert snap.cpu_percent_sys <= snap.cpu_percent_core
+
+    def test_target_fps_none_by_default(self):
+        col = self._make_collector()
+        snap = col._compute_snapshot()
+        assert snap.target_fps is None
+
+    def test_set_target_fps_reflected_in_snapshot(self):
+        col = self._make_collector()
+        col.set_target_fps(60.0)
+        snap = col._compute_snapshot()
+        assert snap.target_fps == 60.0