arthexis 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

ocpp/models.py

@@ -15,6 +15,7 @@ from nodes.models import Node
 
 from core.models import (
     EnergyAccount,
+    EnergyTariff,
     Reference,
     RFID as CoreRFID,
     ElectricVehicle as CoreElectricVehicle,
@@ -35,6 +36,22 @@ class Location(Entity):
     longitude = models.DecimalField(
         max_digits=9, decimal_places=6, null=True, blank=True
     )
+    zone = models.CharField(
+        max_length=3,
+        choices=EnergyTariff.Zone.choices,
+        blank=True,
+        null=True,
+        help_text=_("CFE climate zone used to select matching energy tariffs."),
+    )
+    contract_type = models.CharField(
+        max_length=16,
+        choices=EnergyTariff.ContractType.choices,
+        blank=True,
+        null=True,
+        help_text=_(
+            "CFE service contract type required to match energy tariff pricing."
+        ),
+    )
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return self.name
@@ -48,6 +65,7 @@ class Charger(Entity):
     """Known charge point."""
 
     _PLACEHOLDER_SERIAL_RE = re.compile(r"^<[^>]+>$")
+    _AUTO_LOCATION_SANITIZE_RE = re.compile(r"[^0-9A-Za-z_-]+")
 
     OPERATIVE_STATUSES = {
         "Available",
@@ -324,6 +342,16 @@ class Charger(Entity):
             )
         return normalized
 
+    @classmethod
+    def sanitize_auto_location_name(cls, value: str) -> str:
+        """Return a location name containing only safe characters."""
+
+        sanitized = cls._AUTO_LOCATION_SANITIZE_RE.sub("_", value)
+        sanitized = re.sub(r"_+", "_", sanitized).strip("_")
+        if not sanitized:
+            return "Charger"
+        return sanitized
+
     AGGREGATE_CONNECTOR_SLUG = "all"
 
     def identity_tuple(self) -> tuple[str, int | None]:
@@ -459,7 +487,8 @@ class Charger(Entity):
             if existing:
                 self.location = existing.location
             else:
-                location, _ = Location.objects.get_or_create(name=self.charger_id)
+                auto_name = type(self).sanitize_auto_location_name(self.charger_id)
+                location, _ = Location.objects.get_or_create(name=auto_name)
                 self.location = location
             if update_list is not None and "location" not in update_list:
                 update_list.append("location")
@@ -469,11 +498,17 @@ class Charger(Entity):
         ref_value = self._full_url()
         if url_targets_local_loopback(ref_value):
             return
-        if not self.reference or self.reference.value != ref_value:
+        if not self.reference:
             self.reference = Reference.objects.create(
                 value=ref_value, alt_text=self.charger_id
             )
             super().save(update_fields=["reference"])
+        elif self.reference.value != ref_value:
+            Reference.objects.filter(pk=self.reference_id).update(
+                value=ref_value, alt_text=self.charger_id
+            )
+            self.reference.value = ref_value
+            self.reference.alt_text = self.charger_id
 
     def refresh_manager_node(self, node: Node | None = None) -> Node | None:
         """Ensure ``manager_node`` matches the provided or local node."""
@@ -663,6 +698,14 @@ class ChargerConfiguration(models.Model):
         blank=True,
         help_text=_("Keys returned in the unknownKey list."),
     )
