170 lines
9.4 KiB
Python
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()
|