firefighter-incident 0.0.22__py3-none-any.whl → 0.0.23__py3-none-any.whl

firefighter_tests/test_jira_app/test_timeline_template.py

@@ -0,0 +1,135 @@
+"""Tests for Jira post-mortem timeline template rendering."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+from django.template.loader import render_to_string
+from django.utils import timezone
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.incidents.models.incident_update import IncidentUpdate
+
+if TYPE_CHECKING:
+    from firefighter.incidents.models.incident import Incident
+    from firefighter.incidents.models.user import User
+
+
+@pytest.mark.django_db
+class TestTimelineTemplate:
+    """Test timeline template rendering with chronological ordering."""
+
+    @staticmethod
+    def test_timeline_includes_key_events_and_status_changes() -> None:
+        """Test that timeline includes both key events and status changes in chronological order."""
+        # Create a user
+        user: User = UserFactory.create()
+
+        # Create an incident
+        incident: Incident = IncidentFactory.create(
+            _status=IncidentStatus.POST_MORTEM,
+            created_by=user,
+        )
+
+        # Create key events and status changes at different times
+        base_time = timezone.now()
+
+        # Event 1: detected (key event) - earliest
+        IncidentUpdate.objects.create(
+            incident=incident,
+            event_type="detected",
+            event_ts=base_time,
+            created_by=user,
+            message="Issue was detected",
+        )
+
+        # Event 2: status change to INVESTIGATING - middle
+        IncidentUpdate.objects.create(
+            incident=incident,
+            _status=IncidentStatus.INVESTIGATING,
+            event_ts=base_time + timezone.timedelta(minutes=5),
+            created_by=user,
+        )
+
+        # Event 3: started (key event) - later
+        IncidentUpdate.objects.create(
+            incident=incident,
+            event_type="started",
+            event_ts=base_time + timezone.timedelta(minutes=10),
+            created_by=user,
+            message="Investigation started",
+        )
+
+        # Event 4: status change to MITIGATING - latest
+        IncidentUpdate.objects.create(
+            incident=incident,
+            _status=IncidentStatus.MITIGATING,
+            event_ts=base_time + timezone.timedelta(minutes=15),
+            created_by=user,
+        )
+
+        # Render the timeline template
+        timeline_content = render_to_string(
+            "jira/postmortem/timeline.txt",
+            {"incident": incident},
+        )
+
+        # Verify timeline contains all events
+        assert "Incident created" in timeline_content
+        assert "Key event: Detected" in timeline_content
+        assert "Issue was detected" in timeline_content
+        assert "Status changed to: Investigating" in timeline_content
+        assert "Key event: Started" in timeline_content
+        assert "Investigation started" in timeline_content
+        assert "Status changed to: Mitigating" in timeline_content
+
+        # Verify chronological order by checking positions in the timeline
+        # The events should appear in this order:
+        # 1. Incident created
+        # 2. detected (key event)
+        # 3. INVESTIGATING (status change)
+        # 4. started (key event)
+        # 5. MITIGATING (status change)
+        created_pos = timeline_content.find("Incident created")
+        detected_pos = timeline_content.find("Key event: Detected")
+        investigating_pos = timeline_content.find("Status changed to: Investigating")
+        started_pos = timeline_content.find("Key event: Started")
+        mitigating_pos = timeline_content.find("Status changed to: Mitigating")
+
+        assert created_pos < detected_pos < investigating_pos < started_pos < mitigating_pos, (
+            "Events are not in chronological order"
+        )
+
+    @staticmethod
+    def test_timeline_handles_key_events_without_message() -> None:
+        """Test that timeline handles key events that have no message."""
+        # Create a user
+        user: User = UserFactory.create()
+
+        # Create an incident
+        incident: Incident = IncidentFactory.create(
+            _status=IncidentStatus.POST_MORTEM,
+            created_by=user,
+        )
+
+        # Create a key event without message
+        IncidentUpdate.objects.create(
+            incident=incident,
+            event_type="detected",
+            event_ts=timezone.now(),
+            created_by=user,
+            message=None,
+        )
+
+        # Render the timeline template
+        timeline_content = render_to_string(
+            "jira/postmortem/timeline.txt",
+            {"incident": incident},
+        )
+
+        # Verify the key event appears without a dash for empty message
+        assert "Key event: Detected" in timeline_content
+        # Should not have " - " when there's no message
+        assert "Key event: Detected -" not in timeline_content

firefighter_tests/test_raid/test_raid_signals.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from unittest.mock import Mock, patch
 
 import pytest
+from django.test import override_settings
 
 from firefighter.incidents.enums import IncidentStatus
 from firefighter.incidents.models.incident_update import IncidentUpdate
@@ -19,11 +20,13 @@ class TestIncidentUpdatedCloseJiraTicket:
 
     @patch("firefighter.raid.signals.incident_updated.client.close_issue")
     def test_close_jira_ticket_when_status_changes_to_mitigated(
-        self, mock_close_issue: Mock, incident_factory, user_factory, jira_ticket_factory
+        self, mock_close_issue: Mock, incident_factory, user_factory, jira_ticket_factory, priority_factory
     ) -> None:
-        """Test that Jira ticket is closed when incident status changes to MITIGATED."""
+        """Test that Jira ticket is closed when incident status changes to MITIGATED for P3+."""
         user = user_factory()
-        incident = incident_factory(created_by=user)
+        # Create P3 priority (no postmortem needed)
+        p3_priority = priority_factory(value=3, name="P3", needs_postmortem=False)
+        incident = incident_factory(created_by=user, priority=p3_priority)
         jira_ticket = jira_ticket_factory(incident=incident)
         incident.jira_ticket = jira_ticket
 
@@ -41,14 +44,53 @@ class TestIncidentUpdatedCloseJiraTicket:
             updated_fields=["_status"],
         )
 
-        # Verify close_issue was called
+        # Verify close_issue was called for P3+ incidents
         mock_close_issue.assert_called_once_with(issue_id=jira_ticket.id)
 
+    @override_settings(ENABLE_JIRA_POSTMORTEM=True)
+    @patch("firefighter.raid.signals.incident_updated.client.close_issue")
+    def test_do_not_close_jira_ticket_when_p1_mitigated(
+        self, mock_close_issue: Mock, incident_factory, user_factory, jira_ticket_factory, priority_factory, environment_factory
+    ) -> None:
+        """Test that Jira ticket is NOT closed when P1 incident status changes to MITIGATED.
+
+        For P1/P2 incidents requiring postmortem, the ticket should stay open through
+        MITIGATED and POST_MORTEM phases, closing only at CLOSED.
+        """
+        user = user_factory()
+        # Create P1 priority (needs postmortem)
+        p1_priority = priority_factory(value=1, name="P1", needs_postmortem=True)
+        prd_env = environment_factory(value="PRD", name="Production")
+        incident = incident_factory(created_by=user, priority=p1_priority, environment=prd_env)
+        jira_ticket = jira_ticket_factory(incident=incident)
+        incident.jira_ticket = jira_ticket
+
+        incident_update = IncidentUpdate(
+            incident=incident,
+            status=IncidentStatus.MITIGATED,
+            created_by=user,
+        )
+
+        # Call the signal handler
+        incident_updated_close_ticket_when_mitigated_or_postmortem(
+            sender="update_status",
+            incident=incident,
+            incident_update=incident_update,
+            updated_fields=["_status"],
+        )
+
+        # Verify close_issue was NOT called - P1 needs to go through postmortem first
+        mock_close_issue.assert_not_called()
+
     @patch("firefighter.raid.signals.incident_updated.client.close_issue")
-    def test_close_jira_ticket_when_status_changes_to_postmortem(
+    def test_do_not_close_jira_ticket_when_status_changes_to_postmortem(
         self, mock_close_issue: Mock, incident_factory, user_factory, jira_ticket_factory
     ) -> None:
-        """Test that Jira ticket is closed when incident status changes to POST_MORTEM."""
+        """Test that Jira ticket is NOT closed when incident status changes to POST_MORTEM.
+
+        The ticket should remain open during the post-mortem phase and only close
+        when the incident reaches CLOSED status.
+        """
         user = user_factory()
         incident = incident_factory(created_by=user)
         jira_ticket = jira_ticket_factory(incident=incident)
@@ -68,8 +110,8 @@ class TestIncidentUpdatedCloseJiraTicket:
             updated_fields=["_status"],
         )
 
-        # Verify close_issue was called
-        mock_close_issue.assert_called_once_with(issue_id=jira_ticket.id)
+        # Verify close_issue was NOT called - ticket stays open during PM
+        mock_close_issue.assert_not_called()
 
     @patch("firefighter.raid.signals.incident_updated.client.close_issue")
     def test_close_jira_ticket_when_status_changes_to_closed(

firefighter_tests/test_slack/messages/test_slack_messages.py

@@ -5,6 +5,7 @@ import pytest
 from firefighter.incidents.enums import IncidentStatus
 from firefighter.incidents.factories import IncidentFactory, UserFactory
 from firefighter.incidents.models import IncidentUpdate
+from firefighter.jira_app.models import JiraPostMortem
 from firefighter.slack.factories import IncidentChannelFactory
 from firefighter.slack.messages.slack_messages import (
     SlackMessageDeployWarning,
@@ -12,6 +13,11 @@ from firefighter.slack.messages.slack_messages import (
     SlackMessageIncidentStatusUpdated,
 )
 
+try:
+    from firefighter.confluence.models import PostMortem
+except (ImportError, AttributeError):
+    PostMortem = None
+
 
 @pytest.mark.django_db
 class TestSlackMessageIncidentStatusUpdated:
@@ -31,9 +37,7 @@ class TestSlackMessageIncidentStatusUpdated:
         # Create an IncidentUpdate
         user = UserFactory.create()
         incident_update = IncidentUpdate.objects.create(
-            incident=incident,
-            status=IncidentStatus.MITIGATED,
-            created_by=user
+            incident=incident, status=IncidentStatus.MITIGATED, created_by=user
         )
 
         # Create the message with status_changed=True and in_channel=False
@@ -41,7 +45,7 @@ class TestSlackMessageIncidentStatusUpdated:
             incident=incident,
             incident_update=incident_update,
             in_channel=False,
-            status_changed=True
+            status_changed=True,
         )
 
         # Verify the title contains "Mitigated" (the status label)
@@ -61,9 +65,7 @@ class TestSlackMessageIncidentStatusUpdated:
         # Create an IncidentUpdate
         user = UserFactory.create()
         incident_update = IncidentUpdate.objects.create(
-            incident=incident,
-            status=IncidentStatus.INVESTIGATING,
-            created_by=user
+            incident=incident, status=IncidentStatus.INVESTIGATING, created_by=user
         )
 
         # Create the message with status_changed=True and in_channel=False
@@ -71,7 +73,7 @@ class TestSlackMessageIncidentStatusUpdated:
             incident=incident,
             incident_update=incident_update,
             in_channel=False,
-            status_changed=True
+            status_changed=True,
         )
 
         # Verify the title does NOT contain the MITIGATED-specific format
@@ -93,9 +95,7 @@ class TestSlackMessageIncidentStatusUpdated:
         # Create an IncidentUpdate with status change
         user = UserFactory.create()
         incident_update = IncidentUpdate.objects.create(
-            incident=incident,
-            status=IncidentStatus.CLOSED,
-            created_by=user
+            incident=incident, status=IncidentStatus.CLOSED, created_by=user
         )
 
         # Create the message with in_channel=True (normal case for in-channel messages)
@@ -103,7 +103,7 @@ class TestSlackMessageIncidentStatusUpdated:
             incident=incident,
             incident_update=incident_update,
             in_channel=True,
-            status_changed=True
+            status_changed=True,
         )
 
         # Get the blocks
@@ -118,7 +118,9 @@ class TestSlackMessageIncidentStatusUpdated:
 
         # If there is a status update block, verify it has NO accessory (button)
         if status_update_block:
-            assert status_update_block.accessory is None, "Update button should not be present when incident is CLOSED"
+            assert status_update_block.accessory is None, (
+                "Update button should not be present when incident is CLOSED"
+            )
 
     def test_update_button_shown_when_incident_not_closed(self) -> None:
         """Test that Update Status button IS displayed when incident is NOT CLOSED."""
@@ -131,9 +133,7 @@ class TestSlackMessageIncidentStatusUpdated:
         # Create an IncidentUpdate
         user = UserFactory.create()
         incident_update = IncidentUpdate.objects.create(
-            incident=incident,
-            status=IncidentStatus.INVESTIGATING,
-            created_by=user
+            incident=incident, status=IncidentStatus.INVESTIGATING, created_by=user
         )
 
         # Create the message with in_channel=True
@@ -141,7 +141,7 @@ class TestSlackMessageIncidentStatusUpdated:
             incident=incident,
             incident_update=incident_update,
             in_channel=True,
-            status_changed=True
+            status_changed=True,
         )
 
         # Get the blocks
@@ -156,7 +156,9 @@ class TestSlackMessageIncidentStatusUpdated:
 
         # Verify the block has an accessory (Update button)
         assert status_update_block is not None, "Should have a status update block"
-        assert status_update_block.accessory is not None, "Update button should be present when incident is not CLOSED"
+        assert status_update_block.accessory is not None, (
+            "Update button should be present when incident is not CLOSED"
+        )
         assert status_update_block.accessory.text.text == "Update"
 
 
@@ -183,7 +185,7 @@ class TestSlackMessageDeployWarning:
 
         # The first block should be a HeaderBlock with "(Mitigated)" in the text
         header_block = blocks[0]
-        header_text = header_block.text.text  # type: ignore[attr-defined]
+        header_text = header_block.text.text
 
         assert "(Mitigated)" in header_text
         assert ":warning:" in header_text
@@ -204,7 +206,7 @@ class TestSlackMessageDeployWarning:
 
         # The first block should be a HeaderBlock WITHOUT "(Mitigated)"
         header_block = blocks[0]
-        header_text = header_block.text.text  # type: ignore[attr-defined]
+        header_text = header_block.text.text
 
         assert "(Mitigated)" not in header_text
         assert ":warning:" in header_text
@@ -283,7 +285,10 @@ class TestSlackMessageIncidentDeclaredAnnouncement:
         assert fields_block is not None, "Should have a block with fields"
 
         # Convert fields to strings for easier assertion (access .text attribute)
-        fields_text = " ".join(field.text if hasattr(field, "text") else str(field) for field in fields_block.fields)
+        fields_text = " ".join(
+            field.text if hasattr(field, "text") else str(field)
+            for field in fields_block.fields
+        )
 
         # Verify custom fields are present
         assert "Zendesk Ticket" in fields_text
@@ -316,7 +321,10 @@ class TestSlackMessageIncidentDeclaredAnnouncement:
         assert fields_block is not None, "Should have a block with fields"
 
         # Convert fields to strings (access .text attribute)
-        fields_text = " ".join(field.text if hasattr(field, "text") else str(field) for field in fields_block.fields)
+        fields_text = " ".join(
+            field.text if hasattr(field, "text") else str(field)
+            for field in fields_block.fields
+        )
 
         # Verify custom fields are NOT present
         assert "Zendesk Ticket" not in fields_text
@@ -354,7 +362,10 @@ class TestSlackMessageIncidentDeclaredAnnouncement:
         assert fields_block is not None, "Should have a block with fields"
 
         # Convert fields to strings (access .text attribute)
-        fields_text = " ".join(field.text if hasattr(field, "text") else str(field) for field in fields_block.fields)
+        fields_text = " ".join(
+            field.text if hasattr(field, "text") else str(field)
+            for field in fields_block.fields
+        )
 
         # Verify only zendesk_ticket_id is present
         assert "Zendesk Ticket" in fields_text
@@ -365,3 +376,81 @@ class TestSlackMessageIncidentDeclaredAnnouncement:
         assert "Zoho Desk Ticket" not in fields_text
         assert "Key Account" not in fields_text
         assert "Golden List Seller" not in fields_text
+
+    def test_jira_postmortem_link_displayed_when_present(self) -> None:
+        """Test that Jira post-mortem link is displayed when available."""
+        # Create an incident
+        incident = IncidentFactory.create()
+        user = UserFactory.create()
+
+        # Create a Jira post-mortem for the incident
+        jira_pm = JiraPostMortem.objects.create(
+            incident=incident,
+            jira_issue_key="PM-123",
+            jira_issue_id="12345",
+            created_by=user,
+        )
+
+        # Create the message
+        message = SlackMessageIncidentDeclaredAnnouncement(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Collect all fields from all SectionBlocks
+        all_fields = []
+        for block in blocks:
+            if hasattr(block, "fields") and block.fields:
+                all_fields.extend(block.fields)
+
+        assert len(all_fields) > 0, "Should have blocks with fields"
+
+        # Convert fields to strings (access .text attribute)
+        fields_text = " ".join(
+            field.text if hasattr(field, "text") else str(field)
+            for field in all_fields
+        )
+
+        # Verify Jira post-mortem link is present (now in separate PM block)
+        assert "Jira Post-mortem" in fields_text
+        assert "PM-123" in fields_text
+        assert jira_pm.issue_url in fields_text
+
+    def test_confluence_postmortem_link_displayed_when_present(self) -> None:
+        """Test that Confluence post-mortem link is displayed when available."""
+        if PostMortem is None:
+            pytest.skip("Confluence app not installed")
+
+        # Create an incident
+        incident = IncidentFactory.create()
+
+        # Create a Confluence post-mortem for the incident
+        confluence_pm = PostMortem.objects.create(
+            incident=incident,
+            page_id="123456",
+        )
+
+        # Create the message
+        message = SlackMessageIncidentDeclaredAnnouncement(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Find the SectionBlock with fields
+        fields_block = None
+        for block in blocks:
+            if hasattr(block, "fields") and block.fields:
+                fields_block = block
+                break
+
+        assert fields_block is not None, "Should have a block with fields"
+
+        # Convert fields to strings (access .text attribute)
+        fields_text = " ".join(
+            field.text if hasattr(field, "text") else str(field)
+            for field in fields_block.fields
+        )
+
+        # Verify Confluence post-mortem link is present
+        assert "Confluence Post-mortem" in fields_text
+        assert confluence_pm.page_url in fields_text

firefighter_tests/test_slack/views/modals/test_closure_reason_modal.py

@@ -16,7 +16,7 @@ from firefighter.slack.views.modals.closure_reason import ClosureReasonModal
 class TestClosureReasonModalMessageTabDisabled:
     """Test ClosureReasonModal handles messages_tab_disabled gracefully."""
 
-    def test_closure_reason_handles_messages_tab_disabled(self, caplog: pytest.LogCaptureFixture) -> None:
+    def test_closure_reason_handles_messages_tab_disabled(self, caplog: pytest.LogCaptureFixture, mocker) -> None:
         """Test that messages_tab_disabled error is handled gracefully with warning log."""
         # Create test data
         user = UserFactory.build()
@@ -24,6 +24,14 @@ class TestClosureReasonModalMessageTabDisabled:
         incident = IncidentFactory.build(_status=IncidentStatus.INVESTIGATING, created_by=user)
         incident.save()
 
+        # Mock can_be_closed to return True so the closure can proceed
+        mocker.patch.object(
+            type(incident),
+            "can_be_closed",
+            new_callable=mocker.PropertyMock,
+            return_value=(True, [])
+        )
+
         # Create modal and mock
         modal = ClosureReasonModal()
         ack = MagicMock()
@@ -83,7 +91,7 @@ class TestClosureReasonModalMessageTabDisabled:
                 for record in caplog.records
             )
 
-    def test_closure_reason_reraises_other_slack_errors(self) -> None:
+    def test_closure_reason_reraises_other_slack_errors(self, mocker) -> None:
         """Test that other Slack API errors are re-raised."""
         # Create test data
         user = UserFactory.build()
@@ -91,6 +99,14 @@ class TestClosureReasonModalMessageTabDisabled:
         incident = IncidentFactory.build(_status=IncidentStatus.INVESTIGATING, created_by=user)
         incident.save()
 
+        # Mock can_be_closed to return True so the closure can proceed
+        mocker.patch.object(
+            type(incident),
+            "can_be_closed",
+            new_callable=mocker.PropertyMock,
+            return_value=(True, [])
+        )
+
         # Create modal and mock
         modal = ClosureReasonModal()
         ack = MagicMock()

firefighter_tests/test_slack/views/modals/test_key_event_message.py

@@ -0,0 +1,30 @@
+"""Tests for Slack key event message view."""
+
+from __future__ import annotations
+
+import pytest
+
+from firefighter.slack.views.modals import key_event_message
+
+
+class TestKeyEventMessageImports:
+    """Test that key event message module has necessary imports."""
+
+    @staticmethod
+    def test_signal_imported() -> None:
+        """Test that incident_key_events_updated signal is imported."""
+        # Verify the signal is imported in the module
+        assert hasattr(
+            key_event_message, "incident_key_events_updated"
+        ), "incident_key_events_updated signal should be imported"
+
+
+@pytest.mark.django_db
+class TestKeyEventMessageSignalIntegration:
+    """Integration tests verifying signal is sent - covered by test_jira_app tests."""
+
+    # Note: The actual signal sending is tested in:
+    # - tests/test_jira_app/test_incident_key_events_sync.py
+    # These tests verify the signal handler receives and processes signals correctly.
+    # Testing the Slack view's signal sending requires complex Slack mocking,
+    # so we rely on manual testing and the signal handler tests instead.