Files
2026-10-23 14:32:24 +02:00

578 lines
31 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, ManualReportRevision, PendingEvent
from .bursts import burst_intensity, burst_rate
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_visual_confirmation_is_optional_and_survives_review(self):
url = reverse("fireworks_detect:submit_manual_pending")
for posted, expected in (({}, False), ({"visually_confirmed": "on"}, True)):
with self.subTest(confirmed=expected):
response = self.client.post(url, {"occurrences": "1", **posted})
self.assertEqual(response.status_code, 200)
pending = PendingEvent.objects.latest("pk")
self.assertEqual(pending.visually_confirmed, expected)
self.assertContains(response, f"Visually confirmed: {'Yes' if expected else 'No'}")
update_url = reverse("fireworks_detect:update_manual_pending", args=[pending.pk])
self.client.post(update_url, {"occurrences": "2"})
pending.refresh_from_db()
self.assertEqual(pending.visually_confirmed, expected)
event = pending.approve()
self.assertEqual(event.visually_confirmed, expected)
self.assertContains(self.client.get(reverse("fireworks_detect:event_detail", args=[event.pk])),
f"Visually confirmed</strong><span>{'Yes' if expected else 'No'}")
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 received!")
self.assertContains(response, "4 occurrences")
self.assertContains(response, 'data-result="success"')
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.assertContains(response, 'data-result="error"', status_code=400)
self.assertFalse(PendingEvent.objects.exists())
def test_burst_boundaries_and_intensity_rates(self):
for count, duration, category in ((1, 15, None), (2, 15, None), (3, 15, "light"), (10, 15, "intense"), (10, 30, "moderate"), (10, 60, "light")):
with self.subTest(count=count, duration=duration):
pending = PendingEvent(occurrences=count, observation_duration_minutes=duration, observation_duration_kind="estimated")
self.assertEqual(pending.is_burst, count >= 3)
self.assertEqual(pending.burst_intensity, category)
self.assertEqual(burst_rate(10, 30), Decimal("5"))
self.assertEqual(burst_intensity(10, None), None)
def test_server_rendered_quick_report_with_estimated_duration_and_approximate_time(self):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "10", "occurred_at": "2026-10-09T20:30", "time_approximate": "on",
"duration_minutes": "30", "duration_confirmed": "on",
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Burst Event")
self.assertContains(response, "Moderate")
pending = PendingEvent.objects.get()
self.assertEqual(pending.occurrences, 10)
self.assertEqual(pending.observation_duration_minutes, 30)
self.assertEqual(pending.observation_duration_kind, "estimated")
self.assertTrue(pending.occurrence_time_approximate)
self.assertNotEqual(pending.captured_at, pending.created_at)
self.assertEqual(pending.bangs_per_15_minutes, Decimal("5"))
reviewed = pending.approve()
self.assertEqual(reviewed.observation_duration_minutes, 30)
self.assertEqual(reviewed.captured_at, pending.captured_at)
self.assertEqual(reviewed.submitted_at, pending.created_at)
def test_unaccepted_window_has_no_intensity_and_legacy_burst_stays_compatible(self):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {"occurrences": "3", "duration_minutes": "15"})
self.assertEqual(response.status_code, 200)
pending = PendingEvent.objects.get()
self.assertTrue(pending.is_burst)
self.assertIsNone(pending.observation_duration_minutes)
self.assertIsNone(pending.burst_intensity)
old = Event.objects.create(occurrences=10, original_filename="old report", classifier_response={}, source_type="manual")
self.assertTrue(old.is_burst)
self.assertIsNone(old.burst_intensity)
accepted = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "3", "duration_confirmed": "on",
})
self.assertEqual(accepted.status_code, 200)
self.assertEqual(PendingEvent.objects.latest("pk").observation_duration_minutes, 15)
measured = Event.objects.create(occurrences=10, original_filename="measured", classifier_response={},
observation_duration_minutes=30, observation_duration_kind="measured")
self.assertEqual(measured.burst_intensity, "moderate")
self.assertEqual(measured.observation_duration_kind, "measured")
def test_session_scoped_count_edits_recalculate_and_preserve_original_time(self):
self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "2", "occurred_at": "2026-10-09T20:30",
})
pending = PendingEvent.objects.get()
occurred_at, submitted_at = pending.captured_at, pending.created_at
url = reverse("fireworks_detect:update_manual_pending", args=[pending.pk])
response = self.client.post(url, {"occurrences": "3", "duration_minutes": "15", "duration_confirmed": "on"})
self.assertEqual(response.status_code, 200)
pending.refresh_from_db()
self.assertEqual(pending.burst_intensity, "light")
self.client.post(url, {"occurrences": "10", "duration_minutes": "10", "duration_confirmed": "on"})
pending.refresh_from_db()
self.assertEqual(pending.burst_intensity, "intense")
self.client.post(url, {"occurrences": "10", "duration_minutes": "30", "duration_confirmed": "on"})
pending.refresh_from_db()
self.assertEqual(pending.burst_intensity, "moderate")
self.client.post(url, {"occurrences": "2"})
pending.refresh_from_db()
self.assertFalse(pending.is_burst)
self.assertIsNone(pending.burst_intensity)
self.assertEqual(pending.captured_at, occurred_at)
self.assertEqual(pending.created_at, submitted_at)
self.assertEqual(ManualReportRevision.objects.filter(original_pending_id=pending.pk).count(), 4)
from django.test import Client
self.assertEqual(Client().post(url, {"occurrences": "10"}).status_code, 404)
def test_invalid_estimated_duration_and_future_occurrence_are_rejected(self):
for data in (
{"occurrences": "10", "duration_confirmed": "on", "duration_minutes": "0"},
{"occurrences": "10", "duration_confirmed": "on", "duration_minutes": "1441"},
{"occurrences": "10", "occurred_at": (timezone.localtime() + timedelta(days=1)).strftime("%Y-%m-%dT%H:%M")},
):
with self.subTest(data=data):
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), data)
self.assertEqual(response.status_code, 400)
self.assertFalse(PendingEvent.objects.exists())
def test_map_data_exposes_derived_burst_fields_without_precise_location(self):
event = Event.objects.create(
original_filename="manual burst", classifier_response={}, source_type="manual", occurrences=10,
latitude=Decimal("52.123456"), longitude=Decimal("5.987654"),
observation_duration_minutes=30, observation_duration_kind="estimated",
occurrence_time_approximate=True, captured_at=timezone.now() - timedelta(hours=1),
)
from .views import _events_for_map
mapped, _ = _events_for_map({"date_from": None, "date_to": None, "visual": "all", "source": "manual"})
item = next(item for item in mapped if item["occurrences"] == 10)
self.assertEqual(item["event_kind"], "burst")
self.assertEqual(item["observation_duration_kind"], "estimated")
self.assertEqual(item["bangs_per_15_minutes"], 5.0)
self.assertEqual(item["burst_intensity"], "moderate")
self.assertTrue(item["occurrence_time_approximate"])
self.assertIsNone(item["submitted_on"])
self.assertNotIn("latitude", item)
self.assertNotIn("longitude", item)
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")
self.assertContains(response, "Capture direction")
self.assertContains(response, 'id="manual-decrease"')
self.assertContains(response, 'id="manual-increase"')
self.assertContains(response, 'id="manual-direction-panel"')
self.assertContains(response, 'hx-get="/fireworks/manual-direction/?mode=measure"')
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_direction_subsection_opens_and_closes_with_htmx_fragments(self):
url = reverse("fireworks_detect:manual_direction_panel")
measuring = self.client.get(url, {"mode": "measure"}, HTTP_HX_REQUEST="true")
self.assertContains(measuring, 'id="manual-capture-direction"')
self.assertContains(measuring, 'hx-target="#manual-direction-panel"')
closed = self.client.get(url, HTTP_HX_REQUEST="true")
self.assertContains(closed, 'id="manual-direction-summary"')
self.assertNotContains(closed, 'id="manual-capture-direction"')
def test_dutch_report_labels_and_direction_are_translated(self):
self.client.cookies["django_language"] = "nl"
page = self.client.get(reverse("hello"))
self.assertContains(page, "Hoe vaak hoorde je het?")
self.assertContains(page, "Ik hoorde vuurwerk")
self.assertContains(page, "Start luisteren")
response = self.client.post(reverse("fireworks_detect:submit_manual_pending"), {
"occurrences": "1", "direction_degrees": "192",
})
self.assertContains(response, "Melding ontvangen!")
self.assertContains(response, "Zuid 192°")
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, "Burst Event")
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_source_filter_separates_reviewed_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, 'name="source"')
self.assertContains(response, "Sensor events")
self.assertNotContains(response, sensor_cell)
self.assertNotContains(response, "52.123456")
self.assertNotContains(response, "H3 demo cell")
sensor_response = self.client.get(reverse("fireworks_detect:map"), {"range": "all", "source": "sensor"})
self.assertEqual(len(sensor_response.context["map_events"]), 1)
self.assertEqual(sensor_response.context["map_events"][0]["source_type"], "sensor")
self.assertContains(sensor_response, sensor_cell)
self.assertNotContains(sensor_response, manual_cell)
self.assertNotContains(sensor_response, "53.123456")
both_response = self.client.get(reverse("fireworks_detect:map"), {"range": "all", "source": "all"})
self.assertEqual(len(both_response.context["map_events"]), 2)
self.assertContains(both_response, manual_cell)
self.assertContains(both_response, sensor_cell)
def test_sensor_map_excludes_pending_and_device_only_locations(self):
pending_cell = cell_from_coordinates(Decimal("51.876543"), Decimal("5.123456"))
PendingEvent.objects.create(
original_filename="pending.wav", classifier_response={},
source_type=PendingEvent.SourceType.SENSOR, h3_cell=pending_cell,
)
Event.objects.create(
original_filename="unlocated.wav", classifier_response={},
source_type=Event.SourceType.SENSOR,
device_metadata={"latitude": "52.654321", "longitude": "5.654321"},
)
response = self.client.get(reverse("fireworks_detect:map"), {"range": "all", "source": "sensor"})
self.assertEqual(response.context["map_events"], [])
self.assertNotContains(response, pending_cell)
self.assertNotContains(response, "52.654321")
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.assertContains(response, "2 occurrences")
self.assertContains(response, "Southwest 237°")
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)