this is a push

test/test_alerting.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from backend.alerting import AlertManager
+
+
+class AlertManagerRobotTests(unittest.TestCase):
+    def test_channel_status_does_not_expose_webhook(self) -> None:
+        manager = AlertManager(
+            wechat_webhook_url="https://example.test/wechat-secret",
+            feishu_webhook_url="https://example.test/feishu-secret",
+            feishu_secret="signing-secret",
+        )
+
+        statuses = {item["id"]: item for item in manager.channel_status}
+
+        self.assertTrue(statuses["wechat"]["configured"])
+        self.assertTrue(statuses["feishu"]["configured"])
+        self.assertTrue(statuses["feishu"]["signed"])
+        self.assertNotIn("webhook", repr(statuses).lower())
+        self.assertNotIn("example.test", repr(statuses))
+
+    @patch("backend.alerting.post_json", return_value={})
+    def test_wechat_connection_test_updates_delivery_stats(
+        self,
+        mocked_post_json,
+    ) -> None:
+        manager = AlertManager(
+            wechat_webhook_url="https://example.test/hook"
+        )
+
+        result = manager.test_channel("wechat")
+
+        self.assertEqual(result["last_status"], "success")
+        self.assertEqual(result["delivered"], 1)
+        self.assertEqual(result["tests"], 1)
+        self.assertIsNotNone(result["last_test_at"])
+        mocked_post_json.assert_called_once()
+
+    def test_unconfigured_channel_cannot_send_test(self) -> None:
+        manager = AlertManager()
+
+        with self.assertRaisesRegex(ValueError, "尚未配置"):
+            manager.test_channel("wechat")
+
+    def test_unknown_channel_is_rejected(self) -> None:
+        manager = AlertManager()
+
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            manager.test_channel("unknown")
+
+
+if __name__ == "__main__":
+    unittest.main()

test/test_events.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import unittest
+
+from backend.events import EventStore
+
+
+class EventStoreTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.store = EventStore(max_events=2)
+
+    def create_event(self, session_id: str = "session") -> dict:
+        return self.store.create(
+            session_id=session_id,
+            classes=["fire"],
+            detections=[{"class": "fire", "confidence": 0.82}],
+            notification_channels={"wechat": True, "feishu": False},
+        )
+
+    def test_create_and_summarize_event(self) -> None:
+        event = self.create_event()
+
+        summary = self.store.summary()
+
+        self.assertEqual(event["status"], "pending")
+        self.assertEqual(event["max_confidence"], 0.82)
+        self.assertEqual(summary["total"], 1)
+        self.assertEqual(summary["pending"], 1)
+        self.assertEqual(summary["fire"], 1)
+
+    def test_update_event_status(self) -> None:
+        event = self.create_event()
+
+        updated = self.store.update(event["id"], "resolved")
+
+        self.assertIsNotNone(updated)
+        self.assertEqual(updated["status"], "resolved")
+        self.assertIsNotNone(updated["handled_at"])
+
+    def test_store_respects_maximum_size(self) -> None:
+        first = self.create_event("first")
+        self.create_event("second")
+        self.create_event("third")
+
+        event_ids = {event["id"] for event in self.store.list()}
+
+        self.assertEqual(len(event_ids), 2)
+        self.assertNotIn(first["id"], event_ids)
+
+    def test_invalid_status_is_rejected(self) -> None:
+        event = self.create_event()
+
+        with self.assertRaisesRegex(ValueError, "Unsupported"):
+            self.store.update(event["id"], "invalid")
+
+
+if __name__ == "__main__":
+    unittest.main()