arthexis 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

pages/tests.py

@@ -7,6 +7,7 @@ import django
 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.templatetags.static import static
 from urllib.parse import quote
@@ -15,7 +16,10 @@ 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
+from django.core.cache import cache
+from django.db import connection
 import socket
+from django.db import connection
 from pages.models import (
     Application,
     Landing,
@@ -41,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
@@ -62,7 +67,7 @@ import shutil
 from io import StringIO
 from django.conf import settings
 from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import MagicMock, Mock, call, patch
 from types import SimpleNamespace
 from django.core.management import call_command
 import re
@@ -92,7 +97,7 @@ from nodes.models import (
     NodeFeature,
     NodeFeatureAssignment,
 )
-
+from django.contrib.auth.models import AnonymousUser
 
 class LoginViewTests(TestCase):
     def setUp(self):
@@ -706,6 +711,32 @@ class ViewHistoryLoggingTests(TestCase):
     def setUp(self):
         self.client = Client()
         Site.objects.update_or_create(id=1, defaults={"name": "Terminal"})
+        self.addCleanup(self._reset_purge_task)
+
+    def _reset_purge_task(self):
+        from django_celery_beat.models import PeriodicTask
+
+        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+
+    def _create_local_node(self):
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "base_path": settings.BASE_DIR,
+                "port": 8000,
+            },
+        )
+        return node
+
+    def _enable_celery_feature(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        return node
 
     def test_successful_visit_creates_entry(self):
         resp = self.client.get(reverse("pages:index"))
@@ -750,6 +781,8 @@ class ViewHistoryLoggingTests(TestCase):
         self.assertEqual(user.last_visit_ip_address, "203.0.113.5")
 
     def test_landing_visit_records_lead(self):
+        self._enable_celery_feature()
+
         role = NodeRole.objects.create(name="landing-role")
         application = Application.objects.create(
             name="landing-tests-app", description=""
@@ -774,6 +807,26 @@ class ViewHistoryLoggingTests(TestCase):
         self.assertEqual(lead.path, "/")
         self.assertEqual(lead.referer, "https://example.com/ref")
 
+    def test_landing_visit_does_not_record_lead_without_celery(self):
+        role = NodeRole.objects.create(name="no-celery-role")
+        application = Application.objects.create(
+            name="no-celery-app", description=""
+        )
+        module = Module.objects.create(
+            node_role=role,
+            application=application,
+            path="/",
+            menu="Landing",
+        )
+        landing = module.landings.get(path="/")
+        landing.label = "No Celery"
+        landing.save(update_fields=["label"])
+
+        resp = self.client.get(reverse("pages:index"))
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertFalse(LandingLead.objects.exists())
+
     def test_disabled_landing_does_not_record_lead(self):
         role = NodeRole.objects.create(name="landing-role-disabled")
         application = Application.objects.create(
@@ -894,6 +947,93 @@ class ViewHistoryAdminTests(TestCase):
         self.assertContains(resp, static("core/vendor/chart.umd.min.js"))
 
 
+class LandingLeadAdminTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="lead_admin", password="pwd", email="lead@example.com"
+        )
+        self.client.force_login(self.admin)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "test", "domain": "testserver"}
+        )
+        self.node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "base_path": settings.BASE_DIR,
+                "port": 8000,
+            },
+        )
+        self.node.features.clear()
+        self.addCleanup(self._reset_purge_task)
+
+    def _reset_purge_task(self):
+        from django_celery_beat.models import PeriodicTask
+
+        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+
+    def test_changelist_warns_without_celery(self):
+        url = reverse("admin:pages_landinglead_changelist")
+        response = self.client.get(url)
+        self.assertContains(
+            response,
+            "Landing leads are not being recorded because Celery is not running on this node.",
+        )
+
+    def test_changelist_no_warning_with_celery(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=self.node, feature=feature)
+        url = reverse("admin:pages_landinglead_changelist")
+        response = self.client.get(url)
+        self.assertNotContains(
+            response,
+            "Landing leads are not being recorded because Celery is not running on this node.",
+        )
+
+
+class LandingLeadTaskTests(TestCase):
+    def setUp(self):
+        self.role = NodeRole.objects.create(name="lead-task-role")
+        self.application = Application.objects.create(
+            name="lead-task-app", description=""
+        )
+        self.module = Module.objects.create(
+            node_role=self.role,
+            application=self.application,
+            path="/tasks",
+            menu="Landing",
+        )
+        self.landing = Landing.objects.create(
+            module=self.module,
+            path="/tasks/",
+            label="Tasks Landing",
+            enabled=True,
+        )
+
+    def test_purge_expired_landing_leads_removes_old_records(self):
+        from pages.tasks import purge_expired_landing_leads
+
+        stale = LandingLead.objects.create(landing=self.landing, path="/tasks/")
+        recent = LandingLead.objects.create(landing=self.landing, path="/tasks/")
+        LandingLead.objects.filter(pk=stale.pk).update(
+            created_on=timezone.now() - timedelta(days=31)
+        )
+        LandingLead.objects.filter(pk=recent.pk).update(
+            created_on=timezone.now() - timedelta(days=5)
+        )
+
+        deleted = purge_expired_landing_leads()
+
+        self.assertEqual(deleted, 1)
+        self.assertFalse(LandingLead.objects.filter(pk=stale.pk).exists())
+        self.assertTrue(LandingLead.objects.filter(pk=recent.pk).exists())
+
+
 class LogViewerAdminTests(SimpleTestCase):
     def setUp(self):
         self.factory = RequestFactory()
