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

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

firefighter_tests/test_slack/views/modals/test_open.py

@@ -6,8 +6,10 @@ from unittest.mock import MagicMock, Mock, patch
 import pytest
 from slack_sdk.models.blocks.blocks import (
     ContextBlock,
+    SectionBlock,
 )
 
+from firefighter.incidents.factories import IncidentCategoryFactory
 from firefighter.incidents.forms.create_incident import CreateIncidentFormBase
 from firefighter.incidents.models.user import User
 from firefighter.slack.views.modals.open import OpeningData, OpenModal
@@ -64,6 +66,7 @@ def test_validate_details_form_valid() -> None:
     details_form_modal_class = MagicMock(spec=SetIncidentDetails)
     details_form_class = MagicMock(spec=CreateIncidentFormBase)
     details_form_data = {"key": "value"}
+    open_incident_context = build_opening_data()
 
     details_form_modal_class.form_class = details_form_class
 
@@ -72,7 +75,7 @@ def test_validate_details_form_valid() -> None:
     details_form_class.return_value = details_form_instance
 
     is_valid, returned_form_class, returned_form = OpenModal._validate_details_form(
-        details_form_modal_class, details_form_data
+        details_form_modal_class, details_form_data, open_incident_context
     )
 
     assert is_valid is True
@@ -84,6 +87,7 @@ def test_validate_details_form_invalid() -> None:
     details_form_modal_class = MagicMock(spec=SetIncidentDetails)
     details_form_class = MagicMock(spec=CreateIncidentFormBase)
     details_form_data = {"key": "value"}
+    open_incident_context = build_opening_data()
 
     details_form_modal_class.form_class = details_form_class
 
@@ -92,7 +96,7 @@ def test_validate_details_form_invalid() -> None:
     details_form_class.return_value = details_form_instance
 
     is_valid, returned_form_class, returned_form = OpenModal._validate_details_form(
-        details_form_modal_class, details_form_data
+        details_form_modal_class, details_form_data, open_incident_context
     )
 
     assert is_valid is False
@@ -139,3 +143,143 @@ def test_build_modal_fn_empty(user: User) -> None:
 
     # View should not have a submit button
     assert view.submit is None
+
+
+@pytest.mark.django_db
+def test_get_done_review_blocks_with_custom_fields(
+    user: User, priority_factory, environment_factory
+) -> None:
+    """Test that get_done_review_blocks doesn't crash when form has custom fields."""
+    # Use factories to create DB objects
+    priority = priority_factory(value=1, default=True)
+    environment = environment_factory(value="PRD", default=True)
+    category = IncidentCategoryFactory()
+
+    # Create a mock form with cleaned_data containing custom fields
+    mock_form = MagicMock(spec=CreateIncidentFormBase)
+    mock_form.cleaned_data = {
+        "title": "Test incident with custom fields",
+        "description": "Testing custom fields handling",
+        "priority": priority,
+        "incident_category": category,
+        "environment": [environment],
+        "platform": ["platform-FR"],
+        # Custom fields that should be removed before creating Incident
+        "zendesk_ticket_id": "ZD-12345",
+        "seller_contract_id": "SELLER-789",
+        "zoho_desk_ticket_id": "ZOHO-456",
+        "is_key_account": True,
+        "is_seller_in_golden_list": False,
+        "suggested_team_routing": None,
+    }
+
+    open_incident_context = build_opening_data(response_type="critical")
+
+    # Should not raise TypeError about unexpected keyword arguments
+    blocks = OpenModal.get_done_review_blocks(
+        open_incident_context,
+        user,
+        details_form_done=True,
+        details_form_class=type(mock_form),
+        details_form=mock_form,
+        can_submit=True,
+    )
+
+    # Should return blocks (at least the divider and tada block)
+    assert len(blocks) >= 2
+
+
+@pytest.mark.django_db
+def test_get_done_review_blocks_critical_includes_slack_and_jira_messages(
+    user: User, priority_factory, environment_factory
+) -> None:
+    """Test that critical incidents show both Slack channel and Jira ticket messages."""
+    # Use factories to create DB objects
+    priority = priority_factory(value=1, default=True)
+    environment = environment_factory(value="PRD", default=True)
+    category = IncidentCategoryFactory()
+
+    # Create a mock form with cleaned_data
+    mock_form = MagicMock(spec=CreateIncidentFormBase)
+    mock_form.cleaned_data = {
+        "title": "Test critical incident",
+        "description": "Testing Slack and Jira messages",
+        "priority": priority,
+        "incident_category": category,
+        "environment": [environment],
+    }
+
+    open_incident_context = build_opening_data(response_type="critical")
+
+    blocks = OpenModal.get_done_review_blocks(
+        open_incident_context,
+        user,
+        details_form_done=True,
+        details_form_class=type(mock_form),
+        details_form=mock_form,
+        can_submit=True,
+    )
+
+    # Find the SectionBlock containing the message
+    section_blocks = [block for block in blocks if isinstance(block, SectionBlock)]
+    assert len(section_blocks) >= 1
+
+    # Get the last SectionBlock which should contain the Slack + Jira message
+    message_block = section_blocks[-1].text
+    # Extract text string - it could be a string or a MarkdownTextObject
+    assert message_block is not None, "SectionBlock text should not be None"
+    message_text = message_block.text if hasattr(message_block, "text") else str(message_block)
+
+    # Verify both Slack and Jira messages are present
+    assert ":slack:" in message_text, "Slack channel message should be present for critical incidents"
+    assert "A dedicated Slack channel will be created" in message_text
+    assert ":jira_new:" in message_text
+    assert "An associated Jira ticket will also be created" in message_text
+
+
+@pytest.mark.django_db
+def test_get_done_review_blocks_normal_includes_only_jira_message(
+    user: User, priority_factory, environment_factory
+) -> None:
+    """Test that normal incidents show only Jira ticket message (no Slack channel)."""
+    # Use factories to create DB objects
+    priority = priority_factory(value=4, default=False)
+    environment = environment_factory(value="PRD", default=True)
+    category = IncidentCategoryFactory()
+
+    # Create a mock form with cleaned_data
+    mock_form = MagicMock(spec=CreateIncidentFormBase)
+    mock_form.cleaned_data = {
+        "title": "Test normal incident",
+        "description": "Testing Jira-only message",
+        "priority": priority,
+        "incident_category": category,
+        "environment": [environment],
+    }
+
+    open_incident_context = build_opening_data(response_type="normal")
+
+    blocks = OpenModal.get_done_review_blocks(
+        open_incident_context,
+        user,
+        details_form_done=True,
+        details_form_class=type(mock_form),
+        details_form=mock_form,
+        can_submit=True,
+    )
+
+    # Find the SectionBlock containing the message
+    section_blocks = [block for block in blocks if isinstance(block, SectionBlock)]
+    assert len(section_blocks) >= 1
+
+    # Get the last SectionBlock which should contain only the Jira message
+    message_block = section_blocks[-1].text
+    # Extract text string - it could be a string or a MarkdownTextObject
+    assert message_block is not None, "SectionBlock text should not be None"
+    message_text = message_block.text if hasattr(message_block, "text") else str(message_block)
+
+    # Verify only Jira message is present (no Slack channel mention)
+    assert ":slack:" not in message_text, "Slack channel message should NOT be present for normal incidents"
+    assert "Slack channel" not in message_text
+    assert ":jira_new:" in message_text
+    assert "A Jira ticket will be created" in message_text