arthexis 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

pages/tests.py

@@ -13,10 +13,18 @@ from urllib.parse import quote
 from django.contrib.auth import get_user_model
 from django.contrib.sites.models import Site
 from django.contrib import admin
+from django.contrib.messages.storage.fallback import FallbackStorage
 from django.core.exceptions import DisallowedHost
 import socket
-from pages.models import Application, Module, SiteBadge, Favorite, ViewHistory
-from pages.admin import ApplicationAdmin
+from pages.models import (
+    Application,
+    Module,
+    SiteBadge,
+    Favorite,
+    ViewHistory,
+    UserStory,
+)
+from pages.admin import ApplicationAdmin, UserStoryAdmin, ViewHistoryAdmin
 from pages.screenshot_specs import (
     ScreenshotSpec,
     ScreenshotSpecRunner,
@@ -33,6 +41,7 @@ from core.models import (
     Reference,
     ReleaseManager,
     Todo,
+    TOTPDeviceSettings,
 )
 from django.core.files.uploadedfile import SimpleUploadedFile
 import base64
@@ -41,12 +50,18 @@ import shutil
 from io import StringIO
 from django.conf import settings
 from pathlib import Path
-from unittest.mock import patch, Mock
+from unittest.mock import MagicMock, Mock, patch
 from types import SimpleNamespace
 from django.core.management import call_command
 import re
 from django.contrib.contenttypes.models import ContentType
-from datetime import date, timedelta
+from datetime import (
+    date,
+    datetime,
+    time as datetime_time,
+    timedelta,
+    timezone as datetime_timezone,
+)
 from django.core import mail
 from django.utils import timezone
 from django.utils.text import slugify
@@ -84,6 +99,14 @@ class LoginViewTests(TestCase):
         resp = self.client.get(reverse("pages:login"))
         self.assertContains(resp, "Use Authenticator app")
 
+    def test_cp_simulator_redirect_shows_restricted_message(self):
+        simulator_path = reverse("cp-simulator")
+        resp = self.client.get(f"{reverse('pages:login')}?next={simulator_path}")
+        self.assertContains(
+            resp,
+            "This page is reserved for members only. Please log in to continue.",
+        )
+
     def test_staff_login_redirects_admin(self):
         resp = self.client.post(
             reverse("pages:login"),
@@ -303,6 +326,15 @@ class AuthenticatorSetupTests(TestCase):
         self.assertIn(label, config_url)
         self.assertIn(f"issuer={quote(settings.OTP_TOTP_ISSUER)}", config_url)
 
+    def test_device_config_url_uses_custom_issuer_when_available(self):
+        self.client.post(reverse("pages:authenticator-setup"), {"action": "generate"})
+        device = TOTPDevice.objects.get(user=self.staff)
+        TOTPDeviceSettings.objects.create(device=device, issuer="Custom Co")
+        config_url = device.config_url
+        quoted_issuer = quote("Custom Co")
+        self.assertIn(quoted_issuer, config_url)
+        self.assertIn(f"issuer={quoted_issuer}", config_url)
+
     def test_pending_device_context_includes_qr(self):
         self.client.post(reverse("pages:authenticator-setup"), {"action": "generate"})
         resp = self.client.get(reverse("pages:authenticator-setup"))
@@ -731,6 +763,7 @@ class ViewHistoryAdminTests(TestCase):
         self.assertContains(resp, static("core/vendor/chart.umd.min.js"))
 
     def test_graph_data_endpoint(self):
+        ViewHistory.all_objects.all().delete()
         self._create_history("/", count=2)
         self._create_history("/about/", days_offset=1)
         url = reverse("admin:pages_viewhistory_traffic_data")
@@ -746,6 +779,44 @@ class ViewHistoryAdminTests(TestCase):
         self.assertEqual(totals.get("/"), 2)
         self.assertEqual(totals.get("/about/"), 1)
 
+    def test_graph_data_includes_late_evening_visits(self):
+        target_date = date(2025, 9, 27)
+        entry = ViewHistory.objects.create(
+            path="/late/",
+            method="GET",
+            status_code=200,
+            status_text="OK",
+            error_message="",
+            view_name="pages:index",
+        )
+        local_evening = datetime.combine(target_date, datetime_time(21, 30))
+        aware_evening = timezone.make_aware(
+            local_evening, timezone.get_current_timezone()
+        )
+        entry.visited_at = aware_evening.astimezone(datetime_timezone.utc)
+        entry.save(update_fields=["visited_at"])
+
+        url = reverse("admin:pages_viewhistory_traffic_data")
+        with patch("pages.admin.timezone.localdate", return_value=target_date):
+            resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        data = resp.json()
+        totals = {
+            dataset["label"]: sum(dataset["data"]) for dataset in data["datasets"]
+        }
+        self.assertEqual(totals.get("/late/"), 1)
+
+    def test_graph_data_filters_using_datetime_range(self):
+        admin_view = ViewHistoryAdmin(ViewHistory, admin.site)
+        with patch.object(ViewHistory.objects, "filter") as mock_filter:
+            mock_queryset = mock_filter.return_value
+            mock_queryset.exists.return_value = False
+            admin_view._build_chart_data()
+
+        kwargs = mock_filter.call_args.kwargs
+        self.assertIn("visited_at__gte", kwargs)
+        self.assertIn("visited_at__lt", kwargs)
+
     def test_admin_index_displays_widget(self):
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "viewhistory-mini-module")
@@ -1042,9 +1113,9 @@ class PowerNavTests(TestCase):
             node_role=role, application=awg_app, path="/awg/"
         )
         awg_module.create_landings()
