firefighter-incident 0.0.26__py3-none-any.whl → 0.0.28__py3-none-any.whl

firefighter_tests/test_slack/views/modals/test_closure_reason_modal.py

@@ -9,6 +9,7 @@ from slack_sdk.errors import SlackApiError
 
 from firefighter.incidents.enums import ClosureReason, IncidentStatus
 from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.incidents.models import Environment, Priority
 from firefighter.slack.views.modals.closure_reason import ClosureReasonModal
 
 
@@ -16,12 +17,16 @@ 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, mocker) -> 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()
         user.save()
-        incident = IncidentFactory.build(_status=IncidentStatus.INVESTIGATING, created_by=user)
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.INVESTIGATING, created_by=user
+        )
         incident.save()
 
         # Mock can_be_closed to return True so the closure can proceed
@@ -29,7 +34,7 @@ class TestClosureReasonModalMessageTabDisabled:
             type(incident),
             "can_be_closed",
             new_callable=mocker.PropertyMock,
-            return_value=(True, [])
+            return_value=(True, []),
         )
 
         # Create modal and mock
@@ -46,9 +51,7 @@ class TestClosureReasonModalMessageTabDisabled:
                                 "selected_option": {"value": ClosureReason.CANCELLED}
                             }
                         },
-                        "closure_reference": {
-                            "input_closure_reference": {"value": ""}
-                        },
+                        "closure_reference": {"input_closure_reference": {"value": ""}},
                         "closure_message": {
                             "input_closure_message": {"value": "Test closure message"}
                         },
@@ -63,18 +66,17 @@ class TestClosureReasonModalMessageTabDisabled:
         slack_error_response = MagicMock()
         slack_error_response.get.return_value = "messages_tab_disabled"
 
-        with patch("firefighter.slack.views.modals.closure_reason.respond") as mock_respond:
+        with patch(
+            "firefighter.slack.views.modals.closure_reason.respond"
+        ) as mock_respond:
             mock_respond.side_effect = SlackApiError(
                 message="The request to the Slack API failed.",
-                response=slack_error_response
+                response=slack_error_response,
             )
 
             # Execute
             result = modal.handle_modal_fn(
-                ack=ack,
-                body=body,
-                incident=incident,
-                user=user
+                ack=ack, body=body, incident=incident, user=user
             )
 
             # Assertions
@@ -87,7 +89,8 @@ class TestClosureReasonModalMessageTabDisabled:
 
             # Verify warning was logged
             assert any(
-                "Cannot send DM to user" in record.message and record.levelname == "WARNING"
+                "Cannot send DM to user" in record.message
+                and record.levelname == "WARNING"
                 for record in caplog.records
             )
 
@@ -96,7 +99,9 @@ class TestClosureReasonModalMessageTabDisabled:
         # Create test data
         user = UserFactory.build()
         user.save()
-        incident = IncidentFactory.build(_status=IncidentStatus.INVESTIGATING, created_by=user)
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.INVESTIGATING, created_by=user
+        )
         incident.save()
 
         # Mock can_be_closed to return True so the closure can proceed
@@ -104,7 +109,7 @@ class TestClosureReasonModalMessageTabDisabled:
             type(incident),
             "can_be_closed",
             new_callable=mocker.PropertyMock,
-            return_value=(True, [])
+            return_value=(True, []),
         )
 
         # Create modal and mock
@@ -121,9 +126,7 @@ class TestClosureReasonModalMessageTabDisabled:
                                 "selected_option": {"value": ClosureReason.CANCELLED}
                             }
                         },
-                        "closure_reference": {
-                            "input_closure_reference": {"value": ""}
-                        },
+                        "closure_reference": {"input_closure_reference": {"value": ""}},
                         "closure_message": {
                             "input_closure_message": {"value": "Test closure message"}
                         },
@@ -138,17 +141,97 @@ class TestClosureReasonModalMessageTabDisabled:
         slack_error_response = MagicMock()
         slack_error_response.get.return_value = "channel_not_found"
 
