Files
FireworksApp/members/tests.py
T
2026-10-01 22:43:45 +02:00

271 lines
13 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.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 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, "")
@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, "csrfmiddlewaretoken")
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_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.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"))
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")