-        man_app, _ = Application.objects.get_or_create(name="man")
+        manuals_app, _ = Application.objects.get_or_create(name="pages")
         man_module, _ = Module.objects.get_or_create(
-            node_role=role, application=man_app, path="/man/"
+            node_role=role, application=manuals_app, path="/man/"
         )
         man_module.create_landings()
         User = get_user_model()
@@ -1070,7 +1141,7 @@ class PowerNavTests(TestCase):
                 manuals_module = module
                 break
         self.assertIsNotNone(manuals_module)
-        self.assertEqual(manuals_module.menu_label.upper(), "MANUALS")
+        self.assertEqual(manuals_module.menu_label.upper(), "MANUAL")
         landing_labels = {landing.label for landing in manuals_module.enabled_landings}
         self.assertIn("Manuals", landing_labels)
 
@@ -1163,6 +1234,13 @@ class ApplicationAdminDisplayTests(TestCase):
         config = django_apps.get_app_config("ocpp")
         self.assertContains(resp, config.verbose_name)
 
+    def test_changelist_shows_description(self):
+        Application.objects.create(
+            name="awg", description="Power, Energy and Cost calculations."
+        )
+        resp = self.client.get(reverse("admin:pages_application_changelist"))
+        self.assertContains(resp, "Power, Energy and Cost calculations.")
+
 
 class LandingCreationTests(TestCase):
     def setUp(self):
@@ -1231,8 +1309,16 @@ class RFIDPageTests(TestCase):
         Site.objects.update_or_create(
             id=1, defaults={"domain": "testserver", "name": "pages"}
         )
+        User = get_user_model()
+        self.user = User.objects.create_user("rfid-user", password="pwd")
 
