arthexis 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

ocpp/tests.py

@@ -1,44 +1,84 @@
 import os
+import sys
+import time
+from importlib import util as importlib_util
+from pathlib import Path
+from types import ModuleType
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 
+try:  # pragma: no cover - exercised via test command imports
+    import tests.conftest as tests_conftest  # type: ignore[import-not-found]
+except ModuleNotFoundError:  # pragma: no cover - fallback for pytest importlib mode
+    tests_dir = Path(__file__).resolve().parents[1] / "tests"
+    spec = importlib_util.spec_from_file_location(
+        "tests.conftest", tests_dir / "conftest.py"
+    )
+    if spec is None or spec.loader is None:  # pragma: no cover - defensive
+        raise
+    tests_conftest = importlib_util.module_from_spec(spec)
+    package = sys.modules.setdefault("tests", ModuleType("tests"))
+    package.__path__ = [str(tests_dir)]
+    sys.modules.setdefault("tests.conftest", tests_conftest)
+    spec.loader.exec_module(tests_conftest)
+else:
+    sys.modules.setdefault("tests.conftest", tests_conftest)
+
 import django
 
+django.setup = tests_conftest._original_setup
 django.setup()
 
 from asgiref.testing import ApplicationCommunicator
 from channels.testing import WebsocketCommunicator
 from channels.db import database_sync_to_async
 from asgiref.sync import async_to_sync
-from django.test import Client, TransactionTestCase, TestCase, override_settings
+from django.test import (
+    Client,
+    RequestFactory,
+    TransactionTestCase,
+    TestCase,
+    override_settings,
+)
 from unittest import skip
 from contextlib import suppress
 from types import SimpleNamespace
-from unittest.mock import patch, Mock
+from unittest.mock import patch, Mock, AsyncMock
 from django.contrib.auth import get_user_model
 from django.urls import reverse
 from django.utils import timezone
 from django.utils.dateparse import parse_datetime
+from django.utils.encoding import force_str
 from django.utils.translation import override, gettext as _
 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 config.asgi import application
 
-from .models import Transaction, Charger, Simulator, MeterReading, Location
+from .models import (
+    Transaction,
+    Charger,
+    Simulator,
+    MeterReading,
+    Location,
+    DataTransferMessage,
+)
 from .consumers import CSMSConsumer
-from core.models import EnergyAccount, EnergyCredit, Reference, RFID
+from .views import dispatch_action
+from .status_display import STATUS_BADGE_MAP
+from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
 from django.db.models.deletion import ProtectedError
 from decimal import Decimal
 import json
 import websockets
 import asyncio
-from pathlib import Path
 from .simulator import SimulatorConfig, ChargePointSimulator
+from .evcs import simulate, SimulatorState, _simulators
 import re
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone as dt_timezone
 from .tasks import purge_meter_readings
 from django.db import close_old_connections
 from django.db.utils import OperationalError
@@ -87,6 +127,47 @@ class DummyWebSocket:
         self.sent.append(message)
 
 
+class DispatchActionTests(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    def tearDown(self):  # pragma: no cover - cleanup guard
+        store.pending_calls.clear()
+        store.triggered_followups.clear()
+
+    def test_trigger_message_registers_pending_call(self):
+        charger = Charger.objects.create(charger_id="TRIGGER1")
+        dummy = DummyWebSocket()
+        key = store.set_connection("TRIGGER1", None, dummy)
+        self.addCleanup(lambda: store.connections.pop(key, None))
+        log_key = store.identity_key("TRIGGER1", None)
+        store.clear_log(log_key, log_type="charger")
+        self.addCleanup(lambda: store.clear_log(log_key, log_type="charger"))
+
+        request = self.factory.post(
+            "/chargers/TRIGGER1/action/",
+            data=json.dumps({"action": "trigger_message", "target": "BootNotification"}),
+            content_type="application/json",
+        )
+        request.user = SimpleNamespace(
+            is_authenticated=True,
+            is_superuser=True,
+            is_staff=True,
+        )
+
+        response = dispatch_action(request, "TRIGGER1")
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(dummy.sent)
+        frame = json.loads(dummy.sent[-1])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "TriggerMessage")
+        message_id = frame[1]
+        self.assertIn(message_id, store.pending_calls)
+        metadata = store.pending_calls[message_id]
+        self.assertEqual(metadata.get("action"), "TriggerMessage")
+        self.assertEqual(metadata.get("trigger_target"), "BootNotification")
+        self.assertEqual(metadata.get("log_key"), log_key)
+
 class ChargerFixtureTests(TestCase):
     fixtures = [
         p.name
@@ -188,6 +269,39 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_rejected_connection_logs_query_string(self):
+        raw_serial = "<charger_id>"
+        query_string = "chargeboxid=%3Ccharger_id%3E"
+        pending_key = store.pending_key(Charger.normalize_serial(raw_serial))
+        store.ip_connections.clear()
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = ClientWebsocketCommunicator(
+            application, f"/?{query_string}"
+        )
+
+        try:
+            connected = await communicator.connect()
+            self.assertEqual(connected, (False, 4003))
+
+            log_entries = store.get_logs(pending_key, log_type="charger")
+            self.assertTrue(
+                any(
+                    "Rejected connection:" in entry and query_string in entry
+                    for entry in log_entries
+                ),
+                log_entries,
+            )
+        finally:
+            store.ip_connections.clear()
+            store.clear_log(pending_key, log_type="charger")
+            lower_key = pending_key.lower()
+            for key in list(store.logs["charger"].keys()):
+                if key.lower() == lower_key:
+                    store.logs["charger"].pop(key, None)
+            with suppress(Exception):
+                await communicator.disconnect()
+
     async def test_transaction_saved(self):
         communicator = WebsocketCommunicator(application, "/TEST/")
         connected, _ = await communicator.connect()
@@ -227,9 +341,47 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    def test_status_notification_available_clears_active_session(self):
+        aggregate = Charger.objects.create(charger_id="STATUSCLR")
+        connector = Charger.objects.create(
+            charger_id="STATUSCLR",
+            connector_id=2,
+        )
+        tx = Transaction.objects.create(
+            charger=connector,
+            meter_start=10,
+            start_time=timezone.now(),
+        )
+        store_key = store.identity_key("STATUSCLR", 2)
+        store.transactions[store_key] = tx
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = "STATUSCLR"
+        consumer.store_key = store_key
+        consumer.connector_value = 2
+        consumer.charger = connector
+        consumer.aggregate_charger = aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+        payload = {
+            "connectorId": 2,
+            "status": "Available",
+            "errorCode": "NoError",
+            "transactionId": tx.pk,
+        }
+        try:
+            with patch.object(consumer, "_assign_connector", new=AsyncMock()):
+                async_to_sync(consumer.receive)(
+                    text_data=json.dumps([2, "1", "StatusNotification", payload])
+                )
+        finally:
+            store.transactions.pop(store_key, None)
+        self.assertNotIn(store_key, store.transactions)
+
     async def test_rfid_recorded(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="RFIDREC")
-        communicator = WebsocketCommunicator(application, "/RFIDREC/")
+        communicator = WebsocketCommunicator(application, "/RFIDREC/?cid=RFIDREC")
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
@@ -244,6 +396,82 @@ class CSMSConsumerTests(TransactionTestCase):
         )
         self.assertEqual(tx.rfid, "TAG123")
 
