arthexis 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

ocpp/tests.py

@@ -1,6 +1,8 @@
 import os
 import sys
 import time
+import tempfile
+from collections import deque
 from importlib import util as importlib_util
 from pathlib import Path
 from types import ModuleType
@@ -63,13 +65,17 @@ from .models import (
     Transaction,
     Charger,
     ChargerConfiguration,
+    ConfigurationKey,
     Simulator,
     MeterReading,
+    MeterValue,
     Location,
     DataTransferMessage,
     CPReservation,
+    CPFirmware,
+    CPFirmwareDeployment,
 )
-from .admin import ChargerConfigurationAdmin
+from .admin import ChargerConfigurationAdmin, ConfigurationKeyAdmin, ConfigurationKeyInline
 from .consumers import CSMSConsumer
 from .views import dispatch_action, _transaction_rfid_details, _usage_timeline
 from .status_display import STATUS_BADGE_MAP
@@ -90,7 +96,8 @@ from .tasks import (
     check_charge_point_configuration,
     schedule_daily_charge_point_configuration_checks,
 )
-from django.db import close_old_connections
+from django.db import close_old_connections, connection
+from django.test.utils import CaptureQueriesContext
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
 
@@ -394,6 +401,45 @@ class CPReservationTests(TransactionTestCase):
         self.assertIsNotNone(metadata)
         self.assertEqual(metadata.get("reservation_pk"), reservation.pk)
 
