90 lines
4.9 KiB
Python
90 lines
4.9 KiB
Python
import json
|
|
from datetime import timedelta
|
|
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.management import call_command
|
|
from django.test import TestCase
|
|
from django.urls import reverse
|
|
from django.utils import timezone
|
|
|
|
from .models import BurstSession
|
|
|
|
|
|
class BurstHeartbeatTests(TestCase):
|
|
def setUp(self):
|
|
self.user = get_user_model().objects.create_user(username="burst-a", password="test-password")
|
|
self.other = get_user_model().objects.create_user(username="burst-b", password="test-password")
|
|
self.client.force_login(self.user)
|
|
|
|
def start(self):
|
|
response = self.client.post(reverse("fireworks_detect:burst_start"), {"maximum_minutes": "15"})
|
|
self.assertEqual(response.status_code, 200)
|
|
return BurstSession.objects.get(pk=response.json()["id"])
|
|
|
|
def heartbeat(self, session, sequence=1, frames=100):
|
|
return self.client.post(reverse("fireworks_detect:burst_detail", args=[session.pk]), data=json.dumps({
|
|
"sequence": sequence, "audio_frames": frames, "elapsed_ms": 5000,
|
|
"wall_at": timezone.now().isoformat(), "track_state": "live", "visibility": "visible",
|
|
}), content_type="application/json")
|
|
|
|
def test_sessions_time_out_independently_and_recover(self):
|
|
lost = self.start()
|
|
active = self.start()
|
|
old = timezone.now() - timedelta(seconds=20)
|
|
BurstSession.objects.filter(pk=lost.pk).update(started_at=old, last_seen_at=old)
|
|
self.assertEqual(self.heartbeat(active).status_code, 200)
|
|
call_command("watch_burst_sessions", once=True)
|
|
lost.refresh_from_db()
|
|
active.refresh_from_db()
|
|
self.assertEqual(lost.status, "heartbeat_lost")
|
|
self.assertIsNotNone(lost.timeout_at)
|
|
self.assertEqual(active.status, "listening")
|
|
self.assertIsNone(active.timeout_at)
|
|
self.assertEqual(self.heartbeat(lost).status_code, 200)
|
|
lost.refresh_from_db()
|
|
self.assertEqual(lost.status, "listening")
|
|
self.assertTrue(any(item["kind"] == "heartbeat_recovered" for item in lost.diagnostic_events))
|
|
|
|
def test_replay_and_foreign_session_rejected(self):
|
|
session = self.start()
|
|
self.assertEqual(self.heartbeat(session).status_code, 200)
|
|
self.assertEqual(self.heartbeat(session).status_code, 400)
|
|
self.client.force_login(self.other)
|
|
self.assertEqual(self.heartbeat(session, sequence=2).status_code, 404)
|
|
self.assertEqual(self.client.get(reverse("fireworks_detect:burst_detail", args=[session.pk])).status_code, 404)
|
|
|
|
class BurstSubmissionTests(TestCase):
|
|
def setUp(self):
|
|
self.user = get_user_model().objects.create_user(username="burst-submit", password="test-password")
|
|
self.client.force_login(self.user)
|
|
self.client.cookies["django_language"] = "en"
|
|
|
|
def test_grouped_submission_creates_one_pending_with_two_clips(self):
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
from .models import BurstCapture, PendingEvent
|
|
session = BurstSession.objects.create(owner=self.user, status="review", ended_at=timezone.now())
|
|
wav = b"RIFF" + b"\x00" * 4 + b"WAVEfmt " + b"\x00" * 40
|
|
clips = [SimpleUploadedFile(f"clip-{index}.wav", wav, content_type="audio/wav") for index in range(2)]
|
|
metadata = [{"captured_at": timezone.now().isoformat(), "duration_seconds": 2.0} for _ in clips]
|
|
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
|
|
"burst_session_id": str(session.pk), "burst_audio": clips,
|
|
"burst_captures": json.dumps(metadata), "burst_primary": "1", "occurrences": "2",
|
|
"burst_predictions": json.dumps([{"class": "Fireworks", "score": 0.8}]),
|
|
})
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(PendingEvent.objects.count(), 1)
|
|
self.assertEqual(BurstCapture.objects.filter(session=session).count(), 2)
|
|
self.assertEqual(PendingEvent.objects.get().classifier_response["classification_source"], "browser_yamnet_advisory")
|
|
self.assertEqual(BurstCapture.objects.get(session=session, is_primary=True).audio_file.name, PendingEvent.objects.get().audio_file.name)
|
|
from django.contrib import admin
|
|
self.assertIn("<audio", str(admin.site._registry[PendingEvent].burst_captures(PendingEvent.objects.get())))
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
|
|
"burst_session_id": str(session.pk), "burst_audio": clips,
|
|
"burst_captures": json.dumps(metadata), "burst_primary": "1", "occurrences": "2",
|
|
"burst_predictions": json.dumps([{"class": "Fireworks", "score": 0.8}]),
|
|
}).status_code, 409)
|
|
PendingEvent.objects.get().approve(actor=self.user)
|
|
session.refresh_from_db()
|
|
self.assertIsNotNone(session.event_id)
|
|
self.assertEqual(session.captures.count(), 2)
|