+    evcs_snapshot_at = models.DateTimeField(
+        _("EVCS snapshot at"),
+        null=True,
+        blank=True,
+        help_text=_(
+            "Timestamp when this configuration was received from the charge point."
+        ),
+    )
     raw_payload = models.JSONField(
         default=dict,
         blank=True,
@@ -763,7 +806,11 @@ class Transaction(Entity):
     def vehicle_identifier(self) -> str:
         """Return the preferred vehicle identifier for this transaction."""
 
-        return (self.vid or self.vin or "").strip()
+        vid = (self.vid or "").strip()
+        if vid:
+            return vid
+
+        return (self.vin or "").strip()
 
     @property
     def vehicle_identifier_source(self) -> str:
@@ -1023,6 +1070,8 @@ class DataTransferMessage(models.Model):
 
     class Meta:
         ordering = ["-created_at"]
+        verbose_name = _("Data Message")
+        verbose_name_plural = _("Data Messages")
         indexes = [
             models.Index(
                 fields=["ocpp_message_id"],

ocpp/tasks.py

@@ -1,7 +1,10 @@
+import json
 import logging
+import uuid
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
 
+from asgiref.sync import async_to_sync
 from celery import shared_task
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -11,11 +14,106 @@ from django.db.models import Q
 from core import mailer
 from nodes.models import Node
 
-from .models import MeterValue, Transaction
+from . import store
+from .models import Charger, MeterValue, Transaction
 
 logger = logging.getLogger(__name__)
 
 
+@shared_task
+def check_charge_point_configuration(charger_pk: int) -> bool:
+    """Request the latest configuration from a connected charge point."""
+
+    try:
+        charger = Charger.objects.get(pk=charger_pk)
+    except Charger.DoesNotExist:
+        logger.warning(
+            "Unable to request configuration for missing charger %s",
+            charger_pk,
+        )
+        return False
+
+    connector_value = charger.connector_id
+    if connector_value is not None:
+        logger.debug(
+            "Skipping charger %s: connector %s is not eligible for automatic configuration checks",
+            charger.charger_id,
+            connector_value,
+        )
+        return False
+
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        logger.info(
+            "Charge point %s is not connected; configuration request skipped",
+            charger.charger_id,
+        )
+        return False
+
+    message_id = uuid.uuid4().hex
+    payload: dict[str, object] = {}
+    msg = json.dumps([2, message_id, "GetConfiguration", payload])
+
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:  # pragma: no cover - network error
+        logger.warning(
+            "Failed to send GetConfiguration to %s (%s)",
+            charger.charger_id,
+            exc,
+        )
+        return False
+
+    log_key = store.identity_key(charger.charger_id, connector_value)
+    store.add_log(log_key, f"< {msg}", log_type="charger")
+    store.register_pending_call(
+        message_id,
+        {
+            "action": "GetConfiguration",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "requested_at": timezone.now(),
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        timeout=5.0,
+        action="GetConfiguration",
+        log_key=log_key,
+        message=(
+            "GetConfiguration timed out: charger did not respond"
+            " (operation may not be supported)"
+        ),
+    )
+    logger.info(
+        "Requested configuration from charge point %s",
+        charger.charger_id,
+    )
+    return True
+
+
+@shared_task
+def schedule_daily_charge_point_configuration_checks() -> int:
+    """Dispatch configuration requests for eligible charge points."""
+
+    charger_ids = list(
+        Charger.objects.filter(connector_id__isnull=True).values_list("pk", flat=True)
+    )
+    if not charger_ids:
+        logger.debug("No eligible charge points available for configuration check")
+        return 0
+
+    scheduled = 0
+    for charger_pk in charger_ids:
+        check_charge_point_configuration.delay(charger_pk)
+        scheduled += 1
+    logger.info(
+        "Scheduled configuration checks for %s charge point(s)", scheduled
+    )
+    return scheduled
+
+
 @shared_task
 def purge_meter_values() -> int:
     """Delete meter values older than 7 days.

ocpp/tests.py

@@ -55,6 +55,7 @@ from django.contrib.sites.models import Site
 from django.core.exceptions import ValidationError
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
+from django.contrib.admin.sites import AdminSite
 
 from config.asgi import application
 
@@ -67,8 +68,9 @@ from .models import (
     Location,
     DataTransferMessage,
 )
+from .admin import ChargerConfigurationAdmin
 from .consumers import CSMSConsumer
-from .views import dispatch_action, _transaction_rfid_details
+from .views import dispatch_action, _transaction_rfid_details, _usage_timeline
 from .status_display import STATUS_BADGE_MAP
 from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
@@ -81,7 +83,12 @@ 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, send_daily_session_report
+from .tasks import (
+    purge_meter_readings,
+    send_daily_session_report,
+    check_charge_point_configuration,
+    schedule_daily_charge_point_configuration_checks,
+)
 from django.db import close_old_connections
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
@@ -170,6 +177,36 @@ class DispatchActionTests(TestCase):
         self.assertEqual(metadata.get("trigger_target"), "BootNotification")
         self.assertEqual(metadata.get("log_key"), log_key)
 
+    def test_reset_rejected_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETBLOCK")
+        dummy = DummyWebSocket()
+        connection_key = store.set_connection(charger.charger_id, charger.connector_id, dummy)
+        self.addCleanup(lambda: store.connections.pop(connection_key, None))
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        tx_key = store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        self.addCleanup(lambda: store.transactions.pop(tx_key, None))
+
+        request = self.factory.post(
+            "/chargers/RESETBLOCK/action/",
+            data=json.dumps({"action": "reset"}),
+            content_type="application/json",
+        )
+        request.user = SimpleNamespace(
+            is_authenticated=True,
+            is_superuser=True,
+            is_staff=True,
+        )
+
+        response = dispatch_action(request, charger.charger_id)
+        self.assertEqual(response.status_code, 409)
+        payload = json.loads(response.content.decode("utf-8"))
+        self.assertIn("stop the session first", payload.get("detail", "").lower())
+        self.assertFalse(dummy.sent)
+
 class ChargerFixtureTests(TestCase):
     fixtures = [
         p.name
@@ -211,6 +248,62 @@ class ChargerFixtureTests(TestCase):
         self.assertEqual(cp2.name, "Simulator #2")
 
 
+class ChargerRefreshManagerNodeTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        local = Node.objects.create(
+            hostname="local-node",
+            address="127.0.0.1",
+            port=8000,
+            mac_address="aa:bb:cc:dd:ee:ff",
+            current_relation=Node.Relation.SELF,
+        )
+        Node.objects.filter(pk=local.pk).update(mac_address="AA:BB:CC:DD:EE:FF")
+        cls.local_node = Node.objects.get(pk=local.pk)
+
+    def test_refresh_manager_node_assigns_local_to_unsaved_charger(self):
+        charger = Charger(charger_id="UNSAVED")
+
+        with patch("nodes.models.Node.get_current_mac", return_value="aa:bb:cc:dd:ee:ff"):
+            result = charger.refresh_manager_node()
+
+        self.assertEqual(result, self.local_node)
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_updates_persisted_charger(self):
+        remote = Node.objects.create(
+            hostname="remote-node",
+            address="10.0.0.1",
+            port=9000,
+            mac_address="11:22:33:44:55:66",
+        )
+        charger = Charger.objects.create(
+            charger_id="PERSISTED",
+            manager_node=remote,
+        )
+
+        charger.refresh_manager_node(node=self.local_node)
+
+        self.assertEqual(charger.manager_node, self.local_node)
+        charger.refresh_from_db()
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_handles_missing_local_node(self):
+        remote = Node.objects.create(
+            hostname="existing-manager",
+            address="10.0.0.2",
+            port=9001,
+            mac_address="22:33:44:55:66:77",
+        )
+        charger = Charger(charger_id="NOLOCAL", manager_node=remote)
+
+        with patch.object(Node, "get_local", return_value=None):
+            result = charger.refresh_manager_node()
+
+        self.assertIsNone(result)
+        self.assertEqual(charger.manager_node, remote)
+
+
 class ChargerUrlFallbackTests(TestCase):
     @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
     def test_reference_created_when_site_missing(self):
@@ -757,6 +850,7 @@ class CSMSConsumerTests(TransactionTestCase):
         )()
         self.assertIsNotNone(configuration)
         self.assertEqual(configuration.charger_identifier, "CFGRES")
+        self.assertIsNotNone(configuration.evcs_snapshot_at)
         self.assertEqual(
             configuration.configuration_keys,
             [
@@ -2312,6 +2406,43 @@ class ChargerAdminTests(TestCase):
             store.pop_connection(charger.charger_id, charger.connector_id)
             store.clear_pending_calls(charger.charger_id)
 
+    def test_reset_charger_action_skips_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETADMIN")
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "reset_chargers",
+                    "index": 0,
+                    "select_across": 0,
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertFalse(ws.sent)
+            self.assertContains(response, "stop the session first")
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pop_transaction(charger.charger_id, charger.connector_id)
+
     def test_admin_log_view_displays_entries(self):
         charger = Charger.objects.create(charger_id="LOG2")
         log_id = store.identity_key(charger.charger_id, charger.connector_id)
@@ -2614,6 +2745,81 @@ class ChargerAdminTests(TestCase):
             store.clear_log(pending_key, log_type="charger")
 
 
+class ChargerConfigurationAdminUnitTests(TestCase):
+    def setUp(self):
+        self.admin = ChargerConfigurationAdmin(ChargerConfiguration, AdminSite())
+        self.request_factory = RequestFactory()
+
+    def test_origin_display_returns_evcs_when_snapshot_present(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-EVCS",
+            evcs_snapshot_at=timezone.now(),
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "EVCS")
+
+    def test_origin_display_returns_local_without_snapshot(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-LOCAL",
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "Local")
+
+    def test_save_model_resets_snapshot_timestamp(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-SAVE",
+            evcs_snapshot_at=timezone.now(),
+        )
+        request = self.request_factory.post("/admin/ocpp/chargerconfiguration/")
+        self.admin.save_model(request, configuration, form=None, change=True)
+        configuration.refresh_from_db()
+        self.assertIsNone(configuration.evcs_snapshot_at)
+
+
+class ConfigurationTaskTests(TestCase):
+    def tearDown(self):
+        store.pending_calls.clear()
+
+    def test_check_charge_point_configuration_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="TASKCFG")
+        ws = DummyWebSocket()
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        pending_key = store.pending_key(charger.charger_id)
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        try:
+            result = check_charge_point_configuration.run(charger.pk)
+            self.assertTrue(result)
+            self.assertEqual(len(ws.sent), 1)
+            frame = json.loads(ws.sent[0])
+            self.assertEqual(frame[0], 2)
+            self.assertEqual(frame[2], "GetConfiguration")
+            self.assertIn(frame[1], store.pending_calls)
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pending_calls.clear()
+            store.clear_log(log_key, log_type="charger")
+            store.clear_log(pending_key, log_type="charger")
+
+    def test_check_charge_point_configuration_without_connection(self):
+        charger = Charger.objects.create(charger_id="TASKNOCONN")
+        result = check_charge_point_configuration.run(charger.pk)
+        self.assertFalse(result)
+
+    def test_schedule_daily_checks_only_includes_root_chargers(self):
+        eligible = Charger.objects.create(charger_id="TASKROOT")
+        Charger.objects.create(charger_id="TASKCONN", connector_id=1)
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 1)
+        mock_delay.assert_called_once_with(eligible.pk)
+
+    def test_schedule_daily_checks_returns_zero_without_chargers(self):
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 0)
+        mock_delay.assert_not_called()
+
+
 class LocationAdminTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -2887,6 +3093,28 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    def test_auto_registered_charger_location_name_sanitized(self):
+        async def exercise():
+            communicator = WebsocketCommunicator(
+                application, "/?cid=ACME%20Charger%20%231"
+            )
+            connected, _ = await communicator.connect()
+            self.assertTrue(connected)
+
+            await communicator.disconnect()
+
+            def fetch_location_name() -> str:
+                charger = (
+                    Charger.objects.select_related("location")
+                    .get(charger_id="ACME Charger #1")
+                )
+                return charger.location.name
+
+            location_name = await database_sync_to_async(fetch_location_name)()
+            self.assertEqual(location_name, "ACME_Charger_1")
+
+        async_to_sync(exercise)()
+
     async def test_query_string_cid_supported(self):
         communicator = WebsocketCommunicator(application, "/?cid=QSERIAL")
         connected, _ = await communicator.connect()
@@ -3324,6 +3552,10 @@ class ChargerLocationTests(TestCase):
         second = Charger.objects.create(charger_id="SHARE", connector_id=2)
         self.assertEqual(second.location, first.location)
 
+    def test_location_name_sanitized_when_auto_created(self):
+        charger = Charger.objects.create(charger_id="Name With spaces!#1")
+        self.assertEqual(charger.location.name, "Name_With_spaces_1")
+
 
 class MeterReadingTests(TransactionTestCase):
     async def test_meter_values_saved_as_readings(self):
@@ -4428,6 +4660,122 @@ class ChargerStatusViewTests(TestCase):
         self.assertAlmostEqual(resp.context["tx"].kw, 0.02)
         store.transactions.pop(key, None)
 
+    def test_usage_timeline_rendered_when_chart_unavailable(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(charger_id="TL1", connector_id=1)
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+
+        store.logs["charger"][log_key] = [
+            build_entry(timedelta(days=2), "Available"),
+            build_entry(timedelta(days=1), "Charging"),
+            build_entry(timedelta(hours=12), "Available"),
+        ]
+
+        data, _window = _usage_timeline(charger, [], now=fixed_now)
+        self.assertEqual(len(data), 1)
+        statuses = {segment["status"] for segment in data[0]["segments"]}
+        self.assertIn("charging", statuses)
+        self.assertIn("available", statuses)
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(
+                reverse(
+                    "charger-status-connector",
+                    args=[charger.charger_id, charger.connector_slug],
+                )
+            )
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, "usage-timeline-segment usage-charging")
+
+    def test_usage_timeline_includes_multiple_connectors(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        aggregate = Charger.objects.create(charger_id="TLAGG")
+        connector_one = Charger.objects.create(charger_id="TLAGG", connector_id=1)
+        connector_two = Charger.objects.create(charger_id="TLAGG", connector_id=2)
+
+        def build_entry(connector_id, delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": connector_id,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            key = store.identity_key(aggregate.charger_id, connector_id)
+            store.logs["charger"].setdefault(key, []).append(
+                f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+            )
+
+        build_entry(1, timedelta(days=3), "Available")
+        build_entry(2, timedelta(days=2), "Charging")
+
+        overview = [{"charger": connector_one}, {"charger": connector_two}]
+        data, _window = _usage_timeline(aggregate, overview, now=fixed_now)
+        self.assertEqual(len(data), 2)
+        self.assertTrue(all(entry["segments"] for entry in data))
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(reverse("charger-status", args=[aggregate.charger_id]))
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, connector_one.connector_label)
+        self.assertContains(resp, connector_two.connector_label)
+
+    def test_usage_timeline_merges_repeated_status_entries(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(
+            charger_id="TLDEDUP",
+            connector_id=1,
+            last_status="Available",
+        )
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.logs["charger"][log_key] = [
+            build_entry(timedelta(days=6, hours=12), "Available"),
+            build_entry(timedelta(days=5), "Available"),
+            build_entry(timedelta(days=3, hours=6), "Charging"),
+            build_entry(timedelta(days=2), "Charging"),
+            build_entry(timedelta(days=1), "Available"),
+        ]
+
+        data, window = _usage_timeline(charger, [], now=fixed_now)
+        self.assertIsNotNone(window)
+        self.assertEqual(len(data), 1)
+        segments = data[0]["segments"]
+        self.assertGreaterEqual(len(segments), 1)
+        statuses = [segment["status"] for segment in segments]
+        self.assertEqual(statuses, ["available", "charging", "available"])
+
     def test_diagnostics_status_displayed(self):
         reported_at = timezone.now().replace(microsecond=0)
         charger = Charger.objects.create(