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

firefighter_tests/test_slack/test_signals_downgrade.py

@@ -0,0 +1,147 @@
+"""Tests for incident priority downgrade signal handler."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+
+from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.incidents.models import Priority
+from firefighter.slack.factories import IncidentChannelFactory, SlackUserFactory
+
+if TYPE_CHECKING:
+    from pytest_mock import MockerFixture
+
+
+@pytest.mark.django_db
+class TestIncidentDowngradeSignal:
+    """Test the incident_updated_check_dowmgrade_handler signal."""
+
+    @staticmethod
+    def test_downgrade_hint_shown_for_critical_to_normal(mocker: MockerFixture) -> None:
+        """Test that downgrade hint is shown when downgrading from P1/P2/P3 to P4/P5."""
+        # Create a user with a Slack user
+        user = UserFactory.build()
+        user.save()
+        slack_user = SlackUserFactory.build(user=user)
+        slack_user.save()
+
+        # Get priorities from DB
+        p2 = Priority.objects.get(name="P2")
+        p4 = Priority.objects.get(name="P4")
+
+        # Create an incident with P2 priority
+        incident = IncidentFactory.build(priority=p2, created_by=user)
+        incident.save()
+
+        # Create an incident channel (conversation) for this incident
+        conversation = IncidentChannelFactory.build(incident=incident)
+        conversation.save()
+
+        # Mock the send_message_ephemeral method
+        mock_send = mocker.patch.object(conversation, "send_message_ephemeral")
+
+        # Downgrade from P2 to P4
+        incident.create_incident_update(
+            created_by=user, priority_id=p4.id, message="Downgrading to P4"
+        )
+
+        # Verify the downgrade hint message was sent
+        mock_send.assert_called_once()
+        call_args = mock_send.call_args
+        assert call_args is not None
+        # Check that the message is about the incident not needing an incident channel
+        message = call_args.kwargs["message"]
+        message_text = message.get_text().lower()
+        assert "might not need an incident channel" in message_text or "p4" in message_text or "p5" in message_text
+
+    @staticmethod
+    def test_no_hint_when_staying_in_critical_range(mocker: MockerFixture) -> None:
+        """Test that no hint is shown when changing priority within critical range (P1/P2/P3)."""
+        # Create a user
+        user = UserFactory.build()
+        user.save()
+
+        # Get priorities from DB
+        p1 = Priority.objects.get(name="P1")
+        p3 = Priority.objects.get(name="P3")
+
+        # Create an incident with P1 priority
+        incident = IncidentFactory.build(priority=p1, created_by=user)
+        incident.save()
+
+        # Create an incident channel (conversation) for this incident
+        conversation = IncidentChannelFactory.build(incident=incident)
+        conversation.save()
+
+        # Mock the send_message_ephemeral method
+        mock_send = mocker.patch.object(conversation, "send_message_ephemeral")
+
+        # Update from P1 to P3 (both critical)
+        incident.create_incident_update(
+            created_by=user, priority_id=p3.id, message="Updating to P3"
+        )
+
+        # Verify NO downgrade hint was sent
+        mock_send.assert_not_called()
+
+    @staticmethod
+    def test_no_hint_when_staying_in_normal_range(mocker: MockerFixture) -> None:
+        """Test that no hint is shown when changing priority within normal range (P4/P5)."""
+        # Create a user
+        user = UserFactory.build()
+        user.save()
+
+        # Get priorities from DB
+        p4 = Priority.objects.get(name="P4")
+        p5 = Priority.objects.get(name="P5")
+
+        # Create an incident with P4 priority
+        incident = IncidentFactory.build(priority=p4, created_by=user)
+        incident.save()
+
+        # Create an incident channel (conversation) for this incident
+        conversation = IncidentChannelFactory.build(incident=incident)
+        conversation.save()
+
+        # Mock the send_message_ephemeral method
+        mock_send = mocker.patch.object(conversation, "send_message_ephemeral")
+
+        # Update from P4 to P5 (both normal)
+        incident.create_incident_update(
+            created_by=user, priority_id=p5.id, message="Updating to P5"
+        )
+
+        # Verify NO downgrade hint was sent
+        mock_send.assert_not_called()
+
+    @staticmethod
+    def test_no_hint_when_upgrading_from_normal_to_critical(mocker: MockerFixture) -> None:
+        """Test that no hint is shown when upgrading from P4/P5 to P1/P2/P3."""
+        # Create a user
+        user = UserFactory.build()
+        user.save()
+
+        # Get priorities from DB
+        p5 = Priority.objects.get(name="P5")
+        p2 = Priority.objects.get(name="P2")
+
+        # Create an incident with P5 priority
+        incident = IncidentFactory.build(priority=p5, created_by=user)
+        incident.save()
+
+        # Create an incident channel (conversation) for this incident
+        conversation = IncidentChannelFactory.build(incident=incident)
+        conversation.save()
+
+        # Mock the send_message_ephemeral method
+        mock_send = mocker.patch.object(conversation, "send_message_ephemeral")
+
+        # Upgrade from P5 to P2
+        incident.create_incident_update(
+            created_by=user, priority_id=p2.id, message="Escalating to P2"
+        )
+
+        # Verify NO downgrade hint was sent (this is an upgrade, not a downgrade)
+        mock_send.assert_not_called()

firefighter_tests/test_slack/views/modals/test_edit.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+import logging
+from unittest.mock import MagicMock
+
+import pytest
+from pytest_mock import MockerFixture
+
+from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.incidents.models import Environment, Incident
+from firefighter.slack.views import EditMetaModal
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.django_db
+class TestEditMetaModal:
+    @staticmethod
+    @pytest.fixture
+    def incident(environment_factory) -> Incident:
+        """Returns a valid incident with environment and custom_fields."""
+        env_prd = environment_factory(value="PRD", name="Production", order=0)
+        return IncidentFactory.create(
+            environment=env_prd,
+            custom_fields={"environments": ["PRD"]}
+        )
+
+    @staticmethod
+    @pytest.fixture
+    def multi_env_incident(environment_factory) -> Incident:
+        """Returns an incident with multiple environments in custom_fields."""
+        env_prd = environment_factory(value="PRD", name="Production", order=0)
+        environment_factory(value="STG", name="Staging", order=1)
+        environment_factory(value="INT", name="Integration", order=2)
+
+        return IncidentFactory.create(
+            environment=env_prd,
+            custom_fields={"environments": ["PRD", "STG", "INT"]}
+        )
+
+    @staticmethod
+    def test_build_modal_fn_single_environment(incident: Incident) -> None:
+        """Test building modal with single environment."""
+        modal = EditMetaModal()
+        res = modal.build_modal_fn(incident)
+
+        # Validate the JSON structure
+        assert res.to_dict()
+
+        values = res.to_dict()
+        assert "blocks" in values
+        assert values["title"]["text"] == f"Update incident #{incident.id}"[:24]
+        assert values["submit"]["text"] == "Update incident"
+
+    @staticmethod
+    def test_build_modal_fn_multiple_environments(multi_env_incident: Incident) -> None:
+        """Test building modal with multiple environments in custom_fields."""
+        modal = EditMetaModal()
+        res = modal.build_modal_fn(multi_env_incident)
+
+        # Validate the JSON structure
+        assert res.to_dict()
+
+        values = res.to_dict()
+        assert "blocks" in values
+
+        # The form should show all three environments from custom_fields
+        # We verify this by checking the initial values passed to the form
+        assert multi_env_incident.custom_fields["environments"] == ["PRD", "STG", "INT"]
+
+    @staticmethod
+    def test_build_modal_fn_fallback_to_single_environment(environment_factory) -> None:
+        """Test building modal falls back to single environment when custom_fields is empty."""
+        env_prd = environment_factory(value="PRD", name="Production", order=0)
+        incident = IncidentFactory.create(
+            environment=env_prd,
+            custom_fields={}  # No environments in custom_fields
+        )
+
+        modal = EditMetaModal()
+        res = modal.build_modal_fn(incident)
+
+        # Validate the JSON structure
+        assert res.to_dict()
+
+        values = res.to_dict()
+        assert "blocks" in values
+
+    @staticmethod
+    def test_build_modal_fn_empty_custom_fields(environment_factory) -> None:
+        """Test building modal when custom_fields has no environments."""
+        env_stg = environment_factory(value="STG", name="Staging", order=1)
+        incident = IncidentFactory.create(
+            environment=env_stg,
+            custom_fields={}  # Empty custom_fields
+        )
+
+        modal = EditMetaModal()
+        res = modal.build_modal_fn(incident)
+
+        # Should build successfully and fallback to single environment
+        assert res.to_dict()
+
+    @staticmethod
+    def test_handle_modal_fn_update_title_and_description(
+        mocker: MockerFixture, incident: Incident
+    ) -> None:
+        """Test handling modal submission with title and description updates."""
+        modal = EditMetaModal()
+        trigger_workflow = mocker.patch.object(modal, "_trigger_incident_workflow")
+
+        ack = MagicMock()
+        user = UserFactory.create()
+
+        # Create a submission with updated title and description
+        submission = create_edit_submission(
+            incident=incident,
+            title="Updated Incident Title",
+            description="Updated incident description with more details.",
+        )
+
+        modal.handle_modal_fn(ack=ack, body=submission, incident=incident, user=user)
+
+        # Assert
+        ack.assert_called_once_with()
+        trigger_workflow.assert_called_once()
+        call_kwargs = trigger_workflow.call_args.kwargs
+        assert call_kwargs["title"] == "Updated Incident Title"
+        assert call_kwargs["description"] == "Updated incident description with more details."
+
+    @staticmethod
+    def test_handle_modal_fn_update_environments(
+        mocker: MockerFixture, environment_factory
+    ) -> None:
+        """Test handling modal submission with environment updates."""
+        env_prd = environment_factory(value="PRD", name="Production", order=0)
+        env_stg = environment_factory(value="STG", name="Staging", order=1)
+        env_int = environment_factory(value="INT", name="Integration", order=2)
+
+        incident = IncidentFactory.create(
+            environment=env_prd,
+            custom_fields={"environments": ["PRD"]}
+        )
+
+        modal = EditMetaModal()
+        trigger_workflow = mocker.patch.object(modal, "_trigger_incident_workflow")
+
+        ack = MagicMock()
+        user = UserFactory.create()
+
+        # Create a submission with multiple environments selected
+        submission = create_edit_submission(
+            incident=incident,
+            environment_ids=[str(env_prd.id), str(env_stg.id), str(env_int.id)],
+        )
+
+        modal.handle_modal_fn(ack=ack, body=submission, incident=incident, user=user)
+
+        # Assert
+        ack.assert_called_once_with()
+
+        # Verify custom_fields were updated
+        incident.refresh_from_db()
+        assert set(incident.custom_fields["environments"]) == {"PRD", "STG", "INT"}
+
+        # Verify primary environment is PRD (highest priority)
+        trigger_workflow.assert_called_once()
+        call_kwargs = trigger_workflow.call_args.kwargs
+        assert call_kwargs["environment_id"] == env_prd.id
+
+    @staticmethod
+    def test_handle_modal_fn_change_primary_environment(
+        mocker: MockerFixture, environment_factory
+    ) -> None:
+        """Test changing from one environment to another."""
+        env_prd = environment_factory(value="PRD", name="Production", order=0)
+        env_stg = environment_factory(value="STG", name="Staging", order=1)
+
+        incident = IncidentFactory.create(
+            environment=env_prd,
+            custom_fields={"environments": ["PRD"]}
+        )
+
+        modal = EditMetaModal()
+        trigger_workflow = mocker.patch.object(modal, "_trigger_incident_workflow")
+
+        ack = MagicMock()
+        user = UserFactory.create()
+
+        # Change to STG only
+        submission = create_edit_submission(
+            incident=incident,
+            environment_ids=[str(env_stg.id)],
+        )
+
+        modal.handle_modal_fn(ack=ack, body=submission, incident=incident, user=user)
+
+        # Assert
+        ack.assert_called_once_with()
+
+        # Verify custom_fields were updated to STG
+        incident.refresh_from_db()
+        assert incident.custom_fields["environments"] == ["STG"]
+
+        # Verify primary environment is STG
+        trigger_workflow.assert_called_once()
+        call_kwargs = trigger_workflow.call_args.kwargs
+        assert call_kwargs["environment_id"] == env_stg.id
+
+    @staticmethod
+    def test_handle_modal_fn_no_changes(mocker: MockerFixture, incident: Incident) -> None:
+        """Test handling modal submission with no changes."""
+        modal = EditMetaModal()
+        trigger_workflow = mocker.patch.object(modal, "_trigger_incident_workflow")
+
+        ack = MagicMock()
+        user = UserFactory.create()
+
+        # Create a submission with same values as current incident
+        submission = create_edit_submission(
+            incident=incident,
+            title=incident.title,
+            description=incident.description,
+            environment_ids=[str(incident.environment.id)],
+        )
+
+        modal.handle_modal_fn(ack=ack, body=submission, incident=incident, user=user)
+
+        # Assert that workflow was not triggered (no changes)
+        ack.assert_called_once_with()
+        trigger_workflow.assert_not_called()
+
+    @staticmethod
+    def test_handle_modal_fn_empty_body(incident: Incident) -> None:
+        """Test handling modal with empty body raises TypeError."""
+        modal = EditMetaModal()
+        ack = MagicMock()
+        user = UserFactory.create()
+
+        with pytest.raises(TypeError, match="Expected a values dict in the body"):
+            modal.handle_modal_fn(ack=ack, body={}, incident=incident, user=user)
+
+
+def create_edit_submission(
+    incident: Incident,
+    title: str | None = None,
+    description: str | None = None,
+    environment_ids: list[str] | None = None,
+) -> dict:
+    """Helper function to create a valid edit submission body."""
+    # Use current values as defaults
+    title = title if title is not None else incident.title
+    description = description if description is not None else incident.description
+
+    # Build environment options
+    if environment_ids is None:
+        # Use current incident environment
+        environment_ids = [str(incident.environment.id)] if incident.environment else []
+
+    # Convert environment IDs to options format
+    env_selected_options = []
+    if environment_ids:
+        for env_id in environment_ids:
+            env_obj = Environment.objects.get(id=env_id)
+            env_selected_options.append({
+                "text": {"type": "plain_text", "text": f"{env_obj.value} - {env_obj.description}", "emoji": True},
+                "value": env_id,
+            })
+
+    return {
+        "type": "view_submission",
+        "team": {"id": "T01FJ0NNFQD", "domain": "team-firefighter"},
+        "user": {
+            "id": "U03L9K8P5SA",
+            "username": "john.doe",
+            "name": "john.doe",
+            "team_id": "T01FJ0NNFQD",
+        },
+        "api_app_id": "A03SXN0ENM9",
+        "token": "fake_token",
+        "trigger_id": "3924659449141.1528022763829.670d1c03f8d04cf6655676963267ca4e",
+        "view": {
+            "id": "V03T304049L",
+            "team_id": "T01FJ0NNFQD",
+            "type": "modal",
+            "private_metadata": str(incident.id),
+            "callback_id": "incident_edit_incident",
+            "state": {
+                "values": {
+                    "title": {
+                        "title": {
+                            "type": "plain_text_input",
+                            "value": title,
+                        }
+                    },
+                    "description": {
+                        "description": {
+                            "type": "plain_text_input",
+                            "value": description,
+                        }
+                    },
+                    "environment": {
+                        "environment": {
+                            "type": "multi_static_select",
+                            "selected_options": env_selected_options,
+                        }
+                    },
+                }
+            },
+            "hash": "1660220674.c7elhik9",
+            "title": {"type": "plain_text", "text": f"Update incident #{incident.id}"[:24], "emoji": True},
+            "clear_on_close": False,
+            "notify_on_close": False,
+            "close": None,
+            "submit": {"type": "plain_text", "text": "Update incident", "emoji": True},
+            "app_id": "A03SXN0ENM9",
+            "external_id": "",
+            "app_installed_team_id": "T01FJ0NNFQD",
+            "bot_id": "B03T08W83AQ",
+        },
+        "response_urls": [],
+        "is_enterprise_install": False,
+        "enterprise": None,
+    }

firefighter_tests/test_slack/views/modals/test_opening_unified.py

@@ -419,3 +419,45 @@ class TestOpeningUnifiedModal:
 
         # Verify that suggested_team_routing is NOT in the form (critical incident)
         assert "suggested_team_routing" not in form.fields, "suggested_team_routing should not be present for critical incidents"
+
+    def test_build_modal_fn_handles_environment_uuid_list(
+        self, priority_factory, environment_factory
+    ):
+        """build_modal_fn should handle list of environment UUIDs and preserve order."""
+        priority_factory(value=1, default=True)
+        env_prd = environment_factory(value="PRD", default=True)
+        env_stg = environment_factory(value="STG", default=False)
+
+        modal = OpeningUnifiedModal()
+
+        # Simulate editing scenario where details_form_data contains list of environment UUIDs
+        # IMPORTANT: Order is STG first, then PRD (not alphabetical order)
+        open_incident_context = {
+            "response_type": "critical",
+            "impact_form_data": {},
+            "details_form_data": {
+                "environment": [str(env_stg.id), str(env_prd.id)]  # List of UUIDs (STG, PRD)
+            },
+        }
+
+        # This should NOT raise ValidationError about invalid UUID
+        view = modal.build_modal_fn(open_incident_context=open_incident_context)
+
+        # Should build view without errors
+        assert view is not None
+        assert view.type == "modal"
+        assert len(view.blocks) > 0
+
+        # Verify that the environment block preserves the order (STG, PRD)
+        env_blocks = [b for b in view.blocks if hasattr(b, "block_id") and b.block_id == "environment"]
+        assert len(env_blocks) == 1, "Should find exactly one environment block"
+        env_block = env_blocks[0]
+
+        # Check initial_options preserves order: STG first, then PRD
+        assert hasattr(env_block, "element"), "Block should have an element attribute"
+        assert hasattr(env_block.element, "initial_options"), "Element should have initial_options"
+        initial_options = env_block.element.initial_options
+        assert initial_options is not None, "initial_options should not be None"
+        assert len(initial_options) == 2, "Should have both environments in initial_options"
+        assert initial_options[0].value == str(env_stg.id), "First option should be STG (preserving order)"
+        assert initial_options[1].value == str(env_prd.id), "Second option should be PRD (preserving order)"

firefighter_tests/test_slack/views/modals/test_update_status.py

@@ -332,12 +332,12 @@ class TestUpdateStatusModal:
 
     @staticmethod
     def test_can_close_when_all_conditions_met(mocker: MockerFixture) -> None:
-        """Test that closing is allowed when all conditions are met."""
+        """Test that closing is allowed when all conditions are met for P3+ incidents."""
         # Create a user first
         user = UserFactory.build()
         user.save()
 
-        # Create an incident in MITIGATED status with all conditions met
+        # Create a P3+ incident in MITIGATED status with all conditions met
         incident = IncidentFactory.build(
             _status=IncidentStatus.MITIGATED,
             created_by=user,
@@ -345,6 +345,14 @@ class TestUpdateStatusModal:
         # IMPORTANT: Save the incident so it has an ID for the form to reference
         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 True (all conditions met)
         mocker.patch.object(
             type(incident),
@@ -380,6 +388,68 @@ class TestUpdateStatusModal:
         # Verify that incident update WAS triggered
         trigger_incident_workflow.assert_called_once()
 
+    @staticmethod
+    def test_can_update_priority_without_changing_status(mocker: MockerFixture, priority_factory) -> None:
+        """Test that priority can be updated without changing status.
+
+        This reproduces the bug where trying to update only the priority of a P4
+        incident in MITIGATED status fails with:
+        "Select a valid choice. 40 is not one of the available choices."
+
+        The issue is that the form restricts status choices based on current status,
+        but the initial value (MITIGATED=40) may not be in those restricted choices.
+        """
+        # Create a user first
+        user = UserFactory.build()
+        user.save()
+
+        # Create P3 and P4 priorities
+        p3_priority = priority_factory(value=3, name="P3")
+        p4_priority = priority_factory(value=4, name="P4")
+
+        # Create a P3 incident in MITIGATED status
+        incident = IncidentFactory.build(
+            _status=IncidentStatus.MITIGATED,
+            created_by=user,
+            priority=p3_priority,
+        )
+        incident.save()
+
+        modal = UpdateStatusModal()
+        trigger_incident_workflow = mocker.patch.object(
+            modal, "_trigger_incident_workflow"
+        )
+
+        ack = MagicMock()
+
+        # User tries to change priority from P3 to P4 WITHOUT changing status
+        # The status field will have MITIGATED (40) as initial value, but it's not in the available choices
+        submission_copy = dict(valid_submission)
+        # Status unchanged - keeps MITIGATED (40)
+        submission_copy["view"]["state"]["values"]["status"]["status"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "Mitigated", "emoji": True},
+            "value": "40",  # This should cause validation error with current code
+        }
+        # Change priority to P4
+        submission_copy["view"]["state"]["values"]["priority"]["priority"]["selected_option"] = {
+            "text": {"type": "plain_text", "text": "P4", "emoji": True},
+            "value": str(p4_priority.id),
+        }
+        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 WITHOUT errors
+        # With the bug, this would fail with "Select a valid choice. 40 is not one of the available choices"
+        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')}"
+
+        # Verify that incident update WAS triggered (priority changed)
+        trigger_incident_workflow.assert_called_once()
+
 
 valid_submission = {
     "type": "view_submission",