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, 'id="manual-compass"') self.assertContains(response, 'aria-label="Compass direction" 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)