import json from tempfile import TemporaryDirectory from unittest.mock import MagicMock, patch from django.contrib.auth import get_user_model from django.core import signing from django.core.files.uploadedfile import SimpleUploadedFile from django.core.files.storage import FileSystemStorage from django.test import TestCase, override_settings from django.urls import reverse from .browser_policy import advisory_browser_metadata from .models import BrowserProcessingSettings, ClassificationRule, PendingEvent class BrowserProcessingBetaTests(TestCase): def test_setting_defaults_off_and_admin_can_toggle_it(self): self.assertFalse(BrowserProcessingSettings.enabled()) settings = BrowserProcessingSettings.objects.get(pk=1) self.assertFalse(settings.browser_processing_beta_enabled) staff = get_user_model().objects.create_superuser("beta-admin", "beta@example.com", "password") self.client.force_login(staff) changelist = self.client.get(reverse("admin:fireworks_detect_browserprocessingsettings_changelist")) self.assertContains(changelist, "Disabled — normal submission") url = reverse("admin:fireworks_detect_browserprocessingsettings_change", args=[settings.pk]) self.assertContains(self.client.get(url), "Browser-side media processing (Beta)") self.assertEqual(self.client.post(url, {"browser_processing_beta_enabled": "on", "_save": "Save"}).status_code, 302) self.assertTrue(BrowserProcessingSettings.enabled()) self.assertEqual(self.client.post(url, {"_save": "Save"}).status_code, 302) self.assertFalse(BrowserProcessingSettings.enabled()) self.assertEqual(BrowserProcessingSettings.objects.count(), 1) def test_policy_and_page_config_are_empty_while_disabled(self): ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.WHITELIST) ClassificationRule.objects.create(value="Speech", rule_type=ClassificationRule.RuleType.BLACKLIST) response = self.client.get(reverse("fireworks_detect:browser_policy")) self.assertEqual(response.json(), { "version": 1, "browser_processing_beta_enabled": False, "whitelist": [], "privacy_sensitive_speech": [], "thresholds": {}, }) self.assertIn("no-cache", response["Cache-Control"]) for url in (reverse("hello"), reverse("fireworks_detect:fireworks")): page = self.client.get(url) self.assertContains(page, '"browserProcessingBeta": false') self.assertContains(page, 'id="boomcast-browser-config"') def test_enabled_policy_reuses_current_rules_and_exposes_no_secrets(self): BrowserProcessingSettings.objects.update(browser_processing_beta_enabled=True) ClassificationRule.objects.create(value="Fireworks", rule_type=ClassificationRule.RuleType.WHITELIST) ClassificationRule.objects.create(value="Disabled sound", rule_type=ClassificationRule.RuleType.WHITELIST, enabled=False) ClassificationRule.objects.create(value="Speech", rule_type=ClassificationRule.RuleType.BLACKLIST) ClassificationRule.objects.create(value="Music", rule_type=ClassificationRule.RuleType.BLACKLIST) policy = self.client.get(reverse("fireworks_detect:browser_policy")).json() self.assertTrue(policy["browser_processing_beta_enabled"]) self.assertEqual(policy["whitelist"], ["Fireworks"]) self.assertEqual(policy["privacy_sensitive_speech"], ["Speech"]) self.assertEqual(policy["thresholds"], {}) self.assertNotIn("token", json.dumps(policy).lower()) BrowserProcessingSettings.objects.update(browser_processing_beta_enabled=False) self.assertFalse(self.client.get(reverse("fireworks_detect:browser_policy")).json()["browser_processing_beta_enabled"]) @patch("fireworks_detect.views.urlopen") def test_old_upload_and_advisory_metadata_keep_server_classifier_authoritative(self, urlopen): reply = MagicMock() reply.read.return_value = b'{"predictions": [{"class": "Speech", "score": 0.9}]}' urlopen.return_value.__enter__.return_value = reply url = reverse("fireworks_detect:classify_upload") audio = lambda: SimpleUploadedFile("sample.wav", b"RIFF0000WAVEdata", content_type="audio/wav") old = self.client.post(url, {"audio": audio()}) self.assertEqual(old.status_code, 200) self.assertContains(old, "Speech") metadata = json.dumps({ "browser_processing_used": True, "browser_processing_version": 1, "browser_gate_result": "whitelist_match", "browser_override": False, "secret": "ignored", }) future = self.client.post(url, {"audio": audio(), "browser_processing_metadata": metadata}) self.assertEqual(future.status_code, 200) self.assertContains(future, "Speech") self.assertNotContains(future, "whitelist_match") self.assertEqual(urlopen.call_count, 2) self.assertNotIn(b"whitelist_match", urlopen.call_args.args[0].data) self.assertEqual(advisory_browser_metadata({"browser_processing_metadata": metadata}), { "browser_processing_used": True, "browser_processing_version": 1, "browser_gate_result": "whitelist_match", "browser_override": False, }) self.assertEqual(advisory_browser_metadata({"browser_processing_metadata": '{"browser_gate_result": []}'}), {}) def test_pending_submission_accepts_metadata_without_storing_it_as_classification(self): payload = {"predictions": [{"class": "Fireworks", "score": 0.8}]} token = signing.dumps(payload, salt="fireworks_detect.classification") with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root), patch.object( PendingEvent._meta.get_field("audio_file"), "storage", FileSystemStorage(location=media_root) ): response = self.client.post(reverse("fireworks_detect:submit_pending"), { "audio": SimpleUploadedFile("sample.wav", b"RIFF0000WAVEdata", content_type="audio/wav"), "classification_token": token, "browser_processing_metadata": '{"browser_processing_used": true, "browser_gate_result": "whitelist_match"}', }) self.assertEqual(response.status_code, 200) self.assertEqual(PendingEvent.objects.get().classifier_response, payload)