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

ocpp/store.py

@@ -14,12 +14,15 @@ IDENTITY_SEPARATOR = "#"
 AGGREGATE_SLUG = "all"
 PENDING_SLUG = "pending"
 
+MAX_CONNECTIONS_PER_IP = 2
+
 connections: dict[str, object] = {}
 transactions: dict[str, object] = {}
 logs: dict[str, dict[str, list[str]]] = {"charger": {}, "simulator": {}}
 # store per charger session logs before they are flushed to disk
 history: dict[str, dict[str, object]] = {}
 simulators = {}
+ip_connections: dict[str, set[object]] = {}
 
 # mapping of charger id / cp_path to friendly names used for log files
 log_names: dict[str, dict[str, str]] = {"charger": {}, "simulator": {}}
@@ -51,6 +54,33 @@ def identity_key(serial: str, connector: int | str | None) -> str:
     return f"{serial}{IDENTITY_SEPARATOR}{connector_slug(connector)}"
 
 
+def register_ip_connection(ip: str | None, consumer: object) -> bool:
+    """Track a websocket connection for the provided client IP."""
+
+    if not ip:
+        return True
+    conns = ip_connections.setdefault(ip, set())
+    if consumer in conns:
+        return True
+    if len(conns) >= MAX_CONNECTIONS_PER_IP:
+        return False
+    conns.add(consumer)
+    return True
+
+
+def release_ip_connection(ip: str | None, consumer: object) -> None:
+    """Remove a websocket connection from the active client registry."""
+
+    if not ip:
+        return
+    conns = ip_connections.get(ip)
+    if not conns:
+        return
+    conns.discard(consumer)
+    if not conns:
+        ip_connections.pop(ip, None)
+
+
 def pending_key(serial: str) -> str:
     """Return the key used before a connector id has been negotiated."""
 

ocpp/tests.py

@@ -1,10 +1,20 @@
+import os
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+import django
+
+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 unittest import skip
-from unittest.mock import patch
+from contextlib import suppress
+from types import SimpleNamespace
+from unittest.mock import patch, Mock
 from django.contrib.auth import get_user_model
 from django.urls import reverse
 from django.utils import timezone
@@ -17,8 +27,8 @@ from nodes.models import Node, NodeRole
 from config.asgi import application
 
 from .models import Transaction, Charger, Simulator, MeterReading, Location
-from core.models import EnergyAccount, EnergyCredit
-from core.models import RFID
+from .consumers import CSMSConsumer
+from core.models import EnergyAccount, EnergyCredit, Reference, RFID
 from . import store
 from django.db.models.deletion import ProtectedError
 from decimal import Decimal
@@ -251,11 +261,83 @@ class CSMSConsumerTests(TransactionTestCase):
 
         mock_broadcast.assert_called_once()
         _, kwargs = mock_broadcast.call_args