+    def test_send_cancel_request_dispatches_frame(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=30,
+            id_tag="TAG010",
+        )
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+            ws,
+        )
+        self.addCleanup(
+            store.pop_connection,
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+        )
+
+        message_id = reservation.send_cancel_request()
+        self.assertTrue(ws.sent)
+        frame = json.loads(ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "CancelReservation")
+        self.assertEqual(frame[3]["reservationId"], reservation.pk)
+        metadata = store.pending_calls.get(message_id)
+        self.assertIsNotNone(metadata)
+        self.assertEqual(metadata.get("reservation_pk"), reservation.pk)
+        self.assertEqual(metadata.get("action"), "CancelReservation")
+
     def test_call_result_marks_reservation_confirmed(self):
         start = timezone.now() + timedelta(hours=1)
         reservation = CPReservation.objects.create(
@@ -482,6 +528,95 @@ class CPReservationTests(TransactionTestCase):
         self.assertIsNone(reservation.evcs_confirmed_at)
         self.assertIn("Rejected", reservation.evcs_error or "")
 
+    def test_cancel_reservation_result_updates_status(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG008",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "cancel-success"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "CancelReservation",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_result)(
+            message_id, {"status": "Accepted"}
+        )
+        reservation.refresh_from_db()
+        self.assertEqual(reservation.evcs_status, "Accepted")
+        self.assertFalse(reservation.evcs_confirmed)
+        self.assertIsNone(reservation.evcs_confirmed_at)
+        self.assertEqual(reservation.evcs_error, "")
+
+    def test_cancel_reservation_error_updates_status(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG009",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "cancel-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "CancelReservation",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_error)(
+            message_id,
+            "Rejected",
+            "Connector busy",
+            {"reason": "occupied"},
+        )
+        reservation.refresh_from_db()
+        self.assertEqual(reservation.evcs_status, "")
+        self.assertFalse(reservation.evcs_confirmed)
+        self.assertIsNone(reservation.evcs_confirmed_at)
+        self.assertIn("Rejected", reservation.evcs_error or "")
+
 
 class ChargerUrlFallbackTests(TestCase):
     @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
@@ -532,6 +667,33 @@ class CSMSConsumerTests(TransactionTestCase):
                 await asyncio.sleep(delay)
         raise
 
+    def _create_firmware_deployment(self, charger_id: str) -> int:
+        try:
+            charger = Charger.objects.get(charger_id=charger_id, connector_id=None)
+        except Charger.DoesNotExist:
+            charger = Charger.objects.create(charger_id=charger_id, connector_id=None)
+        firmware = CPFirmware.objects.create(
+            name=f"{charger_id} firmware",
+            filename=f"{charger_id}.bin",
+            payload_binary=b"firmware",
+            content_type="application/octet-stream",
+            source=CPFirmware.Source.DOWNLOAD,
+            is_user_data=True,
+        )
+        deployment = CPFirmwareDeployment.objects.create(
+            firmware=firmware,
+            charger=charger,
+            node=charger.node_origin,
+            ocpp_message_id=f"deploy-{charger_id}",
+            status="Pending",
+            status_info="",
+            status_timestamp=timezone.now(),
+            retrieve_date=timezone.now(),
+            request_payload={},
+            is_user_data=True,
+        )
+        return deployment.pk
+
     async def _send_status_notification(self, serial: str, payload: dict):
         communicator = WebsocketCommunicator(application, f"/{serial}/")
         connected, _ = await communicator.connect()
@@ -712,7 +874,9 @@ class CSMSConsumerTests(TransactionTestCase):
             store.logs.setdefault("charger", {})
             store.logs["charger"].clear()
             for key, entries in original_logs.items():
-                store.logs["charger"][key] = list(entries)
+                store.logs["charger"][key] = deque(
+                    entries, maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES
+                )
             store.log_names.setdefault("charger", {})
             store.log_names["charger"].clear()
             store.log_names["charger"].update(original_log_names)
@@ -977,6 +1141,151 @@ class CSMSConsumerTests(TransactionTestCase):
         self.assertEqual(charger.availability_requested_state, "Inoperative")
         await communicator.disconnect()
 
+    async def test_clear_cache_result_updates_local_auth_version(self):
+        store.pending_calls.clear()
+        log_key = store.identity_key("CLEARCACHE", None)
+        store.clear_log(log_key, log_type="charger")
+        communicator = WebsocketCommunicator(application, "/CLEARCACHE/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "boot",
+                "BootNotification",
+                {"chargePointVendor": "Test", "chargePointModel": "Model"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        message_id = "cc-accepted"
+        requested_at = timezone.now()
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ClearCache",
+                "charger_id": "CLEARCACHE",
+                "connector_id": None,
+                "log_key": log_key,
+                "requested_at": requested_at,
+            },
+        )
+
+        mock_update = AsyncMock()
+        with patch.object(CSMSConsumer, "_update_local_authorization_state", new=mock_update):
+            await communicator.send_json_to([3, message_id, {"status": "Accepted"}])
+            await asyncio.sleep(0.05)
+
+        mock_update.assert_awaited_with(0)
+        result = store.wait_for_pending_call(message_id, timeout=0.1)
+        self.assertIsNotNone(result)
+        payload = result.get("payload") or {}
+        self.assertEqual(payload.get("status"), "Accepted")
+        log_entries = store.logs["charger"].get(log_key, [])
+        self.assertTrue(any("ClearCache result" in entry for entry in log_entries))
+
+        store.clear_log(log_key, log_type="charger")
+        await communicator.disconnect()
+
+    async def test_clear_cache_rejection_updates_timestamp(self):
+        store.pending_calls.clear()
+        log_key = store.identity_key("CLEARCACHE-REJ", None)
+        store.clear_log(log_key, log_type="charger")
+        communicator = WebsocketCommunicator(application, "/CLEARCACHE-REJ/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "boot",
+                "BootNotification",
+                {"chargePointVendor": "Test", "chargePointModel": "Model"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        message_id = "cc-rejected"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ClearCache",
+                "charger_id": "CLEARCACHE-REJ",
+                "connector_id": None,
+                "log_key": log_key,
+            },
+        )
+
+        mock_update = AsyncMock()
+        with patch.object(CSMSConsumer, "_update_local_authorization_state", new=mock_update):
+            await communicator.send_json_to([3, message_id, {"status": "Rejected"}])
+            await asyncio.sleep(0.05)
+
+        mock_update.assert_awaited_with(None)
+        result = store.wait_for_pending_call(message_id, timeout=0.1)
+        self.assertIsNotNone(result)
+        payload = result.get("payload") or {}
+        self.assertEqual(payload.get("status"), "Rejected")
+        log_entries = store.logs["charger"].get(log_key, [])
+        self.assertTrue(any("ClearCache result" in entry for entry in log_entries))
+
+        store.clear_log(log_key, log_type="charger")
+        await communicator.disconnect()
+
+    async def test_clear_cache_error_records_failure(self):
+        store.pending_calls.clear()
+        log_key = store.identity_key("CLEARCACHE-ERR", None)
+        store.clear_log(log_key, log_type="charger")
+        communicator = WebsocketCommunicator(application, "/CLEARCACHE-ERR/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "boot",
+                "BootNotification",
+                {"chargePointVendor": "Test", "chargePointModel": "Model"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        message_id = "cc-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ClearCache",
+                "charger_id": "CLEARCACHE-ERR",
+                "connector_id": None,
+                "log_key": log_key,
+            },
+        )
+
+        mock_update = AsyncMock()
+        with patch.object(CSMSConsumer, "_update_local_authorization_state", new=mock_update):
+            await communicator.send_json_to(
+                [
+                    4,
+                    message_id,
+                    "InternalError",
+                    "Failed",
+                    {"detail": "boom"},
+                ]
+            )
+            await asyncio.sleep(0.05)
+
+        mock_update.assert_awaited_with(None)
+        result = store.wait_for_pending_call(message_id, timeout=0.1)
+        self.assertIsNotNone(result)
+        self.assertFalse(result.get("success"))
+        self.assertEqual(result.get("error_code"), "InternalError")
+        log_entries = store.logs["charger"].get(log_key, [])
+        self.assertTrue(any("ClearCache error" in entry for entry in log_entries))
+
+        store.clear_log(log_key, log_type="charger")
+        await communicator.disconnect()
+
     async def test_get_configuration_result_logged(self):
         store.pending_calls.clear()
         pending_key = store.pending_key("CFGRES")
@@ -1040,6 +1349,30 @@ class CSMSConsumerTests(TransactionTestCase):
                 }
             ],
         )
