firefighter-incident 0.0.14__py3-none-any.whl → 0.0.16__py3-none-any.whl

firefighter_tests/test_slack/views/modals/test_update_status.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import logging
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, PropertyMock
 
 import pytest
 from django.conf import settings
 from pytest_mock import MockerFixture
 
+from firefighter.incidents.enums import IncidentStatus
 from firefighter.incidents.factories import IncidentFactory, UserFactory
 from firefighter.incidents.models import Incident
 from firefighter.slack.views import UpdateStatusModal
@@ -47,7 +48,10 @@ class TestUpdateStatusModal:
             modal.handle_modal_fn(ack=ack, body={}, incident=incident, user=user)
 
     @staticmethod
-    def test_submit_valid_form(mocker: MockerFixture, incident: Incident) -> None:
+    def test_submit_valid_form(mocker: MockerFixture) -> None:
+        # Create an incident in OPEN status so we can transition to INVESTIGATING
+        incident = IncidentFactory.build(_status=IncidentStatus.OPEN)  # OPEN status
+
         modal = UpdateStatusModal()
         trigger_incident_workflow = mocker.patch.object(
             modal, "_trigger_incident_workflow"
@@ -56,14 +60,326 @@ class TestUpdateStatusModal:
         ack = MagicMock()
         user = UserFactory.build()
         user.save()
+
+        # Create a valid submission that transitions from OPEN to INVESTIGATING (valid workflow)
+        valid_submission_copy = dict(valid_submission)
+        # Change status to INVESTIGATING (20) which is valid from OPEN
+        valid_submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Investigating", "emoji": True},
+            "value": "20",
+        }
+
         modal.handle_modal_fn(
-            ack=ack, body=valid_submission, incident=incident, user=user
+            ack=ack, body=valid_submission_copy, incident=incident, user=user
         )
 
         # Assert
         ack.assert_called_once_with()
         trigger_incident_workflow.assert_called_once()
 