-    def test_page_renders(self):
+    def test_page_redirects_when_anonymous(self):
+        resp = self.client.get(reverse("rfid-reader"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
+    def test_page_renders_for_authenticated_user(self):
+        self.client.force_login(self.user)
         resp = self.client.get(reverse("rfid-reader"))
         self.assertContains(resp, "Scanner ready")
 
@@ -1324,6 +1410,29 @@ class FaviconTests(TestCase):
             )
             self.assertContains(resp, b64)
 
+    def test_control_nodes_use_purple_favicon(self):
+        with override_settings(MEDIA_ROOT=self.tmpdir):
+            role, _ = NodeRole.objects.get_or_create(name="Control")
+            Node.objects.update_or_create(
+                mac_address=Node.get_current_mac(),
+                defaults={
+                    "hostname": "localhost",
+                    "address": "127.0.0.1",
+                    "role": role,
+                },
+            )
+            Site.objects.update_or_create(
+                id=1, defaults={"domain": "testserver", "name": ""}
+            )
+            resp = self.client.get(reverse("pages:index"))
+            b64 = (
+                Path(settings.BASE_DIR)
+                .joinpath("pages", "fixtures", "data", "favicon_control.txt")
+                .read_text()
+                .strip()
+            )
+            self.assertContains(resp, b64)
+
 
 class FavoriteTests(TestCase):
     def setUp(self):
@@ -1712,6 +1821,170 @@ class DatasetteTests(TestCase):
             lock_file.unlink(missing_ok=True)
 
 
+class UserStorySubmissionTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.url = reverse("pages:user-story-submit")
+        User = get_user_model()
+        self.user = User.objects.create_user(username="feedbacker", password="pwd")
+
+    def test_authenticated_submission_defaults_to_username(self):
+        self.client.force_login(self.user)
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 5,
+                "comments": "Loved the experience!",
+                "path": "/wizard/step-1/",
+                "take_screenshot": "1",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json(), {"success": True})
+        story = UserStory.objects.get()
+        self.assertEqual(story.name, "feedbacker")
+        self.assertEqual(story.rating, 5)
+        self.assertEqual(story.path, "/wizard/step-1/")
+        self.assertEqual(story.user, self.user)
+        self.assertEqual(story.owner, self.user)
+        self.assertTrue(story.is_user_data)
+        self.assertTrue(story.take_screenshot)
+
+    def test_anonymous_submission_uses_provided_name(self):
+        response = self.client.post(
+            self.url,
+            {
+                "name": "Guest Reviewer",
+                "rating": 3,
+                "comments": "It was fine.",
+                "path": "/status/",
+                "take_screenshot": "on",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(UserStory.objects.count(), 1)
+        story = UserStory.objects.get()
+        self.assertEqual(story.name, "Guest Reviewer")
+        self.assertIsNone(story.user)
+        self.assertIsNone(story.owner)
+        self.assertEqual(story.comments, "It was fine.")
+        self.assertTrue(story.take_screenshot)
+
+    def test_invalid_rating_returns_errors(self):
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 7,
+                "comments": "Way off the scale",
+                "path": "/feedback/",
+                "take_screenshot": "1",
+            },
+        )
+        self.assertEqual(response.status_code, 400)
+        data = response.json()
+        self.assertFalse(UserStory.objects.exists())
+        self.assertIn("rating", data.get("errors", {}))
+
+    def test_anonymous_submission_without_name_uses_fallback(self):
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 2,
+                "comments": "Could be better.",
+                "path": "/feedback/",
+                "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)
+
+    def test_submission_without_screenshot_request(self):
+        response = self.client.post(
+            self.url,
+            {
+                "rating": 4,
+                "comments": "Skip the screenshot, please.",
+                "path": "/feedback/",
+            },
+        )
+        self.assertEqual(response.status_code, 200)
+        story = UserStory.objects.get()
+        self.assertFalse(story.take_screenshot)
+        self.assertIsNone(story.owner)
+
+
+class UserStoryAdminActionTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.factory = RequestFactory()
+        User = get_user_model()
+        self.admin_user = User.objects.create_superuser(
+            username="admin",
+            email="admin@example.com",
+            password="pwd",
+        )
+        self.story = UserStory.objects.create(
+            path="/",
+            name="Feedback",
+            rating=4,
+            comments="Helpful notes",
+            take_screenshot=True,
+        )
+        self.admin = UserStoryAdmin(UserStory, admin.site)
+
+    def _build_request(self):
+        request = self.factory.post("/admin/pages/userstory/")
+        request.user = self.admin_user
+        request.session = self.client.session
+        setattr(request, "_messages", FallbackStorage(request))
+        return request
+
+    @patch("pages.models.github_issues.create_issue")
+    def test_create_github_issues_action_updates_issue_fields(self, mock_create_issue):
+        response = MagicMock()
+        response.json.return_value = {
+            "html_url": "https://github.com/example/repo/issues/123",
+            "number": 123,
+        }
+        mock_create_issue.return_value = response
+
+        request = self._build_request()
+        queryset = UserStory.objects.filter(pk=self.story.pk)
+        self.admin.create_github_issues(request, queryset)
+
+        self.story.refresh_from_db()
+        self.assertEqual(self.story.github_issue_number, 123)
+        self.assertEqual(
+            self.story.github_issue_url,
+            "https://github.com/example/repo/issues/123",
+        )
+
+        mock_create_issue.assert_called_once()
+        args, kwargs = mock_create_issue.call_args
+        self.assertIn("Feedback for", args[0])
+        self.assertIn("**Rating:**", args[1])
+        self.assertEqual(kwargs.get("labels"), ["feedback"])
+        self.assertEqual(
+            kwargs.get("fingerprint"), f"user-story:{self.story.pk}"
+        )
+
+    @patch("pages.models.github_issues.create_issue")
+    def test_create_github_issues_action_skips_existing_issue(self, mock_create_issue):
+        self.story.github_issue_url = "https://github.com/example/repo/issues/5"
+        self.story.github_issue_number = 5
+        self.story.save(update_fields=["github_issue_url", "github_issue_number"])
+
+        request = self._build_request()
+        queryset = UserStory.objects.filter(pk=self.story.pk)
+        self.admin.create_github_issues(request, queryset)
+
+        mock_create_issue.assert_not_called()
+
+
 class ClientReportLiveUpdateTests(TestCase):
     def setUp(self):
         self.client = Client()

