Simplify is_snap_old to return boolean and update notification message

- Changed notification message to vague 'hasn't been updated in a while'
- Simplified is_snap_old to return boolean instead of dictionary
- Removed convert_date_month_year function (no longer needed)
- Updated all tests to work with boolean return value
- Fixed test_is_snap_old_exactly_two_years timestamp to match exactly 2 years

Author: gajeshbhat

templates/store/snap-details/_details.html

@@ -16,11 +16,11 @@ <h3 class="p-muted-heading">Last updated</h3>
       <li>{{ updates[1]["released-at-display"] }} - <small>{{ updates[1]["track"] }}/{{ updates[1]["risk"] }}</small></li>
     {% endif %}
   </ul>
-  {% if old_snap_info and old_snap_info.is_old %}
+  {% if old_snap_info %}
   <div class="p-notification--caution is-borderless">
     <div class="p-notification__content">
       <p class="p-notification__message">
-        This snap hasn't been updated since {{ old_snap_info.last_updated_formatted }}. It might be unmaintained and have stability or security issues.
+        This snap hasn't been updated in a while. It might be unmaintained and have stability or security issues.
       </p>
     </div>
   </div>

tests/store/tests_public_logic.py

@@ -486,54 +486,43 @@ def test_get_last_updated_versions(self):
     def test_is_snap_old_empty_date(self):
         """Test that empty or None date returns not old"""
         result = logic.is_snap_old(None)
-        self.assertFalse(result["is_old"])
-        self.assertEqual(result["years_since_update"], 0)
+        self.assertFalse(result)
 
         result = logic.is_snap_old("")
-        self.assertFalse(result["is_old"])
-        self.assertEqual(result["years_since_update"], 0)
+        self.assertFalse(result)
 
     def test_is_snap_old_invalid_date(self):
         """Test that invalid date returns not old"""
         result = logic.is_snap_old("invalid-date")
-        self.assertFalse(result["is_old"])
-        self.assertEqual(result["years_since_update"], 0)
+        self.assertFalse(result)
 
     @freeze_time("2024-01-01")
     def test_is_snap_old_recent_snap(self):
         """Test that a recently updated snap is not considered old"""
         recent_date = "2023-06-01T10:00:00Z"
         result = logic.is_snap_old(recent_date)
-        self.assertFalse(result["is_old"])
-        self.assertEqual(result["years_since_update"], 0)
-        self.assertIn("last_updated_formatted", result)
+        self.assertFalse(result)
 
-    @freeze_time("2024-01-02")
+    @freeze_time("2024-01-02T10:00:00Z")
     def test_is_snap_old_exactly_two_years(self):
-        """Test that a snap updated over 2 years ago is considered old"""
-        old_date = "2021-12-01T10:00:00Z"  # Over 2 years ago
+        """Test that a snap updated exactly 2 years ago is considered old"""
+        old_date = "2022-01-02T10:00:00Z"  # Exactly 2 years ago
         result = logic.is_snap_old(old_date)
-        self.assertTrue(result["is_old"])
-        self.assertEqual(result["years_since_update"], 2)
-        self.assertIn("last_updated_formatted", result)
+        self.assertTrue(result)
 
     @freeze_time("2024-01-02")
     def test_is_snap_old_very_old_snap(self):
         """Test that a very old snap is considered old"""
         very_old_date = "2020-01-01T10:00:00Z"
         result = logic.is_snap_old(very_old_date)
-        self.assertTrue(result["is_old"])
-        self.assertEqual(result["years_since_update"], 4)
-        self.assertIn("last_updated_formatted", result)
+        self.assertTrue(result)
 
     @freeze_time("2024-01-01")
     def test_is_snap_old_just_under_two_years(self):
         """Test that a snap updated just under 2 years ago is not old"""
         almost_old_date = "2022-02-01T10:00:00Z"
         result = logic.is_snap_old(almost_old_date)