+    @staticmethod
+    def test_cannot_close_without_required_key_events(mocker: MockerFixture) -> None:
+        """Test that closing is prevented when required key events are missing.
+
+        This tests the scenario where a P3+ incident (no postmortem needed) is in
+        MITIGATED status and tries to close, but missing key events blocks it.
+        """
+        # Create a user first
+        user = UserFactory.build()
+        user.save()
+
+        # Create a P3+ incident in MITIGATED status (can go directly to CLOSED)
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.MITIGATED,
+            created_by=user,
+        )
+        incident.save()
+        # Mock needs_postmortem to return False (P3+ incident)
+        mocker.patch.object(
+            type(incident),
+            "needs_postmortem",
+            new_callable=PropertyMock,
+            return_value=False
+        )
+        # Mock can_be_closed to return False with MISSING_REQUIRED_KEY_EVENTS reason
+        mocker.patch.object(
+            type(incident),
+            "can_be_closed",
+            new_callable=PropertyMock,
+            return_value=(False, [("MISSING_REQUIRED_KEY_EVENTS", "Missing key events: detected, started")])
+        )
+
+        modal = UpdateStatusModal()
+        trigger_incident_workflow = mocker.patch.object(
+            modal, "_trigger_incident_workflow"
+        )
+
+        ack = MagicMock()
+        user = UserFactory.build()
+        user.save()
+
+        # Create a submission trying to close the incident
+        submission_copy = dict(valid_submission)
+        # Change status to CLOSED (60)
+        submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Closed", "emoji": True},
+            "value": "60",
+        }
+        # Update the private_metadata to match our test incident
+        submission_copy["view"]["private_metadata"] = str(incident.id)
+
+        modal.handle_modal_fn(
+            ack=ack, body=submission_copy, incident=incident, user=user
+        )
+
+        # Assert that ack was called with errors (may be 1 or 2 calls depending on form validation)
+        assert ack.called
+        # Check the last call (the error response)
+        last_call_kwargs = ack.call_args.kwargs
+        assert "response_action" in last_call_kwargs
+        assert last_call_kwargs["response_action"] == "errors"
+        assert "errors" in last_call_kwargs
+        assert "status" in last_call_kwargs["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
+        assert "Missing key events" in error_msg
+
+        # Verify that incident update was NOT triggered
+        trigger_incident_workflow.assert_not_called()
+
+    @staticmethod
+    def test_cannot_close_from_postmortem_without_key_events(mocker: MockerFixture) -> None:
+        """Test that closing from POST_MORTEM is prevented when key events missing.
+
+        This tests a P1/P2 incident in POST_MORTEM trying to close but blocked
+        by missing key events.
+        """
+        # Create a user first
+        user = UserFactory.build()
+        user.save()
+
+        # Create a P1/P2 incident in POST_MORTEM status
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.POST_MORTEM,
+            created_by=user,
+        )
+        incident.save()
+        # Mock can_be_closed to return False with MISSING_REQUIRED_KEY_EVENTS reason
+        mocker.patch.object(
+            type(incident),
+            "can_be_closed",
+            new_callable=PropertyMock,
+            return_value=(False, [("MISSING_REQUIRED_KEY_EVENTS", "Missing key events: detected, started")])
+        )
+
+        modal = UpdateStatusModal()
+        trigger_incident_workflow = mocker.patch.object(
+            modal, "_trigger_incident_workflow"
+        )
+
+        ack = MagicMock()
+        user = UserFactory.build()
+        user.save()
+
+        # Create a submission trying to close the incident
+        submission_copy = dict(valid_submission)
+        submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Closed", "emoji": True},
+            "value": "60",
+        }
+        submission_copy["view"]["private_metadata"] = str(incident.id)
+
+        modal.handle_modal_fn(
+            ack=ack, body=submission_copy, incident=incident, user=user
+        )
+
+        # Assert that ack was called with errors
+        assert ack.called
+        last_call_kwargs = ack.call_args.kwargs
+        assert "response_action" in last_call_kwargs
+        assert last_call_kwargs["response_action"] == "errors"
+        assert "errors" in last_call_kwargs
+        assert "status" in last_call_kwargs["errors"]
+        error_msg = last_call_kwargs["errors"]["status"]
+        assert "Cannot close this incident" in error_msg
+        assert "Missing key events" in error_msg
+
+        # Verify that incident update was NOT triggered
+        trigger_incident_workflow.assert_not_called()
+
+    @staticmethod
+    def test_cannot_close_p1_p2_without_postmortem(mocker: MockerFixture, priority_factory, environment_factory) -> None:
+        """Test that P1/P2 incidents in PRD cannot be closed directly from INVESTIGATING.
+
+        For P1/P2 incidents requiring post-mortem, although the form allows CLOSED as an option
+        from INVESTIGATING status, the can_be_closed validation should prevent closure with
+        an error message about needing to go through post-mortem.
+        """
+        # Create a user first
+        user = UserFactory.build()
+        user.save()
+
+        # Create P1 priority (needs_postmortem=True) and PRD environment
+        p1_priority = priority_factory(value=1, name="P1", needs_postmortem=True)
+        prd_environment = environment_factory(value="PRD", name="Production")
+
+        # Create a P1/P2 incident in INVESTIGATING status
+        # From INVESTIGATING, the form allows transitioning to CLOSED (but can_be_closed will block it)
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.INVESTIGATING,
+            created_by=user,
+            priority=p1_priority,
+            environment=prd_environment,
+        )
+        incident.save()
+        # Mock can_be_closed to return False with STATUS_NOT_POST_MORTEM reason
+        mocker.patch.object(
+            type(incident),
+            "can_be_closed",
+            new_callable=PropertyMock,
+            return_value=(False, [("STATUS_NOT_POST_MORTEM", "Incident is not in PostMortem status, and needs one because of its priority and environment (P1/PRD).")])
+        )
+
+        modal = UpdateStatusModal()
+
+        # Mock handle_update_status_close_request to NOT show closure reason modal
+        # This allows the test to reach the can_be_closed validation
+        mocker.patch(
+            "firefighter.slack.views.modals.update_status.handle_update_status_close_request",
+            return_value=False
+        )
+
+        trigger_incident_workflow = mocker.patch.object(
+            modal, "_trigger_incident_workflow"
+        )
+
+        ack = MagicMock()
+        user = UserFactory.build()
+        user.save()
+
+        # Create a submission trying to close the incident
+        submission_copy = dict(valid_submission)
+        submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Closed", "emoji": True},
+            "value": "60",
+        }
+        submission_copy["view"]["private_metadata"] = str(incident.id)
+
+        modal.handle_modal_fn(
+            ack=ack, body=submission_copy, incident=incident, user=user
+        )
+
+        # Assert that ack was called with errors
+        assert ack.called
+        last_call_kwargs = ack.call_args.kwargs
+        assert "response_action" in last_call_kwargs
+        assert last_call_kwargs["response_action"] == "errors"
+        assert "errors" in last_call_kwargs
+        assert "status" in last_call_kwargs["errors"]
+        error_msg = last_call_kwargs["errors"]["status"]
+        assert "Cannot close this incident" in error_msg
+        assert "PostMortem status" in error_msg
+
+        # Verify that incident update was NOT triggered
+        trigger_incident_workflow.assert_not_called()
+
+    @staticmethod
+    def test_closure_reason_modal_shown_when_closing_from_investigating(mocker: MockerFixture) -> None:
+        """Test that closure reason modal is shown when trying to close from INVESTIGATING.
+
+        This tests that handle_update_status_close_request correctly shows the
+        closure reason modal and returns True, blocking the normal closure flow.
+        """
+        # Create an incident in INVESTIGATING status
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.INVESTIGATING,
+        )
+
+        modal = UpdateStatusModal()
+
+        # Mock handle_update_status_close_request to return True (modal shown)
+        mock_handle_close = mocker.patch(
+            "firefighter.slack.views.modals.update_status.handle_update_status_close_request",
+            return_value=True
+        )
+
+        trigger_incident_workflow = mocker.patch.object(
+            modal, "_trigger_incident_workflow"
+        )
+
+        ack = MagicMock()
+        user = UserFactory.build()
+        user.save()
+
+        # Create a submission trying to close the incident
+        submission_copy = dict(valid_submission)
+        submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Closed", "emoji": True},
+            "value": "60",
+        }
+        submission_copy["view"]["private_metadata"] = str(incident.id)
+
+        modal.handle_modal_fn(
+            ack=ack, body=submission_copy, incident=incident, user=user
+        )
+
+        # Verify handle_update_status_close_request was called
+        mock_handle_close.assert_called_once_with(ack, submission_copy, incident, IncidentStatus.CLOSED)
+
+        # Verify that incident update was NOT triggered (because closure reason modal was shown)
+        trigger_incident_workflow.assert_not_called()
+
+    @staticmethod
+    def test_can_close_when_all_conditions_met(mocker: MockerFixture) -> None:
+        """Test that closing is allowed when all conditions are met."""
+        # Create a user first
+        user = UserFactory.build()
+        user.save()
+
+        # Create an incident in MITIGATED status with all conditions met
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.MITIGATED,
+            created_by=user,
+        )
+        # IMPORTANT: Save the incident so it has an ID for the form to reference
+        incident.save()
+
+        # Mock can_be_closed to return True (all conditions met)
+        mocker.patch.object(
+            type(incident),
+            "can_be_closed",
+            new_callable=PropertyMock,
+            return_value=(True, [])
+        )
+
+        modal = UpdateStatusModal()
+        trigger_incident_workflow = mocker.patch.object(
+            modal, "_trigger_incident_workflow"
+        )
+
+        ack = MagicMock()
+
+        # Create a submission to close the incident
+        submission_copy = dict(valid_submission)
+        submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Closed", "emoji": True},
+            "value": "60",
+        }
+        submission_copy["view"]["private_metadata"] = str(incident.id)
+
+        modal.handle_modal_fn(
+            ack=ack, body=submission_copy, incident=incident, user=user
+        )
+
+        # Assert that ack was called successfully (no errors)
+        # The first call is the successful ack() without errors
+        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
+
+        # Verify that incident update WAS triggered
+        trigger_incident_workflow.assert_called_once()
+
 
 valid_submission = {
     "type": "view_submission",
@@ -162,6 +478,14 @@ valid_submission = {
                             },
                             "value": "50",
                         },