@@ -1092,6 +1232,45 @@ class SiteAdminScreenshotTests(TestCase):
         mock_capture.assert_called_once_with("http://testserver/")
 
 
+class SiteAdminReloadFixturesTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="fixture-admin", password="pwd", email="admin@example.com"
+        )
+        self.client.force_login(self.admin)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "Terminal", "domain": "testserver"}
+        )
+
+    @patch("pages.admin.call_command")
+    def test_reload_site_fixtures_action(self, mock_call_command):
+        response = self.client.post(
+            reverse("admin:pages_siteproxy_changelist"),
+            {"action": "reload_site_fixtures", "_selected_action": [1]},
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+
+        fixtures_dir = Path(settings.BASE_DIR) / "core" / "fixtures"
+        expected = sorted(fixtures_dir.glob("references__00_site_*.json"))
+        sigil_fixture = fixtures_dir / "sigil_roots__site.json"
+        if sigil_fixture.exists():
+            expected.append(sigil_fixture)
+
+        expected_calls = [
+            call("loaddata", str(path), verbosity=0) for path in expected
+        ]
+        self.assertEqual(mock_call_command.call_args_list, expected_calls)
+
+        if expected_calls:
+            self.assertContains(
+                response,
+                f"Reloaded {len(expected_calls)} site fixtures.",
+            )
+
+
 class AdminBadgesWebsiteTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -1342,6 +1521,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()
@@ -1358,6 +1605,12 @@ class ControlNavTests(TestCase):
             id=1, defaults={"domain": "testserver", "name": ""}
         )
         fixtures = [
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "default__application_pages.json",
+            ),
             Path(
                 settings.BASE_DIR,
                 "pages",
@@ -1388,6 +1641,18 @@ class ControlNavTests(TestCase):
                 "fixtures",
                 "control__landing_ocpp_rfid.json",
             ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "control__module_readme.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "control__landing_readme.json",
+            ),
         ]
         call_command("loaddata", *map(str, fixtures))
 
@@ -1428,6 +1693,84 @@ class ControlNavTests(TestCase):
         self.assertFalse(resp.context["header_references"])
         self.assertNotContains(resp, "https://example.com/hidden")
 
+    def test_readme_pill_visible(self):
+        resp = self.client.get(reverse("pages:readme"))
+        self.assertContains(resp, 'href="/readme/"')
+        self.assertContains(resp, 'badge rounded-pill text-bg-secondary">README')
+
+
+class SatelliteNavTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        role, _ = NodeRole.objects.get_or_create(name="Satellite")
+        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": ""}
+        )
+        fixtures = [
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "default__application_pages.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__application_ocpp.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__module_ocpp.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_ocpp_dashboard.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_ocpp_cp_simulator.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_ocpp_rfid.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__module_readme.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_readme.json",
+            ),
+        ]
+        call_command("loaddata", *map(str, fixtures))
+
+    def test_readme_pill_visible(self):
+        resp = self.client.get(reverse("pages:readme"))
+        self.assertContains(resp, 'href="/readme/"')
+        self.assertContains(resp, 'badge rounded-pill text-bg-secondary">README')
+
 
 class PowerNavTests(TestCase):
     def setUp(self):
@@ -1519,6 +1862,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")
@@ -2069,6 +2489,40 @@ class FavoriteTests(TestCase):
         self.assertNotIn("Packages", labels)
         ContentType.objects.clear_cache()
 
