mirror of
https://github.com/blakeblackshear/frigate.git
synced 2026-06-21 03:41:55 +03:00
e9ef4f978a
* add class * restore runtime state in dispatcher * restore on startup with special case for profile * add tests * update docs * mypy
218 lines
8.4 KiB
Python
218 lines
8.4 KiB
Python
"""Tests for Dispatcher runtime state persistence wiring."""
|
|
|
|
import os
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from frigate.comms.dispatcher import Dispatcher
|
|
from frigate.comms.runtime_state import RuntimeStatePersistence
|
|
|
|
|
|
def _make_camera_mock(
|
|
*,
|
|
enabled: bool = True,
|
|
enabled_in_config: bool = True,
|
|
detect_enabled: bool = True,
|
|
record_enabled: bool = True,
|
|
record_enabled_in_config: bool = True,
|
|
snapshots_enabled: bool = True,
|
|
audio_enabled: bool = True,
|
|
audio_enabled_in_config: bool = True,
|
|
) -> MagicMock:
|
|
"""Build a camera config mock with the fields the in-scope handlers read."""
|
|
camera = MagicMock()
|
|
camera.enabled = enabled
|
|
camera.enabled_in_config = enabled_in_config
|
|
camera.detect.enabled = detect_enabled
|
|
camera.motion.enabled = True # avoid the detect→motion side-effect path
|
|
camera.record.enabled = record_enabled
|
|
camera.record.enabled_in_config = record_enabled_in_config
|
|
camera.snapshots.enabled = snapshots_enabled
|
|
camera.audio.enabled = audio_enabled
|
|
camera.audio.enabled_in_config = audio_enabled_in_config
|
|
return camera
|
|
|
|
|
|
def _build_dispatcher(cameras: dict[str, MagicMock]) -> Dispatcher:
|
|
"""Construct a Dispatcher with the bare-minimum mocks the tests need."""
|
|
config = MagicMock()
|
|
config.cameras = cameras
|
|
config_updater = MagicMock()
|
|
onvif = MagicMock()
|
|
ptz_metrics: dict = {}
|
|
communicators: list = []
|
|
|
|
with (
|
|
patch("frigate.comms.dispatcher.CameraActivityManager"),
|
|
patch("frigate.comms.dispatcher.AudioActivityManager"),
|
|
):
|
|
return Dispatcher(config, config_updater, onvif, ptz_metrics, communicators)
|
|
|
|
|
|
class TestRestoreRuntimeState(unittest.TestCase):
|
|
"""Verify replay routes through handlers and tolerates missing entries."""
|
|
|
|
def setUp(self) -> None:
|
|
self.dispatcher = _build_dispatcher(
|
|
{
|
|
"front_door": _make_camera_mock(),
|
|
"back_yard": _make_camera_mock(),
|
|
}
|
|
)
|
|
# Swap each in-scope handler for a MagicMock so we can assert calls
|
|
# without exercising the handler's own logic.
|
|
self.handler_mocks: dict[str, MagicMock] = {}
|
|
for topic in ("enabled", "detect", "snapshots", "recordings", "audio"):
|
|
mock = MagicMock()
|
|
self.dispatcher._camera_settings_handlers[topic] = mock
|
|
self.handler_mocks[topic] = mock
|
|
|
|
def test_replays_each_stored_entry_through_its_handler(self) -> None:
|
|
self.dispatcher._runtime_state = MagicMock(
|
|
spec=RuntimeStatePersistence,
|
|
load=MagicMock(
|
|
return_value={
|
|
"front_door": {"detect": False, "recordings": False},
|
|
"back_yard": {"audio": False},
|
|
}
|
|
),
|
|
)
|
|
self.dispatcher.restore_runtime_state()
|
|
|
|
self.handler_mocks["detect"].assert_called_once_with("front_door", "OFF")
|
|
self.handler_mocks["recordings"].assert_called_once_with("front_door", "OFF")
|
|
self.handler_mocks["audio"].assert_called_once_with("back_yard", "OFF")
|
|
self.handler_mocks["enabled"].assert_not_called()
|
|
self.handler_mocks["snapshots"].assert_not_called()
|
|
|
|
def test_skips_unknown_cameras(self) -> None:
|
|
self.dispatcher._runtime_state = MagicMock(
|
|
spec=RuntimeStatePersistence,
|
|
load=MagicMock(return_value={"removed_cam": {"detect": False}}),
|
|
)
|
|
self.dispatcher.restore_runtime_state()
|
|
for mock in self.handler_mocks.values():
|
|
mock.assert_not_called()
|
|
|
|
def test_skips_unknown_topics(self) -> None:
|
|
self.dispatcher._runtime_state = MagicMock(
|
|
spec=RuntimeStatePersistence,
|
|
load=MagicMock(return_value={"front_door": {"some_old_topic": True}}),
|
|
)
|
|
self.dispatcher.restore_runtime_state()
|
|
for mock in self.handler_mocks.values():
|
|
mock.assert_not_called()
|
|
|
|
def test_continues_after_handler_exception(self) -> None:
|
|
self.handler_mocks["detect"].side_effect = RuntimeError("boom")
|
|
self.dispatcher._runtime_state = MagicMock(
|
|
spec=RuntimeStatePersistence,
|
|
load=MagicMock(
|
|
return_value={
|
|
"front_door": {"detect": False, "recordings": False},
|
|
}
|
|
),
|
|
)
|
|
# Must not raise; the recordings handler must still run.
|
|
self.dispatcher.restore_runtime_state()
|
|
self.handler_mocks["recordings"].assert_called_once_with("front_door", "OFF")
|
|
|
|
def test_true_value_routes_as_on_payload(self) -> None:
|
|
self.dispatcher._runtime_state = MagicMock(
|
|
spec=RuntimeStatePersistence,
|
|
load=MagicMock(return_value={"front_door": {"detect": True}}),
|
|
)
|
|
self.dispatcher.restore_runtime_state()
|
|
self.handler_mocks["detect"].assert_called_once_with("front_door", "ON")
|
|
|
|
|
|
class TestHandlersPersistViaSet(unittest.TestCase):
|
|
"""Verify each in-scope handler writes to the runtime state on success."""
|
|
|
|
def setUp(self) -> None:
|
|
self.tmp_dir = tempfile.mkdtemp()
|
|
self.config_path = os.path.join(self.tmp_dir, "config.yml")
|
|
with open(self.config_path, "w") as f:
|
|
f.write("")
|
|
self._patcher = patch(
|
|
"frigate.comms.runtime_state.find_config_file",
|
|
return_value=self.config_path,
|
|
)
|
|
self._patcher.start()
|
|
|
|
# Start with everything OFF so each ON payload triggers a real change
|
|
self.cameras = {
|
|
"front_door": _make_camera_mock(
|
|
enabled=False,
|
|
detect_enabled=False,
|
|
record_enabled=False,
|
|
snapshots_enabled=False,
|
|
audio_enabled=False,
|
|
)
|
|
}
|
|
self.dispatcher = _build_dispatcher(self.cameras)
|
|
|
|
def tearDown(self) -> None:
|
|
self._patcher.stop()
|
|
for name in os.listdir(self.tmp_dir):
|
|
os.remove(os.path.join(self.tmp_dir, name))
|
|
os.rmdir(self.tmp_dir)
|
|
|
|
def _stored_state(self) -> dict:
|
|
return RuntimeStatePersistence().load()
|
|
|
|
def test_enabled_handler_persists(self) -> None:
|
|
self.dispatcher._on_enabled_command("front_door", "ON")
|
|
self.assertEqual(self._stored_state(), {"front_door": {"enabled": True}})
|
|
|
|
def test_detect_handler_persists(self) -> None:
|
|
self.dispatcher._on_detect_command("front_door", "ON")
|
|
self.assertEqual(self._stored_state(), {"front_door": {"detect": True}})
|
|
|
|
def test_recordings_handler_persists(self) -> None:
|
|
self.dispatcher._on_recordings_command("front_door", "ON")
|
|
self.assertEqual(self._stored_state(), {"front_door": {"recordings": True}})
|
|
|
|
def test_snapshots_handler_persists(self) -> None:
|
|
self.dispatcher._on_snapshots_command("front_door", "ON")
|
|
self.assertEqual(self._stored_state(), {"front_door": {"snapshots": True}})
|
|
|
|
def test_audio_handler_persists(self) -> None:
|
|
self.dispatcher._on_audio_command("front_door", "ON")
|
|
self.assertEqual(self._stored_state(), {"front_door": {"audio": True}})
|
|
|
|
def test_enabled_in_config_gate_blocks_persistence(self) -> None:
|
|
"""An ON payload rejected by the gate must not be persisted."""
|
|
cam = self.cameras["front_door"]
|
|
cam.enabled_in_config = False
|
|
cam.record.enabled_in_config = False
|
|
cam.audio.enabled_in_config = False
|
|
|
|
self.dispatcher._on_enabled_command("front_door", "ON")
|
|
self.dispatcher._on_recordings_command("front_door", "ON")
|
|
self.dispatcher._on_audio_command("front_door", "ON")
|
|
|
|
self.assertEqual(self._stored_state(), {})
|
|
|
|
|
|
class TestClearPassthrough(unittest.TestCase):
|
|
"""The dispatcher's public clear methods delegate to the store."""
|
|
|
|
def test_clear_runtime_state_for_yaml_keys_passthrough(self) -> None:
|
|
dispatcher = _build_dispatcher({})
|
|
dispatcher._runtime_state = MagicMock(spec=RuntimeStatePersistence)
|
|
keys = ["cameras.front_door.detect.enabled"]
|
|
dispatcher.clear_runtime_state_for_yaml_keys(keys)
|
|
dispatcher._runtime_state.clear_for_yaml_keys.assert_called_once_with(keys)
|
|
|
|
def test_clear_runtime_state_passthrough(self) -> None:
|
|
dispatcher = _build_dispatcher({})
|
|
dispatcher._runtime_state = MagicMock(spec=RuntimeStatePersistence)
|
|
dispatcher.clear_runtime_state()
|
|
dispatcher._runtime_state.clear_all.assert_called_once_with()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|