Files
FireworksApp/fireworks_detect/test_browser_processing.py
T

102 lines
6.3 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": {},
})
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)