pages/urls.py

@@ -18,4 +18,8 @@ urlpatterns = [
         name="invitation-login",
     ),
     path("datasette-auth/", views.datasette_auth, name="datasette-auth"),
+    path("man/", views.manual_list, name="manual-list"),
+    path("man/<slug:slug>/", views.manual_detail, name="manual-detail"),
+    path("man/<slug:slug>/pdf/", views.manual_pdf, name="manual-pdf"),
+    path("feedback/user-story/", views.submit_user_story, name="user-story-submit"),
 ]

pages/views.py

@@ -1,12 +1,14 @@
 import base64
 import logging
 from pathlib import Path
+from types import SimpleNamespace
 import datetime
 import calendar
 import io
 import shutil
 import re
 from html import escape
+from urllib.parse import urlparse
 
 from django.conf import settings
 from django.contrib import admin
@@ -18,10 +20,11 @@ from django.contrib.auth.views import LoginView
 from django import forms
 from django.apps import apps as django_apps
 from utils.sites import get_site
-from django.http import Http404, HttpResponse
-from django.shortcuts import redirect, render
+from django.http import Http404, HttpResponse, JsonResponse
+from django.shortcuts import get_object_or_404, redirect, render
 from nodes.models import Node
 from django.template.response import TemplateResponse
+from django.test import RequestFactory
 from django.urls import NoReverseMatch, reverse
 from django.utils import timezone
 from django.utils.encoding import force_bytes, force_str
@@ -30,6 +33,7 @@ from core import mailer, public_wifi
 from core.backends import TOTP_DEVICE_NAME
 from django.utils.translation import gettext as _
 from django.views.decorators.csrf import csrf_exempt, ensure_csrf_cookie
+from django.views.decorators.http import require_POST
 from django.core.cache import cache
 from django.views.decorators.cache import never_cache
 from django.utils.cache import patch_vary_headers
@@ -47,13 +51,41 @@ except ImportError:  # pragma: no cover - handled gracefully in views
     CalledProcessError = ExecutableNotFound = None
 
 import markdown
