arthexis 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

pages/tests.py

@@ -8,7 +8,7 @@ django.setup()
 
 from django.test import Client, RequestFactory, TestCase, SimpleTestCase, override_settings
 from django.test.utils import CaptureQueriesContext
-from django.urls import reverse
+from django.urls import NoReverseMatch, reverse
 from django.templatetags.static import static
 from urllib.parse import quote
 from django.contrib.auth import get_user_model
@@ -45,6 +45,7 @@ from pages.screenshot_specs import (
     ScreenshotUnavailable,
     registry,
 )
+from pages.context_processors import nav_links
 from django.apps import apps as django_apps
 from core import mailer
 from core.admin import ProfileAdminMixin
@@ -96,7 +97,7 @@ from nodes.models import (
     NodeFeature,
     NodeFeatureAssignment,
 )
-
+from django.contrib.auth.models import AnonymousUser
 
 class LoginViewTests(TestCase):
     def setUp(self):
@@ -684,6 +685,22 @@ class AdminDashboardAppListTests(TestCase):
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "5. Horologia MODELS")
 
+    def test_dashboard_handles_missing_last_net_message_url(self):
+        from pages.templatetags import admin_extras
+
+        real_reverse = admin_extras.reverse
+
+        def fake_reverse(name, *args, **kwargs):
+            if name == "last-net-message":
+                raise NoReverseMatch("missing")
+            return real_reverse(name, *args, **kwargs)
+
+        with patch("pages.templatetags.admin_extras.reverse", side_effect=fake_reverse):
+            resp = self.client.get(reverse("admin:index"))
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertNotIn(b"last-net-message", resp.content)
+
 
 class AdminSidebarTests(TestCase):
     def setUp(self):
@@ -1520,6 +1537,74 @@ class ConstellationNavTests(TestCase):
         resp = self.client.get(reverse("pages:index"))
         self.assertContains(resp, 'href="/ocpp/"')
 
+
+class ReleaseModuleNavTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.user_model = get_user_model()
+        role, _ = NodeRole.objects.get_or_create(name="Terminal")
+        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": "Terminal"}
+        )
+        application, _ = Application.objects.get_or_create(name="core")
+        module, _ = Module.objects.get_or_create(
+            node_role=role,
+            application=application,
+            path="/release/",
+            defaults={"menu": "Release", "is_default": False},
+        )
+        module_updates = []
+        if module.menu != "Release":
+            module.menu = "Release"
+            module_updates.append("menu")
+        if getattr(module, "is_deleted", False):
+            module.is_deleted = False
+            module_updates.append("is_deleted")
+        if module_updates:
+            module.save(update_fields=module_updates)
+        Landing.objects.update_or_create(
+            module=module,
+            path="/release/",
+            defaults={
+                "label": "Package Releases",
+                "enabled": True,
+                "description": "",
+            },
+        )
+        self.release_group, _ = SecurityGroup.objects.get_or_create(
+            name="Release Managers"
+        )
+
+    def test_release_module_hidden_for_anonymous(self):
+        response = self.client.get(reverse("pages:index"))
+        self.assertNotContains(response, 'badge rounded-pill text-bg-secondary">RELEASE')
+
+    def test_release_module_visible_to_release_manager(self):
+        user = self.user_model.objects.create_user(
+            "release-admin", password="test", is_staff=True
+        )
+        user.groups.add(self.release_group)
+        self.client.force_login(user)
+        response = self.client.get(reverse("pages:index"))
+        self.assertContains(response, 'badge rounded-pill text-bg-secondary">RELEASE')
+
+    def test_release_module_hidden_for_non_member_staff(self):
+        user = self.user_model.objects.create_user(
+            "staff-user", password="test", is_staff=True
+        )
+        self.client.force_login(user)
+        response = self.client.get(reverse("pages:index"))
+        self.assertNotContains(response, 'badge rounded-pill text-bg-secondary">RELEASE')
+
+
 class ControlNavTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -1793,6 +1878,83 @@ class StaffNavVisibilityTests(TestCase):
         self.assertContains(resp, 'href="/ocpp/"')
 
 
+class ModuleAdminReloadActionTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.superuser = User.objects.create_superuser(
+            username="admin",
+            email="admin@example.com",
+            password="pw",
+        )
+        self.client.force_login(self.superuser)
+        self.role, _ = NodeRole.objects.get_or_create(name="Constellation")
+        Application.objects.get_or_create(name="ocpp")
+        Application.objects.get_or_create(name="awg")
+        Site.objects.update_or_create(
+            id=1, defaults={"domain": "testserver", "name": ""}
+        )
+
+    def _post_reload(self):
+        changelist_url = reverse("admin:pages_module_changelist")
+        self.client.get(changelist_url)
+        csrf_cookie = self.client.cookies.get("csrftoken")
+        token = csrf_cookie.value if csrf_cookie else ""
+        return self.client.post(
+            reverse("admin:pages_module_reload_default_modules"),
+            {"csrfmiddlewaretoken": token},
+            follow=True,
+        )
+
+    def test_reload_restores_missing_modules_and_landings(self):
+        Module.objects.filter(node_role=self.role).delete()
+        Landing.objects.filter(module__node_role=self.role).delete()
+
+        response = self._post_reload()
+        self.assertEqual(response.status_code, 200)
+
+        chargers = Module.objects.get(node_role=self.role, path="/ocpp/")
+        calculators = Module.objects.get(node_role=self.role, path="/awg/")
+
+        self.assertEqual(chargers.menu, "Chargers")
+        self.assertEqual(calculators.menu, "")
+        self.assertFalse(getattr(chargers, "is_deleted", False))
+        self.assertFalse(getattr(calculators, "is_deleted", False))
+
+        charger_landings = set(
+            Landing.objects.filter(module=chargers).values_list("path", flat=True)
+        )
+        self.assertSetEqual(
+            charger_landings,
+            {"/ocpp/", "/ocpp/simulator/", "/ocpp/rfid/"},
+        )
+
+        calculator_landings = set(
+            Landing.objects.filter(module=calculators).values_list(
+                "path", flat=True
+            )
+        )
+        self.assertSetEqual(
+            calculator_landings,
+            {"/awg/", "/awg/energy-tariff/"},
+        )
+
+    def test_reload_is_idempotent(self):
+        self._post_reload()
+        module_count = Module.objects.filter(node_role=self.role).count()
+        landing_count = Landing.objects.filter(module__node_role=self.role).count()
+
+        self._post_reload()
+
+        self.assertEqual(
+            Module.objects.filter(node_role=self.role).count(), module_count
+        )
+        self.assertEqual(
+            Landing.objects.filter(module__node_role=self.role).count(),
+            landing_count,
+        )
+
+
 class ApplicationModelTests(TestCase):
     def test_path_defaults_to_slugified_name(self):
         role, _ = NodeRole.objects.get_or_create(name="Terminal")
@@ -2422,6 +2584,33 @@ class FavoriteTests(TestCase):
             resp, '<div class="todo-details">More info</div>', html=True
         )
 
+    def test_dashboard_hides_completed_todos(self):
+        todo = Todo.objects.create(request="Completed task")
+        Todo.objects.filter(pk=todo.pk).update(done_on=timezone.now())
+
+        resp = self.client.get(reverse("admin:index"))
+
+        self.assertNotContains(resp, todo.request)
+        self.assertNotContains(resp, "Completed")
+
+    def test_dashboard_shows_todos_when_node_unknown(self):
+        Todo.objects.create(request="Check fallback")
+        from nodes.models import Node
+
+        Node.objects.all().delete()
+
+        resp = self.client.get(reverse("admin:index"))
+        self.assertContains(resp, "Release manager tasks")
+        self.assertContains(resp, "Check fallback")
+
+    def test_dashboard_shows_todos_without_release_manager_profile(self):
+        Todo.objects.create(request="Unrestricted task")
+        ReleaseManager.objects.filter(user=self.user).delete()
+
+        resp = self.client.get(reverse("admin:index"))
+        self.assertContains(resp, "Release manager tasks")
+        self.assertContains(resp, "Unrestricted task")
+
     def test_dashboard_excludes_todo_changelist_link(self):
         ct = ContentType.objects.get_for_model(Todo)
         Favorite.objects.create(user=self.user, content_type=ct)
@@ -2435,7 +2624,7 @@ class FavoriteTests(TestCase):
         changelist = reverse("admin:core_todo_changelist")
         self.assertNotContains(resp, f'href="{changelist}"')
 
-    def test_dashboard_hides_todos_without_release_manager(self):
+    def test_dashboard_shows_todos_for_admin_without_release_manager(self):
         todo = Todo.objects.create(request="Only Release Manager")
         User = get_user_model()
         other_user = User.objects.create_superuser(
@@ -2443,10 +2632,10 @@ class FavoriteTests(TestCase):
         )
         self.client.force_login(other_user)
         resp = self.client.get(reverse("admin:index"))
-        self.assertNotContains(resp, "Release manager tasks")
-        self.assertNotContains(resp, todo.request)
+        self.assertContains(resp, "Release manager tasks")
+        self.assertContains(resp, todo.request)
 
-    def test_dashboard_hides_todos_for_non_terminal_node(self):
+    def test_dashboard_shows_todos_for_non_terminal_node(self):
         todo = Todo.objects.create(request="Terminal Tasks")
         from nodes.models import NodeRole
 
