Fix Starlink's ever updating uptime

homeassistant/components/starlink/coordinator.py

@@ -72,7 +72,6 @@ def __init__(self, hass: HomeAssistant, config_entry: StarlinkConfigEntry) -> No
     def _get_starlink_data(self) -> StarlinkData:
         """Retrieve Starlink data."""
         context = self.channel_context
-        status = status_data(context)
         location = location_data(context)
         sleep = get_sleep_config(context)
         status, obstruction, alert = status_data(context)

homeassistant/components/starlink/sensor.py

@@ -28,6 +28,7 @@
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.util.dt import now
+from homeassistant.util.variance import ignore_variance
 
 from .coordinator import StarlinkConfigEntry, StarlinkData
 from .entity import StarlinkEntity
@@ -91,6 +92,10 @@ async def async_added_to_hass(self) -> None:
             self._attr_native_value = last_native_value
 
 
+uptime_to_stable_datetime = ignore_variance(
+    lambda value: now() - timedelta(seconds=value), timedelta(minutes=1)
+)
+
 SENSORS: tuple[StarlinkSensorEntityDescription, ...] = (
     StarlinkSensorEntityDescription(
         key="ping",
@@ -150,9 +155,7 @@ async def async_added_to_hass(self) -> None:
         translation_key="last_restart",
         device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda data: (
-            now() - timedelta(seconds=data.status["uptime"], milliseconds=-500)
-        ).replace(microsecond=0),
+        value_fn=lambda data: uptime_to_stable_datetime(data.status["uptime"]),
         entity_class=StarlinkSensorEntity,
     ),
     StarlinkSensorEntityDescription(

tests/components/starlink/patchers.py

@@ -9,11 +9,6 @@
     "homeassistant.components.starlink.async_setup_entry", return_value=True
 )
 
-STATUS_DATA_SUCCESS_PATCHER = patch(
-    "homeassistant.components.starlink.coordinator.status_data",
-    return_value=json.loads(load_fixture("status_data_success.json", "starlink")),
-)
-
 LOCATION_DATA_SUCCESS_PATCHER = patch(
     "homeassistant.components.starlink.coordinator.location_data",
     return_value=json.loads(load_fixture("location_data_success.json", "starlink")),
@@ -24,6 +19,12 @@
     return_value=json.loads(load_fixture("sleep_data_success.json", "starlink")),
 )
 
+STATUS_DATA_TARGET = "homeassistant.components.starlink.coordinator.status_data"
+STATUS_DATA_FIXTURE = json.loads(load_fixture("status_data_success.json", "starlink"))
+STATUS_DATA_SUCCESS_PATCHER = patch(
+    STATUS_DATA_TARGET, return_value=STATUS_DATA_FIXTURE
+)
+
 HISTORY_STATS_SUCCESS_PATCHER = patch(
     "homeassistant.components.starlink.coordinator.history_stats",
     return_value=json.loads(load_fixture("history_stats_success.json", "starlink")),

tests/components/starlink/test_init.py

@@ -1,20 +1,31 @@
 """Tests Starlink integration init/unload."""
 
+from copy import deepcopy
+from datetime import datetime, timedelta
 from unittest.mock import patch
 
+from freezegun import freeze_time
+
 from homeassistant.components.starlink.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_IP_ADDRESS
 from homeassistant.core import HomeAssistant, State
+from homeassistant.util import dt as dt_util
 
 from .patchers import (
     HISTORY_STATS_SUCCESS_PATCHER,
     LOCATION_DATA_SUCCESS_PATCHER,
     SLEEP_DATA_SUCCESS_PATCHER,
+    STATUS_DATA_FIXTURE,
     STATUS_DATA_SUCCESS_PATCHER,
+    STATUS_DATA_TARGET,
 )
 
-from tests.common import MockConfigEntry, mock_restore_cache_with_extra_data
+from tests.common import (
+    MockConfigEntry,
+    async_fire_time_changed,
+    mock_restore_cache_with_extra_data,
+)
 
 
 async def test_successful_entry(hass: HomeAssistant) -> None:
@@ -25,9 +36,9 @@ async def test_successful_entry(hass: HomeAssistant) -> None:
     )
 
     with (
-        STATUS_DATA_SUCCESS_PATCHER,
         LOCATION_DATA_SUCCESS_PATCHER,
         SLEEP_DATA_SUCCESS_PATCHER,
+        STATUS_DATA_SUCCESS_PATCHER,
         HISTORY_STATS_SUCCESS_PATCHER,
     ):
         entry.add_to_hass(hass)
@@ -48,9 +59,9 @@ async def test_unload_entry(hass: HomeAssistant) -> None:
     )
 
     with (
-        STATUS_DATA_SUCCESS_PATCHER,
         LOCATION_DATA_SUCCESS_PATCHER,
         SLEEP_DATA_SUCCESS_PATCHER,
+        STATUS_DATA_SUCCESS_PATCHER,
         HISTORY_STATS_SUCCESS_PATCHER,
     ):
         entry.add_to_hass(hass)
