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

core/tests.py

@@ -2,42 +2,56 @@ import os
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
 import django
+
 django.setup()
 
-from django.test import Client, TestCase, RequestFactory
+from django.test import Client, TestCase, RequestFactory, override_settings
 from django.urls import reverse
 from django.http import HttpRequest
 import json
+from decimal import Decimal
 from unittest import mock
+from unittest.mock import patch
 from pathlib import Path
 import subprocess
+from glob import glob
+from datetime import timedelta
+import tempfile
 
 from django.utils import timezone
+from django.contrib.auth.models import Permission
 from .models import (
     User,
+    UserPhoneNumber,
     EnergyAccount,
     ElectricVehicle,
     EnergyCredit,
-    Address,
     Product,
-    Subscription,
     Brand,
     EVModel,
     RFID,
-    FediverseProfile,
     SecurityGroup,
     Package,
     PackageRelease,
+    ReleaseManager,
+    Todo,
+    PublicWifiAccess,
 )
 from django.contrib.admin.sites import AdminSite
-from core.admin import PackageReleaseAdmin, PackageAdmin
+from core.admin import (
+    PackageReleaseAdmin,
+    PackageAdmin,
+    UserAdmin,
+    USER_PROFILE_INLINES,
+)
 from ocpp.models import Transaction, Charger
 
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
 from django.db import IntegrityError
 from .backends import LocalhostAdminBackend
-from core.views import _step_check_pypi, _step_promote_build, _step_publish
+from core.views import _step_check_version, _step_promote_build, _step_publish
+from core import public_wifi
 
 
 class DefaultAdminTests(TestCase):
@@ -78,6 +92,205 @@ class DefaultAdminTests(TestCase):
         )
 
 
