Files
2026-10-22 10:24:33 +02:00

170 lines
9.4 KiB
Python

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
from .codex_usage import _display, get_usage
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()
def test_codex_usage_registry_and_private_panel(self):
from .registry import WIDGETS
self.assertIn("codex_usage", WIDGETS)
item = {"id": str(uuid.uuid4()), "type": "codex_usage", "span": 2, "settings": {}, "visible": True}
self.assertEqual(validate_widgets([item])[0]["type"], "codex_usage")
with self.assertRaises(ValueError):
validate_widgets([item, {**item, "id": str(uuid.uuid4())}])
url = reverse("dashboard:codex_usage")
self.assertEqual(self.client.get(url).status_code, 302)
self.client.force_login(self.one)
with patch("dashboard.views.get_usage", return_value={"windows": [{"title": "5 hours", "remaining": 17, "reset": None, "bucket": "codex"}], "checked": None, "stale": False, "allowed": True}):
response = self.client.get(url)
self.assertContains(response, "17%")
self.assertContains(response, "Reset time unavailable")
def test_codex_usage_normalizes_live_shape_and_stale_cache(self):
raw = {"service": "codex", "status": "ok", "last_checked": "2026-10-21T22:56:50.106Z", "raw": {"ordinaryUsageAllowed": True, "accountId": "private", "rateLimitsByLimitId": {"codex": {"primary": {"usedPercent": 83, "windowDurationMins": 300, "resetsAt": 1792625545}, "secondary": {"usedPercent": 60, "windowDurationMins": 10080, "resetsAt": 1793101162}}}}}
display = _display(raw)
self.assertEqual([window["remaining"] for window in display["windows"]], [17, 40])
self.assertNotIn("private", str(display))
cache = caches["weather"]
cache.delete("codex-usage:v1")
cache.delete("codex-usage:last-good")
cache.set("codex-usage:last-good", display, 60)
with patch("dashboard.codex_usage.urllib.request.urlopen", side_effect=OSError("offline")):
fallback = get_usage()
self.assertTrue(fallback["stale"])
self.assertEqual(fallback["windows"][0]["remaining"], 17)
cache.delete("codex-usage:last-good")
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()