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

ocpp/tests.py

@@ -1,14 +1,32 @@
 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")
 
-import time
-
-import tests.conftest  # noqa: F401
+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 = tests_conftest._original_setup
 django.setup()
 
 from asgiref.testing import ApplicationCommunicator
@@ -30,6 +48,7 @@ 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
@@ -48,6 +67,7 @@ from .models import (
 )
 from .consumers import CSMSConsumer
 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
@@ -55,10 +75,10 @@ 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
@@ -249,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()
@@ -288,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)
 
@@ -305,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):
@@ -376,6 +543,63 @@ 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/")
@@ -734,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
@@ -1223,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]))
@@ -1598,6 +1821,111 @@ class ChargerLandingTests(TestCase):
         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_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")
+
+            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=connector,
+            meter_start=1000,
+            start_time=timezone.now(),
+            rfid="TAGNONE",
+        )
+        key = store.identity_key(connector.charger_id, connector.connector_id)
+        store.transactions[key] = tx
+        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(
             charger_id="NAMED",
@@ -1743,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)
@@ -1925,6 +2272,95 @@ class ChargerAdminTests(TestCase):
             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):
@@ -2027,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
@@ -2087,6 +2537,20 @@ class SimulatorAdminTests(TransactionTestCase):
         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",
@@ -2171,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()
@@ -2790,6 +3352,32 @@ class ChargePointSimulatorTests(TransactionTestCase):
         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)
@@ -3039,6 +3627,27 @@ class DispatchActionViewTests(TestCase):
         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):
         self.client = Client()