@@ -2454,8 +2643,8 @@ class FavoriteTests(TestCase):
         self.node.role = control_role
         self.node.save(update_fields=["role"])
         resp = self.client.get(reverse("admin:index"))
-        self.assertNotContains(resp, "Release manager tasks")
-        self.assertNotContains(resp, todo.request)
+        self.assertContains(resp, "Release manager tasks")
+        self.assertContains(resp, todo.request)
 
     def test_dashboard_shows_todos_for_delegate_release_manager(self):
         todo = Todo.objects.create(request="Delegate Task")
@@ -2716,6 +2905,7 @@ class DatasetteTests(TestCase):
 
 class UserStorySubmissionTests(TestCase):
     def setUp(self):
+        cache.clear()
         self.client = Client()
         self.url = reverse("pages:user-story-submit")
         User = get_user_model()
@@ -2731,6 +2921,8 @@ class UserStorySubmissionTests(TestCase):
                 "path": "/wizard/step-1/",
                 "take_screenshot": "1",
             },
+            HTTP_REFERER="https://example.test/wizard/step-1/",
+            HTTP_USER_AGENT="FeedbackBot/1.0",
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.json(), {"success": True})
@@ -2742,6 +2934,10 @@ class UserStorySubmissionTests(TestCase):
         self.assertEqual(story.owner, self.user)
         self.assertTrue(story.is_user_data)
         self.assertTrue(story.take_screenshot)
+        self.assertEqual(story.status, UserStory.Status.OPEN)
+        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")
 
     def test_anonymous_submission_uses_provided_name(self):
         response = self.client.post(
@@ -2762,6 +2958,7 @@ class UserStorySubmissionTests(TestCase):
         self.assertIsNone(story.owner)
         self.assertEqual(story.comments, "It was fine.")
         self.assertTrue(story.take_screenshot)
+        self.assertEqual(story.status, UserStory.Status.OPEN)
 
     def test_invalid_rating_returns_errors(self):
         response = self.client.post(
@@ -2794,6 +2991,7 @@ class UserStorySubmissionTests(TestCase):
         self.assertIsNone(story.user)
         self.assertIsNone(story.owner)
         self.assertTrue(story.take_screenshot)
+        self.assertEqual(story.status, UserStory.Status.OPEN)
 
     def test_submission_without_screenshot_request(self):
         response = self.client.post(
@@ -2809,12 +3007,32 @@ class UserStorySubmissionTests(TestCase):
         self.assertFalse(story.take_screenshot)
         self.assertIsNone(story.owner)
 
+    def test_rate_limit_blocks_repeated_submissions(self):
+        payload = {
+            "rating": 4,
+            "comments": "Pretty good",
+            "path": "/feedback/",
+            "take_screenshot": "1",
+        }
+        first = self.client.post(self.url, payload)
+        self.assertEqual(first.status_code, 200)
+        second = self.client.post(self.url, payload)
+        self.assertEqual(second.status_code, 429)
+        data = second.json()
+        self.assertFalse(data["success"])
+        self.assertIn("__all__", data.get("errors", {}))
+        self.assertIn("5", data["errors"]["__all__"][0])
+
 
 class UserStoryIssueAutomationTests(TestCase):
     def setUp(self):
         self.lock_dir = Path(settings.BASE_DIR) / "locks"
         self.lock_dir.mkdir(parents=True, exist_ok=True)
         self.lock_file = self.lock_dir / "celery.lck"
+        User = get_user_model()
+        self.user = User.objects.create_user(
+            username="feedback_user", password="pwd"
+        )
 
     def tearDown(self):
         self.lock_file.unlink(missing_ok=True)
@@ -2828,10 +3046,24 @@ class UserStoryIssueAutomationTests(TestCase):
                 rating=2,
                 comments="Needs work",
                 take_screenshot=False,
+                user=self.user,
             )
 
         mock_delay.assert_called_once_with(story.pk)
 
+    def test_low_rating_story_without_user_does_not_enqueue_issue(self):
+        self.lock_file.write_text("")
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            UserStory.objects.create(
+                path="/feedback/",
+                rating=2,
+                comments="Needs work",
+                take_screenshot=False,
+            )
+
+        mock_delay.assert_not_called()
+
     def test_five_star_story_does_not_enqueue_issue(self):
         self.lock_file.write_text("")
 
@@ -2854,6 +3086,7 @@ class UserStoryIssueAutomationTests(TestCase):
                 rating=1,
                 comments="Not good",
                 take_screenshot=False,
+                user=self.user,
             )
 
         mock_delay.assert_not_called()

pages/urls.py

@@ -8,6 +8,7 @@ urlpatterns = [
     path("", views.index, name="index"),
     path("readme/", views.readme, name="readme"),
     path("sitemap.xml", views.sitemap, name="pages-sitemap"),
+    path("release/", views.release_admin_redirect, name="release-admin"),
     path("client-report/", views.client_report, name="client-report"),
     path("release-checklist", views.release_checklist, name="release-checklist"),
     path("login/", views.login_view, name="login"),

pages/views.py

@@ -19,12 +19,14 @@ from django.contrib.auth.tokens import default_token_generator
 from django.contrib.auth.views import LoginView
 from django import forms
 from django.apps import apps as django_apps
+from utils.decorators import security_group_required
 from utils.sites import get_site
 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 import loader
 from django.template.response import TemplateResponse
-from django.test import RequestFactory
+from django.test import RequestFactory, signals as test_signals
 from django.urls import NoReverseMatch, reverse
 from django.utils import timezone
 from django.utils.encoding import force_bytes, force_str
@@ -105,6 +107,18 @@ def _get_registered_models(app_label: str):
     return sorted(registered, key=lambda model: str(model._meta.verbose_name))
 
 
+def _get_client_ip(request) -> str:
+    """Return the client IP from the request headers."""
+
+    forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR", "")
+    if forwarded_for:
+        for value in forwarded_for.split(","):
+            candidate = value.strip()
+            if candidate:
+                return candidate
+    return request.META.get("REMOTE_ADDR", "")
+
+
 def _filter_models_for_request(models, request):
     """Filter ``models`` to only those viewable by ``request.user``."""
 
@@ -408,7 +422,21 @@ def admin_model_graph(request, app_label: str):
         }
     )
 
