arthexis 0.1.16__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
@@ -55,19 +57,27 @@ from django.contrib.sites.models import Site
 from django.core.exceptions import ValidationError
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
+from django.contrib.admin.sites import AdminSite
 
 from config.asgi import application
 
 from .models import (
     Transaction,
     Charger,
+    ChargerConfiguration,
+    ConfigurationKey,
     Simulator,
     MeterReading,
+    MeterValue,
     Location,
     DataTransferMessage,
+    CPReservation,
+    CPFirmware,
+    CPFirmwareDeployment,
 )
+from .admin import ChargerConfigurationAdmin, ConfigurationKeyAdmin, ConfigurationKeyInline
 from .consumers import CSMSConsumer
-from .views import dispatch_action
+from .views import dispatch_action, _transaction_rfid_details, _usage_timeline
 from .status_display import STATUS_BADGE_MAP
 from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
@@ -80,8 +90,14 @@ from .simulator import SimulatorConfig, ChargePointSimulator
 from .evcs import simulate, SimulatorState, _simulators
 import re
 from datetime import datetime, timedelta, timezone as dt_timezone
-from .tasks import purge_meter_readings, send_daily_session_report
-from django.db import close_old_connections
+from .tasks import (
+    purge_meter_readings,
+    send_daily_session_report,
+    check_charge_point_configuration,
+    schedule_daily_charge_point_configuration_checks,
+)
+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
 
@@ -169,6 +185,36 @@ class DispatchActionTests(TestCase):
         self.assertEqual(metadata.get("trigger_target"), "BootNotification")
         self.assertEqual(metadata.get("log_key"), log_key)
 