-        with patch("firefighter.slack.views.modals.closure_reason.respond") as mock_respond:
+        with patch(
+            "firefighter.slack.views.modals.closure_reason.respond"
+        ) as mock_respond:
             mock_respond.side_effect = SlackApiError(
                 message="The request to the Slack API failed.",
-                response=slack_error_response
+                response=slack_error_response,
             )
 
             # Execute and expect exception
             with pytest.raises(SlackApiError):
-                modal.handle_modal_fn(
-                    ack=ack,
-                    body=body,
-                    incident=incident,
-                    user=user
-                )
+                modal.handle_modal_fn(ack=ack, body=body, incident=incident, user=user)
+
+
+@pytest.mark.django_db
+class TestClosureReasonModalEarlyClosureBypass:
+    """Test early-closure path respects submitted closure reason."""
+
+    def test_allows_early_closure_with_submitted_reason(self, settings) -> None:
+        """Ensure can_be_closed passes when a closure reason is provided for early closure."""
+        settings.ENABLE_JIRA_POSTMORTEM = True
+
+        # Ensure required priority/environment for needs_postmortem + PRD
+        priority = Priority.objects.create(
+            name="P1-test",
+            value=9991,
+            description="P1 test",
+            order=9991,
+            needs_postmortem=True,
+        )
+        env, _ = Environment.objects.get_or_create(
+            value="PRD",
+            defaults={
+                "name": "Production",
+                "description": "Production",
+                "order": 9991,
+            },
+        )
+
+        user = UserFactory.create()
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.INVESTIGATING,
+            created_by=user,
+            priority=priority,
+            environment=env,
+        )
+
+        modal = ClosureReasonModal()
+        ack = MagicMock()
+
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "closure_reason": {
+                            "select_closure_reason": {
+                                "selected_option": {"value": ClosureReason.CANCELLED}
+                            }
+                        },
+                        "closure_reference": {
+                            "input_closure_reference": {"value": "INC-42"}
+                        },
+                        "closure_message": {
+                            "input_closure_message": {
+                                "value": "Closing early with reason"
+                            }
+                        },
+                    }
+                },
+                "private_metadata": str(incident.id),
+            },
+            "user": {"id": "U123456"},
+        }
+
+        with patch(
+            "firefighter.slack.views.modals.closure_reason.respond"
+        ) as mock_respond:
+            mock_respond.return_value = None
+
+            result = modal.handle_modal_fn(
+                ack=ack,
+                body=body,
+                incident=incident,
+                user=user,
+            )
+
+        # Early closure should succeed and close the incident
+        assert result is True
+        incident.refresh_from_db()
+        assert incident.status == IncidentStatus.CLOSED
+        assert incident.closure_reason == ClosureReason.CANCELLED
+        assert incident.closure_reference == "INC-42"
+
+        # Ack should clear modal stack
+        ack.assert_called_once_with(response_action="clear")