+    def test_future_action_items_limits_user_data_queries(self):
+        from pages.templatetags import admin_extras
+
+        cache.delete(admin_extras.USER_DATA_MODELS_CACHE_KEY)
+        self.addCleanup(cache.delete, admin_extras.USER_DATA_MODELS_CACHE_KEY)
+
+        for index in range(3):
+            NodeRole.objects.create(name=f"CachedRole{index}", is_user_data=True)
+        for index in range(2):
+            NodeFeature.objects.create(
+                slug=f"cached-feature-{index}",
+                display=f"Feature {index}",
+                is_user_data=True,
+            )
+
+        Node.objects.create(
+            hostname="cached-node",
+            address="127.0.0.1",
+            mac_address="AA:BB:CC:DD:EE:FF",
+            port=8000,
+            is_user_data=True,
+        )
+
+        response = self.client.get(reverse("admin:index"))
+        request = response.wsgi_request
+
+        admin_extras.future_action_items({"request": request})
+        with CaptureQueriesContext(connection) as ctx:
+            admin_extras.future_action_items({"request": request})
+
+        # History and favorites queries should remain bounded regardless of the
+        # number of Entity subclasses with user data.
+        self.assertLessEqual(len(ctx.captured_queries), 4)
+
     def test_favorite_ct_id_recreates_missing_content_type(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
         ct.delete()
@@ -2114,6 +2568,24 @@ class FavoriteTests(TestCase):
             resp, '<div class="todo-details">More info</div>', html=True
         )
 
+    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)
@@ -2127,7 +2599,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(
@@ -2135,10 +2607,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
 
@@ -2146,8 +2618,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")
@@ -2172,6 +2644,62 @@ class FavoriteTests(TestCase):
         self.assertContains(resp, todo.request)
 
 
+class AdminIndexQueryRegressionTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.client = Client()
+        self.user = User.objects.create_superuser(
+            username="queryadmin", password="pwd", email="query@example.com"
+        )
+        self.client.force_login(self.user)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "test", "domain": "testserver"}
+        )
+        favorite_cts = [
+            ContentType.objects.get_for_model(Application),
+            ContentType.objects.get_for_model(Landing),
+        ]
+        for ct in favorite_cts:
+            Favorite.objects.create(user=self.user, content_type=ct)
+
+    def _render_admin_and_count_queries(self):
+        url = reverse("admin:index")
+        with CaptureQueriesContext(connection) as ctx:
+            response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        sql_statements = [query["sql"].lower() for query in ctx.captured_queries]
+        ct_queries = [sql for sql in sql_statements if '"django_content_type"' in sql]
+        favorite_queries = [sql for sql in sql_statements if '"pages_favorite"' in sql]
+        return len(ct_queries), len(favorite_queries)
+
+    def test_admin_index_queries_constant_with_more_models(self):
+        site = admin.site
+        original_registry = site._registry.copy()
+        registry_items = list(original_registry.items())
+        if len(registry_items) < 2:
+            self.skipTest("Not enough registered admin models for regression test")
+
+        for model in original_registry.keys():
+            ContentType.objects.get_for_model(model)
+
+        try:
+            site._registry = dict(registry_items[:1])
+            baseline_ct_queries, baseline_favorite_queries = (
+                self._render_admin_and_count_queries()
+            )
+
+            expanded_limit = min(len(registry_items), 5)
+            site._registry = dict(registry_items[:expanded_limit])
+            expanded_ct_queries, expanded_favorite_queries = (
+                self._render_admin_and_count_queries()
+            )
+        finally:
+            site._registry = original_registry
+
+        self.assertEqual(expanded_ct_queries, baseline_ct_queries)
+        self.assertEqual(expanded_favorite_queries, baseline_favorite_queries)
+
+
 class AdminActionListTests(TestCase):
     def setUp(self):
         User = get_user_model()
@@ -2352,6 +2880,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()
@@ -2367,6 +2896,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})
@@ -2378,6 +2909,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(
@@ -2398,6 +2933,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(
@@ -2430,6 +2966,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(
@@ -2445,6 +2982,90 @@ 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)
+
+    def test_low_rating_story_enqueues_issue_creation_when_celery_enabled(self):
+        self.lock_file.write_text("")
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            story = UserStory.objects.create(
+                path="/feedback/",
+                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("")
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            UserStory.objects.create(
+                path="/feedback/",
+                rating=5,
+                comments="Great!",
+                take_screenshot=True,
+            )
+
+        mock_delay.assert_not_called()
+
+    def test_low_rating_story_skips_when_celery_disabled(self):
+        self.lock_file.unlink(missing_ok=True)
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            UserStory.objects.create(
+                path="/feedback/",
+                rating=1,
+                comments="Not good",
+                take_screenshot=False,
+                user=self.user,
+            )
+
+        mock_delay.assert_not_called()
+
 
 class UserStoryAdminActionTests(TestCase):
     def setUp(self):