tests: playlist_import, log_archiver, sound_stats.SoxStats

aircox/tests/controllers/playlist.csv

@@ -0,0 +1,3 @@
+Artist 1;Title 1;1;0;tag1,tag12;info1
+Artist 2;Title 2;2;1;tag2,tag12;info2
+Artist 3;Title 3;3;2;;

aircox/tests/controllers/test_log_archiver.py

@@ -1,37 +1,110 @@
-import pytest
+from django.utils import timezone as tz
 
-from aircox.controllers.log_archiver import LogArchiver
+import pytest
+from model_bakery import baker
+
+from aircox import models
+from aircox.test import Interface, File
+from aircox.controllers import log_archiver
 
 
 @pytest.fixture
-def log_archiver():
-    return LogArchiver()
+def diffusions(episodes):
+    items = [
+        baker.prepare(
+            models.Diffusion,
+            program=episode.program,
+            episode=episode,
+            type=models.Diffusion.TYPE_ON_AIR,
+        )
+        for episode in episodes
+    ]
+    models.Diffusion.objects.bulk_create(items)
+    return items
+
+
+@pytest.fixture
+def logs(diffusions, sound, tracks):
+    now = tz.now()
+    station = diffusions[0].program.station
+    items = [
+        models.Log(
+            station=diffusion.program.station,
+            type=models.Log.TYPE_START,
+            date=now + tz.timedelta(hours=-10, minutes=i),
+            source="13",
+            diffusion=diffusion,
+        )
+        for i, diffusion in enumerate(diffusions)
+    ]
+    items += [
+        models.Log(
+            station=station,
+            type=models.Log.TYPE_ON_AIR,
+            date=now + tz.timedelta(hours=-9, minutes=i),
+            source="14",
+            track=track,
+            sound=track.sound,
+        )
+        for i, track in enumerate(tracks)
+    ]
+    models.Log.objects.bulk_create(items)
+    return items
+
+
+@pytest.fixture
+def logs_qs(logs):
+    return models.Log.objects.filter(pk__in=(r.pk for r in logs))
+
+
+@pytest.fixture
+def file():
+    return File(data=b"")
+
+
+@pytest.fixture
+def gzip(file):
+    gzip = Interface.inject(log_archiver, "gzip", {"open": file})
+    yield gzip
+    gzip._irelease()
+
+
+@pytest.fixture
+def archiver():
+    return log_archiver.LogArchiver()
 
 
 class TestLogArchiver:
-    def test_get_path(self):
-        pass
+    @pytest.mark.django_db
+    def test_archive_then_load_file(self, archiver, file, gzip, logs, logs_qs):
+        # before logs are deleted from db, get data
+        sorted = archiver.sort_logs(logs_qs)
+        paths = {
+            archiver.get_path(station, date) for station, date in sorted.keys()
+        }
 
-    def test_archive(self):
-        pass
+        count = archiver.archive(logs_qs, keep=False)
+        assert count == len(logs)
+        assert not logs_qs.count()
+        assert all(
+            path in paths for path, *_ in gzip._traces("open", args=True)
+        )
 
-    def test_archive_no_qs(self):
-        pass
+        results = archiver.load_file("dummy path")
+        assert results
 
-    def test_archive_not_keep(self):
-        pass
+    @pytest.mark.django_db
+    def test_archive_no_qs(self, archiver):
+        count = archiver.archive(models.Log.objects.none())
+        assert not count
 
-    def test_sort_log(self):
-        pass
+    @pytest.mark.django_db
+    def test_sort_log(self, archiver, logs_qs):
+        sorted = archiver.sort_logs(logs_qs)
 
-    def test_serialize(self):
-        pass
-
-    def test_load(self):
-        pass
-
-    def test_load_file_not_exists(self):
-        pass
-
-    def test_get_relations(self):
-        pass
+        assert sorted
+        for (station, date), logs in sorted.items():
+            assert all(
+                log.station == station and log.date.date() == date
+                for log in logs
+            )

aircox/tests/controllers/test_playlist_import.py

@@ -1,22 +1,64 @@
+import os
 import pytest
 