+                        {
+                            "text": {
+                                "type": "plain_text",
+                                "text": "Closed",
+                                "emoji": True,
+                            },
+                            "value": "60",
+                        },
                     ],
                 },
             },

firefighter_tests/test_slack/views/modals/test_utils.py

@@ -0,0 +1,135 @@
+"""Test the modal utils module."""
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory
+from firefighter.slack.views.modals.utils import (
+    get_close_modal_view,
+    handle_close_modal_callback,
+    handle_update_status_close_request,
+)
+
+
+@pytest.mark.django_db
+class TestModalUtils:
+    """Test modal utility functions."""
+
+    def test_get_close_modal_view_requires_reason(self):
+        """Test get_close_modal_view when closure reason is required."""
+        # Create incident in OPEN status (requires closure reason)
+        incident = IncidentFactory.create(_status=IncidentStatus.OPEN)
+        body = {}
+
+        with patch("firefighter.slack.views.modals.utils.UpdateStatusForm.requires_closure_reason", return_value=True), \
+             patch("firefighter.slack.views.modals.utils.modal_closure_reason.build_modal_fn") as mock_build:
+            mock_build.return_value = MagicMock()
+
+            result = get_close_modal_view(body, incident)
+
+            assert result is not None
+            mock_build.assert_called_once_with(body, incident)
+
+    def test_get_close_modal_view_no_reason_required(self):
+        """Test get_close_modal_view when closure reason is not required."""
+        # Create incident in POST_MORTEM status (doesn't require closure reason)
+        incident = IncidentFactory.create(_status=IncidentStatus.POST_MORTEM)
+        body = {}
+
+        with patch("firefighter.slack.views.modals.utils.UpdateStatusForm.requires_closure_reason", return_value=False):
+            result = get_close_modal_view(body, incident)
+
+            assert result is None
+
+    def test_handle_close_modal_callback_closure_reason(self):
+        """Test handle_close_modal_callback for closure reason modal."""
+        incident = IncidentFactory.create()
+        user = MagicMock()
+        ack = MagicMock()
+
+        body = {
+            "view": {
+                "callback_id": "incident_closure_reason"
+            }
+        }
+
+        with patch("firefighter.slack.views.modals.utils.modal_closure_reason.handle_modal_fn") as mock_handle:
+            mock_handle.return_value = True
+
+            result = handle_close_modal_callback(ack, body, incident, user)
+
+            assert result is True
+            mock_handle.assert_called_once_with(ack, body, incident, user)
+
+    def test_handle_close_modal_callback_normal_modal(self):
+        """Test handle_close_modal_callback for normal close modal."""
+        incident = IncidentFactory.create()
+        user = MagicMock()
+        ack = MagicMock()
+
+        body = {
+            "view": {
+                "callback_id": "incident_close"  # Not closure reason
+            }
+        }
+
+        result = handle_close_modal_callback(ack, body, incident, user)
+
+        assert result is None
+
+    def test_handle_update_status_close_request_requires_reason(self):
+        """Test handle_update_status_close_request when reason is required."""
+        incident = IncidentFactory.create(_status=IncidentStatus.OPEN)
+        ack = MagicMock()
+        body = {}
+        target_status = IncidentStatus.CLOSED
+
+        with patch("firefighter.slack.views.modals.utils.UpdateStatusForm.requires_closure_reason", return_value=True), \
+             patch("firefighter.slack.views.modals.utils.modal_closure_reason.build_modal_fn") as mock_build:
+            mock_build.return_value = MagicMock()
+
+            result = handle_update_status_close_request(ack, body, incident, target_status)
+
+            assert result is True
+            ack.assert_called_once_with(response_action="push", view=mock_build.return_value)
+            mock_build.assert_called_once_with(body, incident)
+
+    def test_handle_update_status_close_request_no_reason_required(self):
+        """Test handle_update_status_close_request when reason is not required."""
+        incident = IncidentFactory.create(_status=IncidentStatus.POST_MORTEM)
+        ack = MagicMock()
+        body = {}
+        target_status = IncidentStatus.CLOSED
+
+        with patch("firefighter.slack.views.modals.utils.UpdateStatusForm.requires_closure_reason", return_value=False):
+            result = handle_update_status_close_request(ack, body, incident, target_status)
+
+            assert result is False
+            ack.assert_not_called()
+
+    def test_handle_update_status_close_request_non_close_status(self):
+        """Test handle_update_status_close_request for non-close status."""
+        incident = IncidentFactory.create()
+        ack = MagicMock()
+        body = {}
+        target_status = IncidentStatus.INVESTIGATING
+
+        result = handle_update_status_close_request(ack, body, incident, target_status)
+
+        assert result is False
+        ack.assert_not_called()
+
+    def test_handle_close_modal_callback_missing_view(self):
+        """Test handle_close_modal_callback with missing view in body."""
+        incident = IncidentFactory.create()
+        user = MagicMock()
+        ack = MagicMock()
+
+        body = {}  # No view key
+
+        result = handle_close_modal_callback(ack, body, incident, user)
+
+        assert result is None

firefighter/raid/views/open_normal.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from slack_sdk.models.blocks.basic_components import MarkdownTextObject
-from slack_sdk.models.blocks.blocks import ContextBlock
-
-from firefighter.raid.forms import (
-    CreateNormalCustomerIncidentForm,
-    CreateRaidDocumentationRequestIncidentForm,
-    CreateRaidFeatureRequestIncidentForm,
-    CreateRaidInternalIncidentForm,
-    RaidCreateIncidentSellerForm,
-)
-from firefighter.slack.views.modals.opening.set_details import SetIncidentDetails
-
-if TYPE_CHECKING:
-    from firefighter.slack.views.modals.base_modal.form_utils import (
-        SlackFormAttributesDict,
-    )
-
-logger = logging.getLogger(__name__)
-
-slack_fields: SlackFormAttributesDict = {
-    "title": {
-        "input": {
-            "multiline": False,
-            "placeholder": "Summary of the issue.",
-        },
-        "block": {"hint": None},
-    },
-    "description": {
-        "input": {
-            "multiline": True,
-            "placeholder": "Explain your issue in English giving as much details as possible. It helps people handling the issue. \nThis description can be edited later.",
-        },
-        "block": {"hint": None},
-    },
-    "suggested_team_routing": {
-        "widget": {
-            "post_block": ContextBlock(
-                elements=[
-                    MarkdownTextObject(
-                        text="Feature Team or Train that should own the issue. If you don't know access <https://manomano.atlassian.net/wiki/spaces/QRAFT/pages/3970335291/Teams+and+owners|here> for guidance."
-                    ),
-                ]
-            )
-        },
-    },
-    "incident_category": {
-        "input": {
-            "placeholder": "Select incident category",
-        },
-    },
-}
-
-
-class CreateRaidCustomerIncidentFormSlack(CreateNormalCustomerIncidentForm):
-    slack_fields: SlackFormAttributesDict = slack_fields
-
-
-class OpeningRaidCustomerModal(SetIncidentDetails[CreateRaidCustomerIncidentFormSlack]):
-    open_action: str = "open_incident_raid_customer_request"
-    push_action: str = "push_raid_customer_request"
-    callback_id: str = "open_incident_raid_customer_request"
-    id = "raid_customer_request"
-    title = "New Customer Incident"
-
-    form_class = CreateRaidCustomerIncidentFormSlack
-
-
-class CreateRaidDocumentationRequestIncidentFormSlack(
-    CreateRaidDocumentationRequestIncidentForm
-):
-    slack_fields: SlackFormAttributesDict = slack_fields
-
-
-class CreateRaidFeatureRequestIncidentFormSlack(CreateRaidFeatureRequestIncidentForm):
-    slack_fields: SlackFormAttributesDict = slack_fields
-
-
-class OpeningRaidFeatureRequestModal(
-    SetIncidentDetails[CreateRaidFeatureRequestIncidentFormSlack]
-):
-    open_action: str = "open_incident_raid_feature_request"
-    push_action: str = "push_raid_feature_request"
-    callback_id: str = "open_incident_raid_feature_request"
-
-    title = "New Feature Request"
-    form_class = CreateRaidFeatureRequestIncidentFormSlack
-
-
-class OpeningRaidDocumentationRequestModal(
-    SetIncidentDetails[CreateRaidDocumentationRequestIncidentFormSlack]
-):
-    open_action: str = "open_incident_raid_documentation_request"
-    push_action: str = "push_raid_documentation_request"
-    callback_id: str = "open_incident_raid_documentation_request"
-
-    title = "New Documentation Request"
-    form_class = CreateRaidDocumentationRequestIncidentFormSlack
-
-
-class CreateRaidInternalIncidentFormSlack(CreateRaidInternalIncidentForm):
-    slack_fields: SlackFormAttributesDict = slack_fields
-
-
-class OpeningRaidInternalModal(SetIncidentDetails[CreateRaidInternalIncidentFormSlack]):
-    open_action: str = "open_incident_raid_internal_request"
-    push_action: str = "push_raid_internal_request"
-    callback_id: str = "open_incident_raid_internal_request"
-
-    title = "New Internal Incident"
-
-    form_class = CreateRaidInternalIncidentFormSlack
-
-
-class CreateRaidSellerIncidentFormSlack(RaidCreateIncidentSellerForm):
-    slack_fields: SlackFormAttributesDict = slack_fields
-
-
-class OpeningRaidSellerModal(SetIncidentDetails[CreateRaidSellerIncidentFormSlack]):
-    open_action: str = "open_incident_raid_seller_request"
-    push_action: str = "push_raid_seller_request"
-    callback_id: str = "open_incident_raid_seller_request"
-
-    title = "New Seller Incident"
-    form_class = CreateRaidSellerIncidentFormSlack
-
-
-# Instantiate all the modals to register actions
-_modals = [
-    raid_seller := OpeningRaidSellerModal(),
-    raid_internal := OpeningRaidInternalModal(),
-    raid_customer := OpeningRaidCustomerModal(),
-    raid_feature := OpeningRaidFeatureRequestModal(),
-    raid_documentation := OpeningRaidDocumentationRequestModal(),
-]