+class UserOperateAsTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.permission = Permission.objects.get(codename="view_todo")
+
+    def test_staff_user_delegates_permissions(self):
+        delegate = User.objects.create_user(username="delegate", password="secret")
+        delegate.user_permissions.add(self.permission)
+        operator = User.objects.create_user(
+            username="operator", password="secret", is_staff=True
+        )
+        self.assertFalse(operator.has_perm("core.view_todo"))
+        operator.operate_as = delegate
+        operator.full_clean()
+        operator.save()
+        operator.refresh_from_db()
+        self.assertTrue(operator.has_perm("core.view_todo"))
+
+    def test_only_staff_may_operate_as(self):
+        delegate = User.objects.create_user(username="delegate", password="secret")
+        operator = User.objects.create_user(username="operator", password="secret")
+        operator.operate_as = delegate
+        with self.assertRaises(ValidationError):
+            operator.full_clean()
+
+    def test_non_superuser_cannot_operate_as_staff(self):
+        staff_delegate = User.objects.create_user(
+            username="delegate", password="secret", is_staff=True
+        )
+        operator = User.objects.create_user(
+            username="operator", password="secret", is_staff=True
+        )
+        operator.operate_as = staff_delegate
+        with self.assertRaises(ValidationError):
+            operator.full_clean()
+
+    def test_recursive_chain_and_cycle_detection(self):
+        base = User.objects.create_user(username="base", password="secret")
+        base.user_permissions.add(self.permission)
+        middle = User.objects.create_user(
+            username="middle", password="secret", is_staff=True
+        )
+        middle.operate_as = base
+        middle.full_clean()
+        middle.save()
+        top = User.objects.create_superuser(
+            username="top", email="top@example.com", password="secret"
+        )
+        top.operate_as = middle
+        top.full_clean()
+        top.save()
+        top.refresh_from_db()
+        self.assertTrue(top.has_perm("core.view_todo"))
+
+        first = User.objects.create_superuser(
+            username="first", email="first@example.com", password="secret"
+        )
+        second = User.objects.create_superuser(
+            username="second", email="second@example.com", password="secret"
+        )
+        first.operate_as = second
+        first.full_clean()
+        first.save()
+        second.operate_as = first
+        second.full_clean()
+        second.save()
+        self.assertFalse(first._check_operate_as_chain(lambda user: False))
+
+    def test_module_permissions_fall_back(self):
+        delegate = User.objects.create_user(username="helper", password="secret")
+        delegate.user_permissions.add(self.permission)
+        operator = User.objects.create_user(
+            username="mod", password="secret", is_staff=True
+        )
+        operator.operate_as = delegate
+        operator.full_clean()
+        operator.save()
+        self.assertTrue(operator.has_module_perms("core"))
+
+    def test_has_profile_via_delegate(self):
+        delegate = User.objects.create_user(
+            username="delegate", password="secret", is_staff=True
+        )
+        ReleaseManager.objects.create(user=delegate)
+        operator = User.objects.create_superuser(
+            username="operator",
+            email="operator@example.com",
+            password="secret",
+        )
+        operator.operate_as = delegate
+        operator.full_clean()
+        operator.save()
+        profile = operator.get_profile(ReleaseManager)
+        self.assertIsNotNone(profile)
+        self.assertEqual(profile.user, delegate)
+        self.assertTrue(operator.has_profile(ReleaseManager))
+
+    def test_has_profile_via_group_membership(self):
+        member = User.objects.create_user(username="member", password="secret")
+        group = SecurityGroup.objects.create(name="Managers")
+        group.user_set.add(member)
+        profile = ReleaseManager.objects.create(group=group)
+        self.assertEqual(member.get_profile(ReleaseManager), profile)
+        self.assertTrue(member.has_profile(ReleaseManager))
+
+    def test_release_manager_property_uses_delegate_profile(self):
+        delegate = User.objects.create_user(
+            username="delegate-property", password="secret", is_staff=True
+        )
+        profile = ReleaseManager.objects.create(user=delegate)
+        operator = User.objects.create_superuser(
+            username="operator-property",
+            email="operator-property@example.com",
+            password="secret",
+        )
+        operator.operate_as = delegate
+        operator.full_clean()
+        operator.save()
+        self.assertEqual(operator.release_manager, profile)
+
+
+class UserPhoneNumberTests(TestCase):
+    def test_get_phone_numbers_by_priority(self):
+        user = User.objects.create_user(username="phone-user", password="secret")
+        later = UserPhoneNumber.objects.create(
+            user=user, number="+15555550101", priority=10
+        )
+        earlier = UserPhoneNumber.objects.create(
+            user=user, number="+15555550100", priority=1
+        )
+        immediate = UserPhoneNumber.objects.create(
+            user=user, number="+15555550099", priority=0
+        )
+
+        phones = user.get_phones_by_priority()
+        self.assertEqual(phones, [immediate, earlier, later])
+
+    def test_get_phone_numbers_by_priority_orders_by_id_when_equal(self):
+        user = User.objects.create_user(username="phone-order", password="secret")
+        first = UserPhoneNumber.objects.create(
+            user=user, number="+19995550000", priority=0
+        )
+        second = UserPhoneNumber.objects.create(
+            user=user, number="+19995550001", priority=0
+        )
+
+        phones = user.get_phones_by_priority()
+        self.assertEqual(phones, [first, second])
+
+    def test_get_phone_numbers_by_priority_alias(self):
+        user = User.objects.create_user(username="phone-alias", password="secret")
+        phone = UserPhoneNumber.objects.create(
+            user=user, number="+14445550000", priority=3
+        )
+
+        self.assertEqual(user.get_phone_numbers_by_priority(), [phone])
+
+
+class ProfileValidationTests(TestCase):
+    def test_system_user_cannot_receive_profiles(self):
+        system_user = User.objects.get(username=User.SYSTEM_USERNAME)
+        profile = ReleaseManager(user=system_user)
+        with self.assertRaises(ValidationError) as exc:
+            profile.full_clean()
+        self.assertIn("user", exc.exception.error_dict)
+
+
+class UserAdminInlineTests(TestCase):
+    def setUp(self):
+        self.site = AdminSite()
+        self.factory = RequestFactory()
+        self.admin = UserAdmin(User, self.site)
+        self.system_user = User.objects.get(username=User.SYSTEM_USERNAME)
+        self.superuser = User.objects.create_superuser(
+            username="inline-super",
+            email="inline-super@example.com",
+            password="secret",
+        )
+
+    def test_profile_inlines_hidden_for_system_user(self):
+        request = self.factory.get("/")
+        request.user = self.superuser
+        system_inlines = self.admin.get_inline_instances(request, self.system_user)
+        system_profiles = [
+            inline
+            for inline in system_inlines
+            if inline.__class__ in USER_PROFILE_INLINES
+        ]
+        self.assertFalse(system_profiles)
+
+        other_inlines = self.admin.get_inline_instances(request, self.superuser)
+        other_profiles = [
+            inline
+            for inline in other_inlines
+            if inline.__class__ in USER_PROFILE_INLINES
+        ]
+        self.assertEqual(len(other_profiles), len(USER_PROFILE_INLINES))
+
+
 class RFIDLoginTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -112,7 +325,7 @@ class RFIDBatchApiTests(TestCase):
         self.client.force_login(self.user)
 
     def test_export_rfids(self):
