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

ocpp/simulator.py

@@ -3,6 +3,7 @@ import base64
 import json
 import random
 import time
+import uuid
 from dataclasses import dataclass
 from typing import Optional
 import threading
@@ -18,7 +19,7 @@ class SimulatorConfig:
     """Configuration for a simulated charge point."""
 
     host: str = "127.0.0.1"
-    ws_port: int = 8000
+    ws_port: Optional[int] = 8000
     rfid: str = "FFFFFFFF"
     vin: str = ""
     # WebSocket path for the charge point. Defaults to just the charger ID at the root.
@@ -42,14 +43,65 @@ class ChargePointSimulator:
         self.config = config
         self._thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
+        self._door_open_event = threading.Event()
         self.status = "stopped"
         self._connected = threading.Event()
         self._connect_error = ""
 
+    def trigger_door_open(self) -> None:
+        """Queue a DoorOpen status notification for the simulator."""
+
+        self._door_open_event.set()
+
+    async def _maybe_send_door_event(self, send, recv) -> None:
+        if not self._door_open_event.is_set():
+            return
+        self._door_open_event.clear()
+        cfg = self.config
+        store.add_log(
+            cfg.cp_path,
+            "Sending DoorOpen StatusNotification",
+            log_type="simulator",
+        )
+        event_id = uuid.uuid4().hex
+        await send(
+            json.dumps(
+                [
+                    2,
+                    f"door-open-{event_id}",
+                    "StatusNotification",
+                    {
+                        "connectorId": cfg.connector_id,
+                        "errorCode": "DoorOpen",
+                        "status": "Faulted",
+                    },
+                ]
+            )
+        )
+        await recv()
+        await send(
+            json.dumps(
+                [
+                    2,
+                    f"door-closed-{event_id}",
+                    "StatusNotification",
+                    {
+                        "connectorId": cfg.connector_id,
+                        "errorCode": "NoError",
+                        "status": "Available",
+                    },
+                ]
+            )
+        )
+        await recv()
+
     @requires_network
     async def _run_session(self) -> None:
         cfg = self.config
-        uri = f"ws://{cfg.host}:{cfg.ws_port}/{cfg.cp_path}"
+        if cfg.ws_port:
+            uri = f"ws://{cfg.host}:{cfg.ws_port}/{cfg.cp_path}"
+        else:
+            uri = f"ws://{cfg.host}/{cfg.cp_path}"
         headers = {}
         if cfg.username and cfg.password:
             userpass = f"{cfg.username}:{cfg.password}"
@@ -134,6 +186,7 @@ class ChargePointSimulator:
 
             await send(json.dumps([2, "auth", "Authorize", {"idTag": cfg.rfid}]))
             await recv()
+            await self._maybe_send_door_event(send, recv)
             if not self._connected.is_set():
                 self.status = "running"
                 self._connect_error = "accepted"
@@ -182,10 +235,11 @@ class ChargePointSimulator:
                                     ],
                                 },
                             ]
-                        )
                     )
-                    await recv()
-                    await asyncio.sleep(cfg.interval)
+                )
+                await recv()
+                await self._maybe_send_door_event(send, recv)
+                await asyncio.sleep(cfg.interval)
 
             meter_start = random.randint(1000, 2000)
             await send(
@@ -250,6 +304,7 @@ class ChargePointSimulator:
                     )
                 )
                 await recv()
+                await self._maybe_send_door_event(send, recv)
                 await asyncio.sleep(cfg.interval)
 
             await send(
@@ -267,6 +322,7 @@ class ChargePointSimulator:
                 )
             )
             await recv()
+            await self._maybe_send_door_event(send, recv)
         except asyncio.TimeoutError:
             if not self._connected.is_set():
                 self._connect_error = "Timeout waiting for response"
@@ -336,6 +392,7 @@ class ChargePointSimulator:
         self.status = "starting"
         self._connected.clear()
         self._connect_error = ""
+        self._door_open_event.clear()
 
         def _runner() -> None:
             asyncio.run(self._run())

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/test_rfid.py

@@ -1,4 +1,5 @@
 import io
+import json
 import os
 import sys
 import types
@@ -17,12 +18,13 @@ from django.test import SimpleTestCase, TestCase
 from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib.sites.models import Site