@@ -65,7 +76,7 @@ async def test_unload_entry(hass: HomeAssistant) -> None:
 
 
 async def test_restore_cache_with_accumulation(hass: HomeAssistant) -> None:
-    """Test configuring Starlink."""
+    """Test Starlink accumulation."""
     entry = MockConfigEntry(
         domain=DOMAIN,
         data={CONF_IP_ADDRESS: "1.2.3.4:0000"},
@@ -89,9 +100,9 @@ async def test_restore_cache_with_accumulation(hass: HomeAssistant) -> None:
     )
 
     with (
-        STATUS_DATA_SUCCESS_PATCHER,
         LOCATION_DATA_SUCCESS_PATCHER,
         SLEEP_DATA_SUCCESS_PATCHER,
+        STATUS_DATA_SUCCESS_PATCHER,
         HISTORY_STATS_SUCCESS_PATCHER,
     ):
         entry.add_to_hass(hass)
@@ -112,3 +123,62 @@ async def test_restore_cache_with_accumulation(hass: HomeAssistant) -> None:
             await entry.runtime_data.async_refresh()
 
         assert hass.states.get(entity_id).state == str(1 + 0.01572462736977)
+
+
+async def test_last_restart_state(hass: HomeAssistant) -> None:
+    """Test Starlink last restart state."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={CONF_IP_ADDRESS: "1.2.3.4:0000"},
+    )
+    entity_id = "sensor.starlink_last_restart"
+    utc_now = datetime.fromisoformat("2025-10-22T13:31:29+00:00")
+
+    with (
+        LOCATION_DATA_SUCCESS_PATCHER,
+        SLEEP_DATA_SUCCESS_PATCHER,
+        STATUS_DATA_SUCCESS_PATCHER,
+        HISTORY_STATS_SUCCESS_PATCHER,
+    ):
+        with freeze_time(utc_now):
+            entry.add_to_hass(hass)
+
+            await hass.config_entries.async_setup(entry.entry_id)
+            await hass.async_block_till_done()
+
+        assert hass.states.get(entity_id).state == "2025-10-13T06:09:11+00:00"
+
+        with patch.object(entry.runtime_data, "always_update", return_value=True):
+            status_data = deepcopy(STATUS_DATA_FIXTURE)
+            status_data[0]["uptime"] = 804144
+
+            with (
+                freeze_time(utc_now + timedelta(seconds=5)),
+                patch(STATUS_DATA_TARGET, return_value=status_data),
+            ):
+                async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=5))
+                await hass.async_block_till_done(wait_background_tasks=True)
+
+            assert hass.states.get(entity_id).state == "2025-10-13T06:09:11+00:00"
+
+            status_data[0]["uptime"] = 804134
+
+            with (
+                freeze_time(utc_now + timedelta(seconds=10)),
+                patch(STATUS_DATA_TARGET, return_value=status_data),
+            ):
+                async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10))
+                await hass.async_block_till_done(wait_background_tasks=True)
+
+            assert hass.states.get(entity_id).state == "2025-10-13T06:09:11+00:00"
+
+            status_data[0]["uptime"] = 100
+
+            with (
+                freeze_time(utc_now + timedelta(seconds=15)),
+                patch(STATUS_DATA_TARGET, return_value=status_data),
+            ):
+                async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=15))
+                await hass.async_block_till_done(wait_background_tasks=True)
+
+            assert hass.states.get(entity_id).state == "2025-10-22T13:30:04+00:00"