feat: initialize cold display guard

tests/test_cli.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import io
+import json
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from cold_display_guard.cli import run_jsonl
+from cold_display_guard.models import EngineSettings
+
+
+class CliTests(unittest.TestCase):
+    def test_processes_jsonl_observations(self) -> None:
+        settings = EngineSettings(
+            max_dwell_seconds=10,
+            trash_confirmation_seconds=5,
+            zone_ids=("r1c1",),
+        )
+        t0 = datetime(2026, 4, 27, 10, 0, tzinfo=timezone.utc)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            input_path = Path(tmpdir) / "obs.jsonl"
+            input_path.write_text(
+                "\n".join(
+                    [
+                        json.dumps({"ts": t0.isoformat(), "zone_counts": {"r1c1": 1}}),
+                        json.dumps(
+                            {
+                                "ts": (t0 + timedelta(seconds=11)).isoformat(),
+                                "zone_counts": {"r1c1": 0},
+                            }
+                        ),
+                        json.dumps(
+                            {
+                                "ts": (t0 + timedelta(seconds=12)).isoformat(),
+                                "zone_counts": {"r1c1": 0},
+                                "trash_deposit": True,
+                            }
+                        ),
+                    ]
+                ),
+                encoding="utf-8",
+            )
+
+            output = io.StringIO()
+            exit_code = run_jsonl(input_path, settings, output)
+
+        self.assertEqual(exit_code, 0)
+        events = [json.loads(line) for line in output.getvalue().splitlines()]
+        self.assertEqual(
+            [event["event"] for event in events],
+            ["batch_started", "batch_pending_disposal", "batch_discarded"],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_config.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from cold_display_guard.config import load_settings
+
+
+class ConfigTests(unittest.TestCase):
+    def test_loads_settings_from_toml(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = Path(tmpdir) / "config.toml"
+            path.write_text(
+                """
+camera_id = "cam_a"
+
+[thresholds]
+max_dwell_seconds = 30
+trash_confirmation_seconds = 4
+
+[layout]
+rows = 1
+cols = 2
+""".strip(),
+                encoding="utf-8",
+            )
+
+            settings = load_settings(path)
+
+        self.assertEqual(settings.camera_id, "cam_a")
+        self.assertEqual(settings.max_dwell_seconds, 30)
+        self.assertEqual(settings.trash_confirmation_seconds, 4)
+        self.assertEqual(settings.zone_ids, ("r1c1", "r1c2"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_engine.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import unittest
+from datetime import datetime, timedelta, timezone
+
+from cold_display_guard import BatchEngine, EngineSettings, Observation
+
+
+UTC = timezone.utc
+
+
+def obs(ts: datetime, counts: dict[str, int], trash: bool | int = False) -> Observation:
+    return Observation.from_dict(
+        {
+            "ts": ts.isoformat(),
+            "zone_counts": counts,
+            "trash_deposit": trash,
+        }
+    )
+
+
+class BatchEngineTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.settings = EngineSettings(
+            camera_id="test_cam",
+            max_dwell_seconds=10,
+            trash_confirmation_seconds=5,
+            zone_ids=("r1c1", "r1c2"),
+        )
+        self.engine = BatchEngine(self.settings)
+        self.t0 = datetime(2026, 4, 27, 10, 0, tzinfo=UTC)
+
+    def test_starts_batch_when_zone_becomes_occupied(self) -> None:
+        events = self.engine.process(obs(self.t0, {"r1c1": 3}))
+
+        self.assertEqual([event["event"] for event in events], ["batch_started"])
+        self.assertEqual(events[0]["zone_id"], "r1c1")
+        self.assertEqual(events[0]["current_count"], 3)
+
+    def test_consumes_batch_when_removed_before_threshold(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 2}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=9), {"r1c1": 0}))
+
+        self.assertEqual([event["event"] for event in events], ["batch_consumed"])
+        self.assertEqual(events[0]["dwell_seconds"], 9)
+
+    def test_over_threshold_removal_waits_for_disposal_confirmation(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 2}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=10), {"r1c1": 0}))
+
+        self.assertEqual([event["event"] for event in events], ["batch_pending_disposal"])
+        self.assertEqual(events[0]["dwell_seconds"], 10)
+        self.assertIn("disposal_deadline", events[0])
+
+    def test_trash_deposit_confirms_pending_disposal(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 2}))
+        self.engine.process(obs(self.t0 + timedelta(seconds=11), {"r1c1": 0}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=12), {"r1c1": 0}, trash=True))
+
+        self.assertEqual([event["event"] for event in events], ["batch_discarded"])
+
+    def test_missing_trash_deposit_raises_violation_after_deadline(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 2}))
+        self.engine.process(obs(self.t0 + timedelta(seconds=11), {"r1c1": 0}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=17), {"r1c1": 0}))
+
+        self.assertEqual([event["event"] for event in events], ["missing_disposal_violation"])
+        self.assertEqual(events[0]["violation_reasons"], ["missing_disposal"])
+
+    def test_adding_food_before_zone_clears_raises_mixed_batch_violation(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 2}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=1), {"r1c1": 3}))
+
+        self.assertEqual([event["event"] for event in events], ["mixed_batch_violation"])
+        self.assertEqual(events[0]["reason"], "food_added_before_zone_cleared")
+
+    def test_count_decrease_keeps_same_batch_active(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 3}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=1), {"r1c1": 1}))
+
+        self.assertEqual([event["event"] for event in events], ["batch_count_changed"])
+        self.assertEqual(events[0]["previous_count"], 3)
+        self.assertEqual(events[0]["current_count"], 1)
+
+    def test_overdue_food_reappearing_before_disposal_raises_violation(self) -> None:
+        self.engine.process(obs(self.t0, {"r1c1": 2}))
+        self.engine.process(obs(self.t0 + timedelta(seconds=11), {"r1c1": 0}))
+        events = self.engine.process(obs(self.t0 + timedelta(seconds=12), {"r1c2": 1}))
+
+        self.assertEqual(
+            [event["event"] for event in events],
+            ["overdue_return_violation", "batch_started"],
+        )
+        self.assertEqual(events[0]["appeared_zones"], ["r1c2"])
+
+
+if __name__ == "__main__":
+    unittest.main()