-        self.assertEqual(kwargs["subject"], "charging-started")
-        payload = json.loads(kwargs["body"])
-        self.assertEqual(payload["location"], "Test Location")
-        self.assertEqual(payload["sn"], "NETMSG")
-        self.assertEqual(payload["cid"], "1")
+        self.assertEqual(kwargs["subject"], "NETMSG")
+        body = kwargs["body"]
+        self.assertRegex(body, r"^\d+\.\d kWh \d{2}:\d{2}$")
+
+    async def test_consumption_message_updates_existing_entry(self):
+        original_interval = CSMSConsumer.consumption_update_interval
+        CSMSConsumer.consumption_update_interval = 0.01
+        await database_sync_to_async(Charger.objects.create)(charger_id="UPDATEMSG")
+        communicator = WebsocketCommunicator(application, "/UPDATEMSG/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_mock = Mock()
+        message_mock.uuid = "mock-uuid"
+        message_mock.save = Mock()
+        message_mock.propagate = Mock()
+
+        filter_mock = Mock()
+        filter_mock.first.return_value = message_mock
+
+        broadcast_result = SimpleNamespace(uuid="mock-uuid")
+
+        try:
+            with patch(
+                "nodes.models.NetMessage.broadcast", return_value=broadcast_result
+            ) as mock_broadcast, patch(
+                "nodes.models.NetMessage.objects.filter", return_value=filter_mock
+            ):
+                await communicator.send_json_to(
+                    [2, "1", "StartTransaction", {"meterStart": 1}]
+                )
+                await communicator.receive_json_from()
+                mock_broadcast.assert_called_once()
+                await asyncio.sleep(0.05)
+                await communicator.disconnect()
+        finally:
+            CSMSConsumer.consumption_update_interval = original_interval
+            with suppress(Exception):
+                await communicator.disconnect()
+
+        self.assertTrue(message_mock.save.called)
+        self.assertTrue(message_mock.propagate.called)
+
+    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/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_mock = Mock()
+        message_mock.uuid = "mock-uuid"
+        message_mock.save = Mock()
+        message_mock.propagate = Mock()
+
+        filter_mock = Mock()
+        filter_mock.first.return_value = message_mock
+
+        broadcast_result = SimpleNamespace(uuid="mock-uuid")
+
+        try:
+            with patch(
+                "nodes.models.NetMessage.broadcast", return_value=broadcast_result
+            ) as mock_broadcast, patch(
+                "nodes.models.NetMessage.objects.filter", return_value=filter_mock
+            ):
+                await communicator.send_json_to(
+                    [2, "1", "StartTransaction", {"meterStart": 1}]
+                )
+                await communicator.receive_json_from()
+                mock_broadcast.assert_called_once()
+                await communicator.disconnect()
+        finally:
+            with suppress(Exception):
+                await communicator.disconnect()
+
+        self.assertTrue(message_mock.save.called)
+        self.assertTrue(message_mock.propagate.called)
 
     async def test_rfid_unbound_instance_created(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="NEWRFID")
@@ -529,6 +611,62 @@ class CSMSConsumerTests(TransactionTestCase):
         self.assertIn(2, connectors)
         self.assertIn(None, connectors)
 
+    async def test_console_reference_created_for_aggregate_connector(self):
+        communicator = ClientWebsocketCommunicator(
+            application,
+            "/CONREF/",
+            client=("203.0.113.5", 12345),
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to([2, "1", "BootNotification", {}])
+        await communicator.receive_json_from()
+
+        reference = await database_sync_to_async(
+            lambda: Reference.objects.get(alt_text="CONREF Console")
+        )()
+        self.assertEqual(reference.value, "http://203.0.113.5:8900")
+        self.assertTrue(reference.show_in_header)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "2",
+                "StatusNotification",
+                {"connectorId": 1, "status": "Available"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        count = await database_sync_to_async(
+            lambda: Reference.objects.filter(alt_text="CONREF Console").count()
+        )()
+        self.assertEqual(count, 1)
+
+        await communicator.disconnect()
+
+    async def test_console_reference_uses_forwarded_for_header(self):
+        communicator = ClientWebsocketCommunicator(
+            application,
+            "/FORWARDED/",
+            client=("127.0.0.1", 23456),
+            headers=[(b"x-forwarded-for", b"198.51.100.75, 127.0.0.1")],
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+        self.assertIn("198.51.100.75", store.ip_connections)
+
+        await communicator.send_json_to([2, "1", "BootNotification", {}])
+        await communicator.receive_json_from()
+
+        reference = await database_sync_to_async(
+            lambda: Reference.objects.get(alt_text="FORWARDED Console")
+        )()
+        self.assertEqual(reference.value, "http://198.51.100.75:8900")
+
+        await communicator.disconnect()
+
     async def test_transaction_created_from_meter_values(self):
         communicator = WebsocketCommunicator(application, "/NOSTART/")
         connected, _ = await communicator.connect()
@@ -914,6 +1052,78 @@ class CSMSConsumerTests(TransactionTestCase):
         store.transactions.pop(key2, None)
 
 
+    async def test_rate_limit_blocks_third_connection(self):
+        store.ip_connections.clear()
+        ip = "203.0.113.10"
+        communicator1 = ClientWebsocketCommunicator(
+            application, "/IPLIMIT1/", client=(ip, 1001)
+        )
+        communicator2 = ClientWebsocketCommunicator(
+            application, "/IPLIMIT2/", client=(ip, 1002)
+        )
+        communicator3 = ClientWebsocketCommunicator(
+            application, "/IPLIMIT3/", client=(ip, 1003)
+        )
+        other = ClientWebsocketCommunicator(
+            application, "/OTHERIP/", client=("198.51.100.5", 2001)
+        )
+        connected1 = connected2 = connected_other = False
+        try:
+            connected1, _ = await communicator1.connect()
+            self.assertTrue(connected1)
+            connected2, _ = await communicator2.connect()
+            self.assertTrue(connected2)
+            connected3, code = await communicator3.connect()
+            self.assertFalse(connected3)
+            self.assertEqual(code, 4003)
+            connected_other, _ = await other.connect()
+            self.assertTrue(connected_other)
+        finally:
+            if connected1:
+                await communicator1.disconnect()
+            if connected2:
+                await communicator2.disconnect()
+            if connected_other:
+                await other.disconnect()
+
+    async def test_rate_limit_allows_reconnect_after_disconnect(self):
+        store.ip_connections.clear()
+        ip = "203.0.113.20"
+        communicator1 = ClientWebsocketCommunicator(
+            application, "/LIMITRESET1/", client=(ip, 3001)
+        )
+        communicator2 = ClientWebsocketCommunicator(
+            application, "/LIMITRESET2/", client=(ip, 3002)
+        )
+        communicator3 = ClientWebsocketCommunicator(
+            application, "/LIMITRESET3/", client=(ip, 3003)
+        )
+        communicator3_retry = None
+        connected1 = connected2 = connected3_retry = False
+        try:
+            connected1, _ = await communicator1.connect()
+            self.assertTrue(connected1)
+            connected2, _ = await communicator2.connect()
+            self.assertTrue(connected2)
+            connected3, code = await communicator3.connect()
+            self.assertFalse(connected3)
+            self.assertEqual(code, 4003)
+            await communicator1.disconnect()
+            connected1 = False
+            communicator3_retry = ClientWebsocketCommunicator(
+                application, "/LIMITRESET4/", client=(ip, 3004)
+            )
+            connected3_retry, _ = await communicator3_retry.connect()
+            self.assertTrue(connected3_retry)
+        finally:
+            if connected1:
+                await communicator1.disconnect()
+            if connected2:
+                await communicator2.disconnect()
+            if connected3_retry and communicator3_retry is not None:
+                await communicator3_retry.disconnect()
+
+
 class ChargerLandingTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -1281,6 +1491,42 @@ class SimulatorAdminTests(TransactionTestCase):
         resp = self.client.get(url)
         self.assertContains(resp, "ws://h:1111/SIMY/")
 
+    def test_admin_ws_url_without_port(self):
+        sim = Simulator.objects.create(
+            name="SIMNP", cp_path="SIMNP", host="h", ws_port=None
+        )
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.get(url)
+        self.assertContains(resp, "ws://h/SIMNP/")
+
+    def test_send_open_door_action_requires_running_simulator(self):
+        sim = Simulator.objects.create(name="SIMDO", cp_path="SIMDO")
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.post(
+            url,
+            {"action": "send_open_door", "_selected_action": [sim.pk]},
+            follow=True,
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "simulator is not running")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+
+    def test_send_open_door_action_triggers_simulator(self):
+        sim = Simulator.objects.create(name="SIMTRIG", cp_path="SIMTRIG")
+        stub = SimpleNamespace(trigger_door_open=Mock())
+        store.simulators[sim.pk] = stub
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.post(
+            url,
+            {"action": "send_open_door", "_selected_action": [sim.pk]},
+            follow=True,
+        )
+        self.assertEqual(resp.status_code, 200)
+        stub.trigger_door_open.assert_called_once()
+        self.assertContains(resp, "DoorOpen status notification sent")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+        store.simulators.pop(sim.pk, None)
+
     def test_as_config_includes_custom_fields(self):
         sim = Simulator.objects.create(
             name="SIM3",
@@ -1298,6 +1544,45 @@ class SimulatorAdminTests(TransactionTestCase):
         self.assertEqual(cfg.pre_charge_delay, 5)
         self.assertEqual(cfg.vin, "WP0ZZZ99999999999")
 
+    def _post_simulator_change(self, sim: Simulator, **overrides):
+        url = reverse("admin:ocpp_simulator_change", args=[sim.pk])
+        data = {
+            "name": sim.name,
+            "cp_path": sim.cp_path,
+            "host": sim.host,
+            "ws_port": sim.ws_port or "",
+            "rfid": sim.rfid,
+            "duration": sim.duration,
+            "interval": sim.interval,
+            "pre_charge_delay": sim.pre_charge_delay,
+            "kw_max": sim.kw_max,
+            "repeat": "on" if sim.repeat else "",
+            "username": sim.username,
+            "password": sim.password,
+            "door_open": "on" if overrides.get("door_open", False) else "",
+            "_save": "Save",
+        }
+        data.update(overrides)
+        return self.client.post(url, data, follow=True)
+
+    def test_save_model_triggers_door_open(self):
+        sim = Simulator.objects.create(name="SIMSAVE", cp_path="SIMSAVE")
+        stub = SimpleNamespace(trigger_door_open=Mock())
+        store.simulators[sim.pk] = stub
+        resp = self._post_simulator_change(sim, door_open="on")
+        self.assertEqual(resp.status_code, 200)
+        stub.trigger_door_open.assert_called_once()
+        self.assertContains(resp, "DoorOpen status notification sent")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+        store.simulators.pop(sim.pk, None)
+
+    def test_save_model_reports_error_when_not_running(self):
+        sim = Simulator.objects.create(name="SIMERR", cp_path="SIMERR")
+        resp = self._post_simulator_change(sim, door_open="on")
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "simulator is not running")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+
     async def test_unknown_charger_auto_registered(self):
         communicator = WebsocketCommunicator(application, "/NEWCHG/")
         connected, _ = await communicator.connect()
@@ -1781,6 +2066,80 @@ class ChargePointSimulatorTests(TransactionTestCase):
             server.close()
             await server.wait_closed()
 
+    async def test_door_open_event_sends_notifications(self):
+        status_payloads = []
+
+        async def handler(ws):
+            async for msg in ws:
+                data = json.loads(msg)
+                action = data[2]
+                if action == "BootNotification":
+                    await ws.send(
+                        json.dumps(
+                            [
+                                3,
+                                data[1],
+                                {"status": "Accepted", "currentTime": "2024-01-01T00:00:00Z"},
+                            ]
+                        )
+                    )
+                elif action == "Authorize":
+                    await ws.send(json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}]))
+                elif action == "StatusNotification":
+                    status_payloads.append(data[3])
+                    await ws.send(json.dumps([3, data[1], {}]))
+                elif action == "StartTransaction":
+                    await ws.send(
+                        json.dumps(
+                            [
+                                3,
+                                data[1],
+                                {"transactionId": 1, "idTagInfo": {"status": "Accepted"}},
+                            ]
+                        )
+                    )
+                elif action == "MeterValues":
+                    await ws.send(json.dumps([3, data[1], {}]))
+                elif action == "StopTransaction":
+                    await ws.send(json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}]))
+                    break
+
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
+        port = server.sockets[0].getsockname()[1]
+
+        cfg = SimulatorConfig(
+            host="127.0.0.1",
+            ws_port=port,
+            cp_path="SIMDOOR/",
+            duration=0.2,
+            interval=0.05,
+            pre_charge_delay=0.0,
+        )
+        sim = ChargePointSimulator(cfg)
+        sim.trigger_door_open()
+        try:
+            await sim._run_session()
+        finally:
+            server.close()
+            await server.wait_closed()
+            store.clear_log(cfg.cp_path, log_type="simulator")
+
+        door_open_messages = [p for p in status_payloads if p.get("errorCode") == "DoorOpen"]
+        door_closed_messages = [p for p in status_payloads if p.get("errorCode") == "NoError"]
+        self.assertTrue(door_open_messages)
+        self.assertTrue(door_closed_messages)
+        first_open = next(
+            idx for idx, payload in enumerate(status_payloads) if payload.get("errorCode") == "DoorOpen"
+        )
+        first_close = next(
+            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")
+
 
 class PurgeMeterReadingsTaskTests(TestCase):
     def test_purge_old_meter_readings(self):
@@ -2294,3 +2653,20 @@ class LiveUpdateViewTests(TestCase):
         resp = self.client.get(reverse("cp-simulator"))
         self.assertEqual(resp.context["request"].live_update_interval, 5)
         self.assertContains(resp, "setInterval(() => location.reload()")
+
+    def test_dashboard_hides_private_chargers(self):
+        public = Charger.objects.create(charger_id="PUBLICCP")
+        private = Charger.objects.create(
+            charger_id="PRIVATECP", public_display=False
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        chargers = [item["charger"] for item in resp.context["chargers"]]
+        self.assertIn(public, chargers)
+        self.assertNotIn(private, chargers)
+
+        list_response = self.client.get(reverse("charger-list"))
+        payload = list_response.json()
+        ids = [item["charger_id"] for item in payload["chargers"]]
+        self.assertIn(public.charger_id, ids)
+        self.assertNotIn(private.charger_id, ids)