+        tag = await database_sync_to_async(RFID.objects.get)(rfid="TAG123")
+        self.assertFalse(tag.allowed)
+        self.assertIsNotNone(tag.last_seen_on)
+
+        await communicator.disconnect()
+
+    async def test_start_transaction_uses_payload_timestamp(self):
+        communicator = WebsocketCommunicator(application, "/STAMPED/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        start_ts = datetime(2025, 9, 26, 18, 1, tzinfo=dt_timezone.utc)
+        before = timezone.now()
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 5, "timestamp": start_ts.isoformat()},
+            ]
+        )
+        response = await communicator.receive_json_from()
+        after = timezone.now()
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id="STAMPED"
+        )
+        self.assertEqual(tx.start_time, start_ts)
+        self.assertIsNotNone(tx.received_start_time)
+        self.assertGreaterEqual(tx.received_start_time, before)
+        self.assertLessEqual(tx.received_start_time, after)
+
+        await communicator.disconnect()
+
+    async def test_stop_transaction_uses_payload_timestamp(self):
+        communicator = WebsocketCommunicator(application, "/STOPSTAMP/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 10},
+            ]
+        )
+        response = await communicator.receive_json_from()
+        tx_id = response[2]["transactionId"]
+
+        stop_ts = datetime(2025, 9, 26, 18, 5, tzinfo=dt_timezone.utc)
+        before = timezone.now()
+        await communicator.send_json_to(
+            [
+                2,
+                "2",
+                "StopTransaction",
+                {
+                    "transactionId": tx_id,
+                    "meterStop": 20,
+                    "timestamp": stop_ts.isoformat(),
+                },
+            ]
+        )
+        await communicator.receive_json_from()
+        after = timezone.now()
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id="STOPSTAMP"
+        )
+        self.assertEqual(tx.stop_time, stop_ts)
+        self.assertIsNotNone(tx.received_stop_time)
+        self.assertGreaterEqual(tx.received_stop_time, before)
+        self.assertLessEqual(tx.received_stop_time, after)
+
         await communicator.disconnect()
 
     async def test_start_transaction_sends_net_message(self):
@@ -315,6 +543,301 @@ class CSMSConsumerTests(TransactionTestCase):
         self.assertTrue(message_mock.save.called)
         self.assertTrue(message_mock.propagate.called)
 