-        self.assertFalse(result["is_old"])
-        self.assertEqual(result["years_since_update"], 1)
-        self.assertIn("last_updated_formatted", result)
+        self.assertFalse(result)
 
     @freeze_time("2024-01-02")
     def test_is_snap_old_custom_threshold(self):
@@ -542,12 +531,11 @@ def test_is_snap_old_custom_threshold(self):
 
         # With default threshold (2 years), should not be old
         result = logic.is_snap_old(date_one_year_ago)
-        self.assertFalse(result["is_old"])
+        self.assertFalse(result)
 
         # With custom threshold (1 year), should be old
         result = logic.is_snap_old(date_one_year_ago, old_threshold_years=1)
-        self.assertTrue(result["is_old"])
-        self.assertEqual(result["years_since_update"], 1)
+        self.assertTrue(result)
 
     def test_is_snap_old_different_date_formats(self):
         """Test that different ISO date formats are handled correctly"""
@@ -562,19 +550,4 @@ def test_is_snap_old_different_date_formats(self):
         for date_str in dates_to_test:
             with freeze_time("2024-01-02"):
                 result = logic.is_snap_old(date_str)
-                self.assertTrue(
-                    result["is_old"], f"Failed for date format: {date_str}"
-                )
-                self.assertEqual(result["years_since_update"], 4)
-
-    def test_convert_date_month_year(self):
-        """Test the month-year date formatting function"""
-        test_cases = [
-            ("2022-01-14T10:00:00Z", "January 2022"),
-            ("2020-12-25T15:30:00Z", "December 2020"),
-            ("2019-06-01T00:00:00Z", "June 2019"),
-        ]
-
-        for date_str, expected in test_cases:
-            result = logic.convert_date_month_year(date_str)
-            self.assertEqual(result, expected, f"Failed for date: {date_str}")
+                self.assertTrue(result, f"Failed for date format: {date_str}")

webapp/store/logic.py

@@ -204,22 +204,6 @@ def convert_date(date_to_convert):
         return date_parsed.strftime("%-d %B %Y")
 
 
-def convert_date_month_year(date_to_convert):
-    """Convert date to month and year format: Month Year
-
-    Format of date to convert: 2019-01-12T16:48:41.821037+00:00
-    Output: January 2019
-
-    :param date_to_convert: Date to convert
-    :returns: Month and year only
-    """
-    date_parsed = parser.parse(date_to_convert)
-    if date_parsed.tzinfo is None:
-        date_parsed = date_parsed.replace(tzinfo=datetime.timezone.utc)
-
-    return date_parsed.strftime("%B %Y")
-
-
 def is_snap_old(last_updated_date, old_threshold_years=2.0):
     """Check if a snap is considered 'old' based on its last update date
 
@@ -229,11 +213,10 @@ def is_snap_old(last_updated_date, old_threshold_years=2.0):
     :param last_updated_date: The last updated date string in ISO format
     :param old_threshold_years: Number of years to consider a snap old
                                 (default: 2)
-    :returns: Dictionary with 'is_old' boolean and 'years_since_update'
-              integer
+    :returns: True if snap is old, False otherwise
     """
     if not last_updated_date:
-        return {"is_old": False, "years_since_update": 0}
+        return False
 
     try:
         date_parsed = parser.parse(last_updated_date)
@@ -245,18 +228,10 @@ def is_snap_old(last_updated_date, old_threshold_years=2.0):
         delta = relativedelta(now, date_parsed)
         years_since_update = delta.years
 
-        is_old = years_since_update >= old_threshold_years
-
-        return {
-            "is_old": is_old,
-            "years_since_update": years_since_update,
-            "last_updated_formatted": convert_date_month_year(
-                last_updated_date
-            ),
-        }
+        return years_since_update >= old_threshold_years
     except (ValueError, TypeError):
         # If we can't parse the date, assume it's not old
-        return {"is_old": False, "years_since_update": 0}
+        return False
 
 
 categories_list = [