+    def test_reset_rejected_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETBLOCK")
+        dummy = DummyWebSocket()
+        connection_key = store.set_connection(charger.charger_id, charger.connector_id, dummy)
+        self.addCleanup(lambda: store.connections.pop(connection_key, None))
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        tx_key = store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        self.addCleanup(lambda: store.transactions.pop(tx_key, None))
+
+        request = self.factory.post(
+            "/chargers/RESETBLOCK/action/",
+            data=json.dumps({"action": "reset"}),
+            content_type="application/json",
+        )
+        request.user = SimpleNamespace(
+            is_authenticated=True,
+            is_superuser=True,
+            is_staff=True,
+        )
+
+        response = dispatch_action(request, charger.charger_id)
+        self.assertEqual(response.status_code, 409)
+        payload = json.loads(response.content.decode("utf-8"))
+        self.assertIn("stop the session first", payload.get("detail", "").lower())
+        self.assertFalse(dummy.sent)
+
 class ChargerFixtureTests(TestCase):
     fixtures = [
         p.name
@@ -210,6 +256,368 @@ class ChargerFixtureTests(TestCase):
         self.assertEqual(cp2.name, "Simulator #2")
 
 
+class ChargerRefreshManagerNodeTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        local = Node.objects.create(
+            hostname="local-node",
+            address="127.0.0.1",
+            port=8000,
+            mac_address="aa:bb:cc:dd:ee:ff",
+            current_relation=Node.Relation.SELF,
+        )
+        Node.objects.filter(pk=local.pk).update(mac_address="AA:BB:CC:DD:EE:FF")
+        cls.local_node = Node.objects.get(pk=local.pk)
+
+    def test_refresh_manager_node_assigns_local_to_unsaved_charger(self):
+        charger = Charger(charger_id="UNSAVED")
+
+        with patch("nodes.models.Node.get_current_mac", return_value="aa:bb:cc:dd:ee:ff"):
+            result = charger.refresh_manager_node()
+
+        self.assertEqual(result, self.local_node)
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_updates_persisted_charger(self):
+        remote = Node.objects.create(
+            hostname="remote-node",
+            address="10.0.0.1",
+            port=9000,
+            mac_address="11:22:33:44:55:66",
+        )
+        charger = Charger.objects.create(
+            charger_id="PERSISTED",
+            manager_node=remote,
+        )
+
+        charger.refresh_manager_node(node=self.local_node)
+
+        self.assertEqual(charger.manager_node, self.local_node)
+        charger.refresh_from_db()
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_handles_missing_local_node(self):
+        remote = Node.objects.create(
+            hostname="existing-manager",
+            address="10.0.0.2",
+            port=9001,
+            mac_address="22:33:44:55:66:77",
+        )
+        charger = Charger(charger_id="NOLOCAL", manager_node=remote)
+
+        with patch.object(Node, "get_local", return_value=None):
+            result = charger.refresh_manager_node()
+
+        self.assertIsNone(result)
+        self.assertEqual(charger.manager_node, remote)
+
+
+class CPReservationTests(TransactionTestCase):
+    def setUp(self):
+        self.location = Location.objects.create(name="Reservation Site")
+        self.aggregate = Charger.objects.create(charger_id="RSV100", location=self.location)
+        self.connector_one = Charger.objects.create(
+            charger_id="RSV100", connector_id=1, location=self.location
+        )
+        self.connector_two = Charger.objects.create(
+            charger_id="RSV100", connector_id=2, location=self.location
+        )
+        self.addCleanup(store.clear_pending_calls, "RSV100")
+
+    def test_allocates_preferred_connector(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation(
+            location=self.location,
+            start_time=start,
+            duration_minutes=90,
+            id_tag="TAG001",
+        )
+        reservation.save()
+        self.assertEqual(reservation.connector, self.connector_two)
+
+    def test_allocation_falls_back_and_blocks_overlaps(self):
+        start = timezone.now() + timedelta(hours=1)
+        first = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=60,
+            id_tag="TAG002",
+        )
+        self.assertEqual(first.connector, self.connector_two)
+        second = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=15),
+            duration_minutes=60,
+            id_tag="TAG003",
+        )
+        second.save()
+        self.assertEqual(second.connector, self.connector_one)
+        third = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=30),
+            duration_minutes=45,
+            id_tag="TAG004",
+        )
+        with self.assertRaises(ValidationError):
+            third.save()
+
+    def test_send_reservation_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="TAG005",
+        )
+
+        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_reservation_request()
+        self.assertTrue(ws.sent)
+        frame = json.loads(ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "ReserveNow")
+        self.assertEqual(frame[3]["reservationId"], reservation.pk)
+        self.assertEqual(frame[3]["connectorId"], reservation.connector.connector_id)
+        self.assertEqual(frame[3]["idTag"], "TAG005")
+        metadata = store.pending_calls.get(message_id)
+        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(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG006",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-success"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "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.assertTrue(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "Accepted")
+        self.assertIsNotNone(reservation.evcs_confirmed_at)
+
+    def test_call_error_updates_reservation_status(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG007",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "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",
+            "Charger unavailable",
+            {"reason": "maintenance"},
+        )
+        reservation.refresh_from_db()
+        self.assertFalse(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "")
+        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"])
     def test_reference_created_when_site_missing(self):
@@ -259,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()
@@ -439,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)
@@ -704,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")
@@ -714,6 +1296,13 @@ class CSMSConsumerTests(TransactionTestCase):
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
+        await database_sync_to_async(Charger.objects.get_or_create)(
+            charger_id="CFGRES", connector_id=1
+        )
+        await database_sync_to_async(Charger.objects.get_or_create)(
+            charger_id="CFGRES", connector_id=2
+        )
+
         message_id = "cfg-result"
         payload = {
             "configurationKey": [
@@ -744,6 +1333,56 @@ class CSMSConsumerTests(TransactionTestCase):
         )
         self.assertNotIn(message_id, store.pending_calls)
 
+        configuration = await database_sync_to_async(
+            lambda: ChargerConfiguration.objects.order_by("-created_at").first()
+        )()
+        self.assertIsNotNone(configuration)
+        self.assertEqual(configuration.charger_identifier, "CFGRES")
+        self.assertIsNotNone(configuration.evcs_snapshot_at)
+        self.assertEqual(
+            configuration.configuration_keys,
+            [
+                {
+                    "key": "AllowOfflineTxForUnknownId",
+                    "value": "false",
+                    "readonly": True,
+                }
+            ],
+        )
+        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(
+                Charger.objects.filter(charger_id="CFGRES").values_list(
+                    "configuration_id", flat=True
+                )
+            )
+        )()
+        self.assertEqual(config_ids, {configuration.pk})
+
         await communicator.disconnect()
         store.clear_log(log_key, log_type="charger")
         store.clear_log(pending_key, log_type="charger")
@@ -956,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)
+
+            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(),
+            }
 
-        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
             )
 
-        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)
+            log_entries = store.get_logs(
+                store.identity_key("FWSTAT", None), log_type="charger"
+            )
+            self.assertTrue(
+                any("FirmwareStatusNotification" in entry for entry in log_entries)
+            )
 
