Files
FireworksApp/fireworks_detect/tests.py
T
2026-10-02 13:13:38 +02:00

388 lines
20 KiB
Python

from datetime import timedelta
from decimal import Decimal
from unittest.mock import MagicMock, patch
from urllib.error import URLError
from django.core.exceptions import ValidationError
from django.core.files.uploadedfile import SimpleUploadedFile
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.contrib.messages import get_messages, constants as message_levels
from django.db import IntegrityError, transaction
from django.test import TestCase, override_settings
from django.urls import reverse
from django.utils import timezone
from .h3_utils import cell_from_coordinates, h3_resolution
from .models import ClassificationRule, Event, PendingEvent
class ClassificationRuleApiTests(TestCase):
def test_whitelist_returns_only_enabled_whitelist_entries_in_value_order(self):
ClassificationRule.objects.create(value="Explosion", rule_type=ClassificationRule.RuleType.WHITELIST)
ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.WHITELIST)
ClassificationRule.objects.create(value="Disabled firework", rule_type=ClassificationRule.RuleType.WHITELIST, enabled=False)
ClassificationRule.objects.create(value="Speech", rule_type=ClassificationRule.RuleType.BLACKLIST)
response = self.client.get(reverse("classification_rules:whitelist"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {"classifications": ["Explosion", "Fireworks"]})
def test_blacklist_returns_only_enabled_blacklist_entries_in_value_order(self):
ClassificationRule.objects.create(value="Speech", rule_type=ClassificationRule.RuleType.BLACKLIST)
ClassificationRule.objects.create(value="Conversation", rule_type=ClassificationRule.RuleType.BLACKLIST)
ClassificationRule.objects.create(value="Disabled music", rule_type=ClassificationRule.RuleType.BLACKLIST, enabled=False)
ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.WHITELIST)
response = self.client.get(reverse("classification_rules:blacklist"))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {"classifications": ["Conversation", "Speech"]})
def test_classification_rule_is_unique_within_a_rule_type(self):
ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.WHITELIST)
with transaction.atomic():
with self.assertRaises(IntegrityError):
ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.WHITELIST)
ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.BLACKLIST)
class ManualPendingEventTests(TestCase):
def setUp(self):
self.client.cookies["django_language"] = "en"
def test_manual_report_creates_a_timestamped_pending_event(self):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "4",
"latitude": "52.1234567",
"longitude": "5.9876543",
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Report sent to Pending")
pending = PendingEvent.objects.get()
self.assertEqual(pending.original_filename, "Manual fireworks report")
self.assertEqual(pending.source_type, PendingEvent.SourceType.MANUAL)
self.assertEqual(pending.occurrences, 4)
self.assertEqual(pending.latitude, Decimal("52.123457"))
self.assertEqual(pending.longitude, Decimal("5.987654"))
self.assertEqual(pending.h3_cell, cell_from_coordinates(pending.latitude, pending.longitude))
self.assertIsNone(pending.direction_degrees)
self.assertIsNone(pending.direction_accuracy_degrees)
self.assertEqual(pending.direction_source, "")
self.assertFalse(pending.sensor)
self.assertFalse(pending.audio_file)
self.assertEqual(pending.classifier_response, {})
self.assertIsNotNone(pending.created_at)
def test_manual_report_rejects_an_invalid_occurrence_count(self):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {"occurrences": "0"})
self.assertEqual(response.status_code, 400)
self.assertContains(response, "Choose between 1 and 1,000 occurrences.", status_code=400)
self.assertFalse(PendingEvent.objects.exists())
def test_manual_report_accepts_optional_wav_on_the_same_pending_event(self):
from tempfile import TemporaryDirectory
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
wav = SimpleUploadedFile("browser.wav", b"RIFF" + b"\x00" * 4 + b"WAVEfmt ", content_type="audio/wav")
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {"occurrences": "1", "audio": wav})
self.assertEqual(response.status_code, 200)
pending = PendingEvent.objects.get()
self.assertEqual(pending.source_type, PendingEvent.SourceType.MANUAL)
self.assertIn("sound-signal-manual-", pending.audio_file.name)
self.assertNotIn("browser.wav", pending.audio_file.name)
def test_manual_report_rejects_non_wav_attachment(self):
audio = SimpleUploadedFile("bad.wav", b"not a WAV file", content_type="audio/wav")
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {"occurrences": "1", "audio": audio})
self.assertEqual(response.status_code, 400)
self.assertFalse(PendingEvent.objects.exists())
def test_pending_admin_change_page_renders_for_manual_audio(self):
staff = get_user_model().objects.create_superuser("pending-reviewer", "reviewer@example.com", "test-password")
pending = PendingEvent.objects.create(
original_filename="Manual fireworks report",
classifier_response={},
source_type=PendingEvent.SourceType.MANUAL,
audio_file="fireworks_audio/example.wav",
)
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, 'class="audio-play"')
def test_event_details_and_source_type_are_kept_when_a_pending_event_is_approved(self):
pending = PendingEvent.objects.create(
original_filename="Manual fireworks report",
classifier_response={},
source_type=PendingEvent.SourceType.MANUAL,
occurrences=3,
location="Back garden",
latitude=Decimal("52.123456"),
longitude=Decimal("5.987654"),
h3_cell=cell_from_coordinates(Decimal("52.123456"), Decimal("5.987654")),
direction_degrees=237,
direction_accuracy_degrees=8,
direction_source="device_compass",
visually_confirmed=True,
)
event = pending.approve()
self.assertEqual(event.source_type, PendingEvent.SourceType.MANUAL)
self.assertEqual(event.occurrences, 3)
self.assertEqual(event.location, "Back garden")
self.assertEqual(event.latitude, Decimal("52.123456"))
self.assertEqual(event.longitude, Decimal("5.987654"))
self.assertEqual(event.h3_cell, pending.h3_cell)
self.assertEqual(event.direction_degrees, 237)
self.assertEqual(event.direction_accuracy_degrees, 8)
self.assertEqual(event.direction_source, "device_compass")
self.assertTrue(event.visually_confirmed)
def test_existing_style_records_default_to_sensor_source_type(self):
pending = PendingEvent.objects.create(original_filename="recording.wav", classifier_response={})
self.assertEqual(pending.source_type, PendingEvent.SourceType.SENSOR)
def test_home_page_includes_the_manual_report_form(self):
response = self.client.get(reverse("hello"))
self.assertContains(response, "Report fireworks now")
self.assertContains(response, "I heard fireworks — send to Pending")
self.assertContains(response, "Capture direction")
self.assertContains(response, 'manual-direction-panel" hidden')
self.assertContains(response, "htmx.min.js")
self.assertContains(response, "/static/vite/")
self.assertContains(response, 'type="module"')
self.assertContains(response, "Activity map")
self.assertContains(response, "Open map controls")
self.assertContains(response, "Classify a recording")
def test_old_route_preserves_the_previous_landing_page(self):
response = self.client.get(reverse("old_home"))
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Welcome Joren")
self.assertContains(response, "Open fireworks detector")
def test_manual_event_appears_in_the_normal_event_list_with_its_details(self):
event = Event.objects.create(
original_filename="Manual fireworks report",
classifier_response={},
source_type=Event.SourceType.MANUAL,
occurrences=5,
location="Back garden",
latitude=Decimal("52.123456"),
longitude=Decimal("5.987654"),
direction_degrees=237,
direction_accuracy_degrees=8,
visually_confirmed=True,
)
list_response = self.client.get(reverse("fireworks_detect:events_list"))
self.assertContains(list_response, "Manual fireworks report")
self.assertContains(list_response, "5 occurrences")
self.assertContains(list_response, "Back garden")
detail_response = self.client.get(reverse("fireworks_detect:event_detail", args=[event.pk]))
self.assertContains(detail_response, "Report details")
self.assertContains(detail_response, "Visually confirmed")
self.assertContains(detail_response, "Captured location")
self.assertContains(detail_response, cell_from_coordinates(event.latitude, event.longitude))
self.assertNotContains(detail_response, "52.123456, 5.987654")
self.assertContains(detail_response, "237° (SW)")
self.assertContains(detail_response, "Compass accuracy")
@override_settings(FIREWORKS_H3_RESOLUTION=8)
def test_h3_resolution_is_configurable(self):
self.assertEqual(h3_resolution(), 8)
self.assertTrue(cell_from_coordinates(Decimal("52.123456"), Decimal("5.987654")))
def test_map_uses_manual_h3_data_and_excludes_sensor_events(self):
manual_cell = cell_from_coordinates(Decimal("52.123456"), Decimal("5.987654"))
sensor_cell = cell_from_coordinates(Decimal("53.123456"), Decimal("5.987654"))
Event.objects.create(
original_filename="Manual fireworks report",
classifier_response={},
source_type=Event.SourceType.MANUAL,
occurrences=4,
latitude=Decimal("52.123456"),
longitude=Decimal("5.987654"),
h3_cell=manual_cell,
visually_confirmed=True,
direction_degrees=237,
direction_accuracy_degrees=8,
)
Event.objects.create(
original_filename="Sensor recording.wav",
classifier_response={},
source_type=Event.SourceType.SENSOR,
occurrences=9,
latitude=Decimal("53.123456"),
longitude=Decimal("5.987654"),
h3_cell=sensor_cell,
)
response = self.client.get(reverse("fireworks_detect:map"), {"range": "all"})
self.assertContains(response, "H3 resolution 9")
self.assertContains(response, "map-events-data")
self.assertContains(response, manual_cell)
self.assertContains(response, '"direction_degrees": 237.0')
self.assertContains(response, "data-h3-resolution")
self.assertContains(response, 'type="module"')
self.assertContains(response, "sensor layer disabled")
self.assertContains(response, "Sensor events — coming soon")
self.assertNotContains(response, sensor_cell)
self.assertNotContains(response, "52.123456")
self.assertNotContains(response, "H3 demo cell")
def test_map_date_range_filters_manual_reports(self):
recent_cell = cell_from_coordinates(Decimal("52.400000"), Decimal("5.700000"))
older_cell = cell_from_coordinates(Decimal("53.400000"), Decimal("5.700000"))
Event.objects.create(
original_filename="Recent manual report", classifier_response={},
source_type=Event.SourceType.MANUAL, latitude=Decimal("52.400000"),
longitude=Decimal("5.700000"), h3_cell=recent_cell,
)
older = Event.objects.create(
original_filename="Older manual report", classifier_response={},
source_type=Event.SourceType.MANUAL, latitude=Decimal("53.400000"),
longitude=Decimal("5.700000"), h3_cell=older_cell,
)
Event.objects.filter(pk=older.pk).update(created_at=timezone.now() - timedelta(days=8))
response = self.client.get(reverse("fireworks_detect:map"), {"range": "7"})
self.assertContains(response, recent_cell)
self.assertNotContains(response, older_cell)
self.assertContains(response, "Last 7 days")
def test_manual_report_saves_a_valid_compass_direction_and_accuracy(self):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "2",
"direction_degrees": "237",
"direction_accuracy_degrees": "8",
})
self.assertEqual(response.status_code, 200)
pending = PendingEvent.objects.get()
self.assertEqual(pending.direction_degrees, 237)
self.assertEqual(pending.direction_accuracy_degrees, 8)
self.assertEqual(pending.direction_source, "device_compass")
self.assertEqual(pending.direction_cardinal, "SW")
def test_zero_degree_direction_is_valid_and_accuracy_may_be_absent(self):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "1",
"direction_degrees": "0",
})
self.assertEqual(response.status_code, 200)
pending = PendingEvent.objects.get()
self.assertEqual(pending.direction_degrees, 0)
self.assertIsNone(pending.direction_accuracy_degrees)
self.assertEqual(pending.direction_cardinal, "N")
def test_invalid_directions_are_rejected_by_model_validation_and_not_saved_by_manual_submission(self):
for invalid_direction in (-1, 360):
pending = PendingEvent(
original_filename="Manual fireworks report",
classifier_response={},
direction_degrees=invalid_direction,
)
with self.assertRaises(ValidationError):
pending.full_clean()
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "1",
"direction_degrees": str(invalid_direction),
})
self.assertEqual(response.status_code, 200)
saved = PendingEvent.objects.latest("created_at")
self.assertIsNone(saved.direction_degrees)
self.assertIsNone(saved.direction_accuracy_degrees)
self.assertEqual(saved.direction_source, "")
class PendingClassificationAdminTests(TestCase):
def setUp(self):
self.client.cookies["django_language"] = "en"
self.staff = get_user_model().objects.create_superuser("classifier-reviewer", "classifier@example.com", "test-password")
self.client.force_login(self.staff)
def test_classify_button_saves_json_without_approving(self):
from tempfile import TemporaryDirectory
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
audio = SimpleUploadedFile("sample.wav", b"RIFF" + b"\x00" * 4 + b"WAVEdata", content_type="audio/wav")
pending = PendingEvent.objects.create(original_filename="Manual fireworks report", classifier_response={"manual_note": "keep"}, source_type=PendingEvent.SourceType.MANUAL, audio_file=audio)
url = reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk])
change = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
self.assertContains(change, url)
mocked_response = MagicMock()
mocked_response.read.return_value = b'{"predictions": [{"class": "Fireworks", "score": 0.91}]}'
mocked_response.__enter__.return_value = mocked_response
with patch("fireworks_detect.admin.urlopen", return_value=mocked_response) as classifier_call:
response = self.client.post(url)
self.assertEqual(response.status_code, 302)
request = classifier_call.call_args.args[0]
self.assertIn(b'name="file"', request.data)
self.assertIn(b"RIFF", request.data)
pending.refresh_from_db()
self.assertEqual(pending.classifier_response["predictions"][0]["class"], "Fireworks")
self.assertEqual(pending.classifier_response["manual_note"], "keep")
self.assertTrue(PendingEvent.objects.filter(pk=pending.pk).exists())
self.assertFalse(Event.objects.exists())
def test_classify_requires_post_and_audio(self):
pending = PendingEvent.objects.create(original_filename="Manual report", classifier_response={})
url = reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk])
self.assertEqual(self.client.get(url).status_code, 405)
self.assertEqual(self.client.post(url).status_code, 302)
pending.refresh_from_db()
self.assertEqual(pending.classifier_response, {})
def test_classifier_failure_preserves_existing_json_and_pending_record(self):
from tempfile import TemporaryDirectory
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
pending = PendingEvent.objects.create(
original_filename="sample.wav",
classifier_response={"previous": "result"},
audio_file=SimpleUploadedFile("sample.wav", b"RIFFdata", content_type="audio/wav"),
)
url = reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk])
with patch("fireworks_detect.admin.urlopen", side_effect=URLError("offline")):
response = self.client.post(url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(any(message.level == message_levels.ERROR for message in get_messages(response.wsgi_request)))
pending.refresh_from_db()
self.assertEqual(pending.classifier_response, {"previous": "result"})
self.assertTrue(PendingEvent.objects.filter(pk=pending.pk).exists())
def test_view_only_staff_cannot_classify(self):
pending = PendingEvent.objects.create(original_filename="sample.wav", classifier_response={}, audio_file="fireworks_audio/sample.wav")
viewer = get_user_model().objects.create_user("viewer", "viewer@example.com", "test-password", is_staff=True)
viewer.user_permissions.add(Permission.objects.get(codename="view_pendingevent"))
self.client.force_login(viewer)
change = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
self.assertEqual(change.status_code, 200)
self.assertNotContains(change, reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk]))
response = self.client.post(reverse("admin:fireworks_detect_pendingevent_classify", args=[pending.pk]))
self.assertEqual(response.status_code, 403)