+        key_rows = await database_sync_to_async(
+            lambda: [
+                {
+                    "key": item.key,
+                    "value": item.value,
+                    "readonly": item.readonly,
+                    "has_value": item.has_value,
+                }
+                for item in ConfigurationKey.objects.filter(
+                    configuration=configuration
+                ).order_by("position", "id")
+            ]
+        )()
+        self.assertEqual(
+            key_rows,
+            [
+                {
+                    "key": "AllowOfflineTxForUnknownId",
+                    "value": "false",
+                    "readonly": True,
+                    "has_value": True,
+                }
+            ],
+        )
         self.assertEqual(configuration.unknown_keys, [])
         config_ids = await database_sync_to_async(
             lambda: set(
@@ -1262,91 +1595,179 @@ class CSMSConsumerTests(TransactionTestCase):
         await communicator.disconnect()
 
     async def test_firmware_status_notification_updates_database_and_views(self):
+        store.ip_connections.clear()
+        limit = store.MAX_CONNECTIONS_PER_IP
+        store.MAX_CONNECTIONS_PER_IP = 10
         communicator = WebsocketCommunicator(application, "/FWSTAT/")
-        connected, _ = await communicator.connect()
-        self.assertTrue(connected)
+        try:
+            connected, detail = await communicator.connect()
+            self.assertTrue(connected, detail)
 
-        ts = timezone.now().replace(microsecond=0)
-        payload = {
-            "status": "Installing",
-            "statusInfo": "Applying patch",
-            "timestamp": ts.isoformat(),
-        }
+            deployment_pk = await database_sync_to_async(
+                self._create_firmware_deployment
+            )("FWSTAT")
+            ts = timezone.now().replace(microsecond=0)
+            payload = {
+                "status": "Installing",
+                "statusInfo": "Applying patch",
+                "timestamp": ts.isoformat(),
+            }
 
-        await communicator.send_json_to(
-            [2, "1", "FirmwareStatusNotification", payload]
-        )
-        response = await communicator.receive_json_from()
-        self.assertEqual(response, [3, "1", {}])
+            await communicator.send_json_to(
+                [2, "1", "FirmwareStatusNotification", payload]
+            )
+            response = await communicator.receive_json_from()
+            self.assertEqual(response, [3, "1", {}])
 
-        def _fetch_status():
-            charger = Charger.objects.get(charger_id="FWSTAT", connector_id=None)
-            return (
-                charger.firmware_status,
-                charger.firmware_status_info,
-                charger.firmware_timestamp,
+            def _fetch_status():
+                charger = Charger.objects.get(
+                    charger_id="FWSTAT", connector_id=None
+                )
+                return (
+                    charger.firmware_status,
+                    charger.firmware_status_info,
+                    charger.firmware_timestamp,
+                )
+
+            status, info, recorded_ts = await database_sync_to_async(
+                _fetch_status
+            )()
+            self.assertEqual(status, "Installing")
+            self.assertEqual(info, "Applying patch")
+            self.assertIsNotNone(recorded_ts)
+            self.assertEqual(recorded_ts.replace(microsecond=0), ts)
+
+            def _fetch_deployment():
+                return CPFirmwareDeployment.objects.get(pk=deployment_pk)
+
+            deployment = await database_sync_to_async(_fetch_deployment)()
+            self.assertEqual(deployment.status, "Installing")
+            self.assertEqual(deployment.status_info, "Applying patch")
+            self.assertIsNotNone(deployment.status_timestamp)
+            self.assertEqual(
+                deployment.status_timestamp.replace(microsecond=0), ts
+            )
+
+            log_entries = store.get_logs(
+                store.identity_key("FWSTAT", None), log_type="charger"
+            )
+            self.assertTrue(
+                any("FirmwareStatusNotification" in entry for entry in log_entries)
             )
 
-        status, info, recorded_ts = await database_sync_to_async(_fetch_status)()
-        self.assertEqual(status, "Installing")
-        self.assertEqual(info, "Applying patch")
-        self.assertIsNotNone(recorded_ts)
-        self.assertEqual(recorded_ts.replace(microsecond=0), ts)
+            def _fetch_views():
+                User = get_user_model()
+                user = User.objects.create_user(username="fwstatus", password="pw")
+                client = Client()
+                client.force_login(user)
+                detail = client.get(reverse("charger-detail", args=["FWSTAT"]))
+                status_page = client.get(reverse("charger-status", args=["FWSTAT"]))
+                list_response = client.get(reverse("charger-list"))
+                return (
+                    detail.status_code,
+                    json.loads(detail.content.decode()),
+                    status_page.status_code,
+                    status_page.content.decode(),
+                    list_response.status_code,
+                    json.loads(list_response.content.decode()),
+                )
 
-        log_entries = store.get_logs(store.identity_key("FWSTAT", None), log_type="charger")
-        self.assertTrue(
-            any("FirmwareStatusNotification" in entry for entry in log_entries)
+            (
+                detail_code,
+                detail_payload,
+                status_code,
+                html,
+                list_code,
+                list_payload,
+            ) = await database_sync_to_async(_fetch_views)()
+            self.assertEqual(detail_code, 200)
+            self.assertEqual(status_code, 200)
+            self.assertEqual(list_code, 200)
+            self.assertEqual(detail_payload["firmwareStatus"], "Installing")
+            self.assertEqual(detail_payload["firmwareStatusInfo"], "Applying patch")
+            self.assertEqual(detail_payload["firmwareTimestamp"], ts.isoformat())
+            self.assertNotIn('id="firmware-status"', html)
+            self.assertNotIn('id="firmware-status-info"', html)
+            self.assertNotIn('id="firmware-timestamp"', html)
+
+            matching = [
+                item
+                for item in list_payload.get("chargers", [])
+                if item["charger_id"] == "FWSTAT"
+                and item["connector_id"] is None
+            ]
+            self.assertTrue(matching)
+            self.assertEqual(matching[0]["firmwareStatus"], "Installing")
+            self.assertEqual(matching[0]["firmwareStatusInfo"], "Applying patch")
+            list_ts = datetime.fromisoformat(matching[0]["firmwareTimestamp"])
+            self.assertAlmostEqual(list_ts.timestamp(), ts.timestamp(), places=3)
+
+            store.clear_log(
+                store.identity_key("FWSTAT", None), log_type="charger"
+            )
+        finally:
+            with suppress(Exception):
+                await communicator.disconnect()
+            store.MAX_CONNECTIONS_PER_IP = limit
+
+    async def test_update_firmware_call_result_updates_deployment(self):
+        store.ip_connections.clear()
+        limit = store.MAX_CONNECTIONS_PER_IP
+        store.MAX_CONNECTIONS_PER_IP = 10
+        charger = await database_sync_to_async(Charger.objects.create)(
+            charger_id="UPFW", connector_id=None
+        )
+        firmware = await database_sync_to_async(CPFirmware.objects.create)(
+            name="Update firmware",
+            filename="update.bin",
+            payload_binary=b"bin",
+            content_type="application/octet-stream",
+            source=CPFirmware.Source.UPLOAD,
+            is_user_data=True,
+        )
+        deployment = await database_sync_to_async(CPFirmwareDeployment.objects.create)(
+            firmware=firmware,
+            charger=charger,
+            node=charger.node_origin,
+            ocpp_message_id="upfw-msg",
+            status="Pending",
+            status_info="",
+            status_timestamp=timezone.now(),
+            retrieve_date=timezone.now(),
+            request_payload={},
+            is_user_data=True,
         )
 
-        def _fetch_views():
-            User = get_user_model()
-            user = User.objects.create_user(username="fwstatus", password="pw")
-            client = Client()
-            client.force_login(user)
-            detail = client.get(reverse("charger-detail", args=["FWSTAT"]))
-            status_page = client.get(reverse("charger-status", args=["FWSTAT"]))
-            list_response = client.get(reverse("charger-list"))
-            return (
-                detail.status_code,
-                json.loads(detail.content.decode()),
-                status_page.status_code,
-                status_page.content.decode(),
-                list_response.status_code,
-                json.loads(list_response.content.decode()),
-            )
+        message_id = "firmware-update"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "UpdateFirmware",
+                "charger_id": "UPFW",
+                "connector_id": None,
+                "deployment_pk": deployment.pk,
+            },
+        )
 
-        (
-            detail_code,
-            detail_payload,
-            status_code,
-            html,
-            list_code,
-            list_payload,
-        ) = await database_sync_to_async(_fetch_views)()
-        self.assertEqual(detail_code, 200)
-        self.assertEqual(status_code, 200)
-        self.assertEqual(list_code, 200)
-        self.assertEqual(detail_payload["firmwareStatus"], "Installing")
-        self.assertEqual(detail_payload["firmwareStatusInfo"], "Applying patch")
-        self.assertEqual(detail_payload["firmwareTimestamp"], ts.isoformat())
-        self.assertNotIn('id="firmware-status"', html)
-        self.assertNotIn('id="firmware-status-info"', html)
-        self.assertNotIn('id="firmware-timestamp"', html)
-
-        matching = [
-            item
-            for item in list_payload.get("chargers", [])
-            if item["charger_id"] == "FWSTAT" and item["connector_id"] is None
-        ]
-        self.assertTrue(matching)
-        self.assertEqual(matching[0]["firmwareStatus"], "Installing")
-        self.assertEqual(matching[0]["firmwareStatusInfo"], "Applying patch")
-        list_ts = datetime.fromisoformat(matching[0]["firmwareTimestamp"])
-        self.assertAlmostEqual(list_ts.timestamp(), ts.timestamp(), places=3)
+        communicator = WebsocketCommunicator(application, "/UPFW/")
+        try:
+            connected, detail = await communicator.connect()
+            self.assertTrue(connected, detail)
 
-        store.clear_log(store.identity_key("FWSTAT", None), log_type="charger")
+            await communicator.send_json_to([3, message_id, {"status": "Accepted"}])
 
-        await communicator.disconnect()
+            await asyncio.sleep(0.05)
+
+            updated = await database_sync_to_async(CPFirmwareDeployment.objects.get)(
+                pk=deployment.pk
+            )
+            self.assertEqual(updated.status, "Accepted")
+            self.assertIsNotNone(updated.status_timestamp)
+            self.assertFalse(updated.completed_at)
+        finally:
+            with suppress(Exception):
+                await communicator.disconnect()
+            store.MAX_CONNECTIONS_PER_IP = limit
 
     async def test_firmware_status_notification_updates_connector_and_aggregate(
         self,
@@ -1941,6 +2362,35 @@ class CSMSConsumerTests(TransactionTestCase):
         data = json.loads(files[0].read_text())
         self.assertTrue(any("StartTransaction" in m["message"] for m in data))
 
+    def test_session_log_buffer_bounded(self):
+        cid = "BUFFER-LIMIT"
+        session_dir = Path("logs") / "sessions" / cid
+        if session_dir.exists():
+            for file_path in session_dir.glob("*.json"):
+                file_path.unlink()
+
+        tx_id = 999
+        store.start_session_log(cid, tx_id)
+        self.addCleanup(lambda: store.history.pop(cid, None))
+
+        try:
+            metadata = store.history[cid]
+            path = metadata["path"]
+            message_count = store.SESSION_LOG_BUFFER_LIMIT * 3 + 5
+            for idx in range(message_count):
+                store.add_session_message(cid, f"message {idx}")
+                buffer = metadata["buffer"]
+                self.assertLessEqual(len(buffer), store.SESSION_LOG_BUFFER_LIMIT)
+        finally:
+            store.end_session_log(cid)
+
+        self.assertTrue(path.exists())
+        try:
+            payload = json.loads(path.read_text())
+            self.assertEqual(len(payload), message_count)
+        finally:
+            path.unlink(missing_ok=True)
+
     async def test_second_connection_closes_first(self):
         communicator1 = WebsocketCommunicator(application, "/DUPLICATE/")
         connected, _ = await communicator1.connect()
@@ -2923,6 +3373,101 @@ class ChargerAdminTests(TestCase):
             store.clear_log(log_key, log_type="charger")
             store.clear_log(pending_key, log_type="charger")
 
+    def test_get_diagnostics_downloads_file_to_work_directory(self):
+        charger = Charger.objects.create(
+            charger_id="DIAGADMIN",
+            diagnostics_location="https://example.com/diag.tar.gz",
+            diagnostics_status="Uploaded",
+        )
+        fixed_now = datetime(2024, 1, 2, 3, 4, 5, tzinfo=dt_timezone.utc)
+        with tempfile.TemporaryDirectory() as tempdir:
+            base_path = Path(tempdir)
+            response_mock = Mock()
+            response_mock.status_code = 200
+            response_mock.iter_content.return_value = [b"diagnostics"]
+            response_mock.headers = {
+                "Content-Disposition": 'attachment; filename="diagnostics.tar.gz"'
+            }
+            response_mock.close = Mock()
+            with override_settings(BASE_DIR=base_path):
+                with patch("ocpp.admin.requests.get", return_value=response_mock) as mock_get:
+                    with patch("ocpp.admin.timezone.now", return_value=fixed_now):
+                        url = reverse("admin:ocpp_charger_changelist")
+                        response = self.client.post(
+                            url,
+                            {
+                                "action": "get_diagnostics",
+                                "_selected_action": [charger.pk],
+                            },
+                            follow=True,
+                        )
+                self.assertEqual(response.status_code, 200)
+            work_dir = base_path / "work" / "ocpp-admin" / "diagnostics"
+            self.assertTrue(work_dir.exists())
+            files = list(work_dir.glob("*"))
+            self.assertEqual(len(files), 1)
+            saved_file = files[0]
+            self.assertEqual(saved_file.read_bytes(), b"diagnostics")
+            asset_path = saved_file.relative_to(base_path / "work" / "ocpp-admin").as_posix()
+            asset_url = "http://testserver" + reverse(
+                "pages:readme-asset", kwargs={"source": "work", "asset": asset_path}
+            )
+            self.assertContains(response, asset_url)
+            self.assertContains(response, str(saved_file))
+            mock_get.assert_called_once_with(
+                "https://example.com/diag.tar.gz", stream=True, timeout=15
+            )
+            response_mock.close.assert_called_once()
+
+    def test_get_diagnostics_requires_location_reports_warning(self):
+        charger = Charger.objects.create(charger_id="DIAGNOLOC")
+        with tempfile.TemporaryDirectory() as tempdir:
+            base_path = Path(tempdir)
+            with override_settings(BASE_DIR=base_path):
+                url = reverse("admin:ocpp_charger_changelist")
+                response = self.client.post(
+                    url,
+                    {"action": "get_diagnostics", "_selected_action": [charger.pk]},
+                    follow=True,
+                )
+            self.assertEqual(response.status_code, 200)
+            self.assertContains(response, "DIAGNOLOC: no diagnostics location reported.")
+            work_dir = base_path / "work" / "ocpp-admin" / "diagnostics"
+            self.assertTrue(work_dir.exists())
+            self.assertFalse(list(work_dir.iterdir()))
+
+    def test_get_diagnostics_handles_download_error(self):
+        charger = Charger.objects.create(
+            charger_id="DIAGFAIL",
+            diagnostics_location="https://example.com/diag.tar",
+        )
+        response_mock = Mock()
+        response_mock.status_code = 500
+        response_mock.iter_content.return_value = []
+        response_mock.headers = {}
+        response_mock.close = Mock()
+        with tempfile.TemporaryDirectory() as tempdir:
+            base_path = Path(tempdir)
+            with override_settings(BASE_DIR=base_path):
+                with patch("ocpp.admin.requests.get", return_value=response_mock):
+                    url = reverse("admin:ocpp_charger_changelist")
+                    response = self.client.post(
+                        url,
+                        {
+                            "action": "get_diagnostics",
+                            "_selected_action": [charger.pk],
+                        },
+                        follow=True,
+                    )
+                self.assertEqual(response.status_code, 200)
+                self.assertContains(
+                    response, "DIAGFAIL: Diagnostics download returned status 500."
+                )
+            work_dir = base_path / "work" / "ocpp-admin" / "diagnostics"
+            self.assertTrue(work_dir.exists())
+            self.assertFalse(list(work_dir.iterdir()))
+            response_mock.close.assert_called_once()
+
 
 class ChargerConfigurationAdminUnitTests(TestCase):
     def setUp(self):
@@ -2952,6 +3497,38 @@ class ChargerConfigurationAdminUnitTests(TestCase):
         configuration.refresh_from_db()
         self.assertIsNone(configuration.evcs_snapshot_at)
 
+    def test_configuration_key_inline_readonly_helpers(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-INLINE"
+        )
+        configuration.replace_configuration_keys(
+            [
+                {
+                    "key": "HeartbeatInterval",
+                    "value": {"interval": 300},
+                    "readonly": True,
+                    "note": "Check",
+                },
+                {"key": "AuthorizeRemoteTxRequests", "readonly": False},
+            ]
+        )
+        inline = ConfigurationKeyInline(ChargerConfiguration, self.admin.admin_site)
+        entries = list(
+            configuration.configuration_entries.order_by("position", "id")
+        )
+        self.assertEqual(len(entries), 2)
+        self.assertIn("<pre>", inline.value_display(entries[0]))
+        self.assertIn("\"note\"", inline.extra_display(entries[0]))
+        self.assertEqual(inline.value_display(entries[1]), "-")
+        self.assertEqual(inline.extra_display(entries[1]), "-")
+        request = self.request_factory.get("/admin/ocpp/chargerconfiguration/")
+        self.assertFalse(inline.has_add_permission(request, configuration))
+
+    def test_configuration_key_admin_hidden_from_index(self):
+        key_admin = ConfigurationKeyAdmin(ConfigurationKey, AdminSite())
+        perms = key_admin.get_model_perms(self.request_factory.get("/"))
+        self.assertEqual(perms, {})
+
 
 class ConfigurationTaskTests(TestCase):
     def tearDown(self):
@@ -4081,7 +4658,9 @@ class ChargePointSimulatorTests(TransactionTestCase):
         cfg = SimulatorConfig(cp_path="SIMLOG/")
         sim = ChargePointSimulator(cfg)
         store.clear_log(cfg.cp_path, log_type="simulator")
-        store.logs["simulator"][cfg.cp_path] = []
+        store.logs["simulator"][cfg.cp_path] = deque(
+            maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES
+        )
         sent_frames: list[str] = []
 
         async def send(payload: str) -> None:
@@ -4422,6 +5001,28 @@ class DailySessionReportTaskTests(TestCase):
         except FileNotFoundError:
             pass
 
+    def _create_transaction_with_reading(
+        self,
+        charger: Charger,
+        start: datetime,
+        energy: Decimal,
+    ) -> Transaction:
+        transaction = Transaction.objects.create(
+            charger=charger,
+            start_time=start,
+            stop_time=start + timedelta(minutes=30),
+            meter_start=0,
+            connector_id=1,
+        )
+        MeterValue.objects.create(
+            charger=charger,
+            connector_id=1,
+            transaction=transaction,
+            timestamp=start + timedelta(minutes=15),
+            energy=energy,
+        )
+        return transaction
+
     def test_report_sends_email_when_sessions_exist(self):
         User = get_user_model()
         User.objects.create_superuser(
@@ -4475,6 +5076,41 @@ class DailySessionReportTaskTests(TestCase):
         self.assertEqual(count, 0)
         mock_send.assert_not_called()
 
+    def test_report_query_count_constant(self):
+        User = get_user_model()
+        User.objects.create_superuser(
+            username="report-admin", email="report-admin@example.com", password="pw"
+        )
+        charger = Charger.objects.create(charger_id="RPT-QUERY", display_name="Pod Q")
+        base_start = timezone.now().replace(second=0, microsecond=0)
+
+        self._create_transaction_with_reading(
+            charger, base_start, Decimal("1.2")
+        )
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send, CaptureQueriesContext(connection) as ctx_single:
+            count_single = send_daily_session_report()
+
+        self.assertEqual(count_single, 1)
+        mock_send.assert_called_once()
+        single_query_count = len(ctx_single)
+
+        later_start = base_start + timedelta(hours=1)
+        self._create_transaction_with_reading(
+            charger, later_start, Decimal("3.4")
+        )
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send_multi, CaptureQueriesContext(connection) as ctx_multi:
+            count_multi = send_daily_session_report()
+
+        self.assertEqual(count_multi, 2)
+        mock_send_multi.assert_called_once()
+        self.assertEqual(len(ctx_multi), single_query_count)
+
 
 class TransactionKwTests(TestCase):
     def test_kw_sums_meter_readings(self):
@@ -4587,6 +5223,9 @@ class DispatchActionViewTests(TestCase):
         )
         self.mock_wait = self.wait_patch.start()
         self.addCleanup(self.wait_patch.stop)
+        self.schedule_patch = patch("ocpp.views.store.schedule_call_timeout")
+        self.mock_schedule = self.schedule_patch.start()
+        self.addCleanup(self.schedule_patch.stop)
 
     def _close_loop(self):
         try:
@@ -4659,6 +5298,75 @@ class DispatchActionViewTests(TestCase):
         self.assertEqual(self.charger.availability_request_status, "")
         self.assertNotIn(frame[1], store.pending_calls)
 
+    def test_clear_cache_dispatches_frame_and_schedules_timeout(self):
+        with patch("ocpp.views.store.schedule_call_timeout") as mock_timeout:
+            response = self.client.post(
+                self.url,
+                data=json.dumps({"action": "clear_cache"}),
+                content_type="application/json",
+            )
+        self.assertEqual(response.status_code, 200)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(len(self.ws.sent), 1)
+        frame = json.loads(self.ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "ClearCache")
+        self.assertEqual(frame[3], {})
+        mock_timeout.assert_called_once()
+        timeout_call = mock_timeout.call_args
+        self.assertIsNotNone(timeout_call)
+        self.assertEqual(timeout_call.args[0], frame[1])
+        self.assertEqual(timeout_call.kwargs.get("action"), "ClearCache")
+        log_entries = store.logs["charger"].get(self.log_key, [])
+        self.assertTrue(any("ClearCache" in entry for entry in log_entries))
+
+    def test_clear_cache_allows_rejected_status(self):
+        def wait_rejected(message_id, timeout=5.0):
+            metadata = store.pending_calls.pop(message_id, None)
+            store._pending_call_events.pop(message_id, None)
+            store._pending_call_results.pop(message_id, None)
+            return {
+                "success": True,
+                "payload": {"status": "Rejected"},
+                "metadata": dict(metadata or {}),
+            }
+
+        self.mock_wait.side_effect = wait_rejected
+        with patch("ocpp.views.store.schedule_call_timeout") as mock_timeout:
+            response = self.client.post(
+                self.url,
+                data=json.dumps({"action": "clear_cache"}),
+                content_type="application/json",
+            )
+        self.assertEqual(response.status_code, 200)
+        payload = response.json()
+        self.assertIn("sent", payload)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(len(self.ws.sent), 1)
+        frame = json.loads(self.ws.sent[0])
+        self.assertEqual(frame[2], "ClearCache")
+        mock_timeout.assert_called_once()
+        self.mock_wait.side_effect = self._wait_success
+
+    def test_clear_cache_reports_timeout(self):
+        def no_response(message_id, timeout=5.0):
+            return None
+
+        self.mock_wait.side_effect = no_response
+        with patch("ocpp.views.store.schedule_call_timeout") as mock_timeout:
+            response = self.client.post(
+                self.url,
+                data=json.dumps({"action": "clear_cache"}),
+                content_type="application/json",
+            )
+        self.assertEqual(response.status_code, 504)
+        detail = response.json().get("detail", "")
+        self.assertIn("did not receive", detail)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(len(self.ws.sent), 1)
+        mock_timeout.assert_called_once()
+        self.mock_wait.side_effect = self._wait_success
+
     def test_remote_start_reports_rejection(self):
         def rejected(message_id, timeout=5.0):
             metadata = store.pending_calls.pop(message_id, None)
@@ -4721,6 +5429,118 @@ class DispatchActionViewTests(TestCase):
         self.assertIn("did not receive", detail)
         self.mock_wait.side_effect = self._wait_success
 
+    def test_change_configuration_requires_key(self):
+        self.mock_schedule.reset_mock()
+        response = self.client.post(
+            self.url,
+            data=json.dumps({"action": "change_configuration"}),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json().get("detail"), "key required")
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(self.ws.sent, [])
+        self.mock_schedule.assert_not_called()
+
+    def test_change_configuration_rejects_invalid_value_type(self):
+        self.mock_schedule.reset_mock()
+        response = self.client.post(
+            self.url,
+            data=json.dumps(
+                {
+                    "action": "change_configuration",
+                    "key": "HeartbeatInterval",
+                    "value": {"unexpected": "object"},
+                }
+            ),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertIn("value must", response.json().get("detail", ""))
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(self.ws.sent, [])
+        self.mock_schedule.assert_not_called()
+
+    def test_change_configuration_dispatches_frame(self):
+        self.mock_schedule.reset_mock()
+        response = self.client.post(
+            self.url,
+            data=json.dumps(
+                {
+                    "action": "change_configuration",
+                    "key": "HeartbeatInterval",
+                    "value": "120",
+                }
+            ),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 200)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(len(self.ws.sent), 1)
+        frame = json.loads(self.ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "ChangeConfiguration")
+        self.assertEqual(frame[3]["key"], "HeartbeatInterval")
+        self.assertEqual(frame[3]["value"], "120")
+        self.mock_schedule.assert_called_once()
+        log_entries = store.logs["charger"].get(self.log_key, [])
+        self.assertTrue(
+            any("Requested configuration change" in entry for entry in log_entries)
+        )
+
+    def test_change_configuration_reports_rejection(self):
+        self.mock_schedule.reset_mock()
+
+        def rejected(message_id, timeout=5.0):
+            metadata = store.pending_calls.pop(message_id, None)
+            store._pending_call_events.pop(message_id, None)
+            store._pending_call_results.pop(message_id, None)
+            return {
+                "success": True,
+                "payload": {"status": "Rejected"},
+                "metadata": dict(metadata or {}),
+            }
+
+        self.mock_wait.side_effect = rejected
+        response = self.client.post(
+            self.url,
+            data=json.dumps(
+                {
+                    "action": "change_configuration",
+                    "key": "HeartbeatInterval",
+                    "value": "120",
+                }
+            ),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 400)
+        detail = response.json().get("detail", "")
+        self.assertIn("Rejected", detail)
+        self.mock_wait.side_effect = self._wait_success
+
+    def test_change_configuration_reports_timeout(self):
+        self.mock_schedule.reset_mock()
+
+        def no_response(message_id, timeout=5.0):
+            return None
+
+        self.mock_wait.side_effect = no_response
+        response = self.client.post(
+            self.url,
+            data=json.dumps(
+                {
+                    "action": "change_configuration",
+                    "key": "HeartbeatInterval",
+                    "value": "120",
+                }
+            ),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 504)
+        detail = response.json().get("detail", "")
+        self.assertIn("did not receive", detail)
+        self.mock_wait.side_effect = self._wait_success
+
     def test_change_availability_requires_valid_type(self):
         response = self.client.post(
             self.url,
@@ -4728,6 +5548,9 @@ class DispatchActionViewTests(TestCase):
             content_type="application/json",
         )
         self.assertEqual(response.status_code, 400)
+        self.assertEqual(
+            response.json().get("detail"), "invalid availability type"
+        )
         self.loop.run_until_complete(asyncio.sleep(0))
         self.assertEqual(self.ws.sent, [])
         self.assertFalse(store.pending_calls)
@@ -4857,11 +5680,14 @@ class ChargerStatusViewTests(TestCase):
             prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
             return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
 
-        store.logs["charger"][log_key] = [
-            build_entry(timedelta(days=2), "Available"),
-            build_entry(timedelta(days=1), "Charging"),
-            build_entry(timedelta(hours=12), "Available"),
-        ]
+        store.logs["charger"][log_key] = deque(
+            [
+                build_entry(timedelta(days=2), "Available"),
+                build_entry(timedelta(days=1), "Charging"),
+                build_entry(timedelta(hours=12), "Available"),
+            ],
+            maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES,
+        )
 
         data, _window = _usage_timeline(charger, [], now=fixed_now)
         self.assertEqual(len(data), 1)
@@ -4898,7 +5724,9 @@ class ChargerStatusViewTests(TestCase):
             }
             prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
             key = store.identity_key(aggregate.charger_id, connector_id)
-            store.logs["charger"].setdefault(key, []).append(
+            store.logs["charger"].setdefault(
+                key, deque(maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES)
+            ).append(
                 f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
             )
 
@@ -4939,13 +5767,16 @@ class ChargerStatusViewTests(TestCase):
             return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
 
         log_key = store.identity_key(charger.charger_id, charger.connector_id)
-        store.logs["charger"][log_key] = [
-            build_entry(timedelta(days=6, hours=12), "Available"),
-            build_entry(timedelta(days=5), "Available"),
-            build_entry(timedelta(days=3, hours=6), "Charging"),
-            build_entry(timedelta(days=2), "Charging"),
-            build_entry(timedelta(days=1), "Available"),
-        ]
+        store.logs["charger"][log_key] = deque(
+            [
+                build_entry(timedelta(days=6, hours=12), "Available"),
+                build_entry(timedelta(days=5), "Available"),
+                build_entry(timedelta(days=3, hours=6), "Charging"),
+                build_entry(timedelta(days=2), "Charging"),
+                build_entry(timedelta(days=1), "Available"),
+            ],
+            maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES,
+        )
 
         data, window = _usage_timeline(charger, [], now=fixed_now)
         self.assertIsNotNone(window)
@@ -4973,6 +5804,37 @@ class ChargerStatusViewTests(TestCase):
         self.assertContains(resp, "id=\"diagnostics-location\"")
         self.assertContains(resp, "https://example.com/report.tar")
 
+    def test_firmware_download_serves_payload(self):
+        charger = Charger.objects.create(charger_id="DLVIEW")
+        firmware = CPFirmware.objects.create(
+            name="Download",
+            filename="download.bin",
+            payload_binary=b"payload",
+            content_type="application/octet-stream",
+            source=CPFirmware.Source.DOWNLOAD,
+            is_user_data=True,
+        )
+        deployment = CPFirmwareDeployment.objects.create(
+            firmware=firmware,
+            charger=charger,
+            node=charger.node_origin,
+            ocpp_message_id="dl-msg",
+            status="Pending",
+            status_info="",
+            status_timestamp=timezone.now(),
+            retrieve_date=timezone.now(),
+            request_payload={},
+            is_user_data=True,
+        )
+        token = deployment.issue_download_token(lifetime=timedelta(hours=1))
+        response = self.client.get(
+            reverse("cp-firmware-download", args=[deployment.pk, token])
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.content, b"payload")
+        deployment.refresh_from_db()
+        self.assertIsNotNone(deployment.downloaded_at)
+
     def test_connector_status_prefers_connector_diagnostics(self):
         aggregate = Charger.objects.create(
             charger_id="DIAGCONN",
@@ -5492,3 +6354,33 @@ class LiveUpdateViewTests(TestCase):
             reverse("charger-status", args=[restricted.charger_id])
         )
         self.assertEqual(group_denied.status_code, 404)
+
+
+class StoreLogBufferTests(TestCase):
+    def test_add_log_enforces_in_memory_cap(self):
+        cid = "BUFFER-CAP-TEST"
+        log_type = "charger"
+        store.clear_log(cid, log_type=log_type)
+        self.addCleanup(lambda: store.clear_log(cid, log_type=log_type))
+
+        with patch("ocpp.store.MAX_IN_MEMORY_LOG_ENTRIES", 3):
+            for index in range(6):
+                store.add_log(cid, f"message {index}", log_type=log_type)
+
+            buffer = None
+            lower = cid.lower()
+            for key, entries in store.logs[log_type].items():
+                if key.lower() == lower:
+                    buffer = entries
+                    break
+
+            self.assertIsNotNone(buffer, "Expected in-memory log buffer to be created")
+            self.assertIsInstance(buffer, deque)
+            self.assertEqual(len(buffer), 3)
+            self.assertTrue(buffer[0].endswith("message 3"))
+            self.assertTrue(buffer[-1].endswith("message 5"))
+
+            merged = store.get_logs(cid, log_type=log_type)
+
+        self.assertTrue(any(entry.endswith("message 5") for entry in merged))
+        self.assertTrue(any(entry.endswith("message 4") for entry in merged))