#106: tests: aircox_streamer (#110)

- Writes tests for aircox streamer application;
- Add test utilities in aircox

Co-authored-by: bkfox <thomas bkfox net>
Reviewed-on: rc/aircox#110

aircox_streamer/tests/test_controllers_monitor.py

@@ -0,0 +1,251 @@
+from django.utils import timezone as tz
+
+import pytest
+from model_bakery import baker
+
+from aircox import models
+from aircox.test import interface
+from aircox_streamer import controllers
+
+
+@pytest.fixture
+def monitor(streamer):
+    streamer.calls = {}
+    return controllers.Monitor(
+        streamer,
+        tz.timedelta(seconds=10),
+        cancel_timeout=tz.timedelta(minutes=10),
+        sync_timeout=tz.timedelta(minutes=5),
+    )
+
+
+@pytest.fixture
+def diffusion(program, episode):
+    return baker.make(
+        models.Diffusion,
+        program=program,
+        episode=episode,
+        start=tz.now() - tz.timedelta(minutes=10),
+        end=tz.now() + tz.timedelta(minutes=30),
+        schedule=None,
+        type=models.Diffusion.TYPE_ON_AIR,
+    )
+
+
+@pytest.fixture
+def source(monitor, streamer, sound, diffusion):
+    source = next(monitor.streamer.playlists)
+    source.uri = sound.file.path
+    source.episode_id = sound.episode_id
+    source.air_time = diffusion.start + tz.timedelta(seconds=10)
+    return source
+
+
+@pytest.fixture
+def tracks(sound):
+    items = [
+        baker.prepare(models.Track, sound=sound, position=i, timestamp=i * 60)
+        for i in range(0, 4)
+    ]
+    models.Track.objects.bulk_create(items)
+    return items
+
+
+@pytest.fixture
+def log(station, source, sound):
+    return baker.make(
+        models.Log,
+        station=station,
+        type=models.Log.TYPE_START,
+        sound=sound,
+        source=source.id,
+    )
+
+
+class TestMonitor:
+    @pytest.mark.django_db(transaction=True)
+    def test_last_diff_start(self, monitor):
+        pass
+
+    @pytest.mark.django_db(transaction=True)
+    def test___init__(self, monitor):
+        assert isinstance(monitor.logs, models.LogQuerySet)
+        assert isinstance(monitor.last_sound_logs, dict)
+
+    @pytest.mark.django_db(transaction=True)
+    def test_get_logs_queryset(self, monitor, station, sounds):
+        query = monitor.get_logs_queryset()
+        assert all(log.station_id == station.pk for log in query)
+
+    @pytest.mark.django_db(transaction=True)
+    def test_init_last_sound_logs(self, monitor, source, log):
+        monitor.init_last_sound_logs()
+        assert monitor.last_sound_logs[source.id] == log
+
+    @pytest.mark.django_db(transaction=True)
+    def test_monitor(self, monitor, source, log, sound):
+        monitor.streamer.is_ready = True
+        monitor.streamer.source = source
+        interface(
+            monitor,
+            {
+                "trace_sound": log,
+                "trace_tracks": None,
+                "handle_diffusions": None,
+                "sync": None,
+            },
+        )
+
+        monitor.monitor()
+        assert monitor.streamer.calls.get("fetch")
+        assert monitor.calls["trace_sound"] == ((source,), {})
+        assert monitor.calls["trace_tracks"] == ((log,), {})
+        assert monitor.calls["handle_diffusions"]
+        assert monitor.calls["sync"]
+
+    @pytest.mark.django_db(transaction=True)
+    def test_monitor_streamer_not_ready(self, monitor):
+        monitor.streamer.is_ready = False
+        interface(
+            monitor,
+            {
+                "trace_sound": log,
+                "trace_tracks": None,
+                "handle_diffusions": None,
+                "sync": None,
+            },
+        )
+
+        monitor.monitor()
+        assert not monitor.streamer.calls.get("fetch")
+        assert monitor.calls["trace_sound"] is None
+        assert monitor.calls["trace_tracks"] is None
+        assert not monitor.calls["handle_diffusions"]
+        assert not monitor.calls["sync"]
+
+    @pytest.mark.django_db(transaction=True)
+    def test_monitor_no_source_uri(self, monitor, log):
+        source.uri = None
+        monitor.streamer.is_ready = True
+        monitor.streamer.source = source
+        interface(
+            monitor,
+            {
+                "trace_sound": log,
+                "trace_tracks": None,
+                "handle_diffusions": None,
+                "sync": None,
+            },
+        )
+
+        monitor.monitor()
+        assert monitor.streamer.calls.get("fetch")
+        assert monitor.calls["trace_sound"] is None
+        assert monitor.calls["trace_tracks"] is None
+        assert monitor.calls["handle_diffusions"]
+        assert monitor.calls["sync"]
+
+    @pytest.mark.django_db(transaction=True)
+    def test_trace_sound(self, monitor, diffusion, source, sound):
+        monitor.last_sound_logs[source.id] = None
+
+        result = monitor.trace_sound(source)
+        assert result.type == models.Log.TYPE_ON_AIR
+        assert result.source == source.id
+        assert result.sound == sound
+        assert result.diffusion == diffusion
+
+    @pytest.mark.django_db(transaction=True)
+    def test_trace_sound_returns_last_log(self, monitor, source, sound, log):
+        log.sound = sound
+        monitor.last_sound_logs[source.id] = log
+
+        result = monitor.trace_sound(source)
+        assert result == log
+
+    @pytest.mark.django_db(transaction=True)
+    def test_trace_tracks(self, monitor, log, tracks):
+        interface(monitor, {"log": None})
+        for track in tracks:
+            log.date = tz.now() - tz.timedelta(seconds=track.timestamp + 5)
+            monitor.trace_tracks(log)
+
+        assert monitor.calls["log"]
+        log_by_track = [call[1].get("track") for call in monitor.calls["log"]]
+        # only one call of log
+        assert all(log_by_track.count(track) for track in tracks)
+
+    @pytest.mark.django_db(transaction=True)
+    def test_trace_tracks_returns_on_log_diffusion(
+        self, monitor, log, diffusion, tracks
+    ):
+        log.diffusion = None
+        monitor.trace_tracks(log)
+
+    @pytest.mark.django_db(transaction=True)
+    def test_trace_tracks_returns_on_no_tracks_exists(self, monitor, log):
+        log.diffusion = None
+        monitor.trace_tracks(log)
+
+    @pytest.mark.django_db(transaction=True)
+    def test_handle_diffusions(self, monitor):
+        pass
+
+    @pytest.mark.django_db(transaction=True)
+    def test_log(self, monitor, source):
+        log = monitor.log("source", type=models.Log.TYPE_START, comment="test")
+        assert log.source == "source"
+        assert log.type == models.Log.TYPE_START
+        assert log.comment == "test"
+
+    @pytest.mark.django_db(transaction=True)
+    def test_start_diff(
+        self, monitor, diffusion, source, episode, sound, tracks
+    ):
+        result = {}
+        monitor.log = lambda **kw: result.update(kw)
+
+        monitor.start_diff(source, diffusion)
+        assert source.calls["push"] == (sound.file.path,)
+        assert result == {
+            "type": models.Log.TYPE_START,
+            "source": source.id,
+            "diffusion": diffusion,
+            "comment": str(diffusion),
+        }
+
+    @pytest.mark.django_db(transaction=True)
+    def test_cancel_diff(self, monitor, source, diffusion):
+        result = {}
+        monitor.log = lambda **kw: result.update(kw)
+
+        monitor.cancel_diff(source, diffusion)
+        assert diffusion.type == models.Log.TYPE_CANCEL
+        assert result == {
+            "type": models.Log.TYPE_CANCEL,
+            "source": source.id,
+            "diffusion": diffusion,
+            "comment": str(diffusion),
+        }
+
+    @pytest.mark.django_db(transaction=True)
+    def test_sync(self, monitor):
+        now = tz.now()
+        monitor.sync_next = now - tz.timedelta(minutes=1)
+        monitor.sync()
+
+        assert monitor.sync_next >= now + monitor.sync_timeout
+        assert all(
+            source.calls.get("sync") for source in monitor.streamer.playlists
+        )
+
+    @pytest.mark.django_db(transaction=True)
+    def test_sync_timeout_not_reached_skip_sync(self, monitor):
+        monitor.sync_next = tz.now() + tz.timedelta(
+            seconds=monitor.sync_timeout.total_seconds() + 20
+        )
+        monitor.sync()
+        assert all(
+            not source.calls.get("sync")
+            for source in monitor.streamer.playlists
+        )