firefighter_tests/test_slack/views/modals/test_postmortem_modal.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from firefighter.slack.views.modals.postmortem import PostMortemModal
+
+
+class TestPostMortemModal:
+    @staticmethod
+    def _get_text_blocks(view_dict: dict) -> list[str]:
+        return [
+            block.get("text", {}).get("text", "")
+            for block in view_dict.get("blocks", [])
+            if block.get("type") == "section"
+        ]
+
+    @staticmethod
+    def _get_action_elements(view_dict: dict) -> list[dict]:
+        elements: list[dict] = []
+        for block in view_dict.get("blocks", []):
+            if block.get("type") == "actions":
+                elements.extend(block.get("elements", []))
+        return elements
+
+    @staticmethod
+    def test_p1_p2_shows_auto_creation_message(mocker):
+        incident = SimpleNamespace(id=123, needs_postmortem=True)
+
+        # No existing PMs
+        mocker.patch(
+            "firefighter.slack.views.modals.postmortem._safe_has_relation",
+            return_value=False,
+            create=True,
+        )
+
+        view = PostMortemModal().build_modal_fn(incident)
+        view_dict = view.to_dict()
+
+        texts = TestPostMortemModal._get_text_blocks(view_dict)
+        assert any(
+            "automatically created when the incident reaches MITIGATED" in t
+            for t in texts
+        )
+        # No manual-create button for mandatory PMs
+        action_ids = [
+            el.get("action_id")
+            for el in TestPostMortemModal._get_action_elements(view_dict)
+        ]
+        assert "incident_create_postmortem_now" not in action_ids
+
+    @staticmethod
+    def test_p3_shows_optional_message_and_button(mocker):
+        incident = SimpleNamespace(id=456, needs_postmortem=False)
+
+        # No existing PMs
+        mocker.patch(
+            "firefighter.slack.views.modals.postmortem._safe_has_relation",
+            return_value=False,
+            create=True,
+        )
+
+        view = PostMortemModal().build_modal_fn(incident)
+        view_dict = view.to_dict()
+
+        texts = TestPostMortemModal._get_text_blocks(view_dict)
+        assert any("P3 incident post-mortem is not mandatory" in t for t in texts)
+
+        action_ids = [
+            el.get("action_id")
+            for el in TestPostMortemModal._get_action_elements(view_dict)
+        ]
+        assert "incident_create_postmortem_now" in action_ids

firefighter_tests/test_slack/views/modals/test_update_status.py

@@ -129,12 +129,12 @@ class TestUpdateStatusModal:
 
         # Verify that can_be_closed returns False due to missing milestones (real check, no mock)
         can_close, reasons = incident.can_be_closed
