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

ocpp/tests.py

@@ -1931,6 +1931,27 @@ class ChargerLandingTests(TestCase):
         finally:
             store.transactions.pop(key, None)
 
+    def test_public_page_shows_available_when_status_stale(self):
+        charger = Charger.objects.create(
+            charger_id="STALEPUB",
+            last_status="Charging",
+        )
+        response = self.client.get(reverse("charger-page", args=["STALEPUB"]))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(
+            response,
+            'style="background-color: #0d6efd; color: #fff;">Available</span>',
+        )
+
+    def test_admin_status_shows_available_when_status_stale(self):
+        charger = Charger.objects.create(
+            charger_id="STALEADM",
+            last_status="Charging",
+        )
+        response = self.client.get(reverse("charger-status", args=["STALEADM"]))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'id="charger-state">Available</strong>')
+
     def test_public_status_shows_rfid_link_for_known_tag(self):
         aggregate = Charger.objects.create(charger_id="PUBRFID")
         connector = Charger.objects.create(
@@ -2129,6 +2150,32 @@ class ChargerAdminTests(TestCase):
         resp = self.client.get(url)
         self.assertNotContains(resp, charger.reference.image.url)
 
+    def test_toggle_rfid_authentication_action_toggles_value(self):
+        charger_requires = Charger.objects.create(
+            charger_id="RFIDON", require_rfid=True
+        )
+        charger_optional = Charger.objects.create(
+            charger_id="RFIDOFF", require_rfid=False
+        )
+        url = reverse("admin:ocpp_charger_changelist")
+        response = self.client.post(
+            url,
+            {
+                "action": "toggle_rfid_authentication",
+                "_selected_action": [
+                    charger_requires.pk,
+                    charger_optional.pk,
+                ],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        charger_requires.refresh_from_db()
+        charger_optional.refresh_from_db()
+        self.assertFalse(charger_requires.require_rfid)
+        self.assertTrue(charger_optional.require_rfid)
+        self.assertContains(response, "Updated RFID authentication")
+
     def test_admin_lists_log_link(self):
         charger = Charger.objects.create(charger_id="LOG1")
         url = reverse("admin:ocpp_charger_changelist")
@@ -2155,6 +2202,48 @@ class ChargerAdminTests(TestCase):
         finally:
             store.transactions.pop(key, None)
 
+    def test_admin_status_shows_available_when_status_stale(self):
+        charger = Charger.objects.create(
+            charger_id="ADMINSTALE",
+            last_status="Charging",
+        )
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+        available_label = force_str(STATUS_BADGE_MAP["available"][0])
+        self.assertContains(resp, f">{available_label}<")
+
+    def test_recheck_charger_status_action_sends_trigger(self):
+        charger = Charger.objects.create(charger_id="RECHECK1")
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "recheck_charger_status",
+                    "index": 0,
+                    "select_across": 0,
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertTrue(ws.sent)
+            self.assertIn("TriggerMessage", ws.sent[0])
+            self.assertContains(response, "Requested status update")
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.clear_pending_calls(charger.charger_id)
+
     def test_admin_log_view_displays_entries(self):
         charger = Charger.objects.create(charger_id="LOG2")
         log_id = store.identity_key(charger.charger_id, charger.connector_id)
@@ -4442,6 +4531,49 @@ class LiveUpdateViewTests(TestCase):
         )
         self.assertEqual(aggregate_entry["state"], available_label)
 
+    def test_dashboard_connector_treats_finishing_as_available_without_session(self):
+        charger = Charger.objects.create(
+            charger_id="FINISH-STATE",
+            connector_id=1,
+            last_status="Finishing",
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(resp.context)
+        context = resp.context
+        available_label = force_str(STATUS_BADGE_MAP["available"][0])
+        entry = next(
+            item
+            for item in context["chargers"]
+            if item["charger"].pk == charger.pk
+        )
+        self.assertEqual(entry["state"], available_label)
+
+    def test_dashboard_aggregate_treats_finishing_as_available_without_session(self):
+        aggregate = Charger.objects.create(
+            charger_id="FINISH-AGG",
+            connector_id=None,
+            last_status="Finishing",
+        )
+        Charger.objects.create(
+            charger_id=aggregate.charger_id,
+            connector_id=1,
+            last_status="Finishing",
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(resp.context)
+        context = resp.context
+        available_label = force_str(STATUS_BADGE_MAP["available"][0])
+        aggregate_entry = next(
+            item
+            for item in context["chargers"]
+            if item["charger"].pk == aggregate.pk
+        )
+        self.assertEqual(aggregate_entry["state"], available_label)
+
     def test_dashboard_aggregate_uses_connection_when_status_missing(self):
         aggregate = Charger.objects.create(
             charger_id="DASHAGG-CONN", last_status="Charging"

ocpp/views.py

@@ -370,10 +370,6 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
     )
     statuses: list[str] = []
     for sibling in siblings:
-        status_value = (sibling.last_status or "").strip()
-        if status_value:
-            statuses.append(status_value.casefold())
-            continue
         tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -381,9 +377,22 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
                 .order_by("-start_time")
                 .first()
             )
-        if _has_active_session(tx_obj):
+        has_session = _has_active_session(tx_obj)
+        status_value = (sibling.last_status or "").strip()
+        normalized_status = status_value.casefold() if status_value else ""
+        error_code_lower = (sibling.last_error_code or "").strip().lower()
+        if has_session:
             statuses.append("charging")
             continue
+        if (
+            normalized_status in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            statuses.append("available")
+            continue
+        if normalized_status:
+            statuses.append(normalized_status)
+            continue
         if store.is_connected(sibling.charger_id, sibling.connector_id):
             statuses.append("available")
 
@@ -424,6 +433,15 @@ def _charger_state(charger: Charger, tx_obj: Transaction | list | None):
             # while a session is active. Override the badge so the user can see
             # the charger is actually busy.
             label, color = STATUS_BADGE_MAP.get("charging", (_("Charging"), "#198754"))
+        elif (
+            not has_session
+            and key in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            # Some chargers continue reporting "Charging" after a session ends.
+            # When no active transaction exists, surface the state as available
+            # so the UI reflects the actual behaviour at the site.
+            label, color = STATUS_BADGE_MAP.get("available", (_("Available"), "#0d6efd"))
         elif error_code and error_code_lower not in ERROR_OK_VALUES:
             label = _("%(status)s (%(error)s)") % {
                 "status": label,

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
@@ -685,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):
@@ -2568,6 +2584,15 @@ 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