write sound monitor tests

aircox/tests/controllers/test_sound_monitor.py

@@ -1,8 +1,10 @@
+from concurrent import futures
 import logging
 import pytest
 
 from django.utils import timezone as tz
 
+from aircox.conf import settings
 from aircox.models import Sound
 from aircox.controllers import sound_monitor
 from aircox.test import Interface, interface
@@ -25,8 +27,8 @@ def logger():
 
 
 @pytest.fixture
-def interfaces(logger):
-    return {
+def interfaces():
+    items = {
         "SoundFile": Interface.inject(
             sound_monitor,
             "SoundFile",
@@ -41,8 +43,11 @@ def interfaces(logger):
                 "sleep": None,
             },
         ),
-        "datetime": Interface.inject(sound_monitor, "datetime", {now: now}),
+        "datetime": Interface.inject(sound_monitor, "datetime", {"now": now}),
     }
+    yield items
+    for item in items.values():
+        item._irelease()
 
 
 @pytest.fixture
@@ -65,6 +70,23 @@ def modified_task(interfaces):
     return sound_monitor.ModifiedTask()
 
 
+@pytest.fixture
+def monitor_handler(interfaces):
+    pool = Interface(
+        None,
+        {
+            "submit": lambda imeta, *a, **kw: Interface(
+                None,
+                {
+                    "add_done_callback": None,
+                    "done": False,
+                },
+            )
+        },
+    )
+    return sound_monitor.MonitorHandler("/tmp", pool=pool, sync_kw=13)
+
+
 class TestTask:
     def test___init__(self, task):
         assert task.timestamp is not None
@@ -111,7 +133,7 @@ class TestModifiedTask:
         dt_now = now + modified_task.timeout_delta - tz.timedelta(hours=10)
         datetime = Interface.inject(sound_monitor, "datetime", {"now": dt_now})
 
-        def sleep(n):
+        def sleep(imeta, n):
             datetime._imeta.funcs[
                 "now"
             ] = modified_task.timestamp + tz.timedelta(hours=10)
@@ -129,31 +151,124 @@ class TestModifiedTask:
 
 
 class TestMonitorHandler:
-    def test_monitor___init__(self):
-        pass
+    def test_on_created(self, monitor_handler, event):
+        monitor_handler._submit = monitor_handler.pool.submit
+        monitor_handler.on_created(event)
+        trace_args, trace_kwargs = monitor_handler.pool._trace("submit")
+        assert isinstance(trace_args[0], sound_monitor.CreateTask)
+        assert trace_args[1:] == (event, "new")
+        assert trace_kwargs == monitor_handler.sync_kw
 
-    def test_on_created(self):
-        pass
+    def test_on_deleted(self, monitor_handler, event):
+        monitor_handler._submit = monitor_handler.pool.submit
+        monitor_handler.on_deleted(event)
+        trace_args, _ = monitor_handler.pool._trace("submit")
+        assert isinstance(trace_args[0], sound_monitor.DeleteTask)
+        assert trace_args[1:] == (event, "del")
 
-    def test_on_deleted(self):
-        pass
+    def test_on_moved(self, monitor_handler, event):
+        monitor_handler._submit = monitor_handler.pool.submit
+        monitor_handler.on_moved(event)
+        trace_args, trace_kwargs = monitor_handler.pool._trace("submit")
+        assert isinstance(trace_args[0], sound_monitor.MoveTask)
+        assert trace_args[1:] == (event, "mv")
+        assert trace_kwargs == monitor_handler.sync_kw
 
-    def test_on_moved(self):
-        pass
+    def test_on_modified(self, monitor_handler, event):
+        monitor_handler._submit = monitor_handler.pool.submit
+        monitor_handler.on_modified(event)
+        trace_args, trace_kwargs = monitor_handler.pool._trace("submit")
+        assert isinstance(trace_args[0], sound_monitor.ModifiedTask)
+        assert trace_args[1:] == (event, "up")
+        assert trace_kwargs == monitor_handler.sync_kw
 
-    def test_on_modified(self):
-        pass
+    def test__submit(self, monitor_handler, event):
+        handler = Interface()
+        handler, created = monitor_handler._submit(
+            handler, event, "prefix", kw=13
+        )
+        assert created
+        assert handler.future._trace("add_done_callback")
+        assert monitor_handler.pool._trace("submit") == (
+            (handler, event),
+            {"kw": 13},
+        )
 
-    def test__submit(self):
-        pass
+        key = f"prefix:{event.src_path}"
+        assert monitor_handler.jobs.get(key) == handler
+
+
+@pytest.fixture
+def monitor_interfaces():
+    items = {
+        "atexit": Interface.inject(
+            sound_monitor, "atexit", {"register": None, "leave": None}
+        ),
+        "observer": Interface.inject(
+            sound_monitor,
+            "Observer",
+            {
+                "schedule": None,
+                "start": None,
+            },
+        ),
+    }
+    yield items
+    for item in items.values():
+        item.release()
+
+
+@pytest.fixture
+def monitor():
+    yield sound_monitor.SoundMonitor()
 
 
 class SoundMonitor:
-    def test_report(self):
-        pass
+    def test_report(self, monitor, program, logger):
+        monitor.report(program, "component", "content", logger=logger)
+        msg = f"{program}, component: content"
+        assert logger._trace("info", args=True) == (msg,)
 
-    def test_scan(self):
-        pass
+    def test_scan(self, monitor, program, logger):
+        interface = Interface(None, {"scan_for_program": None})
+        monitor.scan_for_program = interface.scan_for_program
+        dirs = monitor.scan(logger)
 
-    def test_monitor(self):
-        pass
+        assert logger._traces("info") == (
+            "scan all programs...",
+            f"#{program.id} {program.title}",
+        )
+        assert dirs == [program.abspath]
+        assert interface._traces("scan_for_program") == (
+            ((program, settings.SOUND_ARCHIVES_SUBDIR), {"logger": logger})(
+                (program, settings.SOUND_EXCERPTS_SUBDIR), {"logger": logger}
+            )
+        )
+
+    def test_monitor(self, monitor, monitor_interfaces, logger):
+        def sleep(*args, **kwargs):
+            monitor.stop()
+
+        time = Interface.inject(sound_monitor, "time", {"sleep": sleep})
+        monitor.monitor(logger=logger)
+        time._irelease()
+
+        observers = monitor_interfaces["observer"].instances
+        observer = observers and observers[0]
+        assert observer
+        schedules = observer._traces("schedule")
+        for (handler, *_), kwargs in schedules:
+            assert isinstance(handler, sound_monitor.MonitorHandler)
+            assert isinstance(handler.pool, futures.ThreadPoolExecutor)
+            assert (handler.subdir, handler.type) in (
+                (settings.SOUND_ARCHIVES_SUBDIR, Sound.TYPE_ARCHIVE),
+                (settings.SOUND_EXCERPTS_SUBDIR, Sound.TYPE_EXCERPT),
+            )
+
+        assert observer._trace("start")
+
+        atexit = monitor_interfaces["atexit"]
+        assert atexit._trace("register")
+        assert atexit._trace("unregister")
+
+        assert observers