-        assert can_close is False, (
-            f"Incident should not be closable without required milestones. Got: {can_close}, reasons: {reasons}"
-        )
-        assert any("MISSING_REQUIRED_KEY_EVENTS" in reason[0] for reason in reasons), (
-            f"Expected MISSING_REQUIRED_KEY_EVENTS in reasons, got: {reasons}"
-        )
+        assert (
+            can_close is False
+        ), f"Incident should not be closable without required milestones. Got: {can_close}, reasons: {reasons}"
+        assert any(
+            "MISSING_REQUIRED_KEY_EVENTS" in reason[0] for reason in reasons
+        ), f"Expected MISSING_REQUIRED_KEY_EVENTS in reasons, got: {reasons}"
 
         modal = UpdateStatusModal()
         trigger_incident_workflow = mocker.patch.object(
@@ -163,26 +163,23 @@ class TestUpdateStatusModal:
         assert ack.called, "ack should have been called"
         # Check the last call (the error response)
         last_call_kwargs = ack.call_args.kwargs
-        assert "response_action" in last_call_kwargs, (
-            f"Expected 'response_action' in ack, got: {last_call_kwargs}"
-        )
-        assert last_call_kwargs["response_action"] == "errors", (
-            f"Expected response_action='errors', got: {last_call_kwargs.get('response_action')}"
-        )
-        assert "errors" in last_call_kwargs, (
-            f"Expected 'errors' in ack, got: {last_call_kwargs}"
-        )
-        assert "status" in last_call_kwargs["errors"], (
-            f"Expected 'status' in errors, got: {last_call_kwargs.get('errors')}"
-        )
+        assert (
+            "response_action" in last_call_kwargs
+        ), f"Expected 'response_action' in ack, got: {last_call_kwargs}"
+        assert (
+            last_call_kwargs["response_action"] == "errors"
+        ), f"Expected response_action='errors', got: {last_call_kwargs.get('response_action')}"
+        assert (
+            "errors" in last_call_kwargs
+        ), f"Expected 'errors' in ack, got: {last_call_kwargs}"
+        assert (
+            "status" in last_call_kwargs["errors"]
+        ), f"Expected 'status' in errors, got: {last_call_kwargs.get('errors')}"
         # Check that the error message mentions the missing key events
         error_msg = last_call_kwargs["errors"]["status"]
-        assert "Cannot close this incident" in error_msg, (
-            f"Expected closure error, got: {error_msg}"
-        )
-        assert "key events" in error_msg.lower(), (
-            f"Expected 'key events' in error, got: {error_msg}"
-        )
+        assert (
+            "missing key events" in error_msg.lower()
+        ), f"Expected missing key events error, got: {error_msg}"
 
         # Verify that incident update was NOT triggered
         trigger_incident_workflow.assert_not_called()
@@ -233,12 +230,12 @@ class TestUpdateStatusModal:
 
         # Verify that can_be_closed returns False due to missing milestones
         can_close, reasons = incident.can_be_closed
-        assert can_close is False, (
-            "Incident should not be closable without required milestones"
-        )
-        assert any("MISSING_REQUIRED_KEY_EVENTS" in reason[0] for reason in reasons), (
-            f"Expected MISSING_REQUIRED_KEY_EVENTS in reasons, got: {reasons}"
-        )
+        assert (
+            can_close is False
+        ), "Incident should not be closable without required milestones"
+        assert any(
+            "MISSING_REQUIRED_KEY_EVENTS" in reason[0] for reason in reasons
+        ), f"Expected MISSING_REQUIRED_KEY_EVENTS in reasons, got: {reasons}"
 
         modal = UpdateStatusModal()
         trigger_incident_workflow = mocker.patch.object(
@@ -264,25 +261,22 @@ class TestUpdateStatusModal:
         # Assert that ack was called with errors
         assert ack.called, "ack should have been called"
         last_call_kwargs = ack.call_args.kwargs
-        assert "response_action" in last_call_kwargs, (
-            f"Expected 'response_action' in ack call, got: {last_call_kwargs}"
-        )
-        assert last_call_kwargs["response_action"] == "errors", (
-            f"Expected response_action='errors', got: {last_call_kwargs.get('response_action')}"
-        )
-        assert "errors" in last_call_kwargs, (
-            f"Expected 'errors' in ack call, got: {last_call_kwargs}"
-        )
-        assert "status" in last_call_kwargs["errors"], (
-            f"Expected 'status' in errors, got: {last_call_kwargs.get('errors')}"
-        )
+        assert (
+            "response_action" in last_call_kwargs
+        ), f"Expected 'response_action' in ack call, got: {last_call_kwargs}"
+        assert (
+            last_call_kwargs["response_action"] == "errors"
+        ), f"Expected response_action='errors', got: {last_call_kwargs.get('response_action')}"
+        assert (
+            "errors" in last_call_kwargs
+        ), f"Expected 'errors' in ack call, got: {last_call_kwargs}"
+        assert (
+            "status" in last_call_kwargs["errors"]
+        ), f"Expected 'status' in errors, got: {last_call_kwargs.get('errors')}"
         error_msg = last_call_kwargs["errors"]["status"]
-        assert "Cannot close this incident" in error_msg, (
-            f"Expected closure error message, got: {error_msg}"
-        )
-        assert "key events" in error_msg.lower(), (
-            f"Expected 'key events' in error message, got: {error_msg}"
-        )
+        assert (
+            "missing key events" in error_msg.lower()
+        ), f"Expected missing key events error message, got: {error_msg}"
 
         # Verify that incident update was NOT triggered
         trigger_incident_workflow.assert_not_called()
@@ -465,9 +459,9 @@ class TestUpdateStatusModal:
         first_call_kwargs = (
             ack.call_args_list[0][1] if ack.call_args_list else ack.call_args.kwargs
         )
-        assert first_call_kwargs == {} or "errors" not in first_call_kwargs, (
-            f"Should allow updating priority without changing status. Got errors: {first_call_kwargs.get('errors')}"
-        )
+        assert (
+            first_call_kwargs == {} or "errors" not in first_call_kwargs
+        ), f"Should allow updating priority without changing status. Got errors: {first_call_kwargs.get('errors')}"
 
         # Verify that incident update WAS triggered (priority changed)
         trigger_incident_workflow.assert_called_once()