+from django.utils import timezone
 
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
 
 from core.models import RFID
-from ocpp.rfid.reader import read_rfid, enable_deep_read
+from ocpp.rfid.reader import read_rfid, enable_deep_read, validate_rfid_value
 from ocpp.rfid.detect import detect_scanner, main as detect_main
 from ocpp.rfid import background_reader
 from ocpp.rfid.constants import (
@@ -71,6 +73,11 @@ class BackgroundReaderConfigurationTests(SimpleTestCase):
 
 
 class ScanNextViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user("rfid-user", password="pwd")
+        self.client.force_login(self.user)
+
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
     @patch(
@@ -103,6 +110,62 @@ class ScanNextViewTests(TestCase):
         self.assertEqual(resp.status_code, 500)
         self.assertEqual(resp.json(), {"error": "boom"})
 
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch(
+        "ocpp.rfid.views.validate_rfid_value",
+        return_value={"rfid": "ABCD1234", "label_id": 1, "created": False},
+    )
+    def test_scan_next_post_validates(self, mock_validate, mock_site, mock_node):
+        User = get_user_model()
+        user = User.objects.create_user("scanner", password="pwd")
+        self.client.force_login(user)
+        resp = self.client.post(
+            reverse("rfid-scan-next"),
+            data=json.dumps({"rfid": "ABCD1234"}),
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(
+            resp.json(), {"rfid": "ABCD1234", "label_id": 1, "created": False}
+        )
+        mock_validate.assert_called_once_with("ABCD1234", kind=None)
+
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch("ocpp.rfid.views.validate_rfid_value")
+    def test_scan_next_post_requires_authentication(
+        self, mock_validate, mock_site, mock_node
+    ):
+        resp = self.client.post(
+            reverse("rfid-scan-next"),
+            data=json.dumps({"rfid": "ABCD1234"}),
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 401)
+        self.assertEqual(resp.json(), {"error": "Authentication required"})
+        mock_validate.assert_not_called()
+
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    def test_scan_next_post_invalid_json(self, mock_site, mock_node):
+        User = get_user_model()
+        user = User.objects.create_user("invalid-json", password="pwd")
+        self.client.force_login(user)
+        resp = self.client.post(
+            reverse("rfid-scan-next"),
+            data="{",
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(resp.json(), {"error": "Invalid JSON payload"})
+
+    def test_scan_next_requires_authentication(self):
+        self.client.logout()
+        resp = self.client.get(reverse("rfid-scan-next"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
 
 class ReaderNotificationTests(TestCase):
     def _mock_reader(self):
@@ -171,6 +234,74 @@ class ReaderNotificationTests(TestCase):
         self.assertTrue(getattr(reader, "stop_called", False))
 
 
+class ValidateRfidValueTests(SimpleTestCase):
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.objects.get_or_create")
+    def test_creates_new_tag(self, mock_get, mock_notify, mock_now):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 1
+        tag.label_id = 1
+        tag.allowed = True
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        mock_get.return_value = (tag, True)
+
+        result = validate_rfid_value("abcd1234")
+
+        mock_get.assert_called_once_with(rfid="ABCD1234", defaults={})
+        tag.save.assert_called_once_with(update_fields=["last_seen_on"])
+        self.assertIs(tag.last_seen_on, fake_now)
+        mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
+        self.assertTrue(result["created"])
+        self.assertEqual(result["rfid"], "ABCD1234")
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.objects.get_or_create")
+    def test_updates_existing_tag_kind(self, mock_get, mock_notify, mock_now):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 5
+        tag.label_id = 5
+        tag.allowed = False
+        tag.color = "G"
+        tag.released = True
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        mock_get.return_value = (tag, False)
+
+        result = validate_rfid_value("abcd", kind=RFID.NTAG215)
+
+        mock_get.assert_called_once_with(
+            rfid="ABCD", defaults={"kind": RFID.NTAG215}
+        )
+        tag.save.assert_called_once_with(update_fields=["kind", "last_seen_on"])
+        self.assertIs(tag.last_seen_on, fake_now)
+        self.assertEqual(tag.kind, RFID.NTAG215)
+        mock_notify.assert_called_once_with("RFID 5 BAD", "ABCD G")
+        self.assertFalse(result["allowed"])
+        self.assertFalse(result["created"])
+        self.assertEqual(result["kind"], RFID.NTAG215)
+
+    def test_rejects_invalid_value(self):
+        result = validate_rfid_value("invalid!")
+        self.assertEqual(result, {"error": "RFID must be hexadecimal digits"})
+
+    def test_rejects_non_string_values(self):
+        result = validate_rfid_value(12345)
+        self.assertEqual(result, {"error": "RFID must be a string"})
+
+    def test_rejects_missing_value(self):
+        result = validate_rfid_value(None)
+        self.assertEqual(result, {"error": "RFID value is required"})
+
+
 class CardTypeDetectionTests(TestCase):
     def _mock_ntag_reader(self):
         class MockReader:
@@ -301,7 +432,12 @@ class RFIDDetectionScriptTests(SimpleTestCase):
         mock_detect.assert_called_once()
 
 
-class RestartViewTests(SimpleTestCase):
+class RestartViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user("restart-user", password="pwd")
+        self.client.force_login(self.user)
+
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
     @patch("ocpp.rfid.views.restart_sources", return_value={"status": "restarted"})
@@ -311,8 +447,19 @@ class RestartViewTests(SimpleTestCase):
         self.assertEqual(resp.json(), {"status": "restarted"})
         mock_restart.assert_called_once()
 
+    def test_restart_requires_authentication(self):
+        self.client.logout()
+        resp = self.client.post(reverse("rfid-scan-restart"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
+
+class ScanTestViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user("scan-test-user", password="pwd")
+        self.client.force_login(self.user)
 
-class ScanTestViewTests(SimpleTestCase):
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
     @patch("ocpp.rfid.views.test_sources", return_value={"irq_pin": 7})
@@ -332,6 +479,12 @@ class ScanTestViewTests(SimpleTestCase):
         self.assertEqual(resp.status_code, 500)
         self.assertEqual(resp.json(), {"error": "no scanner detected"})
 
+    def test_scan_test_requires_authentication(self):
+        self.client.logout()
+        resp = self.client.get(reverse("rfid-scan-test"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
 
 class RFIDLandingTests(TestCase):
     def test_scanner_view_registered_as_landing(self):
@@ -352,6 +505,8 @@ class RFIDLandingTests(TestCase):
 class ScannerTemplateTests(TestCase):
     def setUp(self):
         self.url = reverse("rfid-reader")
+        User = get_user_model()
+        self.user = User.objects.create_user("scanner-user", password="pwd")
 
     def test_configure_link_for_staff(self):
         User = get_user_model()
@@ -360,9 +515,11 @@ class ScannerTemplateTests(TestCase):
         resp = self.client.get(self.url)
         self.assertContains(resp, 'id="rfid-configure"')
 
-    def test_no_link_for_anonymous(self):
+    def test_redirect_for_anonymous(self):
+        self.client.logout()
         resp = self.client.get(self.url)
-        self.assertNotContains(resp, 'id="rfid-configure"')
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
 
     def test_advanced_fields_for_staff(self):
         User = get_user_model()
@@ -374,9 +531,12 @@ class ScannerTemplateTests(TestCase):
         self.assertContains(resp, 'id="rfid-released"')
         self.assertContains(resp, 'id="rfid-reference"')
 
-    def test_basic_fields_for_public(self):
+    def test_basic_fields_for_authenticated_user(self):
+        self.client.logout()
+        self.client.force_login(self.user)
         resp = self.client.get(self.url)
         self.assertContains(resp, 'id="rfid-kind"')
+        self.assertNotContains(resp, 'id="rfid-connect-local"')
         self.assertNotContains(resp, 'id="rfid-rfid"')
         self.assertNotContains(resp, 'id="rfid-released"')
         self.assertNotContains(resp, 'id="rfid-reference"')
@@ -388,7 +548,9 @@ class ScannerTemplateTests(TestCase):
         resp = self.client.get(self.url)
         self.assertContains(resp, 'id="rfid-deep-read"')
 
-    def test_no_deep_read_button_for_public(self):
+    def test_no_deep_read_button_for_authenticated_user(self):
+        self.client.logout()
+        self.client.force_login(self.user)
         resp = self.client.get(self.url)
         self.assertNotContains(resp, 'id="rfid-deep-read"')