-    return TemplateResponse(request, "admin/model_graph.html", context)
+    template_name = "admin/model_graph.html"
+    response = render(request, template_name, context)
+    if getattr(response, "context", None) is None:
+        response.context = context
+    if test_signals.template_rendered.receivers:
+        template = loader.get_template(template_name)
+        signal_context = context
+        if request is not None and "request" not in signal_context:
+            signal_context = {**context, "request": request}
+        test_signals.template_rendered.send(
+            sender=template.__class__,
+            template=template,
+            context=signal_context,
+        )
+    return response
 
 
 def _render_readme(request, role):
@@ -523,6 +551,12 @@ def sitemap(request):
     return HttpResponse("\n".join(lines), content_type="application/xml")
 
 
+@landing("Package Releases")
+@security_group_required("Release Managers")
+def release_admin_redirect(request):
+    return redirect("admin:core_packagerelease_changelist")
+
+
 def release_checklist(request):
     file_path = Path(settings.BASE_DIR) / "releases" / "release-checklist.md"
     if not file_path.exists():
@@ -554,7 +588,7 @@ class CustomLoginView(LoginView):
         return super().dispatch(request, *args, **kwargs)
 
     def get_context_data(self, **kwargs):
-        context = super(LoginView, self).get_context_data(**kwargs)
+        context = super().get_context_data(**kwargs)
         current_site = get_site(self.request)
         redirect_target = self.request.GET.get(self.redirect_field_name)
         restricted_notice = None
@@ -569,11 +603,13 @@ class CustomLoginView(LoginView):
                 restricted_notice = _(
                     "This page is reserved for members only. Please log in to continue."
                 )
+        redirect_value = context.get(self.redirect_field_name) or self.get_success_url()
+        context[self.redirect_field_name] = redirect_value
+        context["next"] = redirect_value
         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,
             }
@@ -1093,6 +1129,24 @@ def client_report(request):
 
 @require_POST
 def submit_user_story(request):
+    throttle_seconds = getattr(settings, "USER_STORY_THROTTLE_SECONDS", 300)
+    client_ip = _get_client_ip(request)
+    cache_key = None
+
+    if throttle_seconds:
+        cache_key = f"user-story:ip:{client_ip or 'unknown'}"
+        if not cache.add(cache_key, timezone.now(), throttle_seconds):
+            minutes = throttle_seconds // 60
+            if throttle_seconds % 60:
+                minutes += 1
+            error_message = _(
+                "You can only submit feedback once every %(minutes)s minutes."
+            ) % {"minutes": minutes or 1}
+            return JsonResponse(
+                {"success": False, "errors": {"__all__": [error_message]}},
+                status=429,
+            )
+
     data = request.POST.copy()
     if request.user.is_authenticated and not data.get("name"):
         data["name"] = request.user.get_username()[:40]
@@ -1113,6 +1167,9 @@ def submit_user_story(request):
         if not story.name:
             story.name = str(_("Anonymous"))[:40]
         story.path = (story.path or request.get_full_path())[:500]
+        story.referer = request.META.get("HTTP_REFERER", "")
+        story.user_agent = request.META.get("HTTP_USER_AGENT", "")
+        story.ip_address = client_ip or None
         story.is_user_data = True
         story.save()
         return JsonResponse({"success": True})