368 lines
18 KiB
Python
368 lines
18 KiB
Python
from socket import timeout as SocketTimeout
|
|
from unittest.mock import MagicMock, patch
|
|
from urllib.error import HTTPError, URLError
|
|
|
|
from django.contrib.auth import get_user_model
|
|
from django.conf import settings
|
|
from django.core.management import call_command
|
|
from django.test import SimpleTestCase, TestCase
|
|
from django.urls import reverse
|
|
from django.utils import translation
|
|
|
|
from notifications.services import NotificationError, send_notification, send_ntfy_notification
|
|
|
|
from .models import PendingNotificationBatch, UserSettings
|
|
|
|
|
|
|
|
class NtfyNotificationServiceTests(SimpleTestCase):
|
|
@patch("notifications.services.urlopen")
|
|
def test_posts_a_title_and_message_to_the_topic_url(self, mock_urlopen):
|
|
response = MagicMock()
|
|
response.getcode.return_value = 200
|
|
mock_urlopen.return_value = response
|
|
|
|
self.assertTrue(send_ntfy_notification("https://ntfy.example.com/private-topic", "Fireworks Detector", "Test message"))
|
|
|
|
request = mock_urlopen.call_args.args[0]
|
|
self.assertEqual(request.get_method(), "POST")
|
|
self.assertEqual(request.data, b"Test message")
|
|
self.assertEqual(request.get_header("Title"), "Fireworks Detector")
|
|
|
|
@patch("notifications.services.urlopen", side_effect=HTTPError("https://ntfy.example.com/topic", 503, "Unavailable", None, None))
|
|
def test_non_success_http_response_is_a_safe_failure(self, mock_urlopen):
|
|
with self.assertRaisesMessage(NotificationError, "HTTP 503"):
|
|
send_ntfy_notification("https://ntfy.example.com/topic", "Title", "Message")
|
|
|
|
@patch("notifications.services.urlopen", side_effect=URLError(SocketTimeout()))
|
|
def test_timeout_is_a_safe_failure(self, mock_urlopen):
|
|
with self.assertRaisesMessage(NotificationError, "timed out"):
|
|
send_ntfy_notification("https://ntfy.example.com/topic", "Title", "Message")
|
|
|
|
|
|
class UserSettingsNtfyTests(TestCase):
|
|
url = "https://ntfy.example.com/private-topic"
|
|
|
|
def setUp(self):
|
|
self.user = get_user_model().objects.create_user(username="first-user", password="secret")
|
|
self.other_user = get_user_model().objects.create_user(username="other-user", password="secret")
|
|
self.client.force_login(self.user)
|
|
|
|
def test_test_endpoint_requires_login(self):
|
|
self.client.logout()
|
|
|
|
response = self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": self.url})
|
|
|
|
self.assertEqual(response.status_code, 302)
|
|
|
|
@patch("members.views.send_ntfy_notification")
|
|
def test_invalid_url_is_rejected_without_sending(self, mock_send):
|
|
response = self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": "not a URL"})
|
|
|
|
self.assertEqual(response.status_code, 400)
|
|
self.assertContains(response, "geldige HTTP- of HTTPS-URL", status_code=400)
|
|
mock_send.assert_not_called()
|
|
|
|
@patch("members.views.send_ntfy_notification")
|
|
def test_successful_test_returns_inline_success_and_marks_current_url_in_session(self, mock_send):
|
|
response = self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": self.url})
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "Testmelding verzonden")
|
|
mock_send.assert_called_once_with(
|
|
self.url,
|
|
title="Vuurwerkdetector",
|
|
message="ntfy-meldingen zijn goed ingesteld.",
|
|
)
|
|
|
|
@patch("members.views.send_ntfy_notification", side_effect=NotificationError("Connection to the ntfy server timed out."))
|
|
def test_delivery_failure_returns_an_inline_safe_error(self, mock_send):
|
|
response = self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": self.url})
|
|
|
|
self.assertEqual(response.status_code, 502)
|
|
self.assertContains(response, "timed out", status_code=502)
|
|
|
|
def test_user_cannot_save_an_untested_url(self):
|
|
response = self.client.post(reverse("user_settings"), {"ntfy_url": self.url, "ntfy_enabled": "on"})
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "Test deze URL")
|
|
settings = UserSettings.objects.get(user=self.user)
|
|
self.assertFalse(settings.ntfy_enabled)
|
|
self.assertEqual(settings.ntfy_url, "")
|
|
|
|
def test_unchecked_url_can_be_saved_without_testing_then_requires_test_to_enable(self):
|
|
response = self.client.post(reverse("user_settings"), {"ntfy_url": self.url})
|
|
self.assertRedirects(response, reverse("user_settings"))
|
|
saved = UserSettings.objects.get(user=self.user)
|
|
self.assertEqual(saved.ntfy_url, self.url)
|
|
self.assertFalse(saved.ntfy_enabled)
|
|
self.assertIsNone(saved.ntfy_last_tested_at)
|
|
response = self.client.post(reverse("user_settings"), {"ntfy_url": self.url, "ntfy_enabled": "on"})
|
|
self.assertContains(response, "Test deze URL")
|
|
|
|
@patch("notifications.services.send_ntfy_notification")
|
|
def test_pending_arrivals_are_grouped_by_minute_and_source(self, mock_send):
|
|
from datetime import timedelta
|
|
from django.utils import timezone
|
|
from fireworks_detect.models import PendingEvent
|
|
|
|
UserSettings.objects.create(user=self.user, ntfy_url=self.url, ntfy_enabled=True)
|
|
PendingEvent.objects.create(original_filename="manual", classifier_response={}, source_type=PendingEvent.SourceType.MANUAL)
|
|
PendingEvent.objects.create(original_filename="sensor", classifier_response={})
|
|
PendingEvent.objects.create(original_filename="sensor2", classifier_response={})
|
|
batch = PendingNotificationBatch.objects.get(user=self.user)
|
|
self.assertEqual((batch.manual_count, batch.sensor_count), (1, 2))
|
|
call_command("send_pending_notifications")
|
|
mock_send.assert_not_called()
|
|
PendingNotificationBatch.objects.filter(pk=batch.pk).update(minute=timezone.now() - timedelta(minutes=2))
|
|
call_command("send_pending_notifications")
|
|
mock_send.assert_called_once()
|
|
self.assertIn("1 handmatig", mock_send.call_args.args[2])
|
|
self.assertIn("2 sensor", mock_send.call_args.args[2])
|
|
self.assertFalse(PendingNotificationBatch.objects.exists())
|
|
PendingEvent.objects.create(original_filename="next", classifier_response={})
|
|
self.assertEqual(PendingNotificationBatch.objects.get(user=self.user).sensor_count, 1)
|
|
|
|
@patch("notifications.services.send_ntfy_notification", side_effect=NotificationError("Could not connect"))
|
|
def test_failed_summary_is_kept_for_retry(self, mock_send):
|
|
from datetime import timedelta
|
|
from django.utils import timezone
|
|
from fireworks_detect.models import PendingEvent
|
|
|
|
UserSettings.objects.create(user=self.user, ntfy_url=self.url, ntfy_enabled=True)
|
|
PendingEvent.objects.create(original_filename="manual", classifier_response={}, source_type=PendingEvent.SourceType.MANUAL)
|
|
PendingNotificationBatch.objects.update(minute=timezone.now() - timedelta(minutes=2))
|
|
call_command("send_pending_notifications")
|
|
self.assertEqual(PendingNotificationBatch.objects.get().manual_count, 1)
|
|
|
|
def test_disabled_user_does_not_accumulate_pending_summaries(self):
|
|
from fireworks_detect.models import PendingEvent
|
|
|
|
UserSettings.objects.create(user=self.user, ntfy_url=self.url, ntfy_enabled=False)
|
|
PendingEvent.objects.create(original_filename="manual", classifier_response={}, source_type=PendingEvent.SourceType.MANUAL)
|
|
self.assertFalse(PendingNotificationBatch.objects.exists())
|
|
|
|
@patch("members.views.send_ntfy_notification")
|
|
def test_successfully_tested_url_can_be_saved(self, mock_send):
|
|
self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": self.url})
|
|
|
|
response = self.client.post(reverse("user_settings"), {"ntfy_url": self.url, "ntfy_enabled": "on"})
|
|
|
|
self.assertRedirects(response, reverse("user_settings"))
|
|
settings = UserSettings.objects.get(user=self.user)
|
|
self.assertEqual(settings.ntfy_url, self.url)
|
|
self.assertTrue(settings.ntfy_enabled)
|
|
self.assertIsNotNone(settings.ntfy_last_tested_at)
|
|
|
|
@patch("members.views.send_ntfy_notification")
|
|
def test_changing_the_url_requires_another_successful_test(self, mock_send):
|
|
self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": self.url})
|
|
self.client.post(reverse("user_settings"), {"ntfy_url": self.url, "ntfy_enabled": "on"})
|
|
|
|
changed_url = "https://ntfy.example.com/another-topic"
|
|
response = self.client.post(reverse("user_settings"), {"ntfy_url": changed_url, "ntfy_enabled": "on"})
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "Test deze URL")
|
|
self.assertEqual(UserSettings.objects.get(user=self.user).ntfy_url, self.url)
|
|
|
|
@patch("members.views.send_ntfy_notification")
|
|
def test_one_users_successful_test_cannot_authorize_another_users_settings(self, mock_send):
|
|
self.client.post(reverse("ntfy_test_notification"), {"ntfy_url": self.url})
|
|
self.client.force_login(self.other_user)
|
|
|
|
response = self.client.post(reverse("user_settings"), {"ntfy_url": self.url, "ntfy_enabled": "on"})
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "Test deze URL")
|
|
settings = UserSettings.objects.get(user=self.other_user)
|
|
self.assertFalse(settings.ntfy_enabled)
|
|
|
|
@patch("notifications.services.send_ntfy_notification")
|
|
def test_reusable_sender_only_delivers_for_enabled_user_settings(self, mock_send):
|
|
self.assertFalse(send_notification(self.user, "Title", "Message"))
|
|
UserSettings.objects.create(user=self.user, ntfy_url=self.url, ntfy_enabled=True)
|
|
|
|
self.assertTrue(send_notification(self.user, "Title", "Message"))
|
|
mock_send.assert_called_once_with(self.url, "Title", "Message")
|
|
|
|
|
|
class FrontendAuthenticationTests(TestCase):
|
|
def setUp(self):
|
|
self.client.cookies[settings.LANGUAGE_COOKIE_NAME] = "en"
|
|
self.user = get_user_model().objects.create_user(username="profile-user", password="secret")
|
|
|
|
def test_frontend_login_page_is_available(self):
|
|
response = self.client.get(reverse("login"))
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "Sign in")
|
|
self.assertContains(response, reverse("register"))
|
|
self.assertContains(response, "csrfmiddlewaretoken")
|
|
|
|
def test_registration_creates_minimal_account_and_signs_in(self):
|
|
response = self.client.post(reverse("register"), {
|
|
"username": "new-user",
|
|
"password1": "long-unique-password-5842",
|
|
"password2": "long-unique-password-5842",
|
|
})
|
|
|
|
self.assertRedirects(response, "/")
|
|
user = get_user_model().objects.get(username="new-user")
|
|
self.assertEqual(user.email, "")
|
|
self.assertEqual(str(self.client.session["_auth_user_id"]), str(user.pk))
|
|
|
|
def test_registration_preserves_safe_login_destination(self):
|
|
login_page = self.client.get(reverse("login"), {"next": "/settings/"})
|
|
self.assertContains(login_page, "/register/?next=/settings/")
|
|
|
|
response = self.client.post(reverse("register"), {
|
|
"username": "another-new-user",
|
|
"password1": "long-unique-password-5842",
|
|
"password2": "long-unique-password-5842",
|
|
"next": "/settings/",
|
|
})
|
|
self.assertRedirects(response, "/settings/")
|
|
|
|
def test_registration_rejects_external_destination(self):
|
|
response = self.client.post(reverse("register"), {
|
|
"username": "safe-user",
|
|
"password1": "long-unique-password-5842",
|
|
"password2": "long-unique-password-5842",
|
|
"next": "https://example.com/steal",
|
|
})
|
|
self.assertRedirects(response, "/")
|
|
|
|
def test_frontend_login_authenticates_and_returns_home(self):
|
|
response = self.client.post(reverse("login"), {"username": "profile-user", "password": "secret"})
|
|
|
|
self.assertRedirects(response, "/")
|
|
|
|
def test_frontend_logout_uses_post_and_returns_home(self):
|
|
self.client.force_login(self.user)
|
|
self.assertEqual(self.client.get(reverse("logout")).status_code, 405)
|
|
response = self.client.post(reverse("logout"))
|
|
self.assertRedirects(response, "/")
|
|
self.assertNotIn("_auth_user_id", self.client.session)
|
|
|
|
def test_protected_settings_redirects_to_frontend_login(self):
|
|
response = self.client.get(reverse("user_settings"))
|
|
|
|
self.assertRedirects(response, "/login/?next=/settings/")
|
|
|
|
def test_profile_circle_is_visible_only_for_authenticated_users(self):
|
|
anonymous_response = self.client.get(reverse("hello"))
|
|
self.assertNotContains(anonymous_response, "class=\"profile-circle\"")
|
|
self.assertContains(anonymous_response, f'href="{reverse("login")}"')
|
|
|
|
self.client.force_login(self.user)
|
|
authenticated_response = self.client.get(reverse("hello"))
|
|
self.assertContains(authenticated_response, "class=\"profile-circle\"")
|
|
self.assertContains(authenticated_response, reverse("user_settings"))
|
|
self.assertContains(authenticated_response, f'action="{reverse("logout")}"')
|
|
self.assertNotContains(authenticated_response, f'href="{reverse("login")}"')
|
|
|
|
|
|
class LanguageSettingsTests(TestCase):
|
|
def setUp(self):
|
|
self.user = get_user_model().objects.create_user(username="language-user", password="secret")
|
|
self.client.force_login(self.user)
|
|
|
|
def test_missing_settings_row_uses_dutch_and_page_displays_it(self):
|
|
response = self.client.get(reverse("user_settings"))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, '<option value="nl" selected>')
|
|
self.assertEqual(UserSettings.objects.get(user=self.user).preferred_language, "nl")
|
|
|
|
def test_language_can_switch_and_persists_between_requests(self):
|
|
for language in ("en", "nl"):
|
|
response = self.client.post(reverse("user_settings"), {
|
|
"save_language": "1", "preferred_language": language,
|
|
})
|
|
self.assertRedirects(response, reverse("user_settings"))
|
|
self.assertEqual(UserSettings.objects.get(user=self.user).preferred_language, language)
|
|
response = self.client.get(reverse("user_settings"), HTTP_ACCEPT_LANGUAGE="en")
|
|
self.assertEqual(response.wsgi_request.LANGUAGE_CODE, language)
|
|
self.assertContains(response, f'<option value="{language}" selected>')
|
|
|
|
def test_invalid_language_is_rejected(self):
|
|
self.client.post(reverse("user_settings"), {"save_language": "1", "preferred_language": "en"})
|
|
response = self.client.post(reverse("user_settings"), {
|
|
"save_language": "1", "preferred_language": "fr",
|
|
})
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertContains(response, "Select a valid choice")
|
|
self.assertEqual(UserSettings.objects.get(user=self.user).preferred_language, "en")
|
|
|
|
def test_anonymous_request_still_works(self):
|
|
self.client.logout()
|
|
response = self.client.get(reverse("hello"))
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
def test_public_switcher_only_appears_for_anonymous_visitors(self):
|
|
self.client.logout()
|
|
self.assertContains(self.client.get(reverse("hello")), 'id="public-language-choice"')
|
|
self.client.force_login(self.user)
|
|
self.assertNotContains(self.client.get(reverse("hello")), 'id="public-language-choice"')
|
|
|
|
def test_anonymous_language_defaults_to_dutch_without_valid_cookie(self):
|
|
self.client.logout()
|
|
self.assertEqual(self.client.get(reverse("hello"), HTTP_ACCEPT_LANGUAGE="en").wsgi_request.LANGUAGE_CODE, "nl")
|
|
self.client.cookies[settings.LANGUAGE_COOKIE_NAME] = "fr"
|
|
self.assertEqual(self.client.get(reverse("hello")).wsgi_request.LANGUAGE_CODE, "nl")
|
|
|
|
def test_dashboard_uses_dutch_catalogue_and_english_source(self):
|
|
self.client.logout()
|
|
self.client.cookies[settings.LANGUAGE_COOKIE_NAME] = "nl"
|
|
response = self.client.get(reverse("hello"))
|
|
self.assertContains(response, "Meld wat je hebt gehoord.")
|
|
self.assertContains(response, 'lang="nl"')
|
|
self.client.cookies[settings.LANGUAGE_COOKIE_NAME] = "en"
|
|
response = self.client.get(reverse("hello"))
|
|
self.assertContains(response, "Report what you heard.")
|
|
self.assertContains(response, 'lang="en"')
|
|
|
|
def test_translated_choice_label_keeps_stored_value_and_urls(self):
|
|
from fireworks_detect.models import PendingEvent
|
|
|
|
with translation.override("nl"):
|
|
self.assertEqual(str(PendingEvent.SourceType.MANUAL.label), "Handmatige melding")
|
|
self.assertEqual(PendingEvent.SourceType.MANUAL.value, "manual")
|
|
self.assertEqual(reverse("fireworks_detect:map"), "/fireworks/map/")
|
|
|
|
def test_anonymous_language_cookie_persists_and_controls_next_request(self):
|
|
self.client.logout()
|
|
for language in ("en", "nl"):
|
|
response = self.client.post(reverse("set_anonymous_language"), {
|
|
"language": language, "next": reverse("hello"),
|
|
})
|
|
self.assertRedirects(response, reverse("hello"))
|
|
cookie = response.cookies[settings.LANGUAGE_COOKIE_NAME]
|
|
self.assertEqual(cookie.value, language)
|
|
self.assertGreater(int(cookie["max-age"]), 0)
|
|
self.assertEqual(self.client.get(reverse("hello")).wsgi_request.LANGUAGE_CODE, language)
|
|
|
|
def test_invalid_language_and_unsafe_redirect_are_rejected(self):
|
|
self.client.logout()
|
|
response = self.client.post(reverse("set_anonymous_language"), {
|
|
"language": "fr", "next": reverse("hello"),
|
|
})
|
|
self.assertEqual(response.status_code, 400)
|
|
self.assertNotIn(settings.LANGUAGE_COOKIE_NAME, response.cookies)
|
|
response = self.client.post(reverse("set_anonymous_language"), {
|
|
"language": "en", "next": "https://evil.example/",
|
|
})
|
|
self.assertNotEqual(response.get("Location"), "https://evil.example/")
|
|
|
|
def test_account_preference_wins_over_anonymous_cookie_on_login(self):
|
|
self.client.logout()
|
|
self.client.post(reverse("set_anonymous_language"), {
|
|
"language": "en", "next": reverse("hello"),
|
|
})
|
|
UserSettings.objects.update_or_create(user=self.user, defaults={"preferred_language": "nl"})
|
|
self.client.post(reverse("login"), {"username": "language-user", "password": "secret"})
|
|
self.assertEqual(UserSettings.objects.get(user=self.user).preferred_language, "nl")
|
|
self.assertEqual(self.client.get(reverse("hello")).wsgi_request.LANGUAGE_CODE, "nl")
|
|
self.assertEqual(self.client.cookies[settings.LANGUAGE_COOKIE_NAME].value, "en")
|