-from aircox.controller.playlist_import import PlaylistImport
+from aircox.test import Interface
+from aircox.controllers import playlist_import
+
+
+csv_data = [
+    {
+        "artist": "Artist 1",
+        "title": "Title 1",
+        "minutes": "1",
+        "seconds": "0",
+        "tags": "tag1,tag12",
+        "info": "info1",
+    },
+    {
+        "artist": "Artist 2",
+        "title": "Title 2",
+        "minutes": "2",
+        "seconds": "1",
+        "tags": "tag2,tag12",
+        "info": "info2",
+    },
+    {
+        "artist": "Artist 3",
+        "title": "Title 3",
+        "minutes": "3",
+        "seconds": "2",
+        "tags": "",
+        "info": "",
+    },
+]
 
 
 @pytest.fixture
-def playlist_import():
-    return PlaylistImport()
+def importer(sound):
+    path = os.path.join(os.path.dirname(__file__), "playlist.csv")
+    return playlist_import.PlaylistImport(path, sound=sound)
 
 
 class TestPlaylistImport:
-    def test_reset(self):
-        pass
+    @pytest.mark.django_db
+    def test_run(self, importer):
+        iface = Interface(None, {"read": None, "make_playlist": None})
+        importer.read = iface.read
+        importer.make_playlist = iface.make_playlist
+        importer.run()
+        assert iface._trace("read")
+        assert iface._trace("make_playlist")
 
-    def test_run(self):
-        pass
+    @pytest.mark.django_db
+    def test_read(self, importer):
+        importer.read()
+        assert importer.data == csv_data
 
-    def test_read(self):
-        pass
-
-    def make_playlist(self):
-        pass
+    @pytest.mark.django_db
+    def test_make_playlist(self, importer, sound):
+        importer.data = csv_data
+        importer.make_playlist()
+        track_artists = sound.track_set.all().values_list("artist", flat=True)
+        csv_artists = {r["artist"] for r in csv_data}
+        assert set(track_artists) == csv_artists
+        # TODO: check other values

aircox/tests/controllers/test_sound_stats.py

@@ -1,30 +1,75 @@
+import subprocess
+
 import pytest
 
-from aircox.controllers.sound_stats import SoxStats, SoundStats
+from aircox.test import Interface
+from aircox.controllers import sound_stats
+
+
+sox_output = """
+    DC offset   0.000000\n
+    Min level   0.000000\n
+    Max level   0.000000\n
+    Pk lev dB       -inf\n
+    RMS lev dB      -inf\n
+    RMS Pk dB       -inf\n
+    RMS Tr dB       -inf\n
+    Crest factor    1.00\n
+    Flat factor   179.37\n
+    Pk count       1.86G\n
+    Bit-depth       0/0\n
+    Num samples     930M\n
+    Length s   19383.312\n
+    Scale max   1.000000\n
+    Window s       0.050\n
+"""
+sox_values = {
+    "DC offset": 0.0,
+    "Min level": 0.0,
+    "Max level": 0.0,
+    "Pk lev dB": float("-inf"),
+    "RMS lev dB": float("-inf"),
+    "RMS Pk dB": float("-inf"),
+    "RMS Tr dB": float("-inf"),
+    "Flat factor": 179.37,
+    "length": 19383.312,
+}
 
 
 @pytest.fixture
-def sox_stats():
-    return SoxStats()
+def sox_interfaces():
+    process = Interface(
+        None, {"communicate": ("", sox_output.encode("utf-8"))}
+    )
+    subprocess = Interface.inject(
+        sound_stats, "subprocess", {"Popen": lambda *_, **__: process}
+    )
+    yield {"process": process, "subprocess": subprocess}
+    subprocess._irelease()
 
 
 @pytest.fixture
-def sound_stats():
-    return SoundStats()
+def sox_stats(sox_interfaces):
+    return sound_stats.SoxStats()
+
+
+@pytest.fixture
+def stats():
+    return sound_stats.SoundStats()
 
 
 class TestSoxStats:
-    def test___init__(self):
-        pass
+    def test_parse(self, sox_stats):
+        values = sox_stats.parse(sox_output)
+        assert values == sox_values
 
-    def test_get(self):
-        pass
-
-    def test_parse(self):
-        pass
-
-    def test_analyse(self):
-        pass
+    def test_analyse(self, sox_stats, sox_interfaces):
+        sox_stats.analyse("fake_path", 1, 2)
+        assert sox_interfaces["subprocess"]._trace("Popen") == (
+            (["sox", "fake_path", "-n", "trim", "1", "2", "stats"],),
+            {"stdout": subprocess.PIPE, "stderr": subprocess.PIPE},
+        )
+        assert sox_stats.values == sox_values
 
 
 class TestSoundStats: