firefighter-incident 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

firefighter_tests/test_slack/views/modals/conftest.py

@@ -0,0 +1,140 @@
+"""Fixtures for unified modal tests."""
+from __future__ import annotations
+
+import pytest
+
+from firefighter.incidents.models import Environment, Priority
+from firefighter.incidents.models.impact import ImpactLevel, ImpactType, LevelChoices
+
+
+@pytest.fixture
+def priority_factory(db):
+    """Factory to create Priority instances."""
+
+    def _create(**kwargs):
+        value = kwargs.get("value", 1)
+        name = kwargs.get("name", f"P{value}")
+        set_as_default = kwargs.get("default", False)
+
+        # If default=True, clear any other defaults first
+        if set_as_default:
+            Priority.objects.filter(default=True).update(default=False)
+
+        defaults = {
+            "emoji": "🔴",
+            "order": value,
+            "default": set_as_default,
+            "enabled_create": True,
+            "enabled_update": True,
+            "needs_postmortem": value <= 2,  # P1-P2 need postmortem
+        }
+        # Remove name and value from kwargs if present
+        kwargs_copy = kwargs.copy()
+        kwargs_copy.pop("name", None)
+        kwargs_copy.pop("value", None)
+        defaults.update(kwargs_copy)
+
+        priority, created = Priority.objects.get_or_create(
+            name=name,
+            value=value,
+            defaults=defaults,
+        )
+
+        # If already exists and we want it as default, just set that
+        if not created and set_as_default:
+            priority.default = True
+            priority.save(update_fields=["default"])
+
+        return priority
+
+    return _create
+
+
+@pytest.fixture
+def environment_factory(db):
+    """Factory to create Environment instances."""
+
+    def _create(**kwargs):
+        value = kwargs.get("value", "TST")
+        set_as_default = kwargs.get("default", False)
+
+        # If default=True, clear any other defaults first
+        if set_as_default:
+            Environment.objects.filter(default=True).update(default=False)
+
+        defaults = {
+            "description": f"Environment {value}",
+            "order": 1,
+            "default": set_as_default,
+        }
+        # Remove value and default from kwargs if present
+        kwargs_copy = kwargs.copy()
+        kwargs_copy.pop("value", None)
+        kwargs_copy.pop("default", None)
+        defaults.update(kwargs_copy)
+
+        environment, created = Environment.objects.get_or_create(
+            value=value,
+            defaults=defaults,
+        )
+
+        # If already exists and we want it as default, just set that
+        if not created and set_as_default:
+            environment.default = True
+            environment.save(update_fields=["default"])
+
+        return environment
+
+    return _create
+
+
+@pytest.fixture
+def impact_level_factory(db):
+    """Factory to create ImpactLevel instances."""
+
+    def _create(**kwargs):
+        # Handle impact__name syntax by extracting nested parameters
+        impact_type_data = {}
+        keys_to_remove = []
+        for key in list(kwargs.keys()):
+            if key.startswith("impact__"):
+                nested_key = key.split("__", 1)[1]
+                impact_type_data[nested_key] = kwargs[key]
+                keys_to_remove.append(key)
+        for key in keys_to_remove:
+            kwargs.pop(key)
+
+        # Create or get ImpactType
+        impact_type = kwargs.pop("impact_type", None)
+        if isinstance(impact_type, ImpactType):
+            pass  # Already have ImpactType instance
+        elif impact_type_data:
+            impact_type_name = impact_type_data.get("name", "Test Impact")
+            impact_type, _ = ImpactType.objects.get_or_create(name=impact_type_name, defaults={
+                "emoji": "📊",
+                "help_text": f"Test {impact_type_name} impact",
+                "value": impact_type_name.lower().replace(" ", "_"),
+                "order": 10,
+            })
+        else:
+            impact_type_name = "Test Impact"
+            impact_type, _ = ImpactType.objects.get_or_create(name=impact_type_name, defaults={
+                "emoji": "📊",
+                "help_text": "Test impact",
+                "value": "test_impact",
+                "order": 10,
+            })
+
+        # Handle value parameter
+        value = kwargs.pop("value", LevelChoices.LOW)
+
+        defaults = {
+            "impact_type": impact_type,
+            "value": value,
+            "name": value.label if hasattr(value, "label") else "Test Level",
+            "emoji": "📊",
+        }
+        defaults.update(kwargs)
+        return ImpactLevel.objects.create(**defaults)
+
+    return _create

firefighter_tests/test_slack/views/modals/test_close.py

@@ -27,7 +27,7 @@ class TestCloseModal:
             new_callable=PropertyMock(return_value=(True, [])),
         )
         incident = IncidentFactory.build()
-        incident.status = IncidentStatus.FIXED
+        incident.status = IncidentStatus.MITIGATED
 
         # Act
         res = modal.build_modal_fn(incident=incident, body={})
@@ -54,7 +54,7 @@ class TestCloseModal:
             return_value=(True, []),
             new_callable=mocker.PropertyMock,
         )
-        incident.status = IncidentStatus.FIXED
+        incident.status = IncidentStatus.MITIGATED
         incident.title = "This is the title"
         incident.description = "This is the description"
 
@@ -72,7 +72,8 @@ class TestCloseModal:
     def test_close_modal_build_cant_close(incident: Incident) -> None:
         # Arrange
         modal = CloseModal()
-        incident.status = IncidentStatus.OPEN
+        # Use MITIGATING (Mitigating) status - cannot close from this status without going through MITIGATED
+        incident.status = IncidentStatus.MITIGATING
 
         # Act
         res = modal.build_modal_fn(incident=incident, body={})
@@ -90,6 +91,67 @@ class TestCloseModal:
             "This incident can't be closed yet." in values["blocks"][0]["text"]["text"]
         )
 
+    @staticmethod
+    def test_close_modal_build_shows_mitigated_status_requirement(
+        mocker: MockerFixture, incident: Incident
+    ) -> None:
+        """Test that the modal shows STATUS_NOT_MITIGATED error with proper references.
+
+        This test covers lines 151, 154, 159 in close.py where MITIGATED.label is used.
+        """
+        # Arrange
+        modal = CloseModal()
+        incident.status = IncidentStatus.INVESTIGATING
+
+        # Mock requires_closure_reason to return False so we bypass the closure reason modal
+        mocker.patch(
+            "firefighter.slack.views.modals.utils.UpdateStatusForm.requires_closure_reason",
+            return_value=False
+        )
+
+        # Mock can_be_closed to return False with STATUS_NOT_MITIGATED reason
+        mocker.patch.object(
+            Incident,
+            "can_be_closed",
+            new_callable=PropertyMock(return_value=(False, [("STATUS_NOT_MITIGATED", "Status not mitigated")])),
+        )
+
+        # Act
+        res = modal.build_modal_fn(incident=incident, body={})
+
+        # Assert
+        assert res.to_dict()
+        values = res.to_dict()
+        assert "blocks" in values
+
+        # Convert blocks to text for easier searching
+        blocks_text = str(values["blocks"])
+
+        # Verify that "Mitigated" (the label) appears in the error message
+        # Line 154: text=f":warning: *Status is not _{IncidentStatus.MITIGATED.label}_* :warning:\n"
+        # Line 159: text=f"You can only close an incident when its status is _{IncidentStatus.MITIGATED.label}_ or _{IncidentStatus.POST_MORTEM.label}_..."
+        assert "Mitigated" in blocks_text
+        assert "Post-mortem" in blocks_text or "Post Mortem" in blocks_text
+
+        # Verify the error message structure
+        assert "This incident can't be closed yet." in values["blocks"][0]["text"]["text"]
+
+    @staticmethod
+    def test_close_modal_build_shows_closure_reason_from_open(incident: Incident) -> None:
+        # Arrange
+        modal = CloseModal()
+        incident.status = IncidentStatus.OPEN
+
+        # Act
+        res = modal.build_modal_fn(incident=incident, body={})
+
+        # Assert
+        assert res.to_dict()
+        values = res.to_dict()
+        assert "blocks" in values
+        # Should show closure reason form
+        assert "Closure Reason Required" in values["blocks"][0]["text"]["text"]
+
     @staticmethod
     def test_submit_empty_bodied_form() -> None:
         modal = CloseModal()
@@ -220,13 +282,13 @@ valid_submission = {
             },
             {
                 "type": "input",
-                "block_id": "component",
+                "block_id": "incident_category",
                 "label": {"type": "plain_text", "text": "Issue category", "emoji": True},
                 "optional": False,
                 "dispatch_action": False,
                 "element": {
                     "type": "static_select",
-                    "action_id": "component",
+                    "action_id": "incident_category",
                     "placeholder": {
                         "type": "plain_text",
                         "text": "Select affected issue category",
@@ -909,8 +971,8 @@ valid_submission = {
                         "value": "This is a valid description.",
                     }
                 },
-                "component": {
-                    "component": {
+                "incident_category": {
+                    "incident_category": {
                         "type": "static_select",
                         "selected_option": {
                             "text": {
@@ -972,7 +1034,7 @@ valid_submission = {
 invalid_title = deepcopy(valid_submission)
 invalid_title["view"]["state"]["values"]["title"]["title"]["value"] = "short"  # type: ignore
 
-invalid_component = deepcopy(valid_submission)
-invalid_component["view"]["state"]["values"]["component"]["component"][
+invalid_incident_category = deepcopy(valid_submission)
+invalid_incident_category["view"]["state"]["values"]["incident_category"]["incident_category"][
     "selected_option"
 ]["value"] = "notauuid-d445-4fc9-92eb-e742ee14fd4a"  # type: ignore

firefighter_tests/test_slack/views/modals/test_closure_reason_modal.py

@@ -0,0 +1,138 @@
+"""Tests for ClosureReasonModal - Slack modal for closing incidents with a reason."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from slack_sdk.errors import SlackApiError
+
+from firefighter.incidents.enums import ClosureReason, IncidentStatus
+from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.slack.views.modals.closure_reason import ClosureReasonModal
+
+
+@pytest.mark.django_db
+class TestClosureReasonModalMessageTabDisabled:
+    """Test ClosureReasonModal handles messages_tab_disabled gracefully."""
+
+    def test_closure_reason_handles_messages_tab_disabled(self, caplog: pytest.LogCaptureFixture) -> 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.save()
+
+        # Create modal and mock
+        modal = ClosureReasonModal()
+        ack = MagicMock()
+
+        # Create valid form submission
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "closure_reason": {
+                            "select_closure_reason": {
+                                "selected_option": {"value": ClosureReason.CANCELLED}
+                            }
+                        },
+                        "closure_reference": {
+                            "input_closure_reference": {"value": ""}
+                        },
+                        "closure_message": {
+                            "input_closure_message": {"value": "Test closure message"}
+                        },
+                    }
+                },
+                "private_metadata": str(incident.id),
+            },
+            "user": {"id": "U123456"},
+        }
+
+        # Mock respond to raise messages_tab_disabled error
+        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:
+            mock_respond.side_effect = SlackApiError(
+                message="The request to the Slack API failed.",
+                response=slack_error_response
+            )
+
+            # Execute
+            result = modal.handle_modal_fn(
+                ack=ack,
+                body=body,
+                incident=incident,
+                user=user
+            )
+
+            # Assertions
+            assert result is True  # Incident should still be closed successfully
+
+            # Verify incident was closed
+            incident.refresh_from_db()
+            assert incident.status == IncidentStatus.CLOSED
+            assert incident.closure_reason == ClosureReason.CANCELLED
+
+            # Verify warning was logged
+            assert any(
+                "Cannot send DM to user" in record.message and record.levelname == "WARNING"
+                for record in caplog.records
+            )
+
+    def test_closure_reason_reraises_other_slack_errors(self) -> None:
+        """Test that other Slack API errors are re-raised."""
+        # Create test data
+        user = UserFactory.build()
+        user.save()
+        incident = IncidentFactory.build(_status=IncidentStatus.INVESTIGATING, created_by=user)
+        incident.save()
+
+        # Create modal and mock
+        modal = ClosureReasonModal()
+        ack = MagicMock()
+
+        # Create valid form submission
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "closure_reason": {
+                            "select_closure_reason": {
+                                "selected_option": {"value": ClosureReason.CANCELLED}
+                            }
+                        },
+                        "closure_reference": {
+                            "input_closure_reference": {"value": ""}
+                        },
+                        "closure_message": {
+                            "input_closure_message": {"value": "Test closure message"}
+                        },
+                    }
+                },
+                "private_metadata": str(incident.id),
+            },
+            "user": {"id": "U123456"},
+        }
+
+        # Mock respond to raise different Slack error
+        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:
+            mock_respond.side_effect = SlackApiError(
+                message="The request to the Slack API failed.",
+                response=slack_error_response
+            )
+
+            # Execute and expect exception
+            with pytest.raises(SlackApiError):
+                modal.handle_modal_fn(
+                    ack=ack,
+                    body=body,
+                    incident=incident,
+                    user=user
+                )

firefighter_tests/test_slack/views/modals/test_form_utils_multiple_choice.py

@@ -0,0 +1,249 @@
+"""Tests for form_utils.py support of multiple choice fields."""
+from __future__ import annotations
+
+import pytest
+from django import forms
+
+from firefighter.incidents.models import Environment
+from firefighter.slack.views.modals.base_modal.form_utils import (
+    SlackForm,
+    slack_view_submission_to_dict,
+)
+
+
+@pytest.mark.django_db
+class TestMultipleChoiceFields:
+    """Test that SlackForm correctly handles ModelMultipleChoiceField and MultipleChoiceField."""
+
+    def test_model_multiple_choice_field_with_initial_list(self, environment_factory):
+        """Test ModelMultipleChoiceField with list of model instances as initial."""
+        class TestForm(forms.Form):
+            environments = forms.ModelMultipleChoiceField(
+                queryset=Environment.objects.all(),
+                required=True,
+            )
+
+        # Create test environments
+        env1 = environment_factory(value="PRD", default=True)
+        env2 = environment_factory(value="STG", default=True)
+        default_envs = [env1, env2]
+
+        slack_form = SlackForm(TestForm)(initial={"environments": default_envs})
+        blocks = slack_form.slack_blocks()
+
+        # Should generate blocks without errors
+        assert len(blocks) > 0
+
+        # Find the environment block
+        env_block = next(b for b in blocks if b.block_id == "environments")
+        assert env_block is not None
+
+        # Check it's a multi-select element
+        assert env_block.element.type == "multi_static_select"
+
+        # Check initial options
+        if default_envs:
+            assert len(env_block.element.initial_options) == len(default_envs)
+
+    def test_model_multiple_choice_field_with_callable_initial(self, environment_factory):
+        """Test ModelMultipleChoiceField with callable returning list."""
+        # Create test environments
+        environment_factory(value="PRD", default=True)
+        environment_factory(value="STG", default=True)
+
+        def get_default_envs():
+            return list(Environment.objects.filter(default=True))
+
+        class TestForm(forms.Form):
+            environments = forms.ModelMultipleChoiceField(
+                queryset=Environment.objects.all(),
+                initial=get_default_envs,
+                required=True,
+            )
+
+        slack_form = SlackForm(TestForm)()
+        blocks = slack_form.slack_blocks()
+
+        # Should generate blocks without errors
+        assert len(blocks) > 0
+
+    def test_multiple_choice_field_with_initial_list(self):
+        """Test MultipleChoiceField with list of values as initial."""
+
+        class TestForm(forms.Form):
+            platforms = forms.MultipleChoiceField(
+                choices=[
+                    ("FR", "France"),
+                    ("DE", "Germany"),
+                    ("UK", "United Kingdom"),
+                ],
+                initial=["FR", "UK"],
+                required=True,
+            )
+
+        slack_form = SlackForm(TestForm)()
+        blocks = slack_form.slack_blocks()
+
+        # Should generate blocks without errors
+        assert len(blocks) > 0
+
+        # Find the platforms block
+        platform_block = next(b for b in blocks if b.block_id == "platforms")
+        assert platform_block is not None
+
+        # Check it's a multi-select element
+        assert platform_block.element.type == "multi_static_select"
+
+        # Check initial options
+        assert len(platform_block.element.initial_options) == 2
+
+    def test_multiple_choice_field_empty_initial(self):
+        """Test MultipleChoiceField with no initial value."""
+
+        class TestForm(forms.Form):
+            platforms = forms.MultipleChoiceField(
+                choices=[
+                    ("FR", "France"),
+                    ("DE", "Germany"),
+                ],
+                required=False,
+            )
+
+        slack_form = SlackForm(TestForm)()
+        blocks = slack_form.slack_blocks()
+
+        assert len(blocks) > 0
+
+        # Find the platforms block
+        platform_block = next(b for b in blocks if b.block_id == "platforms")
+
+        # Should have no initial_options
+        assert not hasattr(platform_block.element, "initial_options") or not platform_block.element.initial_options
+
+
+@pytest.mark.django_db
+class TestSlackViewSubmissionToDict:
+    """Test parsing of multi-select responses from Slack."""
+
+    def test_multi_static_select_parsing(self):
+        """Test that multi_static_select responses are parsed as lists."""
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "environment": {
+                            "environment": {
+                                "type": "multi_static_select",
+                                "selected_options": [
+                                    {"value": "uuid-1"},
+                                    {"value": "uuid-2"},
+                                ],
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        result = slack_view_submission_to_dict(body)
+
+        assert "environment" in result
+        assert isinstance(result["environment"], list)
+        assert result["environment"] == ["uuid-1", "uuid-2"]
+
+    def test_multi_static_select_empty(self):
+        """Test that empty multi_static_select returns empty list."""
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "environment": {
+                            "environment": {
+                                "type": "multi_static_select",
+                                "selected_options": [],
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        result = slack_view_submission_to_dict(body)
+
+        assert "environment" in result
+        assert isinstance(result["environment"], list)
+        assert result["environment"] == []
+
+    def test_checkboxes_checked(self):
+        """Test that checked checkboxes (BooleanField) return True."""
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "is_key_account": {
+                            "is_key_account": {
+                                "type": "checkboxes",
+                                "selected_options": [
+                                    {"value": "True"},
+                                ],
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        result = slack_view_submission_to_dict(body)
+
+        assert "is_key_account" in result
+        assert result["is_key_account"] is True
+
+    def test_checkboxes_unchecked(self):
+        """Test that unchecked checkboxes (BooleanField) return False."""
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "is_key_account": {
+                            "is_key_account": {
+                                "type": "checkboxes",
+                                "selected_options": [],
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        result = slack_view_submission_to_dict(body)
+
+        assert "is_key_account" in result
+        assert result["is_key_account"] is False
+
+    def test_multiple_checkboxes(self):
+        """Test that multiple checkboxes are parsed correctly."""
+        body = {
+            "view": {
+                "state": {
+                    "values": {
+                        "is_key_account": {
+                            "is_key_account": {
+                                "type": "checkboxes",
+                                "selected_options": [{"value": "True"}],
+                            }
+                        },
+                        "is_seller_in_golden_list": {
+                            "is_seller_in_golden_list": {
+                                "type": "checkboxes",
+                                "selected_options": [],  # Unchecked
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        result = slack_view_submission_to_dict(body)
+
+        assert result["is_key_account"] is True
+        assert result["is_seller_in_golden_list"] is False