arthexis 0.1.21__py3-none-any.whl → 0.1.22__py3-none-any.whl

pages/tests.py

@@ -62,6 +62,7 @@ from core.models import (
     RFID,
     ReleaseManager,
     SecurityGroup,
+    GoogleCalendarProfile,
     Todo,
     TOTPDeviceSettings,
 )
@@ -71,8 +72,11 @@ import base64
 import json
 import tempfile
 import shutil
+from datetime import timedelta
 from io import StringIO
 from django.conf import settings
+from django.utils import timezone
+from django.utils.html import escape
 from pathlib import Path
 from unittest.mock import MagicMock, Mock, call, patch
 from types import SimpleNamespace
@@ -90,6 +94,7 @@ from datetime import (
 from django.core import mail
 from django.utils import timezone
 from django.utils.text import slugify
+from django.utils import translation
 from django.utils.translation import gettext
 from django_otp import DEVICE_ID_SESSION_KEY
 from django_otp.oath import TOTP
@@ -195,6 +200,41 @@ class LoginViewTests(TestCase):
         )
         self.assertRedirects(resp, "/nodes/list/")
 
+    def test_homepage_excludes_version_banner_for_anonymous(self):
+        response = self.client.get(reverse("pages:index"))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertNotContains(response, "__versionCheckInitialized")
+
+    def test_homepage_includes_version_banner_for_staff(self):
+        self.client.force_login(self.staff)
+        response = self.client.get(reverse("pages:index"))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "__versionCheckInitialized")
+
+
+class AdminTemplateVersionBannerTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.staff = User.objects.create_user(
+            username="admin-staff", password="pwd", is_staff=True
+        )
+
+    def test_admin_login_excludes_version_banner_for_anonymous(self):
+        response = self.client.get(reverse("admin:login"))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertNotContains(response, "__versionCheckInitialized")
+
+    def test_admin_dashboard_includes_version_banner_for_staff(self):
+        self.client.force_login(self.staff)
+        response = self.client.get(reverse("admin:index"))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "__versionCheckInitialized")
+
     def test_staff_redirects_next_when_specified(self):
         resp = self.client.post(
             reverse("pages:login") + "?next=/nodes/list/",
@@ -715,6 +755,66 @@ class AdminSidebarTests(TestCase):
         self.assertContains(resp, 'id="admin-collapsible-apps"')
 
 
+class AdminGoogleCalendarSidebarTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="calendar_admin", password="pwd", email="admin@example.com"
+        )
+        self.client.force_login(self.admin)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "test", "domain": "testserver"}
+        )
+        Node.objects.create(hostname="testserver", address="127.0.0.1")
+
+    def test_calendar_module_hidden_without_profile(self):
+        resp = self.client.get(reverse("admin:index"))
+        self.assertNotContains(resp, 'id="google-calendar-module"', html=False)
+
+    @patch("core.models.GoogleCalendarProfile.fetch_events")
+    def test_calendar_module_shows_events_for_user(self, fetch_events):
+        fetch_events.return_value = [
+            {
+                "summary": "Standup",
+                "start": timezone.now(),
+                "end": None,
+                "all_day": False,
+                "html_link": "https://calendar.google.com/event",
+                "location": "HQ",
+            }
+        ]
+        GoogleCalendarProfile.objects.create(
+            user=self.admin,
+            calendar_id="example@group.calendar.google.com",
+            api_key="secret",
+            display_name="Team Calendar",
+        )
+
+        resp = self.client.get(reverse("admin:index"))
+
+        self.assertContains(resp, 'id="google-calendar-module"', html=False)
+        self.assertContains(resp, "Standup")
+        self.assertContains(resp, "Open full calendar")
+        fetch_events.assert_called_once()
+
+    @patch("core.models.GoogleCalendarProfile.fetch_events")
+    def test_calendar_module_uses_group_profile(self, fetch_events):
+        fetch_events.return_value = []
+        group = SecurityGroup.objects.create(name="Calendar Group")
+        self.admin.groups.add(group)
+        GoogleCalendarProfile.objects.create(
+            group=group,
+            calendar_id="group@calendar.google.com",
+            api_key="secret",
+        )
+
+        resp = self.client.get(reverse("admin:index"))
+
+        self.assertContains(resp, 'id="google-calendar-module"', html=False)
+        fetch_events.assert_called_once()
+
+
 class ViewHistoryLoggingTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -816,6 +916,35 @@ class ViewHistoryLoggingTests(TestCase):
         self.assertEqual(lead.path, "/")
         self.assertEqual(lead.referer, "https://example.com/ref")
 