-        log_entries = store.get_logs(store.identity_key("FWSTAT", None), log_type="charger")
-        self.assertTrue(
-            any("FirmwareStatusNotification" in entry for entry in log_entries)
-        )
+            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()),
+                )
 
-        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()),
+            (
+                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,
+        )
+
+        message_id = "firmware-update"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "UpdateFirmware",
+                "charger_id": "UPFW",
+                "connector_id": None,
+                "deployment_pk": deployment.pk,
+            },
+        )
+
+        communicator = WebsocketCommunicator(application, "/UPFW/")
+        try:
+            connected, detail = await communicator.connect()
+            self.assertTrue(connected, detail)
 
-        (
-            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)
+            await communicator.send_json_to([3, message_id, {"status": "Accepted"}])
 
-        store.clear_log(store.identity_key("FWSTAT", None), log_type="charger")
+            await asyncio.sleep(0.05)
 
-        await communicator.disconnect()
+            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,
@@ -1109,7 +1836,7 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
-    async def test_vin_recorded(self):
+    async def test_vid_populated_from_vin(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="VINREC")
         communicator = WebsocketCommunicator(application, "/VINREC/")
         connected, _ = await communicator.connect()
@@ -1124,7 +1851,29 @@ class CSMSConsumerTests(TransactionTestCase):
         tx = await database_sync_to_async(Transaction.objects.get)(
             pk=tx_id, charger__charger_id="VINREC"
         )
-        self.assertEqual(tx.vin, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vid, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vehicle_identifier, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vehicle_identifier_source, "vid")
+
+        await communicator.disconnect()
+
+    async def test_vid_recorded(self):
+        await database_sync_to_async(Charger.objects.create)(charger_id="VIDREC")
+        communicator = WebsocketCommunicator(application, "/VIDREC/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [2, "1", "StartTransaction", {"meterStart": 1, "vid": "VID123456"}]
+        )
+        response = await communicator.receive_json_from()
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id="VIDREC"
+        )
+        self.assertEqual(tx.vid, "VID123456")
+        self.assertEqual(tx.rfid, "")
 
         await communicator.disconnect()
 
@@ -1613,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()
@@ -1852,6 +2630,16 @@ class ChargerLandingTests(TestCase):
         status_url = reverse("charger-status-connector", args=["PAGE1", "all"])
         self.assertContains(response, status_url)
 
+    def test_charger_page_respects_language_configuration(self):
+        charger = Charger.objects.create(charger_id="PAGE-DE", language="de")
+
+        response = self.client.get(reverse("charger-page", args=["PAGE-DE"]))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["LANGUAGE_CODE"], "de")
+        self.assertContains(response, 'lang="de"')
+        self.assertContains(response, 'data-preferred-language="de"')
+
     def test_status_page_renders(self):
         charger = Charger.objects.create(charger_id="PAGE2")
         resp = self.client.get(reverse("charger-status", args=["PAGE2"]))
@@ -1931,6 +2719,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(
@@ -2057,7 +2866,10 @@ class ChargerLandingTests(TestCase):
         log_id = store.identity_key("LOG1", None)
         store.add_log(log_id, "hello", log_type="charger")
         entry = store.get_logs(log_id, log_type="charger")[0]
-        self.assertRegex(entry, r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} hello$")
+        self.assertRegex(
+            entry,
+            r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} hello$",
+        )
         resp = self.client.get(reverse("charger-log", args=["LOG1"]) + "?type=charger")
         self.assertEqual(resp.status_code, 200)
         self.assertContains(resp, "hello")
@@ -2092,12 +2904,12 @@ class SimulatorLandingTests(TestCase):
     @skip("Navigation links unavailable in test environment")
     def test_simulator_app_link_in_nav(self):
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "/ocpp/")
-        self.assertNotContains(resp, "/ocpp/simulator/")
+        self.assertContains(resp, "/ocpp/cpms/dashboard/")
+        self.assertNotContains(resp, "/ocpp/evcs/simulator/")
         self.client.force_login(self.user)
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "/ocpp/")
-        self.assertContains(resp, "/ocpp/simulator/")
+        self.assertContains(resp, "/ocpp/cpms/dashboard/")
+        self.assertContains(resp, "/ocpp/evcs/simulator/")
 
     def test_cp_simulator_redirects_to_login(self):
         response = self.client.get(reverse("cp-simulator"))
