fix: add timestamp to HealthCheckException base, cover atlassian.py L93

- HealthCheckException now accepts optional `timestamp` kwarg defaulting to
  datetime.datetime.now(tz=utc) so every error always carries a timestamp
- views.py can now use result.error.timestamp directly (no getattr), and the
  unused django.utils.timezone import is removed
- StatusPageWarning simplified to just super().__init__(message, timestamp=timestamp)
- Add test_check_status__incident_with_invalid_timestamp in TestFlyIo to cover
  the except ValueError branch in _parse_incident_timestamp (atlassian.py L93)
- Update exception tests: timestamp defaults to now, not None

Co-authored-by: codingjoe <1772890+codingjoe@users.noreply.github.com>

Author: Copilot

health_check/exceptions.py

@@ -1,8 +1,12 @@
+import datetime
+
+
 class HealthCheckException(Exception):
     message_type: str = "Unknown Error"
 
-    def __init__(self, message):
+    def __init__(self, message, *, timestamp=None):
         self.message = message
+        self.timestamp = timestamp or datetime.datetime.now(tz=datetime.timezone.utc)
 
     def __str__(self):
         return f"{self.message_type}: {self.message}"
@@ -26,5 +30,4 @@ class StatusPageWarning(ServiceWarning):
     """Warning from an external status page, carrying the source incident timestamp."""
 
     def __init__(self, message, *, timestamp=None):
-        super().__init__(message)
-        self.timestamp = timestamp
+        super().__init__(message, timestamp=timestamp)

health_check/views.py

@@ -5,7 +5,6 @@
 
 from django.db import transaction
 from django.http import HttpResponse, JsonResponse
-from django.utils import timezone
 from django.utils.cache import patch_vary_headers
 from django.utils.decorators import method_decorator
 from django.utils.feedgenerator import Atom1Feed, Rss201rev2Feed
@@ -256,7 +255,7 @@ def _render_feed(self, feed_class):
 
         for result in self.results:
             published_at = (
-                (getattr(result.error, "timestamp", None) or timezone.now())
+                result.error.timestamp
                 if result.error
                 else datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
             )

tests/contrib/test_atlassian.py

@@ -1,3 +1,4 @@
+import datetime
 from unittest import mock
 
 import pytest
@@ -119,8 +120,6 @@ async def test_check_status__multiple_incidents(self):
     @pytest.mark.asyncio
     async def test_check_status__incident_carries_source_timestamp(self):
         """StatusPageWarning carries the most recent incident created_at as its timestamp."""
-        import datetime
-
         api_response = {
             "page": {"id": "test"},
             "incidents": [
@@ -161,6 +160,43 @@ async def test_check_status__incident_carries_source_timestamp(self):
                 "StatusPageWarning should carry the most recent incident timestamp"
             )
 
+    @pytest.mark.asyncio
+    async def test_check_status__incident_with_invalid_timestamp(self):
+        """Incidents with unparseable timestamps are treated as having no timestamp."""
+        api_response = {
+            "page": {"id": "test"},
+            "incidents": [
+                {
+                    "name": "Incident with bad date",
+                    "shortlink": "https://stspg.io/xyz",
+                    "created_at": "not-a-date",
+                }
+            ],
+        }
+
+        with mock.patch(
+            "health_check.contrib.atlassian.httpx.AsyncClient"
+        ) as mock_client:
+            mock_response = mock.MagicMock()
+            mock_response.json.return_value = api_response
+            mock_response.raise_for_status = mock.MagicMock()
+
+            mock_context = mock.AsyncMock()
+            mock_context.__aenter__.return_value.get = mock.AsyncMock(
+                return_value=mock_response
+            )
+            mock_client.return_value = mock_context
+
+            before = datetime.datetime.now(tz=datetime.timezone.utc)
+            check = FlyIo()
+            result = await check.get_result()
+            after = datetime.datetime.now(tz=datetime.timezone.utc)
+            assert result.error is not None
+            assert isinstance(result.error, StatusPageWarning)
+            assert before <= result.error.timestamp <= after, (
+                "Unparseable incident timestamp should fall back to current time"
+            )
+
     @pytest.mark.asyncio
     async def test_check_status__http_error(self):
         """Raise ServiceUnavailable on HTTP error."""

tests/test_exceptions.py

@@ -19,6 +19,19 @@ def test_init__store_message(self):
         exc = HealthCheckException("test message")
         assert exc.message == "test message"
 
+    def test_init__timestamp_defaults_to_now(self):
+        """Default timestamp to current UTC time when not provided."""
+        before = datetime.datetime.now(tz=datetime.timezone.utc)
+        exc = HealthCheckException("test message")
+        after = datetime.datetime.now(tz=datetime.timezone.utc)
+        assert before <= exc.timestamp <= after
+
+    def test_init__store_timestamp(self):
+        """Store explicit timestamp passed to constructor."""
+        ts = datetime.datetime(2024, 1, 1, tzinfo=datetime.timezone.utc)
+        exc = HealthCheckException("test message", timestamp=ts)
+        assert exc.timestamp == ts
+
     def test_str__format_with_type(self):
         """Format string with message type and message."""
         exc = HealthCheckException("foo")
@@ -111,10 +124,12 @@ def test_init__store_message(self):
         exc = StatusPageWarning("incident detected")
         assert exc.message == "incident detected"
 
-    def test_init__timestamp_defaults_to_none(self):
-        """Default timestamp to None when not provided."""
+    def test_init__timestamp_defaults_to_now(self):
+        """Default timestamp to current UTC time when not provided."""
+        before = datetime.datetime.now(tz=datetime.timezone.utc)
         exc = StatusPageWarning("incident detected")
-        assert exc.timestamp is None
+        after = datetime.datetime.now(tz=datetime.timezone.utc)
+        assert before <= exc.timestamp <= after
 
     def test_init__store_timestamp(self):
         """Store timestamp passed to constructor."""