162 lines
10 KiB
Python
162 lines
10 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"')
|
|
self.assertNotContains(page, 'id="browser-processing-toggle"')
|
|
|
|
def test_frontend_toggle_only_appears_when_admin_enables_beta_and_defaults_off(self):
|
|
for url in (reverse("hello"), reverse("fireworks_detect:fireworks")):
|
|
self.assertNotContains(self.client.get(url), 'id="browser-processing-toggle"')
|
|
BrowserProcessingSettings.objects.update(browser_processing_beta_enabled=True)
|
|
for url in (reverse("hello"), reverse("fireworks_detect:fireworks")):
|
|
page = self.client.get(url)
|
|
self.assertContains(page, 'id="browser-processing-toggle" type="checkbox"')
|
|
self.assertNotContains(page, 'id="browser-processing-toggle" type="checkbox" checked')
|
|
self.assertContains(page, 'accept="audio/*,.wav,.mp3,.m4a,.ogg,.flac,.aac,.opus"')
|
|
|
|
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)
|