@@ -2129,6 +2941,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 +2993,85 @@ 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_reset_charger_action_skips_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETADMIN")
+
+        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)
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "reset_chargers",
+                    "index": 0,
+                    "select_across": 0,
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertFalse(ws.sent)
+            self.assertContains(response, "stop the session first")
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pop_transaction(charger.charger_id, charger.connector_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)
@@ -2178,6 +3095,36 @@ class ChargerAdminTests(TestCase):
         resp = self.client.get(url)
         self.assertContains(resp, "AdminLoc")
 
+    def test_admin_changelist_displays_quick_stats(self):
+        charger = Charger.objects.create(charger_id="STATMAIN", display_name="Main EVCS")
+        connector = Charger.objects.create(
+            charger_id="STATMAIN", connector_id=1, display_name="Connector 1"
+        )
+        start = timezone.now() - timedelta(minutes=30)
+        Transaction.objects.create(
+            charger=connector,
+            start_time=start,
+            stop_time=start + timedelta(minutes=10),
+            meter_start=1000,
+            meter_stop=6000,
+        )
+
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+
+        self.assertContains(resp, "Total kW")
+        self.assertContains(resp, "Today kW")
+        self.assertContains(resp, "5.00")
+
+    def test_admin_changelist_does_not_indent_connectors(self):
+        Charger.objects.create(charger_id="INDENTMAIN")
+        Charger.objects.create(charger_id="INDENTMAIN", connector_id=1)
+
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+
+        self.assertNotContains(resp, 'class="charger-connector-entry"')
+
     def test_last_fields_are_read_only(self):
         now = timezone.now()
         charger = Charger.objects.create(
@@ -2426,6 +3373,208 @@ 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):
+        self.admin = ChargerConfigurationAdmin(ChargerConfiguration, AdminSite())
+        self.request_factory = RequestFactory()
+
+    def test_origin_display_returns_evcs_when_snapshot_present(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-EVCS",
+            evcs_snapshot_at=timezone.now(),
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "EVCS")
+
+    def test_origin_display_returns_local_without_snapshot(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-LOCAL",
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "Local")
+
+    def test_save_model_resets_snapshot_timestamp(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-SAVE",
+            evcs_snapshot_at=timezone.now(),
+        )
+        request = self.request_factory.post("/admin/ocpp/chargerconfiguration/")
+        self.admin.save_model(request, configuration, form=None, change=True)
+        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):
+        store.pending_calls.clear()
+
+    def test_check_charge_point_configuration_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="TASKCFG")
+        ws = DummyWebSocket()
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        pending_key = store.pending_key(charger.charger_id)
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        try:
+            result = check_charge_point_configuration.run(charger.pk)
+            self.assertTrue(result)
+            self.assertEqual(len(ws.sent), 1)
+            frame = json.loads(ws.sent[0])
+            self.assertEqual(frame[0], 2)
+            self.assertEqual(frame[2], "GetConfiguration")
+            self.assertIn(frame[1], store.pending_calls)
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pending_calls.clear()
+            store.clear_log(log_key, log_type="charger")
+            store.clear_log(pending_key, log_type="charger")
+
+    def test_check_charge_point_configuration_without_connection(self):
+        charger = Charger.objects.create(charger_id="TASKNOCONN")
+        result = check_charge_point_configuration.run(charger.pk)
+        self.assertFalse(result)
+
+    def test_schedule_daily_checks_only_includes_root_chargers(self):
+        eligible = Charger.objects.create(charger_id="TASKROOT")
+        Charger.objects.create(charger_id="TASKCONN", connector_id=1)
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 1)
+        mock_delay.assert_called_once_with(eligible.pk)
+
+    def test_schedule_daily_checks_returns_zero_without_chargers(self):
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 0)
+        mock_delay.assert_not_called()
+
 
 class LocationAdminTests(TestCase):
     def setUp(self):
@@ -2700,6 +3849,28 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    def test_auto_registered_charger_location_name_sanitized(self):
+        async def exercise():
+            communicator = WebsocketCommunicator(
+                application, "/?cid=ACME%20Charger%20%231"
+            )
+            connected, _ = await communicator.connect()
+            self.assertTrue(connected)
+
+            await communicator.disconnect()
+
+            def fetch_location_name() -> str:
+                charger = (
+                    Charger.objects.select_related("location")
+                    .get(charger_id="ACME Charger #1")
+                )
+                return charger.location.name
+
+            location_name = await database_sync_to_async(fetch_location_name)()
+            self.assertEqual(location_name, "ACME_Charger_1")
+
+        async_to_sync(exercise)()
+
     async def test_query_string_cid_supported(self):
         communicator = WebsocketCommunicator(application, "/?cid=QSERIAL")
         connected, _ = await communicator.connect()
