arthexis 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

nodes/tests.py

@@ -1293,6 +1293,51 @@ class NodeRegisterCurrentTests(TestCase):
             PeriodicTask.objects.filter(name="pages_purge_landing_leads").exists()
         )
 
+    def test_ocpp_session_report_task_syncs_with_feature(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "port": 9400,
+                "base_path": settings.BASE_DIR,
+            },
+        )
+        task_name = "ocpp_send_daily_session_report"
+        PeriodicTask.objects.filter(name=task_name).delete()
+
+        with patch("nodes.models.mailer.can_send_email", return_value=True):
+            NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+
+        self.assertTrue(PeriodicTask.objects.filter(name=task_name).exists())
+
+        NodeFeatureAssignment.objects.filter(node=node, feature=feature).delete()
+        self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
+
+    def test_ocpp_session_report_task_requires_email(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "port": 9500,
+                "base_path": settings.BASE_DIR,
+            },
+        )
+        task_name = "ocpp_send_daily_session_report"
+        PeriodicTask.objects.filter(name=task_name).delete()
+
+        with patch("nodes.models.mailer.can_send_email", return_value=False):
+            NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+
+        self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
+
 
 class CheckRegistrationReadyCommandTests(TestCase):
     def test_command_completes_successfully(self):
@@ -1348,6 +1393,16 @@ class NodeAdminTests(TestCase):
         self.assertContains(response, f'href="{snapshot_url}"')
         self.assertContains(response, f'href="{stream_url}"')
 