+    async def test_assign_connector_promotes_pending_connection(self):
+        serial = "ASSIGNPROMOTE"
+        path = f"/{serial}/"
+        pending_key = store.pending_key(serial)
+        new_key = store.identity_key(serial, 1)
+        aggregate_key = store.identity_key(serial, None)
+
+        store.connections.pop(pending_key, None)
+        store.connections.pop(new_key, None)
+        store.logs["charger"].pop(new_key, None)
+        store.log_names["charger"].pop(new_key, None)
+        store.log_names["charger"].pop(aggregate_key, None)
+
+        aggregate = await database_sync_to_async(Charger.objects.create)(
+            charger_id=serial,
+            connector_id=None,
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"path": path, "headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = serial
+        consumer.store_key = pending_key
+        consumer.connector_value = None
+        consumer.client_ip = "127.0.0.1"
+        consumer.charger = aggregate
+        consumer.aggregate_charger = aggregate
+
+        store.connections[pending_key] = consumer
+
+        try:
+            with patch.object(Charger, "refresh_manager_node", autospec=True) as mock_refresh:
+                mock_refresh.return_value = None
+                await consumer._assign_connector(1)
+
+            self.assertEqual(consumer.store_key, new_key)
+            self.assertNotIn(pending_key, store.connections)
+
+            connector = await database_sync_to_async(Charger.objects.get)(
+                charger_id=serial,
+                connector_id=1,
+            )
+            self.assertEqual(consumer.charger.pk, connector.pk)
+            self.assertEqual(consumer.charger.connector_id, 1)
+            self.assertIsNone(consumer.aggregate_charger.connector_id)
+
+            self.assertIn(new_key, store.log_names["charger"])
+            self.assertIn(aggregate_key, store.log_names["charger"])
+
+            self.assertNotIn(pending_key, store.connections)
+        finally:
+            store.connections.pop(new_key, None)
+            store.connections.pop(pending_key, None)
+            store.logs["charger"].pop(new_key, None)
+            store.log_names["charger"].pop(new_key, None)
+            store.log_names["charger"].pop(aggregate_key, None)
+            await database_sync_to_async(Charger.objects.filter(charger_id=serial).delete)()
+
+    async def test_change_availability_result_updates_model(self):
+        store.pending_calls.clear()
+        communicator = WebsocketCommunicator(application, "/AVAILRES/")
+        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 = "ca-result"
+        requested_at = timezone.now()
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ChangeAvailability",
+                "charger_id": "AVAILRES",
+                "connector_id": None,
+                "availability_type": "Inoperative",
+                "requested_at": requested_at,
+            },
+        )
+        await communicator.send_json_to([3, message_id, {"status": "Accepted"}])
+        await asyncio.sleep(0.05)
+
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="AVAILRES", connector_id=None
+        )
+        self.assertEqual(charger.availability_state, "Inoperative")
+        self.assertEqual(charger.availability_request_status, "Accepted")
+        self.assertEqual(charger.availability_requested_state, "Inoperative")
+        await communicator.disconnect()
+
+    async def test_get_configuration_result_logged(self):
+        store.pending_calls.clear()
+        pending_key = store.pending_key("CFGRES")
+        store.clear_log(pending_key, log_type="charger")
+        log_key = store.identity_key("CFGRES", None)
+        store.clear_log(log_key, log_type="charger")
+        communicator = WebsocketCommunicator(application, "/CFGRES/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_id = "cfg-result"
+        payload = {
+            "configurationKey": [
+                {
+                    "key": "AllowOfflineTxForUnknownId",
+                    "readonly": True,
+                    "value": "false",
+                }
+            ]
+        }
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "GetConfiguration",
+                "charger_id": "CFGRES",
+                "connector_id": None,
+                "log_key": log_key,
+                "requested_at": timezone.now(),
+            },
+        )
+
+        await communicator.send_json_to([3, message_id, payload])
+        await asyncio.sleep(0.05)
+
+        log_entries = store.get_logs(log_key, log_type="charger")
+        self.assertTrue(
+            any("GetConfiguration result" in entry for entry in log_entries)
+        )
+        self.assertNotIn(message_id, store.pending_calls)
+
+        await communicator.disconnect()
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+
+    async def test_get_configuration_error_logged(self):
+        store.pending_calls.clear()
+        pending_key = store.pending_key("CFGERR")
+        store.clear_log(pending_key, log_type="charger")
+        log_key = store.identity_key("CFGERR", None)
+        store.clear_log(log_key, log_type="charger")
+        communicator = WebsocketCommunicator(application, "/CFGERR/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_id = "cfg-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "GetConfiguration",
+                "charger_id": "CFGERR",
+                "connector_id": None,
+                "log_key": log_key,
+                "requested_at": timezone.now(),
+            },
+        )
+
+        await communicator.send_json_to(
+            [4, message_id, "InternalError", "Boom", {"detail": "nope"}]
+        )
+        await asyncio.sleep(0.05)
+
+        log_entries = store.get_logs(log_key, log_type="charger")
+        self.assertTrue(
+            any("GetConfiguration error" in entry for entry in log_entries)
+        )
+        self.assertNotIn(message_id, store.pending_calls)
+
+        await communicator.disconnect()
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+
+    async def test_trigger_message_follow_up_logged(self):
+        store.pending_calls.clear()
+        cid = "TRIGLOG"
+        pending_key = store.pending_key(cid)
+        log_key = store.identity_key(cid, None)
+        store.clear_log(pending_key, log_type="charger")
+        store.clear_log(log_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{cid}/")
+        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 = "trigger-result"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "TriggerMessage",
+                "charger_id": cid,
+                "connector_id": None,
+                "log_key": log_key,
+                "trigger_target": "BootNotification",
+                "trigger_connector": None,
+            },
+        )
+
+        await communicator.send_json_to([3, message_id, {"status": "Accepted"}])
+        await asyncio.sleep(0.05)
+        self.assertNotIn(message_id, store.pending_calls)
+
+        log_entries = store.get_logs(log_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "TriggerMessage BootNotification result" in entry
+                or "TriggerMessage result" in entry
+                for entry in log_entries
+            )
+        )
+
+        await communicator.send_json_to(
+            [
+                2,
+                "trigger-follow",
+                "BootNotification",
+                {"chargePointVendor": "Test", "chargePointModel": "Model"},
+            ]
+        )
+        await communicator.receive_json_from()
+        await asyncio.sleep(0.05)
+
+        log_entries = store.get_logs(log_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "TriggerMessage follow-up received: BootNotification" in entry
+                for entry in log_entries
+            )
+        )
+
+        await communicator.disconnect()
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+
+    async def test_status_notification_updates_availability_state(self):
+        store.pending_calls.clear()
+        communicator = WebsocketCommunicator(application, "/STATAVAIL/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "boot",
+                "BootNotification",
+                {"chargePointVendor": "Test", "chargePointModel": "Model"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        await communicator.send_json_to(
+            [
+                2,
+                "stat1",
+                "StatusNotification",
+                {"connectorId": 1, "errorCode": "NoError", "status": "Unavailable"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="STATAVAIL", connector_id=1
+        )
+        self.assertEqual(charger.availability_state, "Inoperative")
+
+        await communicator.send_json_to(
+            [
+                2,
+                "stat2",
+                "StatusNotification",
+                {"connectorId": 1, "errorCode": "NoError", "status": "Available"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="STATAVAIL", connector_id=1
+        )
+        self.assertEqual(charger.availability_state, "Operative")
+        await communicator.disconnect()
+
     async def test_consumption_message_final_update_on_disconnect(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="FINALMSG")
         communicator = WebsocketCommunicator(application, "/FINALMSG/")
@@ -435,14 +958,9 @@ class CSMSConsumerTests(TransactionTestCase):
         self.assertEqual(detail_payload["firmwareStatus"], "Installing")
         self.assertEqual(detail_payload["firmwareStatusInfo"], "Applying patch")
         self.assertEqual(detail_payload["firmwareTimestamp"], ts.isoformat())
-        self.assertIn('id="firmware-status">Installing<', html)
-        self.assertIn('id="firmware-status-info">Applying patch<', html)
-        match = re.search(
-            r'id="firmware-timestamp"[^>]*data-iso="([^"]+)"', html
-        )
-        self.assertIsNotNone(match)
-        parsed_iso = datetime.fromisoformat(match.group(1))
-        self.assertAlmostEqual(parsed_iso.timestamp(), ts.timestamp(), places=3)
+        self.assertNotIn('id="firmware-status"', html)
+        self.assertNotIn('id="firmware-status-info"', html)
+        self.assertNotIn('id="firmware-timestamp"', html)
 
         matching = [
             item
@@ -924,7 +1442,11 @@ class CSMSConsumerTests(TransactionTestCase):
         self.assertContains(status_resp, "background-color: #dc3545")
 
         aggregate_status = self.client.get(reverse("charger-status", args=[serial]))
-        self.assertContains(aggregate_status, "Reported status")
+        self.assertContains(
+            aggregate_status,
+            f"Serial Number: {serial}",
+        )
+        self.assertNotContains(aggregate_status, 'id="last-status-raw"')
         self.assertContains(aggregate_status, "Info: Relay malfunction")
 
         page_resp = self.client.get(reverse("charger-page", args=[serial]))
@@ -1153,6 +1675,92 @@ class CSMSConsumerTests(TransactionTestCase):
             if connected3_retry and communicator3_retry is not None:
                 await communicator3_retry.disconnect()
 
+    async def test_data_transfer_inbound_persists_message(self):
+        store.pending_calls.clear()
+        communicator = WebsocketCommunicator(application, "/DTIN/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        payload = {"vendorId": "Acme", "messageId": "diag", "data": {"foo": "bar"}}
+        await communicator.send_json_to([2, "dt-msg", "DataTransfer", payload])
+        response = await communicator.receive_json_from()
+        self.assertEqual(response, [3, "dt-msg", {"status": "UnknownVendorId"}])
+
+        await communicator.disconnect()
+
+        message = await database_sync_to_async(DataTransferMessage.objects.get)(
+            ocpp_message_id="dt-msg"
+        )
+        self.assertEqual(
+            message.direction, DataTransferMessage.DIRECTION_CP_TO_CSMS
+        )
+        self.assertEqual(message.vendor_id, "Acme")
+        self.assertEqual(message.message_id, "diag")
+        self.assertEqual(message.payload, payload)
+        self.assertEqual(message.status, "UnknownVendorId")
+        self.assertIsNotNone(message.responded_at)
+
+    async def test_data_transfer_action_round_trip(self):
+        store.pending_calls.clear()
+        communicator = WebsocketCommunicator(application, "/DTOUT/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        User = get_user_model()
+        user = await database_sync_to_async(User.objects.create_user)(
+            username="dtuser", password="pw"
+        )
+        await database_sync_to_async(self.client.force_login)(user)
+
+        url = reverse("charger-action", args=["DTOUT"])
+        request_payload = {
+            "action": "data_transfer",
+            "vendorId": "AcmeCorp",
+            "messageId": "ping",
+            "data": {"echo": "value"},
+        }
+        response = await database_sync_to_async(self.client.post)(
+            url,
+            data=json.dumps(request_payload),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 200)
+        response_body = json.loads(response.content.decode())
+        sent_frame = json.loads(response_body["sent"])
+        self.assertEqual(sent_frame[2], "DataTransfer")
+        sent_payload = sent_frame[3]
+        self.assertEqual(sent_payload["vendorId"], "AcmeCorp")
+        self.assertEqual(sent_payload.get("messageId"), "ping")
+
+        outbound = await communicator.receive_json_from()
+        self.assertEqual(outbound, sent_frame)
+
+        message_id = sent_frame[1]
+        record = await database_sync_to_async(DataTransferMessage.objects.get)(
+            ocpp_message_id=message_id
+        )
+        self.assertEqual(
+            record.direction, DataTransferMessage.DIRECTION_CSMS_TO_CP
+        )
+        self.assertEqual(record.status, "Pending")
+        self.assertIsNone(record.response_data)
+        self.assertIn(message_id, store.pending_calls)
+        self.assertEqual(store.pending_calls[message_id]["message_pk"], record.pk)
+
+        reply_payload = {"status": "Accepted", "data": {"result": "ok"}}
+        await communicator.send_json_to([3, message_id, reply_payload])
+        await asyncio.sleep(0.05)
+
+        updated = await database_sync_to_async(DataTransferMessage.objects.get)(
+            pk=record.pk
+        )
+        self.assertEqual(updated.status, "Accepted")
+        self.assertEqual(updated.response_data, {"result": "ok"})
+        self.assertIsNotNone(updated.responded_at)
+        self.assertNotIn(message_id, store.pending_calls)
+
+        await communicator.disconnect()
+
 
 class ChargerLandingTests(TestCase):
     def setUp(self):
@@ -1175,28 +1783,148 @@ class ChargerLandingTests(TestCase):
                     "Plug in your vehicle and slide your RFID card over the reader to begin charging."
                 ),
             )
-            self.assertContains(response, _("Advanced View"))
-        status_url = reverse("charger-status-connector", args=["PAGE1", "all"])
-        self.assertContains(response, status_url)
+            self.assertContains(response, _("Advanced View"))
+        status_url = reverse("charger-status-connector", args=["PAGE1", "all"])
+        self.assertContains(response, status_url)
+
+    def test_status_page_renders(self):
+        charger = Charger.objects.create(charger_id="PAGE2")
+        resp = self.client.get(reverse("charger-status", args=["PAGE2"]))
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "PAGE2")
+
+    def test_placeholder_serial_rejected(self):
+        with self.assertRaises(ValidationError):
+            Charger.objects.create(charger_id="<charger_id>")
+
+    def test_placeholder_serial_not_created_from_status_view(self):
+        existing = Charger.objects.count()
+        response = self.client.get(reverse("charger-status", args=["<charger_id>"]))
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(Charger.objects.count(), existing)
+        self.assertFalse(
+            Location.objects.filter(
+                name__startswith="<", name__endswith=">", chargers__isnull=True
+            ).exists()
+        )
+
+    def test_charger_page_shows_progress(self):
+        charger = Charger.objects.create(charger_id="STATS")
+        tx = Transaction.objects.create(
+            charger=charger,
+            meter_start=1000,
+            start_time=timezone.now(),
+        )
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
+        resp = self.client.get(reverse("charger-page", args=["STATS"]))
+        self.assertContains(resp, "progress-bar")
+        store.transactions.pop(key, None)
+
+    def test_public_page_overrides_available_status_when_charging(self):
+        charger = Charger.objects.create(
+            charger_id="STATEPUB",
+            last_status="Available",
+        )
+        tx = Transaction.objects.create(
+            charger=charger,
+            meter_start=1000,
+            start_time=timezone.now(),
+        )
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
+        try:
+            response = self.client.get(reverse("charger-page", args=["STATEPUB"]))
+            self.assertEqual(response.status_code, 200)
+            self.assertContains(
+                response,
+                'class="badge" style="background-color: #198754;">Charging</span>',
+            )
+        finally:
+            store.transactions.pop(key, None)
+
+    def test_admin_status_overrides_available_status_when_charging(self):
+        charger = Charger.objects.create(
+            charger_id="STATEADM",
+            last_status="Available",
+        )
+        tx = Transaction.objects.create(
+            charger=charger,
+            meter_start=1000,
+            start_time=timezone.now(),
+        )
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
+        try:
+            response = self.client.get(reverse("charger-status", args=["STATEADM"]))
+            self.assertEqual(response.status_code, 200)
+            self.assertContains(response, 'id="charger-state">Charging</strong>')
+            self.assertContains(
+                response,
+                'style="width:20px;height:20px;background-color: #198754;"',
+            )
+        finally:
+            store.transactions.pop(key, None)
 
-    def test_status_page_renders(self):
-        charger = Charger.objects.create(charger_id="PAGE2")
-        resp = self.client.get(reverse("charger-status", args=["PAGE2"]))
-        self.assertEqual(resp.status_code, 200)
-        self.assertContains(resp, "PAGE2")
+    def test_public_status_shows_rfid_link_for_known_tag(self):
+        aggregate = Charger.objects.create(charger_id="PUBRFID")
+        connector = Charger.objects.create(
+            charger_id="PUBRFID",
+            connector_id=1,
+        )
+        tx = Transaction.objects.create(
+            charger=connector,
+            meter_start=1000,
+            start_time=timezone.now(),
+            rfid="TAGLINK",
+        )
+        key = store.identity_key(connector.charger_id, connector.connector_id)
+        store.transactions[key] = tx
+        tag = RFID.objects.create(rfid="TAGLINK")
+        admin_url = reverse("admin:core_rfid_change", args=[tag.pk])
+        try:
+            response = self.client.get(
+                reverse(
+                    "charger-page-connector",
+                    args=[connector.charger_id, connector.connector_slug],
+                )
+            )
+            self.assertContains(response, admin_url)
+            self.assertContains(response, "TAGLINK")
 
-    def test_charger_page_shows_progress(self):
-        charger = Charger.objects.create(charger_id="STATS")
+            overview = self.client.get(reverse("charger-page", args=[aggregate.charger_id]))
+            self.assertContains(overview, admin_url)
+        finally:
+            store.transactions.pop(key, None)
+
+    def test_public_status_shows_rfid_text_when_unknown(self):
+        Charger.objects.create(charger_id="PUBTEXT")
+        connector = Charger.objects.create(
+            charger_id="PUBTEXT",
+            connector_id=1,
+        )
         tx = Transaction.objects.create(
-            charger=charger,
+            charger=connector,
             meter_start=1000,
             start_time=timezone.now(),
+            rfid="TAGNONE",
         )
-        key = store.identity_key(charger.charger_id, charger.connector_id)
+        key = store.identity_key(connector.charger_id, connector.connector_id)
         store.transactions[key] = tx
-        resp = self.client.get(reverse("charger-page", args=["STATS"]))
-        self.assertContains(resp, "progress-bar")
-        store.transactions.pop(key, None)
+        try:
+            response = self.client.get(
+                reverse(
+                    "charger-page-connector",
+                    args=[connector.charger_id, connector.connector_slug],
+                )
+            )
+            self.assertContains(response, "TAGNONE")
+            self.assertNotContains(response, "TAGNONE</a>")
+
+            overview = self.client.get(reverse("charger-page", args=[connector.charger_id]))
+            self.assertContains(overview, "TAGNONE")
+        finally:
+            store.transactions.pop(key, None)
 
     def test_display_name_used_on_public_pages(self):
         charger = Charger.objects.create(
@@ -1306,6 +2034,12 @@ class SimulatorLandingTests(TestCase):
         self.assertContains(resp, "/ocpp/")
         self.assertContains(resp, "/ocpp/simulator/")
 
+    def test_cp_simulator_redirects_to_login(self):
+        response = self.client.get(reverse("cp-simulator"))
+        login_url = reverse("pages:login")
+        self.assertEqual(response.status_code, 302)
+        self.assertIn(login_url, response.url)
+
 
 class ChargerAdminTests(TestCase):
     def setUp(self):
@@ -1337,6 +2071,25 @@ class ChargerAdminTests(TestCase):
         log_url = reverse("admin:ocpp_charger_log", args=[charger.pk])
         self.assertContains(resp, log_url)
 
+    def test_admin_status_overrides_available_when_active_session(self):
+        charger = Charger.objects.create(
+            charger_id="ADMINCHARGE",
+            last_status="Available",
+        )
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+        )
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            resp = self.client.get(url)
+            charging_label = force_str(STATUS_BADGE_MAP["charging"][0])
+            self.assertContains(resp, f">{charging_label}<")
+        finally:
+            store.transactions.pop(key, None)
+
     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)
@@ -1374,6 +2127,35 @@ class ChargerAdminTests(TestCase):
         self.assertNotContains(resp, 'name="last_heartbeat"')
         self.assertNotContains(resp, 'name="last_meter_values"')
 
+    def test_admin_action_sets_availability_state(self):
+        charger = Charger.objects.create(charger_id="AVAIL1")
+        url = reverse("admin:ocpp_charger_changelist")
+        response = self.client.post(
+            url,
+            {
+                "action": "set_availability_state_inoperative",
+                "_selected_action": [charger.pk],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        charger.refresh_from_db()
+        self.assertEqual(charger.availability_state, "Inoperative")
+        self.assertIsNotNone(charger.availability_state_updated_at)
+
+        response = self.client.post(
+            url,
+            {
+                "action": "set_availability_state_operative",
+                "_selected_action": [charger.pk],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        charger.refresh_from_db()
+        self.assertEqual(charger.availability_state, "Operative")
+        self.assertIsNotNone(charger.availability_state_updated_at)
+
     def test_purge_action_removes_data(self):
         charger = Charger.objects.create(charger_id="PURGE1")
         Transaction.objects.create(
@@ -1411,6 +2193,174 @@ class ChargerAdminTests(TestCase):
         self.client.post(delete_url, {"post": "yes"})
         self.assertFalse(Charger.objects.filter(pk=charger.pk).exists())
 
+    def test_fetch_configuration_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="CFGADMIN", connector_id=1)
+        ws = DummyWebSocket()
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.clear_log(log_key, log_type="charger")
+        pending_key = store.pending_key(charger.charger_id)
+        store.clear_log(pending_key, log_type="charger")
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        store.pending_calls.clear()
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "fetch_cp_configuration",
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            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)
+            metadata = store.pending_calls[frame[1]]
+            self.assertEqual(metadata.get("action"), "GetConfiguration")
+            self.assertEqual(metadata.get("charger_id"), charger.charger_id)
+            self.assertEqual(metadata.get("connector_id"), charger.connector_id)
+            self.assertEqual(metadata.get("log_key"), log_key)
+            log_entries = store.get_logs(log_key, log_type="charger")
+            self.assertTrue(
+                any("GetConfiguration" in entry for entry in log_entries)
+            )
+        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_fetch_configuration_timeout_logged(self):
+        charger = Charger.objects.create(charger_id="CFGWAIT", connector_id=1)
+        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)
+        store.pending_calls.clear()
+        original_schedule = store.schedule_call_timeout
+        try:
+            with patch("ocpp.admin.store.schedule_call_timeout") as mock_schedule:
+                def _side_effect(message_id, *, timeout=5.0, **kwargs):
+                    kwargs["timeout"] = 0.05
+                    return original_schedule(message_id, **kwargs)
+
+                mock_schedule.side_effect = _side_effect
+                url = reverse("admin:ocpp_charger_changelist")
+                response = self.client.post(
+                    url,
+                    {
+                        "action": "fetch_cp_configuration",
+                        "_selected_action": [charger.pk],
+                    },
+                    follow=True,
+                )
+                self.assertEqual(response.status_code, 200)
+                mock_schedule.assert_called_once()
+            time.sleep(0.1)
+            log_entries = store.get_logs(log_key, log_type="charger")
+            self.assertTrue(
+                any("GetConfiguration timed out" in entry for entry in log_entries)
+            )
+        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_remote_stop_action_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="STOPME", connector_id=1)
+        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)
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+        )
+        tx_key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[tx_key] = tx
+        store.pending_calls.clear()
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "remote_stop_transaction",
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(len(ws.sent), 1)
+            frame = json.loads(ws.sent[0])
+            self.assertEqual(frame[0], 2)
+            self.assertEqual(frame[2], "RemoteStopTransaction")
+            self.assertIn("transactionId", frame[3])
+            self.assertEqual(frame[3]["transactionId"], tx.pk)
+            self.assertIn(frame[1], store.pending_calls)
+            metadata = store.pending_calls[frame[1]]
+            self.assertEqual(metadata.get("action"), "RemoteStopTransaction")
+            self.assertEqual(metadata.get("charger_id"), charger.charger_id)
+            self.assertEqual(metadata.get("connector_id"), charger.connector_id)
+            self.assertEqual(metadata.get("transaction_id"), tx.pk)
+            self.assertEqual(metadata.get("log_key"), log_key)
+            log_entries = store.get_logs(log_key, log_type="charger")
+            self.assertTrue(
+                any("RemoteStopTransaction" in entry for entry in log_entries)
+            )
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pending_calls.clear()
+            store.transactions.pop(tx_key, None)
+            store.clear_log(log_key, log_type="charger")
+            store.clear_log(pending_key, log_type="charger")
+
+    def test_reset_action_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="RESETME", connector_id=1)
+        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)
+        store.pending_calls.clear()
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "reset_chargers",
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(len(ws.sent), 1)
+            frame = json.loads(ws.sent[0])
+            self.assertEqual(frame[0], 2)
+            self.assertEqual(frame[2], "Reset")
+            self.assertEqual(frame[3], {"type": "Soft"})
+            self.assertIn(frame[1], store.pending_calls)
+            metadata = store.pending_calls[frame[1]]
+            self.assertEqual(metadata.get("action"), "Reset")
+            self.assertEqual(metadata.get("charger_id"), charger.charger_id)
+            self.assertEqual(metadata.get("connector_id"), charger.connector_id)
+            self.assertEqual(metadata.get("log_key"), log_key)
+            log_entries = store.get_logs(log_key, log_type="charger")
+            self.assertTrue(any("Reset" in entry for entry in log_entries))
+        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")
+
 
 class LocationAdminTests(TestCase):
     def setUp(self):
@@ -1513,6 +2463,20 @@ class SimulatorAdminTests(TransactionTestCase):
         mock_start.assert_called_once()
         store.simulators.clear()
 
+    @patch("ocpp.admin.ChargePointSimulator.start")
+    def test_start_simulator_change_action(self, mock_start):
+        sim = Simulator.objects.create(name="SIMCHG", cp_path="SIMCHG")
+        mock_start.return_value = (True, "Started", "/tmp/log")
+        resp = self._post_simulator_change(
+            sim,
+            _action="start_simulator_action",
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "View Log")
+        self.assertContains(resp, "/tmp/log")
+        mock_start.assert_called_once()
+        store.simulators.clear()
+
     def test_admin_shows_ws_url(self):
         sim = Simulator.objects.create(
             name="SIM2", cp_path="SIMY", host="h", ws_port=1111
@@ -1557,6 +2521,36 @@ class SimulatorAdminTests(TransactionTestCase):
         self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
         store.simulators.pop(sim.pk, None)
 
+    @patch("ocpp.admin.asyncio.get_running_loop", side_effect=RuntimeError)
+    def test_stop_simulator_runs_without_event_loop(self, mock_get_loop):
+        sim = Simulator.objects.create(name="SIMSTOP", cp_path="SIMSTOP")
+        stopper = SimpleNamespace(stop=AsyncMock())
+        store.simulators[sim.pk] = stopper
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.post(
+            url,
+            {"action": "stop_simulator", "_selected_action": [sim.pk]},
+            follow=True,
+        )
+        self.assertEqual(resp.status_code, 200)
+        stopper.stop.assert_awaited_once()
+        self.assertTrue(mock_get_loop.called)
+        self.assertNotIn(sim.pk, store.simulators)
+
+    @patch("ocpp.admin.asyncio.get_running_loop", side_effect=RuntimeError)
+    def test_stop_simulator_change_action(self, mock_get_loop):
+        sim = Simulator.objects.create(name="SIMCHGSTOP", cp_path="SIMCHGSTOP")
+        stopper = SimpleNamespace(stop=AsyncMock())
+        store.simulators[sim.pk] = stopper
+        resp = self._post_simulator_change(
+            sim,
+            _action="stop_simulator_action",
+        )
+        self.assertEqual(resp.status_code, 200)
+        stopper.stop.assert_awaited_once()
+        self.assertTrue(mock_get_loop.called)
+        self.assertNotIn(sim.pk, store.simulators)
+
     def test_as_config_includes_custom_fields(self):
         sim = Simulator.objects.create(
             name="SIM3",
@@ -1566,6 +2560,10 @@ class SimulatorAdminTests(TransactionTestCase):
             duration=500,
             pre_charge_delay=5,
             vin="WP0ZZZ99999999999",
+            configuration_keys=[
+                {"key": "HeartbeatInterval", "value": "300", "readonly": True}
+            ],
+            configuration_unknown_keys=["Bogus"],
         )
         cfg = sim.as_config()
         self.assertEqual(cfg.interval, 3.5)
@@ -1573,6 +2571,11 @@ class SimulatorAdminTests(TransactionTestCase):
         self.assertEqual(cfg.duration, 500)
         self.assertEqual(cfg.pre_charge_delay, 5)
         self.assertEqual(cfg.vin, "WP0ZZZ99999999999")
+        self.assertEqual(
+            cfg.configuration_keys,
+            [{"key": "HeartbeatInterval", "value": "300", "readonly": True}],
+        )
+        self.assertEqual(cfg.configuration_unknown_keys, ["Bogus"])
 
     def _post_simulator_change(self, sim: Simulator, **overrides):
         url = reverse("admin:ocpp_simulator_change", args=[sim.pk])
@@ -1590,6 +2593,10 @@ class SimulatorAdminTests(TransactionTestCase):
             "username": sim.username,
             "password": sim.password,
             "door_open": "on" if overrides.get("door_open", False) else "",
+            "configuration_keys": json.dumps(sim.configuration_keys or []),
+            "configuration_unknown_keys": json.dumps(
+                sim.configuration_unknown_keys or []
+            ),
             "_save": "Save",
         }
         data.update(overrides)
@@ -1628,6 +2635,104 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_query_string_cid_supported(self):
+        communicator = WebsocketCommunicator(application, "/?cid=QSERIAL")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(charger_id="QSERIAL")
+        self.assertEqual(charger.last_path, "/")
+
+    async def test_query_string_charge_point_id_supported(self):
+        communicator = WebsocketCommunicator(
+            application, "/?chargePointId=QCHARGE"
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(charger_id="QCHARGE")
+        self.assertEqual(charger.last_path, "/")
+
+    async def test_query_string_charge_box_id_supported(self):
+        communicator = WebsocketCommunicator(
+            application, "/?chargeBoxId=QBOX"
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(charger_id="QBOX")
+        self.assertEqual(charger.last_path, "/")
+
+    async def test_query_string_charge_box_id_case_insensitive(self):
+        communicator = WebsocketCommunicator(
+            application, "/?CHARGEBOXID=CaseSense"
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="CaseSense"
+        )
+        self.assertEqual(charger.last_path, "/")
+
+    async def test_query_string_charge_box_id_snake_case_supported(self):
+        communicator = WebsocketCommunicator(
+            application, "/?charge_box_id=SnakeCase"
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="SnakeCase"
+        )
+        self.assertEqual(charger.last_path, "/")
+
+    async def test_query_string_charge_box_id_strips_whitespace(self):
+        communicator = WebsocketCommunicator(
+            application, "/?chargeBoxId=%20Trimmed%20Value%20"
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="Trimmed Value"
+        )
+        self.assertEqual(charger.last_path, "/")
+
+    async def test_query_string_cid_overrides_path_segment(self):
+        communicator = WebsocketCommunicator(application, "/ocpp?cid=QSEGOVR")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(charger_id="QSEGOVR")
+        self.assertEqual(charger.last_path, "/ocpp")
+
+    async def test_query_string_charge_point_id_overrides_path_segment(self):
+        communicator = WebsocketCommunicator(
+            application, "/ocpp?chargePointId=QPSEG"
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.disconnect()
+
+        charger = await database_sync_to_async(Charger.objects.get)(charger_id="QPSEG")
+        self.assertEqual(charger.last_path, "/ocpp")
+
     async def test_nested_path_accepted_and_recorded(self):
         communicator = WebsocketCommunicator(application, "/foo/NEST/")
         connected, _ = await communicator.connect()
@@ -2167,8 +3272,175 @@ class ChargePointSimulatorTests(TransactionTestCase):
             idx for idx, payload in enumerate(status_payloads) if payload.get("errorCode") == "NoError"
         )
         self.assertLess(first_open, first_close)
-        self.assertEqual(door_open_messages[0].get("status"), "Faulted")
-        self.assertEqual(door_closed_messages[0].get("status"), "Available")
+
+    async def test_get_configuration_uses_configured_keys(self):
+        cfg = SimulatorConfig(
+            configuration_keys=[
+                {"key": "HeartbeatInterval", "value": "300", "readonly": True},
+                {"key": "MeterValueSampleInterval", "value": 900},
+            ],
+            configuration_unknown_keys=["UnknownX"],
+        )
+        sim = ChargePointSimulator(cfg)
+        sent: list[list[object]] = []
+
+        async def send(msg: str):
+            sent.append(json.loads(msg))
+
+        async def recv():  # pragma: no cover - should not be called
+            raise AssertionError("recv should not be called for GetConfiguration")
+
+        handled = await sim._handle_csms_call(
+            [
+                2,
+                "cfg-1",
+                "GetConfiguration",
+                {"key": ["HeartbeatInterval", "UnknownX", "MissingKey"]},
+            ],
+            send,
+            recv,
+        )
+        self.assertTrue(handled)
+        self.assertEqual(len(sent), 1)
+        frame = sent[0]
+        self.assertEqual(frame[0], 3)
+        self.assertEqual(frame[1], "cfg-1")
+        payload = frame[2]
+        self.assertIn("configurationKey", payload)
+        self.assertEqual(
+            payload["configurationKey"],
+            [{"key": "HeartbeatInterval", "value": "300", "readonly": True}],
+        )
+        self.assertIn("unknownKey", payload)
+        self.assertCountEqual(payload["unknownKey"], ["UnknownX", "MissingKey"])
+
+    async def test_get_configuration_without_filter_returns_all(self):
+        cfg = SimulatorConfig(
+            configuration_keys=[
+                {"key": "AuthorizeRemoteTxRequests", "value": True},
+                {"key": "ConnectorPhaseRotation", "value": "ABC"},
+            ],
+            configuration_unknown_keys=["GhostKey"],
+        )
+        sim = ChargePointSimulator(cfg)
+        sent: list[list[object]] = []
+
+        async def send(msg: str):
+            sent.append(json.loads(msg))
+
+        async def recv():  # pragma: no cover - should not be called
+            raise AssertionError("recv should not be called for GetConfiguration")
+
+        handled = await sim._handle_csms_call(
+            [2, "cfg-2", "GetConfiguration", {}],
+            send,
+            recv,
+        )
+        self.assertTrue(handled)
+        frame = sent[0]
+        payload = frame[2]
+        keys = payload.get("configurationKey")
+        self.assertEqual(len(keys), 2)
+        returned_keys = {item["key"] for item in keys}
+        self.assertEqual(
+            returned_keys,
+            {"AuthorizeRemoteTxRequests", "ConnectorPhaseRotation"},
+        )
+        values = {item["key"]: item.get("value") for item in keys}
+        self.assertEqual(values["AuthorizeRemoteTxRequests"], "True")
+        self.assertEqual(values["ConnectorPhaseRotation"], "ABC")
+        self.assertIn("unknownKey", payload)
+        self.assertEqual(payload["unknownKey"], ["GhostKey"])
+
+    async def test_unknown_action_returns_call_error(self):
+        cfg = SimulatorConfig(cp_path="SIM-CALL-ERROR/")
+        sim = ChargePointSimulator(cfg)
+        sent: list[list[object]] = []
+
+        async def send(msg: str):
+            sent.append(json.loads(msg))
+
+        async def recv():  # pragma: no cover - should not be called
+            raise AssertionError("recv should not be called for unsupported actions")
+
+        handled = await sim._handle_csms_call(
+            [2, "msg-1", "Reset", {"type": "Soft"}],
+            send,
+            recv,
+        )
+
+        self.assertTrue(handled)
+        self.assertEqual(len(sent), 1)
+        frame = sent[0]
+        self.assertEqual(frame[0], 4)
+        self.assertEqual(frame[1], "msg-1")
+        self.assertEqual(frame[2], "NotSupported")
+        self.assertIn("Reset", frame[3])
+        self.assertIsInstance(frame[4], dict)
+
+    async def test_trigger_message_heartbeat_follow_up(self):
+        cfg = SimulatorConfig()
+        sim = ChargePointSimulator(cfg)
+        sent: list[list[object]] = []
+        recv_count = 0
+
+        async def send(msg: str):
+            sent.append(json.loads(msg))
+
+        async def recv():
+            nonlocal recv_count
+            recv_count += 1
+            return json.dumps([3, f"ack-{recv_count}", {}])
+
+        handled = await sim._handle_csms_call(
+            [
+                2,
+                "trigger-req",
+                "TriggerMessage",
+                {"requestedMessage": "Heartbeat"},
+            ],
+            send,
+            recv,
+        )
+
+        self.assertTrue(handled)
+        self.assertGreaterEqual(len(sent), 2)
+        result_frame = sent[0]
+        follow_up_frame = sent[1]
+        self.assertEqual(result_frame[0], 3)
+        self.assertEqual(result_frame[1], "trigger-req")
+        self.assertEqual(result_frame[2].get("status"), "Accepted")
+        self.assertEqual(follow_up_frame[0], 2)
+        self.assertEqual(follow_up_frame[2], "Heartbeat")
+        self.assertEqual(recv_count, 1)
+
+    async def test_trigger_message_rejected_for_invalid_connector(self):
+        cfg = SimulatorConfig(connector_id=5)
+        sim = ChargePointSimulator(cfg)
+        sent: list[list[object]] = []
+
+        async def send(msg: str):
+            sent.append(json.loads(msg))
+
+        async def recv():  # pragma: no cover - should not be called
+            raise AssertionError("recv should not be called for rejected TriggerMessage")
+
+        handled = await sim._handle_csms_call(
+            [
+                2,
+                "trigger-invalid",
+                "TriggerMessage",
+                {"requestedMessage": "StatusNotification", "connectorId": 1},
+            ],
+            send,
+            recv,
+        )
+
+        self.assertTrue(handled)
+        self.assertEqual(len(sent), 1)
+        self.assertEqual(sent[0][0], 3)
+        self.assertEqual(sent[0][1], "trigger-invalid")
+        self.assertEqual(sent[0][2].get("status"), "Rejected")
 
 
 class PurgeMeterReadingsTaskTests(TestCase):
@@ -2275,6 +3547,8 @@ class DispatchActionViewTests(TestCase):
         )
         store.clear_log(self.log_key, log_type="charger")
         self.addCleanup(store.clear_log, self.log_key, "charger")
+        store.pending_calls.clear()
+        self.addCleanup(store.pending_calls.clear)
         self.url = reverse(
             "charger-action-connector",
             args=[self.charger.charger_id, self.charger.connector_slug],
@@ -2321,6 +3595,58 @@ class DispatchActionViewTests(TestCase):
             any("RemoteStartTransaction" in entry for entry in log_entries)
         )
 
+    def test_change_availability_dispatches_frame(self):
+        response = self.client.post(
+            self.url,
+            data=json.dumps({"action": "change_availability", "type": "Inoperative"}),
+            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], "ChangeAvailability")
+        self.assertEqual(frame[3]["type"], "Inoperative")
+        self.assertEqual(frame[3]["connectorId"], 1)
+        self.assertIn(frame[1], store.pending_calls)
+        self.charger.refresh_from_db()
+        self.assertEqual(self.charger.availability_requested_state, "Inoperative")
+        self.assertIsNotNone(self.charger.availability_requested_at)
+        self.assertEqual(self.charger.availability_request_status, "")
+
+    def test_change_availability_requires_valid_type(self):
+        response = self.client.post(
+            self.url,
+            data=json.dumps({"action": "change_availability"}),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 400)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(self.ws.sent, [])
+        self.assertFalse(store.pending_calls)
+
+
+class SimulatorStateMappingTests(TestCase):
+    def tearDown(self):
+        _simulators[1] = SimulatorState()
+        _simulators[2] = SimulatorState()
+
+    def test_simulate_uses_requested_state(self):
+        calls = []
+
+        async def fake(cp_idx, *args, sim_state=None, **kwargs):
+            calls.append(sim_state)
+            if sim_state is not None:
+                sim_state.running = False
+
+        with patch("ocpp.evcs.simulate_cp", new=fake):
+            coro = simulate(cp=2, daemon=True, threads=1)
+            asyncio.run(coro)
+
+        self.assertEqual(len(calls), 1)
+        self.assertIs(calls[0], _simulators[2])
+
 
 class ChargerStatusViewTests(TestCase):
     def setUp(self):
@@ -2700,3 +4026,69 @@ class LiveUpdateViewTests(TestCase):
         ids = [item["charger_id"] for item in payload["chargers"]]
         self.assertIn(public.charger_id, ids)
         self.assertNotIn(private.charger_id, ids)
+
+    def test_dashboard_restricts_to_owner_users(self):
+        User = get_user_model()
+        owner = User.objects.create_user(username="owner", password="pw")
+        other = User.objects.create_user(username="outsider", password="pw")
+        unrestricted = Charger.objects.create(charger_id="UNRESTRICTED")
+        restricted = Charger.objects.create(charger_id="RESTRICTED")
+        restricted.owner_users.add(owner)
+
+        self.client.force_login(owner)
+        owner_resp = self.client.get(reverse("ocpp-dashboard"))
+        owner_chargers = [item["charger"] for item in owner_resp.context["chargers"]]
+        self.assertIn(unrestricted, owner_chargers)
+        self.assertIn(restricted, owner_chargers)
+
+        self.client.force_login(other)
+        other_resp = self.client.get(reverse("ocpp-dashboard"))
+        other_chargers = [item["charger"] for item in other_resp.context["chargers"]]
+        self.assertIn(unrestricted, other_chargers)
+        self.assertNotIn(restricted, other_chargers)
+
+        self.client.force_login(owner)
+        detail_resp = self.client.get(
+            reverse("charger-page", args=[restricted.charger_id])
+        )
+        self.assertEqual(detail_resp.status_code, 200)
+
+        self.client.force_login(other)
+        denied_resp = self.client.get(
+            reverse("charger-page", args=[restricted.charger_id])
+        )
+        self.assertEqual(denied_resp.status_code, 404)
+
+    def test_dashboard_restricts_to_owner_groups(self):
+        User = get_user_model()
+        group = SecurityGroup.objects.create(name="Operations")
+        member = User.objects.create_user(username="member", password="pw")
+        outsider = User.objects.create_user(username="visitor", password="pw")
+        member.groups.add(group)
+        unrestricted = Charger.objects.create(charger_id="GROUPFREE")
+        restricted = Charger.objects.create(charger_id="GROUPLOCKED")
+        restricted.owner_groups.add(group)
+
+        self.client.force_login(member)
+        member_resp = self.client.get(reverse("ocpp-dashboard"))
+        member_chargers = [item["charger"] for item in member_resp.context["chargers"]]
+        self.assertIn(unrestricted, member_chargers)
+        self.assertIn(restricted, member_chargers)
+
+        self.client.force_login(outsider)
+        outsider_resp = self.client.get(reverse("ocpp-dashboard"))
+        outsider_chargers = [item["charger"] for item in outsider_resp.context["chargers"]]
+        self.assertIn(unrestricted, outsider_chargers)
+        self.assertNotIn(restricted, outsider_chargers)
+
+        self.client.force_login(member)
+        status_resp = self.client.get(
+            reverse("charger-status", args=[restricted.charger_id])
+        )
+        self.assertEqual(status_resp.status_code, 200)
+
+        self.client.force_login(outsider)
+        group_denied = self.client.get(
+            reverse("charger-status", args=[restricted.charger_id])
+        )
+        self.assertEqual(group_denied.status_code, 404)