import json import uuid import hashlib from unittest.mock import patch from django.contrib.auth import get_user_model from django.core.cache import caches from datetime import datetime from zoneinfo import ZoneInfo from django.test import TestCase from django.urls import reverse from .models import DashboardLayout from .views import validate_widgets from .weather import ForecastUnavailable, coordinates, get_forecast from .buienradar import RainUnavailable, get_rain, parse_forecast class DashboardTests(TestCase): def setUp(self): self.one = get_user_model().objects.create_user(username="one", password="password") self.two = get_user_model().objects.create_user(username="two", password="password") def test_registry_rejects_duplicate_single_instance(self): item = {"id": str(uuid.uuid4()), "type": "welcome", "span": 2, "settings": {}, "visible": True} with self.assertRaises(ValueError): validate_widgets([item, {**item, "id": str(uuid.uuid4())}]) def test_user_and_page_layouts_are_independent(self): self.client.force_login(self.one) self.client.get(reverse("dashboard:index")) self.client.get(reverse("dashboard:page", args=["personal"])) self.client.force_login(self.two) self.client.get(reverse("dashboard:index")) self.assertEqual(DashboardLayout.objects.count(), 3) ids = [widget["id"] for layout in DashboardLayout.objects.all() for widget in layout.widgets] self.assertEqual(len(ids), len(set(ids))) def test_layout_update_is_scoped_to_authenticated_user(self): self.client.force_login(self.one) self.client.get(reverse("dashboard:index")) original = DashboardLayout.objects.get(user=self.one, page="overview") self.client.force_login(self.two) response = self.client.put( reverse("dashboard:layout", args=["overview"]), json.dumps({"revision": 0, "widgets": []}), content_type="application/json", ) self.assertEqual(response.status_code, 200) original.refresh_from_db() self.assertEqual(original.revision, 0) self.assertEqual(len(original.widgets), 2) def test_reorder_persists_and_revision_conflict(self): self.client.force_login(self.one) self.client.get(reverse("dashboard:index")) layout = DashboardLayout.objects.get(user=self.one, page="overview") widgets = list(reversed(layout.widgets)) url = reverse("dashboard:layout", args=["overview"]) response = self.client.put(url, json.dumps({"revision": 0, "widgets": widgets}), content_type="application/json") self.assertEqual(response.status_code, 200) layout.refresh_from_db() self.assertEqual([item["type"] for item in layout.widgets], ["shortcuts", "welcome"]) self.assertEqual(self.client.put(url, json.dumps({"revision": 0, "widgets": widgets}), content_type="application/json").status_code, 409) def test_open_meteo_registry_and_authenticated_endpoint(self): self.assertEqual(self.client.post(reverse("dashboard:open_meteo"), data="{}", content_type="application/json").status_code, 302) self.client.force_login(self.one) with patch("dashboard.views.get_forecast", return_value={"current": {}, "hourly": {}, "daily": {}, "stale": False}): response = self.client.post(reverse("dashboard:open_meteo"), json.dumps({"latitude": 52.96, "longitude": 5.92}), content_type="application/json") self.assertEqual(response.status_code, 200) self.assertIn("open_meteo", __import__("dashboard.registry", fromlist=["WIDGETS"]).WIDGETS) def test_weather_coordinate_validation_and_shared_cache(self): with self.assertRaises(ValueError): coordinates("nan", 5) caches["weather"].clear() payload = {"current": {"temperature_2m": 10}, "hourly": {"time": ["2026-10-14T12:00"]}, "daily": {}, "fetched_at": "2026-10-14T10:00:00+00:00"} with patch("dashboard.weather.request_forecast", return_value=payload) as fetch: first = get_forecast(52.961, 5.919) second = get_forecast(52.96, 5.92) self.assertFalse(first["stale"]) self.assertEqual(second["current"]["temperature_2m"], 10) fetch.assert_called_once() caches["weather"].clear() def test_weather_provider_failure_is_isolated(self): self.client.force_login(self.one) with patch("dashboard.views.get_forecast", side_effect=ForecastUnavailable("Weather service is temporarily unavailable")): response = self.client.post(reverse("dashboard:open_meteo"), json.dumps({"latitude": 52.96, "longitude": 5.92}), content_type="application/json") self.assertEqual(response.status_code, 503) def test_weather_stale_cache_is_labeled_after_provider_failure(self): cache = caches["weather"] cache.clear() key = hashlib.sha256(b"open-meteo:v1:52.96:5.92").hexdigest() cache.set(f"stale:{key}", {"current": {"temperature_2m": 8}, "hourly": {"time": ["2026-10-14T12:00"]}, "daily": {}, "fetched_at": "2026-10-14T10:00:00+00:00"}, 60) with patch("dashboard.weather.request_forecast", side_effect=OSError("provider offline")): result = get_forecast(52.96, 5.92) self.assertTrue(result["stale"]) self.assertEqual(result["current"]["temperature_2m"], 8) cache.clear() def test_buienradar_feed_parsing_crosses_midnight(self): now = datetime(2026, 10, 14, 23, 54, tzinfo=ZoneInfo("Europe/Amsterdam")) points = parse_forecast("000|23:55\n077|00:00\n125|00:05\n", now=now) self.assertEqual(points[0]["label"], "None") self.assertAlmostEqual(points[1]["mm_per_hour"], 0.1) self.assertEqual(points[1]["time"][:10], "2026-10-15") self.assertEqual(points[2]["label"], "Moderate") self.assertIsNone(parse_forecast("255|23:55\n", now=now)[0]["mm_per_hour"]) with self.assertRaises(RainUnavailable): parse_forecast("not a feed", now=now) def test_buienradar_endpoint_auth_range_and_cache(self): url = reverse("dashboard:buienradar") self.assertEqual(self.client.post(url, data="{}", content_type="application/json").status_code, 302) self.client.force_login(self.one) self.assertEqual(self.client.post(url, json.dumps({"latitude": 40, "longitude": 5}), content_type="application/json").status_code, 400) caches["weather"].clear() payload = {"points": [{"time": "2026-10-14T23:55:00+02:00", "mm_per_hour": 0, "label": "None"}], "fetched_at": "2026-10-14T21:55:00+00:00"} with patch("dashboard.buienradar.request_rain", return_value=payload) as fetch: first = get_rain(52.961, 5.919) second = get_rain(52.96, 5.92) self.assertFalse(first["stale"]) self.assertEqual(second["points"], first["points"]) fetch.assert_called_once() caches["weather"].clear() def test_buienradar_stale_fallback(self): cache = caches["weather"] cache.clear() key = hashlib.sha256(b"buienradar:v1:52.96:5.92").hexdigest() cache.set(f"stale:{key}", {"points": [{"time": "2026-10-14T23:55:00+02:00", "mm_per_hour": 0, "label": "None"}], "fetched_at": "2026-10-14T21:55:00+00:00"}, 60) with patch("dashboard.buienradar.request_rain", side_effect=OSError("offline")): result = get_rain(52.96, 5.92) self.assertTrue(result["stale"]) cache.clear()