+    def test_node_feature_list_shows_waveform_action_when_enabled(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="audio-capture", defaults={"display": "Audio Capture"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        response = self.client.get(reverse("admin:nodes_nodefeature_changelist"))
+        action_url = reverse("admin:nodes_nodefeature_view_waveform")
+        self.assertContains(response, f'href="{action_url}"')
+
     def test_node_feature_list_hides_default_action_when_disabled(self):
         self._create_local_node()
         NodeFeature.objects.get_or_create(
@@ -1750,6 +1805,34 @@ class NodeAdminTests(TestCase):
         self.assertEqual(response.context_data["stream_embed"], "unsupported")
         self.assertContains(response, "camera-stream__unsupported")
 
+    def test_view_waveform_requires_enabled_feature(self):
+        self._create_local_node()
+        NodeFeature.objects.get_or_create(
+            slug="audio-capture", defaults={"display": "Audio Capture"}
+        )
+        response = self.client.get(
+            reverse("admin:nodes_nodefeature_view_waveform"), follow=True
+        )
+        self.assertEqual(response.status_code, 200)
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        self.assertEqual(response.wsgi_request.path, changelist_url)
+        self.assertContains(
+            response, "Audio Capture feature is not enabled on this node."
+        )
+
+    def test_view_waveform_renders_when_feature_enabled(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="audio-capture", defaults={"display": "Audio Capture"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        response = self.client.get(reverse("admin:nodes_nodefeature_view_waveform"))
+        self.assertEqual(response.status_code, 200)
+        response.render()
+        self.assertEqual(response.context_data["feature"], feature)
+        self.assertEqual(response.context_data["title"], "Audio Capture Waveform")
+        self.assertContains(response, "audio-capture__canvas")
+
     @patch("nodes.admin.requests.post")
     def test_import_rfids_action_fetches_and_imports(self, mock_post):
         local = self._create_local_node()
@@ -2496,6 +2579,8 @@ class NetMessagePropagationTests(TestCase):
     def test_propagate_forwards_to_three_and_notifies_local(
         self, mock_notify, mock_post
     ):
+        mock_post.return_value.ok = True
+        mock_post.return_value.status_code = 200
         msg = NetMessage.objects.create(subject="s", body="b", reach=self.role)
         with patch.object(Node, "get_local", return_value=self.local):
             msg.propagate(seen=[str(self.remotes[0].uuid)])
@@ -2512,6 +2597,13 @@ class NetMessagePropagationTests(TestCase):
         self.assertNotIn(sender_addr, targets)
         self.assertEqual(msg.propagated_to.count(), 4)
         self.assertTrue(msg.complete)
+        self.assertEqual(len(msg.confirmed_peers), mock_post.call_count)
+        self.assertTrue(
+            all(entry["status"] == "acknowledged" for entry in msg.confirmed_peers.values())
+        )
+        self.assertTrue(
+            all(entry["status_code"] == 200 for entry in msg.confirmed_peers.values())
+        )
 
     @patch("requests.post")
     @patch("core.notifications.notify", return_value=False)
@@ -2587,6 +2679,21 @@ class NetMessagePropagationTests(TestCase):
         self.assertTrue(NetMessage.objects.filter(pk=old_remote.pk).exists())
         self.assertTrue(NetMessage.objects.filter(pk=msg.pk).exists())
 
+    @patch("core.notifications.notify", return_value=False)
+    def test_propagate_records_error_status(self, mock_notify):
+        msg = NetMessage.objects.create(subject="s", body="b", reach=self.role)
+        with (
+            patch.object(Node, "get_local", return_value=self.local),
+            patch("random.shuffle", side_effect=lambda seq: None),
+            patch("requests.post", side_effect=Exception("boom")),
+        ):
+            msg.propagate()
+
+        self.assertTrue(msg.confirmed_peers)
+        self.assertTrue(
+            all(entry["status"] == "error" for entry in msg.confirmed_peers.values())
+        )
+
 
 class NetMessageSignatureTests(TestCase):
     def setUp(self):
@@ -3196,6 +3303,18 @@ class NodeFeatureTests(TestCase):
         self.assertIn("Take a Snapshot", labels)
         self.assertIn("View stream", labels)
 
+    def test_audio_capture_feature_has_view_waveform_action(self):
+        feature = NodeFeature.objects.create(
+            slug="audio-capture", display="Audio Capture"
+        )
+        actions = feature.get_default_actions()
+        self.assertEqual(len(actions), 1)
+        action = actions[0]
+        self.assertEqual(action.label, "View Waveform")
+        self.assertEqual(
+            action.url_name, "admin:nodes_nodefeature_view_waveform"
+        )
+
     def test_default_action_missing_when_unconfigured(self):
         feature = NodeFeature.objects.create(
             slug="custom-feature", display="Custom Feature"

nodes/utils.py

@@ -89,6 +89,7 @@ def save_screenshot(
     transaction_uuid=None,
     *,
     content: str | None = None,
+    user=None,
 ):
     """Save screenshot file info if not already recorded.
 
@@ -115,6 +116,8 @@ def save_screenshot(
         data["transaction_uuid"] = transaction_uuid
     if content is not None:
         data["content"] = content
+    if user is not None:
+        data["user"] = user
     with suppress_default_classifiers():
         sample = ContentSample.objects.create(**data)
     run_default_classifiers(sample)

ocpp/consumers.py

@@ -321,6 +321,44 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             except (TypeError, ValueError):
                 return
         if connector_value is None:
+            aggregate = self.aggregate_charger
+            if (
+                not aggregate
+                or aggregate.connector_id is not None
+                or aggregate.charger_id != self.charger_id
+            ):
+                aggregate, _ = await database_sync_to_async(
+                    Charger.objects.get_or_create
+                )(
+                    charger_id=self.charger_id,
+                    connector_id=None,
+                    defaults={"last_path": self.scope.get("path", "")},
+                )
+                await database_sync_to_async(aggregate.refresh_manager_node)()
+                self.aggregate_charger = aggregate
+            self.charger = self.aggregate_charger
+            previous_key = self.store_key
+            new_key = store.identity_key(self.charger_id, None)
+            if previous_key != new_key:
+                existing_consumer = store.connections.get(new_key)
+                if existing_consumer is not None and existing_consumer is not self:
+                    await existing_consumer.close()
+                store.reassign_identity(previous_key, new_key)
+                store.connections[new_key] = self
+                store.logs["charger"].setdefault(new_key, [])
+            aggregate_name = await sync_to_async(
+                lambda: self.charger.name or self.charger.charger_id
+            )()
+            friendly_name = aggregate_name or self.charger_id
+            store.register_log_name(new_key, friendly_name, log_type="charger")
+            store.register_log_name(
+                store.identity_key(self.charger_id, None),
+                friendly_name,
+                log_type="charger",
+            )
+            store.register_log_name(self.charger_id, friendly_name, log_type="charger")
+            self.store_key = new_key
+            self.connector_value = None
             if not self._header_reference_created and self.client_ip:
                 await database_sync_to_async(self._ensure_console_reference)()
                 self._header_reference_created = True

ocpp/models.py

@@ -854,11 +854,26 @@ class DataTransferMessage(models.Model):
         on_delete=models.CASCADE,
         related_name="data_transfer_messages",
     )
-    connector_id = models.PositiveIntegerField(null=True, blank=True)
+    connector_id = models.PositiveIntegerField(
+        null=True,
+        blank=True,
+        verbose_name="Connector ID",
+    )
     direction = models.CharField(max_length=16, choices=DIRECTION_CHOICES)
-    ocpp_message_id = models.CharField(max_length=64)
-    vendor_id = models.CharField(max_length=255, blank=True)
-    message_id = models.CharField(max_length=255, blank=True)
+    ocpp_message_id = models.CharField(
+        max_length=64,
+        verbose_name="OCPP message ID",
+    )
+    vendor_id = models.CharField(
+        max_length=255,
+        blank=True,
+        verbose_name="Vendor ID",
+    )
+    message_id = models.CharField(
+        max_length=255,
+        blank=True,
+        verbose_name="Message ID",
+    )
     payload = models.JSONField(default=dict, blank=True)
     status = models.CharField(max_length=64, blank=True)
     response_data = models.JSONField(null=True, blank=True)

ocpp/tasks.py

@@ -1,11 +1,17 @@
 import logging
-from datetime import timedelta
+from datetime import date, datetime, time, timedelta
+from pathlib import Path
 
 from celery import shared_task
+from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.utils import timezone
 from django.db.models import Q
 
-from .models import MeterValue
+from core import mailer
+from nodes.models import Node
+
+from .models import MeterValue, Transaction
 
 logger = logging.getLogger(__name__)
 
@@ -29,3 +35,151 @@ def purge_meter_values() -> int:
 
 # Backwards compatibility alias
 purge_meter_readings = purge_meter_values
+
+
+def _resolve_report_window() -> tuple[datetime, datetime, date]:
+    """Return the start/end datetimes for today's reporting window."""
+
+    current_tz = timezone.get_current_timezone()
+    today = timezone.localdate()
+    start = timezone.make_aware(datetime.combine(today, time.min), current_tz)
+    end = start + timedelta(days=1)
+    return start, end, today
+
+
+def _session_report_recipients() -> list[str]:
+    """Return the list of recipients for the daily session report."""
+
+    User = get_user_model()
+    recipients = list(
+        User.objects.filter(is_superuser=True)
+        .exclude(email="")
+        .values_list("email", flat=True)
+    )
+    if recipients:
+        return recipients
+
+    fallback = getattr(settings, "DEFAULT_FROM_EMAIL", "").strip()
+    return [fallback] if fallback else []
+
+
+def _format_duration(delta: timedelta | None) -> str:
+    """Return a compact string for ``delta`` or ``"in progress"``."""
+
+    if delta is None:
+        return "in progress"
+    total_seconds = int(delta.total_seconds())
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    parts: list[str] = []
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    if seconds or not parts:
+        parts.append(f"{seconds}s")
+    return " ".join(parts)
+
+
+def _format_charger(transaction: Transaction) -> str:
+    """Return a human friendly label for ``transaction``'s charger."""
+
+    charger = transaction.charger
+    if charger is None:
+        return "Unknown charger"
+    for attr in ("display_name", "name", "charger_id"):
+        value = getattr(charger, attr, "")
+        if value:
+            return str(value)
+    return str(charger)
+
+
+@shared_task
+def send_daily_session_report() -> int:
+    """Send a summary of today's OCPP sessions when email is available."""
+
+    if not mailer.can_send_email():
+        logger.info("Skipping OCPP session report: email not configured")
+        return 0
+
+    celery_lock = Path(settings.BASE_DIR) / "locks" / "celery.lck"
+    if not celery_lock.exists():
+        logger.info("Skipping OCPP session report: celery feature disabled")
+        return 0
+
+    recipients = _session_report_recipients()
+    if not recipients:
+        logger.info("Skipping OCPP session report: no recipients found")
+        return 0
+
+    start, end, today = _resolve_report_window()
+    transactions = list(
+        Transaction.objects.filter(start_time__gte=start, start_time__lt=end)
+        .select_related("charger", "account")
+        .order_by("start_time")
+    )
+    if not transactions:
+        logger.info("No OCPP sessions recorded on %s", today.isoformat())
+        return 0
+
+    total_energy = sum(transaction.kw for transaction in transactions)
+    lines = [
+        f"OCPP session report for {today.isoformat()}",
+        "",
+        f"Total sessions: {len(transactions)}",
+        f"Total energy: {total_energy:.2f} kWh",
+        "",
+    ]
+
+    for index, transaction in enumerate(transactions, start=1):
+        start_local = timezone.localtime(transaction.start_time)
+        stop_local = (
+            timezone.localtime(transaction.stop_time)
+            if transaction.stop_time
+            else None
+        )
+        duration = _format_duration(
+            stop_local - start_local if stop_local else None
+        )
+        account = transaction.account.name if transaction.account else "N/A"
+        connector = (
+            f"Connector {transaction.connector_id}" if transaction.connector_id else None
+        )
+        lines.append(f"{index}. {_format_charger(transaction)}")
+        lines.append(f"   Account: {account}")
+        if transaction.rfid:
+            lines.append(f"   RFID: {transaction.rfid}")
+        if connector:
+            lines.append(f"   {connector}")
+        lines.append(
+            "   Start: "
+            f"{start_local.strftime('%H:%M:%S %Z')}"
+        )
+        if stop_local:
+            lines.append(
+                "   Stop: "
+                f"{stop_local.strftime('%H:%M:%S %Z')} ({duration})"
+            )
+        else:
+            lines.append("   Stop: in progress")
+        lines.append(f"   Energy: {transaction.kw:.2f} kWh")
+        lines.append("")
+
+    subject = f"OCPP session report for {today.isoformat()}"
+    body = "\n".join(lines).strip()
+
+    node = Node.get_local()
+    if node is not None:
+        node.send_mail(subject, body, recipients)
+    else:
+        mailer.send(
+            subject,
+            body,
+            recipients,
+            getattr(settings, "DEFAULT_FROM_EMAIL", None),
+        )
+
+    logger.info(
+        "Sent OCPP session report for %s to %s", today.isoformat(), ", ".join(recipients)
+    )
+    return len(transactions)

ocpp/test_rfid.py

@@ -1,6 +1,7 @@
 import io
 import json
 import os
+import subprocess
 import sys
 import types
 from datetime import datetime, timezone as dt_timezone
@@ -394,10 +395,11 @@ class ValidateRfidValueTests(SimpleTestCase):
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
     @patch("ocpp.rfid.reader.subprocess.run")
     @patch("ocpp.rfid.reader.RFID.register_scan")
     def test_external_command_success(
-        self, mock_register, mock_run, mock_notify, mock_now
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
     ):
         fake_now = object()
         mock_now.return_value = fake_now
@@ -414,6 +416,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         mock_run.return_value = types.SimpleNamespace(
             returncode=0, stdout="ok\n", stderr=""
         )
+        mock_popen.return_value = object()
 
         result = validate_rfid_value("abcd1234")
 
@@ -424,6 +427,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = run_kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCD1234")
         self.assertEqual(env.get("RFID_LABEL_ID"), "1")
+        mock_popen.assert_not_called()
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
         self.assertTrue(result["allowed"])
@@ -436,10 +440,11 @@ class ValidateRfidValueTests(SimpleTestCase):
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
     @patch("ocpp.rfid.reader.subprocess.run")
     @patch("ocpp.rfid.reader.RFID.register_scan")
     def test_external_command_failure_blocks_tag(
-        self, mock_register, mock_run, mock_notify, mock_now
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
     ):
         fake_now = object()
         mock_now.return_value = fake_now
@@ -456,6 +461,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         mock_run.return_value = types.SimpleNamespace(
             returncode=1, stdout="", stderr="failure"
         )
+        mock_popen.return_value = object()
 
         result = validate_rfid_value("ffff")
 
@@ -469,6 +475,42 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stdout"), "")
         self.assertEqual(output.get("stderr"), "failure")
         self.assertEqual(output.get("error"), "")
+        mock_popen.assert_not_called()
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_post_command_runs_after_success(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 3
+        tag.label_id = 3
+        tag.allowed = True
+        tag.external_command = ""
+        tag.post_auth_command = "echo done"
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        mock_register.return_value = (tag, False)
+        result = validate_rfid_value("abcdef")
+
+        mock_run.assert_not_called()
+        mock_popen.assert_called_once()
+        args, kwargs = mock_popen.call_args
+        self.assertEqual(args[0], "echo done")
+        env = kwargs.get("env", {})
+        self.assertEqual(env.get("RFID_VALUE"), "ABCDEF")
+        self.assertEqual(env.get("RFID_LABEL_ID"), "3")
+        self.assertIs(kwargs.get("stdout"), subprocess.DEVNULL)
+        self.assertIs(kwargs.get("stderr"), subprocess.DEVNULL)
+        self.assertTrue(result["allowed"])
+        mock_notify.assert_called_once_with("RFID 3 OK", "ABCDEF B")
 
 
 class CardTypeDetectionTests(TestCase):

ocpp/tests.py

@@ -40,6 +40,7 @@ from django.test import (
     TestCase,
     override_settings,
 )
+from django.conf import settings
 from unittest import skip
 from contextlib import suppress
 from types import SimpleNamespace
@@ -79,7 +80,7 @@ from .simulator import SimulatorConfig, ChargePointSimulator
 from .evcs import simulate, SimulatorState, _simulators
 import re
 from datetime import datetime, timedelta, timezone as dt_timezone
-from .tasks import purge_meter_readings
+from .tasks import purge_meter_readings, send_daily_session_report
 from django.db import close_old_connections
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
@@ -2981,6 +2982,46 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_heartbeat_refreshes_aggregate_after_connector_status(self):
+        store.ip_connections.clear()
+        store.connections.clear()
+        await database_sync_to_async(Charger.objects.create)(charger_id="HBAGG")
+        communicator = WebsocketCommunicator(application, "/HBAGG/")
+        connect_result = await communicator.connect()
+        self.assertTrue(connect_result[0], connect_result)
+
+        status_payload = {
+            "connectorId": 2,
+            "status": "Faulted",
+            "errorCode": "ReaderFailure",
+        }
+        await communicator.send_json_to(
+            [2, "1", "StatusNotification", status_payload]
+        )
+        await communicator.receive_json_from()
+
+        aggregate = await database_sync_to_async(Charger.objects.get)(
+            charger_id="HBAGG", connector_id=None
+        )
+        connector = await database_sync_to_async(Charger.objects.get)(
+            charger_id="HBAGG", connector_id=2
+        )
+        previous_heartbeat = aggregate.last_heartbeat
+
+        await communicator.send_json_to([2, "2", "Heartbeat", {}])
+        await communicator.receive_json_from()
+
+        await database_sync_to_async(aggregate.refresh_from_db)()
+        await database_sync_to_async(connector.refresh_from_db)()
+
+        self.assertIsNotNone(aggregate.last_heartbeat)
+        if previous_heartbeat:
+            self.assertNotEqual(aggregate.last_heartbeat, previous_heartbeat)
+        if connector.last_heartbeat:
+            self.assertNotEqual(aggregate.last_heartbeat, connector.last_heartbeat)
+
+        await communicator.disconnect()
+
 
 class ChargerLocationTests(TestCase):
     def test_lat_lon_fields_saved(self):
@@ -3676,6 +3717,75 @@ class PurgeMeterReadingsTaskTests(TestCase):
         self.assertTrue(MeterReading.objects.filter(pk=reading.pk).exists())
 
 
+class DailySessionReportTaskTests(TestCase):
+    def setUp(self):
+        super().setUp()
+        self.locks_dir = Path(settings.BASE_DIR) / "locks"
+        self.locks_dir.mkdir(parents=True, exist_ok=True)
+        self.celery_lock = self.locks_dir / "celery.lck"
+        self.celery_lock.write_text("")
+        self.addCleanup(self._cleanup_lock)
+
+    def _cleanup_lock(self):
+        try:
+            self.celery_lock.unlink()
+        except FileNotFoundError:
+            pass
+
+    def test_report_sends_email_when_sessions_exist(self):
+        User = get_user_model()
+        User.objects.create_superuser(
+            username="report-admin",
+            email="report-admin@example.com",
+            password="pw",
+        )
+        charger = Charger.objects.create(charger_id="RPT1", display_name="Pod 1")
+        start = timezone.now().replace(hour=10, minute=0, second=0, microsecond=0)
+        Transaction.objects.create(
+            charger=charger,
+            start_time=start,
+            stop_time=start + timedelta(hours=1),
+            meter_start=0,
+            meter_stop=2500,
+            connector_id=2,
+            rfid="AA11",
+        )
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 1)
+        self.assertTrue(mock_send.called)
+        args, _kwargs = mock_send.call_args
+        self.assertIn("OCPP session report", args[0])
+        self.assertIn("Pod 1", args[1])
+        self.assertIn("report-admin@example.com", args[2])
+        self.assertGreaterEqual(len(args[2]), 1)
+
+    def test_report_skips_when_no_sessions(self):
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 0)
+        mock_send.assert_not_called()
+
+    def test_report_skips_without_celery_feature(self):
+        if self.celery_lock.exists():
+            self.celery_lock.unlink()
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 0)
+        mock_send.assert_not_called()
+
+
 class TransactionKwTests(TestCase):
     def test_kw_sums_meter_readings(self):
         charger = Charger.objects.create(charger_id="SUM1")