-        tag_black = RFID.objects.create(rfid="CARD999")
+        tag_black = RFID.objects.create(rfid="CARD999", custom_label="Main Tag")
         tag_white = RFID.objects.create(rfid="CARD998", color=RFID.WHITE)
         self.account.rfids.add(tag_black, tag_white)
         response = self.client.get(reverse("rfid-batch"))
@@ -123,6 +336,7 @@ class RFIDBatchApiTests(TestCase):
                 "rfids": [
                     {
                         "rfid": "CARD999",
+                        "custom_label": "Main Tag",
                         "energy_accounts": [self.account.id],
                         "allowed": True,
                         "color": "B",
@@ -141,6 +355,7 @@ class RFIDBatchApiTests(TestCase):
                 "rfids": [
                     {
                         "rfid": "CARD111",
+                        "custom_label": "",
                         "energy_accounts": [],
                         "allowed": True,
                         "color": "W",
@@ -160,6 +375,7 @@ class RFIDBatchApiTests(TestCase):
                 "rfids": [
                     {
                         "rfid": "CARD112",
+                        "custom_label": "",
                         "energy_accounts": [],
                         "allowed": True,
                         "color": "B",
@@ -174,6 +390,7 @@ class RFIDBatchApiTests(TestCase):
             "rfids": [
                 {
                     "rfid": "A1B2C3D4",
+                    "custom_label": "Imported Tag",
                     "energy_accounts": [self.account.id],
                     "allowed": True,
                     "color": "W",
@@ -191,6 +408,7 @@ class RFIDBatchApiTests(TestCase):
         self.assertTrue(
             RFID.objects.filter(
                 rfid="A1B2C3D4",
+                custom_label="Imported Tag",
                 energy_accounts=self.account,
                 color=RFID.WHITE,
                 released=True,
@@ -237,6 +455,11 @@ class RFIDValidationTests(TestCase):
         found = RFID.get_account_by_rfid("abcd1234")
         self.assertEqual(found, acc)
 
+    def test_custom_label_length(self):
+        tag = RFID(rfid="FACE1234", custom_label="x" * 33)
+        with self.assertRaises(ValidationError):
+            tag.full_clean()
+
 
 class RFIDAssignmentTests(TestCase):
     def setUp(self):
@@ -279,7 +502,9 @@ class EnergyAccountTests(TestCase):
 
     def test_service_account_ignores_balance(self):
         user = User.objects.create_user(username="service", password="x")
-        acc = EnergyAccount.objects.create(user=user, service_account=True, name="SERVICE")
+        acc = EnergyAccount.objects.create(
+            user=user, service_account=True, name="SERVICE"
+        )
         self.assertTrue(acc.can_authorize())
 
     def test_account_without_user(self):
@@ -331,7 +556,43 @@ class AddressTests(TestCase):
         self.assertEqual(user.address, addr)
 
 
-class SubscriptionTests(TestCase):
+class PublicWifiUtilitiesTests(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(username="wifi", password="pwd")
+
+    def test_grant_public_access_records_allowlist(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            allow_file = base / "locks" / "public_wifi_allow.list"
+            with override_settings(BASE_DIR=base):
+                with patch("core.public_wifi._iptables_available", return_value=False):
+                    public_wifi.grant_public_access(self.user, "AA:BB:CC:DD:EE:FF")
+            self.assertTrue(allow_file.exists())
+            content = allow_file.read_text()
+            self.assertIn("aa:bb:cc:dd:ee:ff", content)
+            self.assertTrue(
+                PublicWifiAccess.objects.filter(
+                    user=self.user, mac_address="aa:bb:cc:dd:ee:ff"
+                ).exists()
+            )
+
+    def test_revoke_public_access_for_user_updates_allowlist(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            allow_file = base / "locks" / "public_wifi_allow.list"
+            with override_settings(BASE_DIR=base):
+                with patch("core.public_wifi._iptables_available", return_value=False):
+                    access = public_wifi.grant_public_access(
+                        self.user, "AA:BB:CC:DD:EE:FF"
+                    )
+                    public_wifi.revoke_public_access_for_user(self.user)
+            access.refresh_from_db()
+            self.assertIsNotNone(access.revoked_on)
+            if allow_file.exists():
+                self.assertNotIn("aa:bb:cc:dd:ee:ff", allow_file.read_text())
+
+
+class LiveSubscriptionTests(TestCase):
     def setUp(self):
         self.client = Client()
         self.user = User.objects.create_user(username="bob", password="pwd")
@@ -339,22 +600,41 @@ class SubscriptionTests(TestCase):
         self.product = Product.objects.create(name="Gold", renewal_period=30)
         self.client.force_login(self.user)
 
-    def test_create_and_list_subscription(self):
+    def test_create_and_list_live_subscription(self):
         response = self.client.post(
-            reverse("add-subscription"),
+            reverse("add-live-subscription"),
             data={"account_id": self.account.id, "product_id": self.product.id},
             content_type="application/json",
         )
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(Subscription.objects.count(), 1)
+        self.account.refresh_from_db()
+        self.assertEqual(
+            self.account.live_subscription_product,
+            self.product,
+        )
+        self.assertIsNotNone(self.account.live_subscription_start_date)
+        self.assertEqual(
+            self.account.live_subscription_start_date,
+            timezone.localdate(),
+        )
+        self.assertEqual(
+            self.account.live_subscription_next_renewal,
+            self.account.live_subscription_start_date
+            + timedelta(days=self.product.renewal_period),
+        )
 
         list_resp = self.client.get(
-            reverse("subscription-list"), {"account_id": self.account.id}
+            reverse("live-subscription-list"), {"account_id": self.account.id}
         )
         self.assertEqual(list_resp.status_code, 200)
         data = list_resp.json()
-        self.assertEqual(len(data["subscriptions"]), 1)
-        self.assertEqual(data["subscriptions"][0]["product__name"], "Gold")
+        self.assertEqual(len(data["live_subscriptions"]), 1)
+        self.assertEqual(data["live_subscriptions"][0]["product__name"], "Gold")
+        self.assertEqual(data["live_subscriptions"][0]["id"], self.account.id)
+        self.assertEqual(
+            data["live_subscriptions"][0]["next_renewal"],
+            str(self.account.live_subscription_next_renewal),
+        )
 
     def test_product_list(self):
         response = self.client.get(reverse("product-list"))
@@ -394,8 +674,8 @@ class EVBrandFixtureTests(TestCase):
     def test_ev_brand_fixture_loads(self):
         call_command(
             "loaddata",
-            "core/fixtures/ev_brands.json",
-            "core/fixtures/ev_models.json",
+            *sorted(glob("core/fixtures/ev_brands__*.json")),
+            *sorted(glob("core/fixtures/ev_models__*.json")),
             verbosity=0,
         )
         porsche = Brand.objects.get(name="Porsche")
@@ -408,11 +688,14 @@ class EVBrandFixtureTests(TestCase):
         )
         self.assertTrue(EVModel.objects.filter(brand=porsche, name="Taycan").exists())
         self.assertTrue(EVModel.objects.filter(brand=audi, name="e-tron GT").exists())
+        self.assertTrue(EVModel.objects.filter(brand=porsche, name="Macan").exists())
+        model3 = EVModel.objects.get(brand__name="Tesla", name="Model 3 RWD")
+        self.assertEqual(model3.est_battery_kwh, Decimal("57.50"))
 
     def test_brand_from_vin(self):
         call_command(
             "loaddata",
-            "core/fixtures/ev_brands.json",
+            *sorted(glob("core/fixtures/ev_brands__*.json")),
             verbosity=0,
         )
         self.assertEqual(Brand.from_vin("WP0ZZZ12345678901").name, "Porsche")
@@ -424,9 +707,9 @@ class RFIDFixtureTests(TestCase):
     def test_fixture_assigns_gelectriic_rfid(self):
         call_command(
             "loaddata",
-            "core/fixtures/users.json",
-            "core/fixtures/energy_accounts.json",
-            "core/fixtures/rfids.json",
+            "core/fixtures/users__arthexis.json",
+            "core/fixtures/energy_accounts__gelectriic.json",
+            "core/fixtures/rfids__ffffffff.json",
             verbosity=0,
         )
         account = EnergyAccount.objects.get(name="GELECTRIIC")
@@ -458,37 +741,6 @@ class SecurityGroupTests(TestCase):
         self.assertIn(user, child.user_set.all())
 
 
-class FediverseProfileTests(TestCase):
-    def setUp(self):
-        self.user = User.objects.create_user(username="fed", password="secret")
-
-    @mock.patch("requests.get")
-    def test_connection_success_sets_verified(self, mock_get):
-        mock_get.return_value.ok = True
-        mock_get.return_value.raise_for_status.return_value = None
-        profile = FediverseProfile.objects.create(
-            user=self.user,
-            service=FediverseProfile.MASTODON,
-            host="example.com",
-            handle="fed",
-            access_token="tok",
-        )
-        self.assertTrue(profile.test_connection())
-        self.assertIsNotNone(profile.verified_on)
-
-    @mock.patch("requests.get", side_effect=Exception("boom"))
-    def test_connection_failure_raises(self, mock_get):
-        profile = FediverseProfile.objects.create(
-            user=self.user,
-            service=FediverseProfile.MASTODON,
-            host="example.com",
-            handle="fed",
-        )
-        with self.assertRaises(ValidationError):
-            profile.test_connection()
-        self.assertIsNone(profile.verified_on)
-
-
 class ReleaseProcessTests(TestCase):
     def setUp(self):
         self.package = Package.objects.create(name="pkg")
@@ -499,14 +751,14 @@ class ReleaseProcessTests(TestCase):
     @mock.patch("core.views.release_utils._git_clean", return_value=False)
     def test_step_check_requires_clean_repo(self, git_clean):
         with self.assertRaises(Exception):
-            _step_check_pypi(self.release, {}, Path("rel.log"))
+            _step_check_version(self.release, {}, Path("rel.log"))
 
     @mock.patch("core.views.release_utils._git_clean", return_value=True)
     @mock.patch("core.views.release_utils.network_available", return_value=False)
     def test_step_check_keeps_repo_clean(self, network_available, git_clean):
         version_path = Path("VERSION")
         original = version_path.read_text(encoding="utf-8")
-        _step_check_pypi(self.release, {}, Path("rel.log"))
+        _step_check_version(self.release, {}, Path("rel.log"))
         proc = subprocess.run(
             ["git", "status", "--porcelain", str(version_path)],
             capture_output=True,
@@ -524,9 +776,7 @@ class ReleaseProcessTests(TestCase):
     @mock.patch("core.views.subprocess.run")
     @mock.patch("core.views.PackageRelease.dump_fixture")
     @mock.patch("core.views.release_utils.promote", side_effect=Exception("boom"))
-    def test_promote_cleans_repo_on_failure(
-        self, promote, dump_fixture, run
-    ):
+    def test_promote_cleans_repo_on_failure(self, promote, dump_fixture, run):
         with self.assertRaises(Exception):
             _step_promote_build(self.release, {}, Path("rel.log"))
         dump_fixture.assert_not_called()
@@ -688,12 +938,9 @@ class PackageReleaseAdminActionTests(TestCase):
         mock_get.return_value.json.return_value = {
             "releases": {"1.0.0": [], "1.1.0": []}
         }
-        self.admin.refresh_from_pypi(
-            self.request, PackageRelease.objects.none()
-        )
-        self.assertTrue(
-            PackageRelease.objects.filter(version="1.1.0").exists()
-        )
+        self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
+        new_release = PackageRelease.objects.get(version="1.1.0")
+        self.assertEqual(new_release.revision, "")
         dump.assert_called_once()
 
 
@@ -772,3 +1019,51 @@ class PackageReleaseChangelistTests(TestCase):
         )
         self.assertContains(response, refresh_url, html=False)
 
+
+class TodoDoneTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(User.objects.get(username="admin"))
+
+    def test_mark_done_sets_timestamp(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        todo.refresh_from_db()
+        self.assertIsNotNone(todo.done_on)
+        self.assertFalse(todo.is_deleted)
+
+
+class TodoUrlValidationTests(TestCase):
+    def test_relative_url_valid(self):
+        todo = Todo(request="Task", url="/path")
+        todo.full_clean()  # should not raise
+
+    def test_absolute_url_invalid(self):
+        todo = Todo(request="Task", url="https://example.com/path")
+        with self.assertRaises(ValidationError):
+            todo.full_clean()
+
+
+class TodoUniqueTests(TestCase):
+    def test_request_unique_case_insensitive(self):
+        Todo.objects.create(request="Task")
+        with self.assertRaises(IntegrityError):
+            Todo.objects.create(request="task")
+
+
+class TodoAdminPermissionTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(User.objects.get(username="admin"))
+
+    def test_add_view_disallowed(self):
+        resp = self.client.get(reverse("admin:core_todo_add"))
+        self.assertEqual(resp.status_code, 403)
+
+    def test_change_form_loads(self):
+        todo = Todo.objects.create(request="Task")
+        resp = self.client.get(reverse("admin:core_todo_change", args=[todo.pk]))
+        self.assertEqual(resp.status_code, 200)

core/tests_liveupdate.py

@@ -0,0 +1,17 @@
+from django.test import RequestFactory, TestCase
+from django.views.generic import TemplateView
+
+from core.liveupdate import LiveUpdateMixin
+
+
+class DummyView(LiveUpdateMixin, TemplateView):
+    template_name = "pages/base.html"
+    live_update_interval = 7
+
+
+class LiveUpdateMixinTests(TestCase):
+    def test_mixin_sets_request_interval(self):
+        factory = RequestFactory()
+        request = factory.get("/")
+        DummyView.as_view()(request)
+        self.assertEqual(request.live_update_interval, 7)

core/urls.py

@@ -6,6 +6,6 @@ urlpatterns = [
     path("rfid-login/", views.rfid_login, name="rfid-login"),
     path("rfids/", views.rfid_batch, name="rfid-batch"),
     path("products/", views.product_list, name="product-list"),
-    path("subscribe/", views.add_subscription, name="add-subscription"),
-    path("list/", views.subscription_list, name="subscription-list"),
+    path("live-subscribe/", views.add_live_subscription, name="add-live-subscription"),
+    path("live-list/", views.live_subscription_list, name="live-subscription-list"),
 ]