+
+
+MARKDOWN_EXTENSIONS = ["toc", "tables", "mdx_truly_sane_lists"]
+
+
+def _render_markdown_with_toc(text: str) -> tuple[str, str]:
+    """Render ``text`` to HTML and return the HTML and stripped TOC."""
+
+    md = markdown.Markdown(extensions=MARKDOWN_EXTENSIONS)
+    html = md.convert(text)
+    toc_html = md.toc
+    toc_html = _strip_toc_wrapper(toc_html)
+    return html, toc_html
+
+
+def _strip_toc_wrapper(toc_html: str) -> str:
+    """Normalize ``markdown``'s TOC output by removing the wrapper ``div``."""
+
+    toc_html = toc_html.strip()
+    if toc_html.startswith('<div class="toc">'):
+        toc_html = toc_html[len('<div class="toc">') :]
+        if toc_html.endswith("</div>"):
+            toc_html = toc_html[: -len("</div>")]
+    return toc_html.strip()
 from pages.utils import landing
 from core.liveupdate import live_update
 from django_otp import login as otp_login
 from django_otp.plugins.otp_totp.models import TOTPDevice
 import qrcode
-from .forms import AuthenticatorEnrollmentForm, AuthenticatorLoginForm
-from .models import Module
+from .forms import (
+    AuthenticatorEnrollmentForm,
+    AuthenticatorLoginForm,
+    UserStoryForm,
+)
+from .models import Module, UserManual, UserStory
 
 
 logger = logging.getLogger(__name__)
@@ -407,14 +439,7 @@ def index(request):
         candidates.append(root_base / "README.md")
     readme_file = next((p for p in candidates if p.exists()), root_base / "README.md")
     text = readme_file.read_text(encoding="utf-8")
-    md = markdown.Markdown(extensions=["toc", "tables"])
-    html = md.convert(text)
-    toc_html = md.toc
-    if toc_html.strip().startswith('<div class="toc">'):
-        toc_html = toc_html.strip()[len('<div class="toc">') :]
-        if toc_html.endswith("</div>"):
-            toc_html = toc_html[: -len("</div>")]
-        toc_html = toc_html.strip()
+    html, toc_html = _render_markdown_with_toc(text)
     title = "README" if readme_file.name.startswith("README") else readme_file.stem
     context = {"content": html, "title": title, "toc": toc_html}
     response = render(request, "pages/readme.html", context)
@@ -447,14 +472,7 @@ def release_checklist(request):
     if not file_path.exists():
         raise Http404("Release checklist not found")
     text = file_path.read_text(encoding="utf-8")
-    md = markdown.Markdown(extensions=["toc", "tables"])
-    html = md.convert(text)
-    toc_html = md.toc
-    if toc_html.strip().startswith('<div class="toc">'):
-        toc_html = toc_html.strip()[len('<div class="toc">') :]
-        if toc_html.endswith("</div>"):
-            toc_html = toc_html[: -len("</div>")]
-        toc_html = toc_html.strip()
+    html, toc_html = _render_markdown_with_toc(text)
     context = {"content": html, "title": "Release Checklist", "toc": toc_html}
     response = render(request, "pages/readme.html", context)
     patch_vary_headers(response, ["Accept-Language", "Cookie"])
@@ -482,12 +500,26 @@ class CustomLoginView(LoginView):
     def get_context_data(self, **kwargs):
         context = super(LoginView, self).get_context_data(**kwargs)
         current_site = get_site(self.request)
+        redirect_target = self.request.GET.get(self.redirect_field_name)
+        restricted_notice = None
+        if redirect_target:
+            parsed_target = urlparse(redirect_target)
+            target_path = parsed_target.path or redirect_target
+            try:
+                simulator_path = reverse("cp-simulator")
+            except NoReverseMatch:  # pragma: no cover - simulator may be uninstalled
+                simulator_path = None
+            if simulator_path and target_path.startswith(simulator_path):
+                restricted_notice = _(
+                    "This page is reserved for members only. Please log in to continue."
+                )
         context.update(
             {
                 "site": current_site,
                 "site_name": getattr(current_site, "name", ""),
                 "next": self.get_success_url(),
                 "can_request_invite": mailer.can_send_email(),
+                "restricted_notice": restricted_notice,
             }
         )
         return context
@@ -709,11 +741,14 @@ def request_invite(request):
                 try:
                     node_error = None
                     node = Node.get_local()
+                    outbox = getattr(node, "email_outbox", None) if node else None
                     if node:
                         try:
                             result = node.send_mail(subject, body, [email])
