Files
FireworksApp/fireworks_detect/test_browser_processing.py
T

151 lines
9.6 KiB
Python

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": {},
"model_version": "google-yamnet-1", "model_url": "", "class_map_url": "",
})
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.assertIn("Speech", policy["privacy_sensitive_speech"])
self.assertEqual(policy["thresholds"], {"relevance": 0.5, "speech": 0.5})
self.assertEqual(policy["model_url"], "/static/browser-yamnet/model.json")
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)
@patch("fireworks_detect.views.urlopen")
def test_speech_override_runs_server_classifier_and_enters_pending(self, urlopen):
reply = MagicMock()
reply.read.return_value = b'{"predictions": [{"class": "Speech", "score": 0.9}]}'
urlopen.return_value.__enter__.return_value = reply
BrowserProcessingSettings.objects.update(browser_processing_beta_enabled=True)
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:classify_upload"), {
"audio": SimpleUploadedFile("speech.wav", b"RIFF0000WAVEdata", content_type="audio/wav"),
"browser_processing_metadata": json.dumps({
"browser_processing_used": True, "browser_processing_version": 1,
"browser_gate_result": "speech_only", "browser_override": True,
}),
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, "review-submission")
pending = PendingEvent.objects.get()
self.assertEqual(pending.classifier_response, {"predictions": [{"class": "Speech", "score": 0.9}]})
self.assertEqual(urlopen.call_count, 1)
self.assertNotIn(b"speech_only", urlopen.call_args.args[0].data)
@patch("fireworks_detect.views.urlopen")
def test_no_match_override_enters_pending_and_forged_whitelist_does_not_skip_classifier(self, urlopen):
reply = MagicMock()
reply.read.return_value = b'{"predictions": [{"class": "Music", "score": 0.9}]}'
urlopen.return_value.__enter__.return_value = reply
BrowserProcessingSettings.objects.update(browser_processing_beta_enabled=True)
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:classify_upload"), {
"audio": SimpleUploadedFile("music.wav", b"RIFF0000WAVEdata", content_type="audio/wav"),
"browser_processing_metadata": '{"browser_gate_result":"no_match","browser_override":true}',
})
self.assertEqual(response.status_code, 200)
self.assertEqual(PendingEvent.objects.count(), 1)
response = self.client.post(reverse("fireworks_detect:classify_upload"), {
"audio": SimpleUploadedFile("sample.wav", b"RIFF0000WAVEdata", content_type="audio/wav"),
"browser_processing_metadata": '{"browser_gate_result":"whitelist_match","browser_override":false}',
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Music")
self.assertEqual(PendingEvent.objects.count(), 1)
self.assertEqual(urlopen.call_count, 2)