+    def test_pages_config_purges_old_view_history(self):
+        ViewHistory.objects.all().delete()
+
+        old_entry = ViewHistory.objects.create(
+            path="/old/",
+            method="GET",
+            status_code=200,
+            status_text="OK",
+        )
+        new_entry = ViewHistory.objects.create(
+            path="/recent/",
+            method="GET",
+            status_code=200,
+            status_text="OK",
+        )
+
+        ViewHistory.objects.filter(pk=old_entry.pk).update(
+            visited_at=timezone.now() - timedelta(days=20)
+        )
+        ViewHistory.objects.filter(pk=new_entry.pk).update(
+            visited_at=timezone.now() - timedelta(days=10)
+        )
+
+        config = django_apps.get_app_config("pages")
+        config._purge_view_history()
+
+        self.assertFalse(ViewHistory.objects.filter(pk=old_entry.pk).exists())
+        self.assertTrue(ViewHistory.objects.filter(pk=new_entry.pk).exists())
+
     def test_landing_visit_does_not_record_lead_without_celery(self):
         role = NodeRole.objects.create(name="no-celery-role")
         application = Application.objects.create(
@@ -913,6 +1042,44 @@ class ViewHistoryAdminTests(TestCase):
         self.assertEqual(totals.get("/"), 2)
         self.assertEqual(totals.get("/about/"), 1)
 
+    def test_graph_data_endpoint_respects_days_parameter(self):
+        ViewHistory.all_objects.all().delete()
+        reference_date = date(2025, 5, 1)
+        tz = timezone.get_current_timezone()
+        path = "/range/"
+
+        for offset in range(10):
+            entry = ViewHistory.objects.create(
+                path=path,
+                method="GET",
+                status_code=200,
+                status_text="OK",
+                error_message="",
+                view_name="pages:index",
+            )
+            visited_date = reference_date - timedelta(days=offset)
+            visited_at = timezone.make_aware(
+                datetime.combine(visited_date, datetime_time(12, 0)), tz
+            )
+            entry.visited_at = visited_at
+            entry.save(update_fields=["visited_at"])
+
+        url = reverse("admin:pages_viewhistory_traffic_data")
+        with patch("pages.admin.timezone.localdate", return_value=reference_date):
+            resp = self.client.get(url, {"days": 7})
+
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+
+        self.assertEqual(len(data.get("labels", [])), 7)
+        self.assertEqual(data.get("meta", {}).get("start"), (reference_date - timedelta(days=6)).isoformat())
+        self.assertEqual(data.get("meta", {}).get("end"), reference_date.isoformat())
+
+        totals = {
+            dataset["label"]: sum(dataset["data"]) for dataset in data.get("datasets", [])
+        }
+        self.assertEqual(totals.get(path), 7)
+
     def test_graph_data_includes_late_evening_visits(self):
         target_date = date(2025, 9, 27)
         entry = ViewHistory.objects.create(
@@ -2657,6 +2824,20 @@ class FavoriteTests(TestCase):
         self.assertEqual(fav.custom_label, "Apps")
         self.assertTrue(fav.user_data)
 
+    def test_add_favorite_defaults_user_data_checked(self):
+        ct = ContentType.objects.get_by_natural_key("pages", "application")
+        url = reverse("admin:favorite_toggle", args=[ct.id])
+        resp = self.client.get(url)
+        self.assertContains(resp, 'name="user_data" checked')
+
+    def test_add_favorite_with_priority(self):
+        ct = ContentType.objects.get_by_natural_key("pages", "application")
+        url = reverse("admin:favorite_toggle", args=[ct.id])
+        resp = self.client.post(url, {"priority": "7"})
+        self.assertRedirects(resp, reverse("admin:index"))
+        fav = Favorite.objects.get(user=self.user, content_type=ct)
+        self.assertEqual(fav.priority, 7)
+
     def test_cancel_link_uses_next(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
         next_url = reverse("admin:pages_application_changelist")
@@ -2666,14 +2847,31 @@ class FavoriteTests(TestCase):
         resp = self.client.get(url)
         self.assertContains(resp, f'href="{next_url}"')
 
-    def test_existing_favorite_redirects_to_list(self):
+    def test_existing_favorite_shows_update_form(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
-        Favorite.objects.create(user=self.user, content_type=ct)
+        favorite = Favorite.objects.create(
+            user=self.user, content_type=ct, custom_label="Apps", user_data=True
+        )
         url = reverse("admin:favorite_toggle", args=[ct.id])
         resp = self.client.get(url)
-        self.assertRedirects(resp, reverse("admin:favorite_list"))
-        resp = self.client.get(reverse("admin:favorite_list"))
-        self.assertContains(resp, ct.name)
+        self.assertContains(resp, "Update Favorite")
+        self.assertContains(resp, "value=\"Apps\"")
+        self.assertContains(resp, "checked")
+        self.assertContains(resp, "name=\"remove\"")
+
+        resp = self.client.post(url, {"custom_label": "Apps Updated"})
+        self.assertRedirects(resp, reverse("admin:index"))
+        favorite.refresh_from_db()
+        self.assertEqual(favorite.custom_label, "Apps Updated")
+        self.assertFalse(favorite.user_data)
+
+    def test_remove_existing_favorite_from_toggle(self):
+        ct = ContentType.objects.get_by_natural_key("pages", "application")
+        Favorite.objects.create(user=self.user, content_type=ct)
+        url = reverse("admin:favorite_toggle", args=[ct.id])
+        resp = self.client.post(url, {"remove": "1"})
+        self.assertRedirects(resp, reverse("admin:index"))
+        self.assertFalse(Favorite.objects.filter(user=self.user, content_type=ct).exists())
 
     def test_update_user_data_from_list(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
@@ -2684,6 +2882,15 @@ class FavoriteTests(TestCase):
         fav.refresh_from_db()
         self.assertTrue(fav.user_data)
 
+    def test_update_priority_from_list(self):
+        ct = ContentType.objects.get_by_natural_key("pages", "application")
+        fav = Favorite.objects.create(user=self.user, content_type=ct, priority=3)
+        url = reverse("admin:favorite_list")
+        resp = self.client.post(url, {f"priority_{fav.pk}": "12"})
+        self.assertRedirects(resp, url)
+        fav.refresh_from_db()
+        self.assertEqual(fav.priority, 12)
+
     def test_dashboard_includes_favorites_and_user_data(self):
         fav_ct = ContentType.objects.get_by_natural_key("pages", "application")
         Favorite.objects.create(
@@ -2694,6 +2901,12 @@ class FavoriteTests(TestCase):
         self.assertContains(resp, reverse("admin:pages_application_changelist"))
         self.assertContains(resp, reverse("admin:nodes_noderole_changelist"))
 
+    def test_dashboard_shows_empty_todo_state(self):
+        Todo.objects.all().delete()
+        resp = self.client.get(reverse("admin:index"))
+        self.assertContains(resp, "Release manager tasks")
+        self.assertContains(resp, "No pending TODOs")
+
     def test_dashboard_merges_duplicate_future_actions(self):
         ct = ContentType.objects.get_for_model(NodeRole)
         Favorite.objects.create(user=self.user, content_type=ct)
@@ -2933,7 +3146,11 @@ class FavoriteTests(TestCase):
         todo = Todo.objects.create(request="Do thing")
         resp = self.client.get(reverse("admin:index"))
         done_url = reverse("todo-done", args=[todo.pk])
-        self.assertContains(resp, todo.request)
+        tooltip = escape(todo.request)
+        self.assertContains(resp, f'title="{tooltip}"')
+        self.assertContains(resp, f'aria-label="{tooltip}"')
+        task_label = gettext("Task %(counter)s") % {"counter": 1}
+        self.assertContains(resp, task_label)
         self.assertContains(resp, f'action="{done_url}"')
         self.assertContains(resp, "DONE")
 
@@ -2961,7 +3178,8 @@ class FavoriteTests(TestCase):
 
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "Release manager tasks")
-        self.assertContains(resp, "Check fallback")
+        tooltip = escape("Check fallback")
+        self.assertContains(resp, f'title="{tooltip}"')
 
     def test_dashboard_shows_todos_without_release_manager_profile(self):
         Todo.objects.create(request="Unrestricted task")
@@ -2969,7 +3187,8 @@ class FavoriteTests(TestCase):
 
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "Release manager tasks")
-        self.assertContains(resp, "Unrestricted task")
+        tooltip = escape("Unrestricted task")
+        self.assertContains(resp, f'title="{tooltip}"')
 
     def test_dashboard_excludes_todo_changelist_link(self):
         ct = ContentType.objects.get_for_model(Todo)
@@ -2993,7 +3212,8 @@ class FavoriteTests(TestCase):
         self.client.force_login(other_user)
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "Release manager tasks")
-        self.assertContains(resp, todo.request)
+        tooltip = escape(todo.request)
+        self.assertContains(resp, f'title="{tooltip}"')
 
     def test_dashboard_shows_todos_for_non_terminal_node(self):
         todo = Todo.objects.create(request="Terminal Tasks")
@@ -3004,7 +3224,8 @@ class FavoriteTests(TestCase):
         self.node.save(update_fields=["role"])
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "Release manager tasks")
-        self.assertContains(resp, todo.request)
+        tooltip = escape(todo.request)
+        self.assertContains(resp, f'title="{tooltip}"')
 
     def test_dashboard_shows_todos_for_delegate_release_manager(self):
         todo = Todo.objects.create(request="Delegate Task")
@@ -3026,7 +3247,8 @@ class FavoriteTests(TestCase):
         self.client.force_login(operator)
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "Release manager tasks")
-        self.assertContains(resp, todo.request)
+        tooltip = escape(todo.request)
+        self.assertContains(resp, f'title="{tooltip}"')
 
 
 class AdminIndexQueryRegressionTests(TestCase):
@@ -3229,6 +3451,14 @@ class UserStorySubmissionTests(TestCase):
         self.url = reverse("pages:user-story-submit")
         User = get_user_model()
         self.user = User.objects.create_user(username="feedbacker", password="pwd")
+        self.capture_patcher = patch("pages.views.capture_screenshot", autospec=True)
+        self.save_patcher = patch("pages.views.save_screenshot", autospec=True)
+        self.mock_capture = self.capture_patcher.start()
+        self.mock_save = self.save_patcher.start()
+        self.mock_capture.return_value = Path("/tmp/fake.png")
+        self.mock_save.return_value = None
+        self.addCleanup(self.capture_patcher.stop)
+        self.addCleanup(self.save_patcher.stop)
 
     def test_authenticated_submission_defaults_to_username(self):
         self.client.force_login(self.user)
@@ -3257,12 +3487,98 @@ class UserStorySubmissionTests(TestCase):
         self.assertEqual(story.referer, "https://example.test/wizard/step-1/")
         self.assertEqual(story.user_agent, "FeedbackBot/1.0")
         self.assertEqual(story.ip_address, "127.0.0.1")
+        expected_language = (translation.get_language() or "").split("-")[0]
+        self.assertTrue(story.language_code)
+        self.assertTrue(
+            story.language_code.startswith(expected_language),
+            story.language_code,
+        )
+
+    def test_submission_records_request_language(self):
+        self.client.cookies[settings.LANGUAGE_COOKIE_NAME] = "es"
+        with translation.override("es"):
+            response = self.client.post(
+                self.url,
+                {
+                    "rating": 4,
+                    "comments": "Buena experiencia",
+                    "path": "/es/soporte/",
+                    "take_screenshot": "1",
+                },
+                HTTP_ACCEPT_LANGUAGE="es",
+            )
 
-    def test_anonymous_submission_uses_provided_name(self):
+        self.assertEqual(response.status_code, 200)
+        story = UserStory.objects.get()
+        self.assertEqual(story.language_code, "es")
+
+    def test_superuser_submission_creates_triage_todo(self):
+        Todo.objects.all().delete()
+        superuser = get_user_model().objects.create_superuser(
+            username="overseer", email="overseer@example.com", password="pwd"
+        )
+        Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": "local-node",
+                "address": "127.0.0.1",
+                "port": 8000,
+                "public_endpoint": "local-node",
+            },
+        )
+        self.client.force_login(superuser)
+        comments = "Review analytics dashboard flow"
         response = self.client.post(
             self.url,
             {
-                "name": "Guest Reviewer",
+                "rating": 5,
+                "comments": comments,
+                "path": "/reports/analytics/",
+                "take_screenshot": "0",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(Todo.objects.count(), 1)
+        todo = Todo.objects.get()
+        self.assertEqual(todo.request, f"Triage {comments}")
+        self.assertTrue(todo.is_user_data)
+        self.assertEqual(todo.original_user, superuser)
+        self.assertTrue(todo.original_user_is_authenticated)
+        self.assertEqual(todo.origin_node, Node.get_local())
+
+    def test_screenshot_request_links_saved_sample(self):
+        self.client.force_login(self.user)
+        screenshot_file = Path("/tmp/fake.png")
+        self.mock_capture.return_value = screenshot_file
+        sample = ContentSample.objects.create(kind=ContentSample.IMAGE)
+        self.mock_save.return_value = sample
+
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 5,
+                "comments": "Loved the experience!",
+                "path": "/wizard/step-1/",
+                "take_screenshot": "1",
+            },
+            HTTP_REFERER="https://example.test/wizard/step-1/",
+        )
+
+        self.assertEqual(response.status_code, 200)
+        story = UserStory.objects.get()
+        self.assertEqual(story.screenshot, sample)
+        self.mock_capture.assert_called_once_with("https://example.test/wizard/step-1/")
+        self.mock_save.assert_called_once_with(
+            screenshot_file,
+            method="USER_STORY",
+            user=self.user,
+        )
+
+    def test_anonymous_submission_uses_provided_email(self):
+        response = self.client.post(
+            self.url,
+            {
+                "name": "guest@example.com",
                 "rating": 3,
                 "comments": "It was fine.",
                 "path": "/status/",
@@ -3272,7 +3588,7 @@ class UserStorySubmissionTests(TestCase):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(UserStory.objects.count(), 1)
         story = UserStory.objects.get()
-        self.assertEqual(story.name, "Guest Reviewer")
+        self.assertEqual(story.name, "guest@example.com")
         self.assertIsNone(story.user)
         self.assertIsNone(story.owner)
         self.assertEqual(story.comments, "It was fine.")
@@ -3294,7 +3610,7 @@ class UserStorySubmissionTests(TestCase):
         self.assertFalse(UserStory.objects.exists())
         self.assertIn("rating", data.get("errors", {}))
 
-    def test_anonymous_submission_without_name_uses_fallback(self):
+    def test_anonymous_submission_without_email_returns_errors(self):
         response = self.client.post(
             self.url,
             {
@@ -3304,18 +3620,32 @@ class UserStorySubmissionTests(TestCase):
                 "take_screenshot": "1",
             },
         )
-        self.assertEqual(response.status_code, 200)
-        story = UserStory.objects.get()
-        self.assertEqual(story.name, "Anonymous")
-        self.assertIsNone(story.user)
-        self.assertIsNone(story.owner)
-        self.assertTrue(story.take_screenshot)
-        self.assertEqual(story.status, UserStory.Status.OPEN)
+        self.assertEqual(response.status_code, 400)
+        self.assertFalse(UserStory.objects.exists())
+        data = response.json()
+        self.assertIn("name", data.get("errors", {}))
+
+    def test_anonymous_submission_with_invalid_email_returns_errors(self):
+        response = self.client.post(
+            self.url,
+            {
+                "name": "Guest Reviewer",
+                "rating": 3,
+                "comments": "Needs improvement.",
+                "path": "/feedback/",
+                "take_screenshot": "1",
+            },
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertFalse(UserStory.objects.exists())
+        data = response.json()
+        self.assertIn("name", data.get("errors", {}))
 
     def test_submission_without_screenshot_request(self):
         response = self.client.post(
             self.url,
             {
+                "name": "guest@example.com",
                 "rating": 4,
                 "comments": "Skip the screenshot, please.",
                 "path": "/feedback/",
@@ -3325,9 +3655,14 @@ class UserStorySubmissionTests(TestCase):
         story = UserStory.objects.get()
         self.assertFalse(story.take_screenshot)
         self.assertIsNone(story.owner)
+        self.assertIsNone(story.screenshot)
+        self.assertEqual(story.status, UserStory.Status.OPEN)
+        self.mock_capture.assert_not_called()
+        self.mock_save.assert_not_called()
 
     def test_rate_limit_blocks_repeated_submissions(self):
         payload = {
+            "name": "guest@example.com",
             "rating": 4,
             "comments": "Pretty good",
             "path": "/feedback/",
@@ -3428,6 +3763,8 @@ class UserStoryAdminActionTests(TestCase):
             comments="Helpful notes",
             take_screenshot=True,
         )
+        self.story.language_code = "es"
+        self.story.save(update_fields=["language_code"])
         self.admin = UserStoryAdmin(UserStory, admin.site)
 
     def _build_request(self):
@@ -3461,6 +3798,8 @@ class UserStoryAdminActionTests(TestCase):
         args, kwargs = mock_create_issue.call_args
         self.assertIn("Feedback for", args[0])
         self.assertIn("**Rating:**", args[1])
+        self.assertIn("**Language:**", args[1])
+        self.assertIn("(es)", args[1])
         self.assertEqual(kwargs.get("labels"), ["feedback"])
         self.assertEqual(
             kwargs.get("fingerprint"), f"user-story:{self.story.pk}"

pages/urls.py

@@ -6,6 +6,11 @@ app_name = "pages"
 
 urlpatterns = [
     path("", views.index, name="index"),
+    path(
+        "read/assets/<str:source>/<path:asset>",
+        views.readme_asset,
+        name="readme-asset",
+    ),
     path("read/<path:doc>/edit/", views.readme_edit, name="readme-edit"),
     path("read/", views.readme, name="readme"),
     path("read/<path:doc>", views.readme, name="readme-document"),