Use latest known Core version as reference

Instead of using current date to determine if Core version is more than
2 years old, use the latest known Core version as reference point and
check if current version is more than 24 releases behind.

This is crucial because when update information refresh is disabled due to
unsupported Core version, using date would create a permanent unsupported
state. Even if users update to the last known version in 4+ years, the
system would remain unsupported. By using latest known version as reference,
updating Core to the last known version makes the system supported again,
allowing update information refresh to resume.

This ensures users can always escape the unsupported state by updating
to the last known Core version, maintaining the update refresh cycle.

Author: agners

supervisor/resolution/evaluations/core_version.py

@@ -1,6 +1,5 @@
 """Evaluation class for Core version."""
 
-from datetime import datetime, timedelta
 import logging
 
 from awesomeversion import (
@@ -43,25 +42,44 @@ def states(self) -> list[CoreState]:
 
     async def evaluate(self) -> bool:
         """Run evaluation."""
-        if not (current := self.sys_homeassistant.version):
+        if not (current := self.sys_homeassistant.version) or not (
+            latest := self.sys_homeassistant.latest_version
+        ):
             return False
 
         # Skip evaluation for landingpage version
         if current == LANDINGPAGE:
             return False
 
         try:
-            # Calculate if the current version was released more than 2 years ago
-            # Home Assistant releases happen monthly, so approximately 24 versions per 2 years
-            # However, we'll be more precise and check based on actual version numbers
-            # Home Assistant uses CalVer versioning scheme like 2024.1, 2024.2, etc.
-
-            # Calculate 2 years ago from now
-            two_years_ago = datetime.now() - timedelta(days=730)  # 2 years = 730 days
-            cutoff_year = two_years_ago.year
-            cutoff_month = two_years_ago.month
-
-            # Create a cutoff version based on the date 2 years ago
+            # We use the latest known version as reference instead of current date.
+            # This is crucial because when update information refresh is disabled due to
+            # unsupported Core version, using date would create a permanent unsupported state.
+            # Even if the user updates to the last known version, the system would remain
+            # unsupported in 4+ years. By using latest known version, updating Core to the
+            # last known version makes the system supported again, allowing update refresh.
+            #
+            # Home Assistant uses CalVer versioning (2024.1, 2024.2, etc.) with monthly releases.
+            # We consider versions more than 24 releases (approximately 2 years) behind as unsupported.
+
+            # Extract year and month from latest version to calculate cutoff
+            latest_parts = str(latest).split(".")
+            if len(latest_parts) < 2:
+                return True  # Invalid latest version format
+
+            latest_year = int(latest_parts[0])
+            latest_month = int(latest_parts[1])
+
+            # Calculate 24 months back from latest version
+            cutoff_month = latest_month - 24
+            cutoff_year = latest_year
+
+            # Handle year rollover
+            while cutoff_month <= 0:
+                cutoff_month += 12
+                cutoff_year -= 1
+
+            # Create cutoff version
             cutoff_version = AwesomeVersion(
                 f"{cutoff_year}.{cutoff_month}",
                 ensure_strategy=AwesomeVersionStrategy.CALVER,
@@ -70,12 +88,12 @@ async def evaluate(self) -> bool:
             # Compare current version with the cutoff
             return current < cutoff_version
 
-        except AwesomeVersionException as err:
+        except (AwesomeVersionException, ValueError, IndexError) as err:
             # This is run regularly, avoid log spam by logging at debug level
             _LOGGER.debug(
-                "Failed to parse Home Assistant version '%s' or cutoff version '%s': %s",
+                "Failed to parse Home Assistant version '%s' or latest version '%s': %s",
                 current,
-                cutoff_version,
+                latest,
                 err,
             )
             # Consider non-parseable versions as unsupported

tests/resolution/evaluation/test_evaluate_core_version.py

@@ -1,6 +1,5 @@
 """Test Core Version evaluation."""
 
-from datetime import datetime
 from unittest.mock import PropertyMock, patch
 
 from awesomeversion import AwesomeVersion
@@ -14,23 +13,29 @@
 
 
 @pytest.mark.parametrize(
-    "current,expected",
+    "current,latest,expected",
     [
-        ("2022.1.0", True),  # More than 2 years old, should be unsupported
-        ("2023.12.0", False),  # Less than 2 years old, should be supported
-        (f"{datetime.now().year}.1", False),  # Current year, supported
-        (f"{datetime.now().year - 1}.12", False),  # 1 year old, supported
-        (f"{datetime.now().year - 2}.1", True),  # 2 years old, unsupported
-        (f"{datetime.now().year - 3}.1", True),  # 3 years old, unsupported
-        ("2021.6.0", True),  # Very old version, unsupported
-        ("0.116.4", True),  # Old version scheme, should be unsupported
-        ("0.118.1", True),  # Old version scheme, should be unsupported
-        ("landingpage", False),  # Landingpage version, should be supported
-        (None, False),  # No current version info, check skipped
+        ("2022.1.0", "2024.12.0", True),  # More than 24 versions behind, unsupported
+        ("2023.1.0", "2024.12.0", False),  # Less than 24 versions behind, supported
+        ("2024.1.0", "2024.12.0", False),  # Recent version, supported
+        ("2024.12.0", "2024.12.0", False),  # Same as latest, supported
+        ("2024.11.0", "2024.12.0", False),  # 1 month behind, supported
+        (
+            "2022.12.0",
+            "2024.12.0",
+            False,
+        ),  # Exactly 24 months behind, supported (boundary)
+        ("2022.11.0", "2024.12.0", True),  # More than 24 months behind, unsupported
+        ("2021.6.0", "2024.12.0", True),  # Very old version, unsupported
+        ("0.116.4", "2024.12.0", True),  # Old version scheme, should be unsupported
+        ("0.118.1", "2024.12.0", True),  # Old version scheme, should be unsupported
+        ("landingpage", "2024.12.0", False),  # Landingpage version, should be supported
+        (None, "2024.12.0", False),  # No current version info, check skipped
+        ("2024.1.0", None, False),  # No latest version info, check skipped
     ],
 )
 async def test_core_version_evaluation(
-    coresys: CoreSys, current: str | None, expected: bool
+    coresys: CoreSys, current: str | None, latest: str | None, expected: bool
 ):
     """Test evaluation logic on Core versions."""
     evaluation = EvaluateCoreVersion(coresys)
@@ -45,9 +50,7 @@ async def test_core_version_evaluation(
         patch.object(
             HomeAssistant,
             "latest_version",
-            new=PropertyMock(
-                return_value=AwesomeVersion("2024.12.0")
-            ),  # Mock latest version
+            new=PropertyMock(return_value=latest and AwesomeVersion(latest)),
         ),
     ):
         assert evaluation.reason not in coresys.resolution.unsupported
@@ -74,8 +77,8 @@ async def test_core_version_evaluation_no_latest(coresys: CoreSys):
     ):
         assert evaluation.reason not in coresys.resolution.unsupported
         await evaluation()
-        # Without latest version info, old versions should be marked as unsupported
-        assert evaluation.reason in coresys.resolution.unsupported
+        # Without latest version info, evaluation should be skipped (not run)
+        assert evaluation.reason not in coresys.resolution.unsupported
 
 
 async def test_core_version_invalid_format(coresys: CoreSys):