158 lines
8.8 KiB
Python
158 lines
8.8 KiB
Python
from unittest.mock import MagicMock, patch
|
|
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
from django.test import Client, TestCase
|
|
from django.urls import reverse
|
|
|
|
from fireworks_detect.models import Event, PendingEvent, Sensor
|
|
|
|
|
|
class SensorSettingsTests(TestCase):
|
|
def setUp(self):
|
|
self.alice = get_user_model().objects.create_user(username="sensor_alice", password="pass")
|
|
self.bob = get_user_model().objects.create_user(username="sensor_bob", password="pass")
|
|
self.client.force_login(self.alice)
|
|
|
|
def test_create_list_and_existing_api(self):
|
|
response = self.client.post(reverse("create_sensor"), {"name": "Balcony"})
|
|
sensor = Sensor.objects.get(name="Balcony")
|
|
self.assertEqual(sensor.owner, self.alice)
|
|
token = response.context["token"]
|
|
self.assertNotIn(token, sensor.token_hash)
|
|
self.assertTrue(sensor.token_matches(token))
|
|
self.assertContains(response, token)
|
|
self.assertNotContains(self.client.get(reverse("manage_sensor", args=[sensor.pk])), token)
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:sensor_heartbeat"), HTTP_AUTHORIZATION=f"Bearer {token}").status_code, 200)
|
|
self.client.post(reverse("create_sensor"), {"name": "Portable"})
|
|
self.assertEqual(Sensor.objects.filter(owner=self.alice).count(), 2)
|
|
|
|
Sensor.objects.create(name="System")
|
|
Sensor.objects.create(name="Bob's device", owner=self.bob)
|
|
listing = self.client.get(reverse("user_settings"))
|
|
self.assertContains(listing, "Balcony")
|
|
self.assertContains(listing, "Portable")
|
|
self.assertContains(listing, f"<code>{sensor.pk}</code>", html=True)
|
|
self.assertNotContains(listing, "System")
|
|
self.assertNotContains(listing, "Bob's device")
|
|
self.client.force_login(self.bob)
|
|
listing = self.client.get(reverse("user_settings"))
|
|
self.assertContains(listing, "Bob's device")
|
|
self.assertNotContains(listing, "Balcony")
|
|
|
|
def test_htmx_sensor_card_opens_updates_and_closes(self):
|
|
sensor = Sensor.objects.create(name="Balcony", owner=self.alice)
|
|
headers = {"HTTP_HX_REQUEST": "true"}
|
|
|
|
detail = self.client.get(reverse("manage_sensor", args=[sensor.pk]), **headers)
|
|
self.assertContains(detail, "Balcony")
|
|
self.assertContains(detail, f"<code>{sensor.pk}</code>", html=True)
|
|
self.assertContains(detail, reverse("sensor_list"))
|
|
self.assertNotContains(detail, "<!doctype html>")
|
|
|
|
renamed = self.client.post(reverse("rename_sensor", args=[sensor.pk]), {"name": "Roof"}, **headers)
|
|
self.assertContains(renamed, "Roof")
|
|
self.assertNotContains(renamed, "<!doctype html>")
|
|
|
|
listing = self.client.get(reverse("sensor_list"), **headers)
|
|
self.assertContains(listing, "Roof")
|
|
self.assertContains(listing, reverse("manage_sensor", args=[sensor.pk]))
|
|
|
|
full_page = self.client.get(reverse("manage_sensor", args=[sensor.pk]))
|
|
self.assertContains(full_page, "<!doctype html>")
|
|
self.assertContains(full_page, "settings-shell")
|
|
|
|
def test_htmx_create_shows_token_once_and_remove_restores_list(self):
|
|
headers = {"HTTP_HX_REQUEST": "true"}
|
|
created = self.client.post(reverse("create_sensor"), {"name": "Portable"}, **headers)
|
|
sensor = Sensor.objects.get(name="Portable")
|
|
token = created.context["token"]
|
|
self.assertContains(created, token)
|
|
self.assertIn("no-store", created["Cache-Control"])
|
|
self.assertNotContains(self.client.get(reverse("manage_sensor", args=[sensor.pk]), **headers), token)
|
|
|
|
removed = self.client.post(reverse("remove_sensor", args=[sensor.pk]), {"confirm": "remove"}, **headers)
|
|
self.assertContains(removed, "My sensors")
|
|
self.assertNotContains(removed, "Portable")
|
|
self.assertEqual(self.client.get(reverse("manage_sensor", args=[sensor.pk]), **headers).status_code, 404)
|
|
|
|
def test_owner_can_manage_rotate_and_archive_preserving_history(self):
|
|
sensor = Sensor.objects.create(name="Balcony", owner=self.alice)
|
|
old_token = sensor.issue_token()
|
|
pending = PendingEvent.objects.create(sensor=sensor, original_filename="test.wav", classifier_response={})
|
|
event = Event.objects.create(sensor=sensor, original_filename="test.wav", classifier_response={})
|
|
self.assertEqual(self.client.post(reverse("rename_sensor", args=[sensor.pk]), {"name": "Roof"}).status_code, 302)
|
|
sensor.refresh_from_db()
|
|
self.assertEqual(sensor.name, "Roof")
|
|
self.client.post(reverse("toggle_sensor", args=[sensor.pk]))
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:sensor_heartbeat"), HTTP_AUTHORIZATION=f"Bearer {old_token}").status_code, 401)
|
|
self.client.post(reverse("toggle_sensor", args=[sensor.pk]))
|
|
response = self.client.post(reverse("rotate_sensor", args=[sensor.pk]), {"confirm": "rotate"})
|
|
new_token = response.context["token"]
|
|
self.assertNotEqual(old_token, new_token)
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:sensor_heartbeat"), HTTP_AUTHORIZATION=f"Bearer {old_token}").status_code, 401)
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:sensor_heartbeat"), HTTP_AUTHORIZATION=f"Bearer {new_token}").status_code, 200)
|
|
self.assertNotContains(self.client.get(reverse("manage_sensor", args=[sensor.pk])), new_token)
|
|
self.client.post(reverse("remove_sensor", args=[sensor.pk]), {"confirm": "remove"})
|
|
sensor.refresh_from_db()
|
|
self.assertIsNotNone(sensor.archived_at)
|
|
self.assertFalse(sensor.is_active)
|
|
self.assertFalse(sensor.token_hash)
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:sensor_heartbeat"), HTTP_AUTHORIZATION=f"Bearer {new_token}").status_code, 401)
|
|
self.assertEqual(PendingEvent.objects.get(pk=pending.pk).sensor_id, sensor.pk)
|
|
self.assertEqual(Event.objects.get(pk=event.pk).sensor_id, sensor.pk)
|
|
self.assertEqual(self.client.get(reverse("manage_sensor", args=[sensor.pk])).status_code, 404)
|
|
|
|
def test_cross_user_id_tampering_is_404_and_does_not_change_sensor(self):
|
|
sensor = Sensor.objects.create(name="Bob's device", owner=self.bob)
|
|
token = sensor.issue_token()
|
|
self.assertEqual(self.client.get(reverse("manage_sensor", args=[sensor.pk])).status_code, 404)
|
|
actions = [
|
|
("rename_sensor", {"name": "Stolen"}),
|
|
("toggle_sensor", {}),
|
|
("rotate_sensor", {"confirm": "rotate"}),
|
|
("remove_sensor", {"confirm": "remove"}),
|
|
]
|
|
for route, data in actions:
|
|
self.assertEqual(self.client.post(reverse(route, args=[sensor.pk]), data).status_code, 404)
|
|
sensor.refresh_from_db()
|
|
self.assertEqual(sensor.name, "Bob's device")
|
|
self.assertTrue(sensor.is_active)
|
|
self.assertTrue(sensor.token_matches(token))
|
|
self.assertIsNone(sensor.archived_at)
|
|
|
|
def test_unowned_sensor_token_still_authenticates(self):
|
|
sensor = Sensor.objects.create(name="System")
|
|
token = sensor.issue_token()
|
|
self.assertEqual(self.client.post(reverse("fireworks_detect:sensor_heartbeat"), HTTP_X_SENSOR_TOKEN=token).status_code, 200)
|
|
|
|
@patch("fireworks_detect.views.urlopen")
|
|
def test_user_sensor_classification_keeps_sensor_relationship(self, urlopen):
|
|
sensor = Sensor.objects.create(name="Balcony", owner=self.alice)
|
|
token = sensor.issue_token()
|
|
reply = MagicMock()
|
|
reply.read.return_value = b'{"top_class":"Fireworks"}'
|
|
urlopen.return_value.__enter__.return_value = reply
|
|
audio = SimpleUploadedFile("sample.wav", b"RIFF0000WAVEdata", content_type="audio/wav")
|
|
response = self.client.post(reverse("fireworks_detect:classify"), {"file": audio}, HTTP_AUTHORIZATION=f"Bearer {token}")
|
|
self.assertEqual(response.status_code, 201)
|
|
self.assertEqual(PendingEvent.objects.get(pk=response.json()["pending_event_id"]).sensor_id, sensor.pk)
|
|
|
|
def test_mutating_forms_require_csrf(self):
|
|
sensor = Sensor.objects.create(name="Balcony", owner=self.alice)
|
|
client = Client(enforce_csrf_checks=True)
|
|
client.force_login(self.alice)
|
|
for route, data in [
|
|
("create_sensor", {"name": "Portable"}),
|
|
("rename_sensor", {"name": "Roof"}),
|
|
("toggle_sensor", {}),
|
|
("rotate_sensor", {"confirm": "rotate"}),
|
|
("remove_sensor", {"confirm": "remove"}),
|
|
]:
|
|
args = [] if route == "create_sensor" else [sensor.pk]
|
|
self.assertEqual(client.post(reverse(route, args=args), data).status_code, 403)
|
|
sensor.refresh_from_db()
|
|
self.assertEqual(sensor.name, "Balcony")
|
|
self.assertTrue(sensor.is_active)
|
|
self.assertIsNone(sensor.archived_at)
|