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

firefighter_tests/test_slack/messages/test_slack_messages.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import pytest
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory, UserFactory
+from firefighter.incidents.models import IncidentUpdate
+from firefighter.slack.factories import IncidentChannelFactory
+from firefighter.slack.messages.slack_messages import (
+    SlackMessageDeployWarning,
+    SlackMessageIncidentDeclaredAnnouncement,
+    SlackMessageIncidentStatusUpdated,
+)
+
+
+@pytest.mark.django_db
+class TestSlackMessageIncidentStatusUpdated:
+    """Test SlackMessageIncidentStatusUpdated message generation."""
+
+    def test_title_when_status_mitigated_and_changed(self) -> None:
+        """Test that title mentions MITIGATED when incident reaches MITIGATED status.
+
+        Covers line 445: elif incident.status == IncidentStatus.MITIGATED and status_changed:
+        """
+        # Create an incident in MITIGATED status
+        incident = IncidentFactory.create(_status=IncidentStatus.MITIGATED)
+
+        # Create an IncidentChannel for slack_channel_name
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an IncidentUpdate
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            status=IncidentStatus.MITIGATED,
+            created_by=user
+        )
+
+        # Create the message with status_changed=True and in_channel=False
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=False,
+            status_changed=True
+        )
+
+        # Verify the title contains "Mitigated" (the status label)
+        assert message.title_text is not None
+        assert "Mitigated" in message.title_text
+        assert ":large_green_circle:" in message.title_text
+        assert incident.slack_channel_name in message.title_text
+
+    def test_title_when_status_not_mitigated(self) -> None:
+        """Test that title does not use MITIGATED-specific format when status is different."""
+        # Create an incident in INVESTIGATING status
+        incident = IncidentFactory.create(_status=IncidentStatus.INVESTIGATING)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an IncidentUpdate
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            status=IncidentStatus.INVESTIGATING,
+            created_by=user
+        )
+
+        # Create the message with status_changed=True and in_channel=False
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=False,
+            status_changed=True
+        )
+
+        # Verify the title does NOT contain the MITIGATED-specific format
+        assert message.title_text is not None
+        assert ":large_green_circle:" not in message.title_text
+        assert "has received an update" in message.title_text
+
+    def test_no_update_button_when_incident_closed(self) -> None:
+        """Test that Update Status button is NOT displayed when incident is CLOSED.
+
+        This prevents showing an action button in an archived channel.
+        """
+        # Create an incident in CLOSED status
+        incident = IncidentFactory.create(_status=IncidentStatus.CLOSED)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an IncidentUpdate with status change
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            status=IncidentStatus.CLOSED,
+            created_by=user
+        )
+
+        # Create the message with in_channel=True (normal case for in-channel messages)
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=True,
+            status_changed=True
+        )
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Find any SectionBlock with the "message_status_update" block_id
+        status_update_block = None
+        for block in blocks:
+            if hasattr(block, "block_id") and block.block_id == "message_status_update":
+                status_update_block = block
+                break
+
+        # If there is a status update block, verify it has NO accessory (button)
+        if status_update_block:
+            assert status_update_block.accessory is None, "Update button should not be present when incident is CLOSED"
+
+    def test_update_button_shown_when_incident_not_closed(self) -> None:
+        """Test that Update Status button IS displayed when incident is NOT CLOSED."""
+        # Create an incident in INVESTIGATING status (not closed)
+        incident = IncidentFactory.create(_status=IncidentStatus.INVESTIGATING)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create an IncidentUpdate
+        user = UserFactory.create()
+        incident_update = IncidentUpdate.objects.create(
+            incident=incident,
+            status=IncidentStatus.INVESTIGATING,
+            created_by=user
+        )
+
+        # Create the message with in_channel=True
+        message = SlackMessageIncidentStatusUpdated(
+            incident=incident,
+            incident_update=incident_update,
+            in_channel=True,
+            status_changed=True
+        )
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Find the SectionBlock with "message_status_update" block_id
+        status_update_block = None
+        for block in blocks:
+            if hasattr(block, "block_id") and block.block_id == "message_status_update":
+                status_update_block = block
+                break
+
+        # Verify the block has an accessory (Update button)
+        assert status_update_block is not None, "Should have a status update block"
+        assert status_update_block.accessory is not None, "Update button should be present when incident is not CLOSED"
+        assert status_update_block.accessory.text.text == "Update"
+
+
+@pytest.mark.django_db
+class TestSlackMessageDeployWarning:
+    """Test SlackMessageDeployWarning message generation."""
+
+    def test_header_when_incident_mitigated(self) -> None:
+        """Test that header includes '(Mitigated)' when incident is MITIGATED.
+
+        Covers line 694: text=f":warning: Deploy warning {'(Mitigated) ' if self.incident.status == IncidentStatus.MITIGATED else ''}:warning:"
+        """
+        # Create an incident in MITIGATED status
+        incident = IncidentFactory.create(_status=IncidentStatus.MITIGATED)
+
+        # Create an IncidentChannel for conversation.name
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create the deploy warning message
+        message = SlackMessageDeployWarning(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # The first block should be a HeaderBlock with "(Mitigated)" in the text
+        header_block = blocks[0]
+        header_text = header_block.text.text  # type: ignore[attr-defined]
+
+        assert "(Mitigated)" in header_text
+        assert ":warning:" in header_text
+
+    def test_header_when_incident_not_mitigated(self) -> None:
+        """Test that header does NOT include '(Mitigated)' when incident is not MITIGATED."""
+        # Create an incident in INVESTIGATING status
+        incident = IncidentFactory.create(_status=IncidentStatus.INVESTIGATING)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create the deploy warning message
+        message = SlackMessageDeployWarning(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # The first block should be a HeaderBlock WITHOUT "(Mitigated)"
+        header_block = blocks[0]
+        header_text = header_block.text.text  # type: ignore[attr-defined]
+
+        assert "(Mitigated)" not in header_text
+        assert ":warning:" in header_text
+
+    def test_additional_blocks_when_incident_mitigated_or_above(self) -> None:
+        """Test that additional blocks are added when incident status >= MITIGATED.
+
+        Covers line 705: if self.incident.status >= IncidentStatus.MITIGATED:
+        """
+        # Create an incident in MITIGATED status
+        incident = IncidentFactory.create(_status=IncidentStatus.MITIGATED)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create the deploy warning message
+        message = SlackMessageDeployWarning(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # When status >= MITIGATED, there should be MORE than 2 blocks
+        # (HeaderBlock + SectionBlock + additional blocks from line 706)
+        assert len(blocks) > 2
+
+    def test_no_additional_blocks_when_incident_below_mitigated(self) -> None:
+        """Test that NO additional blocks are added when incident status < MITIGATED."""
+        # Create an incident in INVESTIGATING status (below MITIGATED)
+        incident = IncidentFactory.create(_status=IncidentStatus.INVESTIGATING)
+
+        # Create an IncidentChannel
+        IncidentChannelFactory.create(incident=incident)
+
+        # Create the deploy warning message
+        message = SlackMessageDeployWarning(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # When status < MITIGATED, there should be exactly 2 blocks
+        # (HeaderBlock + SectionBlock only, no additional blocks)
+        assert len(blocks) == 2
+
+
+@pytest.mark.django_db
+class TestSlackMessageIncidentDeclaredAnnouncement:
+    """Test SlackMessageIncidentDeclaredAnnouncement message with custom fields."""
+
+    def test_custom_fields_displayed_when_present(self) -> None:
+        """Test that custom fields are displayed in the incident announcement."""
+        # Create an incident with custom fields
+        incident = IncidentFactory.create(
+            custom_fields={
+                "zendesk_ticket_id": "12345",
+                "seller_contract_id": "SELLER-67890",
+                "zoho_desk_ticket_id": "ZD-11111",
+                "is_key_account": True,
+                "is_seller_in_golden_list": True,
+            }
+        )
+
+        # Create the message
+        message = SlackMessageIncidentDeclaredAnnouncement(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Find the SectionBlock with fields (should contain custom fields)
+        # This is typically the 4th block (index 3)
+        fields_block = None
+        for block in blocks:
+            if hasattr(block, "fields") and block.fields:
+                fields_block = block
+                break
+
+        assert fields_block is not None, "Should have a block with fields"
+
+        # Convert fields to strings for easier assertion (access .text attribute)
+        fields_text = " ".join(field.text if hasattr(field, "text") else str(field) for field in fields_block.fields)
+
+        # Verify custom fields are present
+        assert "Zendesk Ticket" in fields_text
+        assert "12345" in fields_text
+        assert "Seller Contract" in fields_text
+        assert "SELLER-67890" in fields_text
+        assert "Zoho Desk Ticket" in fields_text
+        assert "ZD-11111" in fields_text
+        assert "Key Account" in fields_text
+        assert "Golden List Seller" in fields_text
+
+    def test_custom_fields_not_displayed_when_absent(self) -> None:
+        """Test that custom fields are NOT displayed when not present."""
+        # Create an incident WITHOUT custom fields
+        incident = IncidentFactory.create(custom_fields={})
+
+        # Create the message
+        message = SlackMessageIncidentDeclaredAnnouncement(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Find the SectionBlock with fields
+        fields_block = None
+        for block in blocks:
+            if hasattr(block, "fields") and block.fields:
+                fields_block = block
+                break
+
+        assert fields_block is not None, "Should have a block with fields"
+
+        # Convert fields to strings (access .text attribute)
+        fields_text = " ".join(field.text if hasattr(field, "text") else str(field) for field in fields_block.fields)
+
+        # Verify custom fields are NOT present
+        assert "Zendesk Ticket" not in fields_text
+        assert "Seller Contract" not in fields_text
+        assert "Zoho Desk Ticket" not in fields_text
+        assert "Key Account" not in fields_text
+        assert "Golden List Seller" not in fields_text
+
+    def test_partial_custom_fields_displayed(self) -> None:
+        """Test that only filled custom fields are displayed."""
+        # Create an incident with only some custom fields
+        incident = IncidentFactory.create(
+            custom_fields={
+                "zendesk_ticket_id": "12345",
+                # seller_contract_id not set
+                # zoho_desk_ticket_id not set
+                "is_key_account": False,  # False should not display
+                # is_seller_in_golden_list not set
+            }
+        )
+
+        # Create the message
+        message = SlackMessageIncidentDeclaredAnnouncement(incident=incident)
+
+        # Get the blocks
+        blocks = message.get_blocks()
+
+        # Find the SectionBlock with fields
+        fields_block = None
+        for block in blocks:
+            if hasattr(block, "fields") and block.fields:
+                fields_block = block
+                break
+
+        assert fields_block is not None, "Should have a block with fields"
+
+        # Convert fields to strings (access .text attribute)
+        fields_text = " ".join(field.text if hasattr(field, "text") else str(field) for field in fields_block.fields)
+
+        # Verify only zendesk_ticket_id is present
+        assert "Zendesk Ticket" in fields_text
+        assert "12345" in fields_text
+
+        # Verify others are NOT present
+        assert "Seller Contract" not in fields_text
+        assert "Zoho Desk Ticket" not in fields_text
+        assert "Key Account" not in fields_text
+        assert "Golden List Seller" not in fields_text

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()