arthexis 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

ocpp/tests.py

@@ -2,33 +2,53 @@ import os
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 
+import time
+
+import tests.conftest  # noqa: F401
+
 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.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 core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
 from django.db.models.deletion import ProtectedError
 from decimal import Decimal
@@ -87,6 +107,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
@@ -141,6 +202,17 @@ class ChargerUrlFallbackTests(TestCase):
         self.assertTrue(charger.reference.value.startswith("http://fallback.example"))
         self.assertTrue(charger.reference.value.endswith("/c/NO_SITE/"))
 
+    def test_reference_not_created_for_loopback_domain(self):
+        site = Site.objects.get_current()
+        site.domain = "127.0.0.1"
+        site.save()
+        Site.objects.clear_cache()
+
+        charger = Charger.objects.create(charger_id="LOCAL_LOOP")
+        charger.refresh_from_db()
+
+        self.assertIsNone(charger.reference)
+
 
 class SinkConsumerTests(TransactionTestCase):
     async def test_sink_replies(self):
@@ -304,6 +376,244 @@ class CSMSConsumerTests(TransactionTestCase):
         self.assertTrue(message_mock.save.called)
         self.assertTrue(message_mock.propagate.called)
 
+    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/")
@@ -667,6 +977,25 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_console_reference_skips_loopback_ip(self):
+        communicator = ClientWebsocketCommunicator(
+            application,
+            "/LOCAL/",
+            client=("127.0.0.1", 34567),
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to([2, "1", "BootNotification", {}])
+        await communicator.receive_json_from()
+
+        exists = await database_sync_to_async(
+            lambda: Reference.objects.filter(alt_text="LOCAL Console").exists()
+        )()
+        self.assertFalse(exists)
+
+        await communicator.disconnect()
+
     async def test_transaction_created_from_meter_values(self):
         communicator = WebsocketCommunicator(application, "/NOSTART/")
         connected, _ = await communicator.connect()
@@ -1123,6 +1452,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):
@@ -1155,6 +1570,21 @@ class ChargerLandingTests(TestCase):
         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(
@@ -1276,6 +1706,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):
@@ -1344,6 +1780,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(
@@ -1381,6 +1846,85 @@ 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")
+
 
 class LocationAdminTests(TestCase):
     def setUp(self):
@@ -1527,6 +2071,22 @@ 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)
+
     def test_as_config_includes_custom_fields(self):
         sim = Simulator.objects.create(
             name="SIM3",
@@ -1536,6 +2096,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)
@@ -1543,6 +2107,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])
@@ -1560,6 +2129,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)
@@ -2137,8 +2710,149 @@ 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_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):
@@ -2245,6 +2959,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],
@@ -2291,6 +3007,37 @@ 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 ChargerStatusViewTests(TestCase):
     def setUp(self):
@@ -2670,3 +3417,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)