92 lines
4.6 KiB
Python
92 lines
4.6 KiB
Python
import io
|
|
import json
|
|
import struct
|
|
import wave
|
|
from tempfile import TemporaryDirectory
|
|
from unittest.mock import patch
|
|
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
from django.test import TestCase, override_settings
|
|
from django.urls import reverse
|
|
|
|
from .models import PendingEvent, Sensor, SensorSubmission
|
|
|
|
|
|
def wav_bytes():
|
|
stream = io.BytesIO()
|
|
with wave.open(stream, "wb") as wav:
|
|
wav.setnchannels(1)
|
|
wav.setsampwidth(2)
|
|
wav.setframerate(16000)
|
|
wav.writeframes(struct.pack("<16000h", *([0] * 16000)))
|
|
return stream.getvalue()
|
|
|
|
|
|
class SensorSubmissionTests(TestCase):
|
|
def setUp(self):
|
|
self.owner = get_user_model().objects.create_user("sensor-owner", password="test")
|
|
self.sensor = Sensor.objects.create(name="Waveshare V2", owner=self.owner)
|
|
self.token = self.sensor.issue_token()
|
|
self.url = reverse("sensor_pending")
|
|
self.audio = wav_bytes()
|
|
|
|
def submit(self, token=None, **fields):
|
|
data = {
|
|
"sensor_id": str(self.sensor.pk), "event_id": "device-event-1",
|
|
"captured_at": "2026-10-09T10:00:00Z", "duration_seconds": "1",
|
|
"firmware_version": "0.1.0-concept",
|
|
"file": SimpleUploadedFile("event.wav", self.audio, content_type="audio/wav"),
|
|
}
|
|
data.update(fields)
|
|
return self.client.post(self.url, data, HTTP_AUTHORIZATION=f"Bearer {token or self.token}")
|
|
|
|
def test_authenticated_upload_is_classified_and_retry_is_idempotent(self):
|
|
response_body = io.BytesIO(json.dumps({"predictions": [{"class": "Fireworks", "score": 0.8}], "duration_seconds": 1}).encode())
|
|
with TemporaryDirectory() as media, override_settings(MEDIA_ROOT=media), patch("fireworks_detect.views.urlopen", return_value=response_body) as classify:
|
|
first = self.submit(trigger_type="audio_spike", latitude="52.1")
|
|
second = self.submit()
|
|
self.assertEqual(first.status_code, 201)
|
|
self.assertEqual(second.status_code, 200)
|
|
self.assertEqual(first.json()["submission_id"], second.json()["submission_id"])
|
|
self.assertEqual(PendingEvent.objects.count(), 1)
|
|
self.assertEqual(SensorSubmission.objects.count(), 1)
|
|
self.assertEqual(classify.call_count, 1)
|
|
pending = PendingEvent.objects.get()
|
|
self.assertEqual(pending.sensor, self.sensor)
|
|
self.assertEqual(pending.source_type, "sensor")
|
|
self.assertFalse(pending.latitude)
|
|
self.assertEqual(pending.device_metadata["latitude"], "52.1")
|
|
self.assertTrue(pending.audio_file.storage.exists(pending.audio_file.name))
|
|
|
|
def test_pending_admin_shows_sensor_details(self):
|
|
staff = get_user_model().objects.create_superuser("reviewer-sensor", password="test")
|
|
pending = PendingEvent.objects.create(sensor=self.sensor, source_type="sensor", original_filename="event.wav", classifier_response={"predictions": [{"class": "Fireworks", "score": 0.8}]}, firmware_version="0.1.0-concept", device_metadata={"trigger_type": "audio_spike"})
|
|
self.client.force_login(staff)
|
|
response = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "sensor-owner")
|
|
self.assertContains(response, "0.1.0-concept")
|
|
self.assertContains(response, "audio_spike")
|
|
|
|
def test_classifier_failure_keeps_event_retryable(self):
|
|
from urllib.error import URLError
|
|
with patch("fireworks_detect.views.urlopen", side_effect=URLError("offline")):
|
|
response = self.submit()
|
|
self.assertEqual(response.status_code, 502)
|
|
self.assertEqual(response.json()["code"], "classifier_unavailable")
|
|
self.assertFalse(PendingEvent.objects.exists())
|
|
self.assertFalse(SensorSubmission.objects.exists())
|
|
|
|
def test_existing_event_id_with_different_audio_conflicts(self):
|
|
SensorSubmission.objects.create(sensor=self.sensor, event_id="device-event-1", audio_sha256="0" * 64)
|
|
response = self.submit()
|
|
self.assertEqual(response.status_code, 409)
|
|
self.assertEqual(response.json()["code"], "event_id_conflict")
|
|
|
|
def test_bad_token_sensor_mismatch_and_malformed_audio_are_rejected(self):
|
|
self.assertEqual(self.submit(token="wrong").status_code, 401)
|
|
self.assertEqual(self.submit(sensor_id="999").status_code, 403)
|
|
self.assertEqual(self.submit(file=SimpleUploadedFile("bad.wav", b"not wav", content_type="audio/wav")).status_code, 400)
|
|
self.assertFalse(PendingEvent.objects.exists())
|