+                            lead.sent_via_outbox = outbox
                         except Exception as exc:
                             node_error = exc
+                            lead.sent_via_outbox = None
                             logger.exception(
                                 "Node send_mail failed, falling back to default backend"
                             )
@@ -724,6 +759,7 @@ def request_invite(request):
                         result = mailer.send(
                             subject, body, [email], settings.DEFAULT_FROM_EMAIL
                         )
+                        lead.sent_via_outbox = None
                     lead.sent_on = timezone.now()
                     if node_error:
                         lead.error = (
@@ -738,9 +774,10 @@ def request_invite(request):
                     )
                 except Exception as exc:
                     lead.error = f"{exc}. Ensure the email service is reachable and settings are correct."
+                    lead.sent_via_outbox = None
                     logger.exception("Failed to send invitation email to %s", email)
             if lead.sent_on or lead.error:
-                lead.save(update_fields=["sent_on", "error"])
+                lead.save(update_fields=["sent_on", "error", "sent_via_outbox"])
             sent = True
     return render(request, "pages/request_invite.html", {"form": form, "sent": sent})
 
@@ -998,7 +1035,86 @@ def client_report(request):
     return render(request, "pages/client_report.html", context)
 
 
+@require_POST
+def submit_user_story(request):
+    data = request.POST.copy()
+    if request.user.is_authenticated and not data.get("name"):
+        data["name"] = request.user.get_username()[:40]
+    if not data.get("path"):
+        data["path"] = request.get_full_path()
+
+    form = UserStoryForm(data)
+    if request.user.is_authenticated:
+        form.instance.user = request.user
+
+    if form.is_valid():
+        story = form.save(commit=False)
+        if request.user.is_authenticated:
+            story.user = request.user
+            story.owner = request.user
+            if not story.name:
+                story.name = request.user.get_username()[:40]
+        if not story.name:
+            story.name = str(_("Anonymous"))[:40]
+        story.path = (story.path or request.get_full_path())[:500]
+        story.is_user_data = True
+        story.save()
+        return JsonResponse({"success": True})
+
+    return JsonResponse({"success": False, "errors": form.errors}, status=400)
+
+
 def csrf_failure(request, reason=""):
     """Custom CSRF failure view with a friendly message."""
     logger.warning("CSRF failure on %s: %s", request.path, reason)
     return render(request, "pages/csrf_failure.html", status=403)
+
+
+def _admin_context(request):
+    context = admin.site.each_context(request)
+    if not context.get("has_permission"):
+        rf = RequestFactory()
+        mock_request = rf.get(request.path)
+        mock_request.user = SimpleNamespace(
+            is_active=True,
+            is_staff=True,
+            is_superuser=True,
+            has_perm=lambda perm, obj=None: True,
+            has_module_perms=lambda app_label: True,
+        )
+        context["available_apps"] = admin.site.get_app_list(mock_request)
+        context["has_permission"] = True
+    return context
+
+
+def admin_manual_list(request):
+    manuals = UserManual.objects.order_by("title")
+    context = _admin_context(request)
+    context["manuals"] = manuals
+    return render(request, "admin_doc/manuals.html", context)
+
+
+def admin_manual_detail(request, slug):
+    manual = get_object_or_404(UserManual, slug=slug)
+    context = _admin_context(request)
+    context["manual"] = manual
+    return render(request, "admin_doc/manual_detail.html", context)
+
+
+def manual_pdf(request, slug):
+    manual = get_object_or_404(UserManual, slug=slug)
+    pdf_data = base64.b64decode(manual.content_pdf)
+    response = HttpResponse(pdf_data, content_type="application/pdf")
+    response["Content-Disposition"] = f'attachment; filename="{manual.slug}.pdf"'
+    return response
+
+
+@landing(_("Manuals"))
+def manual_list(request):
+    manuals = UserManual.objects.order_by("title")
+    return render(request, "pages/manual_list.html", {"manuals": manuals})
+
+
+def manual_detail(request, slug):
+    manual = get_object_or_404(UserManual, slug=slug)
+    return render(request, "pages/manual_detail.html", {"manual": manual})