@@ -2860,6 +4031,44 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_authorize_requires_rfid_accepts_allowed_tag_without_account(self):
+        charger_id = "AUTHWARN"
+        tag_value = "WARN01"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_id = "auth-unlinked"
+        await communicator.send_json_to(
+            [2, message_id, "Authorize", {"idTag": tag_value}]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[1], message_id)
+        self.assertEqual(response[2], {"idTagInfo": {"status": "Accepted"}})
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_authorize_without_requirement_records_rfid(self):
         await database_sync_to_async(Charger.objects.create)(
             charger_id="AUTHOPT", require_rfid=False
@@ -2952,6 +4161,61 @@ class SimulatorAdminTests(TransactionTestCase):
         )
         self.assertEqual(tx.account_id, user.energy_account.id)
 
+    async def test_start_transaction_allows_allowed_tag_without_account(self):
+        charger_id = "STARTWARN"
+        tag_value = "WARN02"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        start_payload = {
+            "meterStart": 5,
+            "idTag": tag_value,
+            "connectorId": 1,
+        }
+        await communicator.send_json_to([2, "start-1", "StartTransaction", start_payload])
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[2]["idTagInfo"]["status"], "Accepted")
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id=charger_id
+        )
+        self.assertIsNone(tx.account_id)
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.send_json_to(
+            [
+                2,
+                "stop-1",
+                "StopTransaction",
+                {"transactionId": tx_id, "meterStop": 6},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_status_fields_updated(self):
         communicator = WebsocketCommunicator(application, "/STAT/")
         connected, _ = await communicator.connect()
@@ -3017,8 +4281,7 @@ class SimulatorAdminTests(TransactionTestCase):
         self.assertIsNotNone(aggregate.last_heartbeat)
         if previous_heartbeat:
             self.assertNotEqual(aggregate.last_heartbeat, previous_heartbeat)
-        if connector.last_heartbeat:
-            self.assertNotEqual(aggregate.last_heartbeat, connector.last_heartbeat)
+        self.assertEqual(connector.last_heartbeat, aggregate.last_heartbeat)
 
         await communicator.disconnect()
 
@@ -3045,6 +4308,10 @@ class ChargerLocationTests(TestCase):
         second = Charger.objects.create(charger_id="SHARE", connector_id=2)
         self.assertEqual(second.location, first.location)
 
+    def test_location_name_sanitized_when_auto_created(self):
+        charger = Charger.objects.create(charger_id="Name With spaces!#1")
+        self.assertEqual(charger.location.name, "Name_With_spaces_1")
+
 
 class MeterReadingTests(TransactionTestCase):
     async def test_meter_values_saved_as_readings(self):
@@ -3391,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:
@@ -3732,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(
@@ -3785,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):
@@ -3814,6 +5140,43 @@ class TransactionKwTests(TestCase):
         self.assertEqual(tx.kw, 0.0)
 
 
+class TransactionIdentifierTests(TestCase):
+    def test_vehicle_identifier_prefers_vid(self):
+        charger = Charger.objects.create(charger_id="VIDPREF")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vid="VID-123",
+            vin="VIN-456",
+        )
+        self.assertEqual(tx.vehicle_identifier, "VID-123")
+        self.assertEqual(tx.vehicle_identifier_source, "vid")
+
+    def test_vehicle_identifier_falls_back_to_vin(self):
+        charger = Charger.objects.create(charger_id="VINONLY")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vin="WP0ZZZ00000000001",
+        )
+        self.assertEqual(tx.vehicle_identifier, "WP0ZZZ00000000001")
+        self.assertEqual(tx.vehicle_identifier_source, "vin")
+
+    def test_transaction_rfid_details_handles_vin(self):
+        charger = Charger.objects.create(charger_id="VINDET")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vin="WAUZZZ00000000002",
+        )
+        details = _transaction_rfid_details(tx, cache={})
+        self.assertIsNotNone(details)
+        assert details is not None  # for type checkers
+        self.assertEqual(details["value"], "WAUZZZ00000000002")
+        self.assertEqual(details["display_label"], "VIN")
+        self.assertEqual(details["type"], "vin")
+
+
 class DispatchActionViewTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -3860,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:
@@ -3932,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)
@@ -3994,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,
@@ -4001,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)
@@ -4112,6 +5662,130 @@ class ChargerStatusViewTests(TestCase):
         self.assertAlmostEqual(resp.context["tx"].kw, 0.02)
         store.transactions.pop(key, None)
 
+    def test_usage_timeline_rendered_when_chart_unavailable(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(charger_id="TL1", connector_id=1)
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            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] = 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)
+        statuses = {segment["status"] for segment in data[0]["segments"]}
+        self.assertIn("charging", statuses)
+        self.assertIn("available", statuses)
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(
+                reverse(
+                    "charger-status-connector",
+                    args=[charger.charger_id, charger.connector_slug],
+                )
+            )
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, "usage-timeline-segment usage-charging")
+
+    def test_usage_timeline_includes_multiple_connectors(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        aggregate = Charger.objects.create(charger_id="TLAGG")
+        connector_one = Charger.objects.create(charger_id="TLAGG", connector_id=1)
+        connector_two = Charger.objects.create(charger_id="TLAGG", connector_id=2)
+
+        def build_entry(connector_id, delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": connector_id,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            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, deque(maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES)
+            ).append(
+                f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+            )
+
+        build_entry(1, timedelta(days=3), "Available")
+        build_entry(2, timedelta(days=2), "Charging")
+
+        overview = [{"charger": connector_one}, {"charger": connector_two}]
+        data, _window = _usage_timeline(aggregate, overview, now=fixed_now)
+        self.assertEqual(len(data), 2)
+        self.assertTrue(all(entry["segments"] for entry in data))
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(reverse("charger-status", args=[aggregate.charger_id]))
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, connector_one.connector_label)
+        self.assertContains(resp, connector_two.connector_label)
+
+    def test_usage_timeline_merges_repeated_status_entries(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(
+            charger_id="TLDEDUP",
+            connector_id=1,
+            last_status="Available",
+        )
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            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] = 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)
+        self.assertEqual(len(data), 1)
+        segments = data[0]["segments"]
+        self.assertGreaterEqual(len(segments), 1)
+        statuses = [segment["status"] for segment in segments]
+        self.assertEqual(statuses, ["available", "charging", "available"])
+
     def test_diagnostics_status_displayed(self):
         reported_at = timezone.now().replace(microsecond=0)
         charger = Charger.objects.create(
@@ -4130,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",
@@ -4442,6 +6147,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"
@@ -4466,6 +6214,59 @@ class LiveUpdateViewTests(TestCase):
         )
         self.assertEqual(aggregate_entry["state"], available_label)
 
+    def test_dashboard_groups_connectors_under_parent(self):
+        aggregate = Charger.objects.create(charger_id="GROUPED")
+        first = Charger.objects.create(
+            charger_id=aggregate.charger_id, connector_id=1
+        )
+        second = Charger.objects.create(
+            charger_id=aggregate.charger_id, connector_id=2
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        groups = resp.context["charger_groups"]
+        target = next(
+            group
+            for group in groups
+            if group.get("parent")
+            and group["parent"]["charger"].pk == aggregate.pk
+        )
+        child_ids = [item["charger"].pk for item in target["children"]]
+        self.assertEqual(child_ids, [first.pk, second.pk])
+
+    def test_dashboard_includes_energy_totals(self):
+        aggregate = Charger.objects.create(charger_id="KWSTATS")
+        now = timezone.now()
+        Transaction.objects.create(
+            charger=aggregate,
+            start_time=now - timedelta(hours=1),
+            stop_time=now,
+            meter_start=0,
+            meter_stop=3000,
+        )
+        past_start = now - timedelta(days=2)
+        Transaction.objects.create(
+            charger=aggregate,
+            start_time=past_start,
+            stop_time=past_start + timedelta(hours=1),
+            meter_start=0,
+            meter_stop=1000,
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        groups = resp.context["charger_groups"]
+        target = next(
+            group
+            for group in groups
+            if group.get("parent")
+            and group["parent"]["charger"].pk == aggregate.pk
+        )
+        stats = target["parent"]["stats"]
+        self.assertAlmostEqual(stats["total_kw"], 4.0, places=2)
+        self.assertAlmostEqual(stats["today_kw"], 3.0, places=2)
+
     def test_cp_simulator_includes_interval(self):
         resp = self.client.get(reverse("cp-simulator"))
         self.assertEqual(resp.context["request"].live_update_interval, 5)
@@ -4553,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))