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

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"')