firefighter-incident 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

firefighter_tests/test_raid/test_raid_forms.py

@@ -195,9 +195,12 @@ class TestAlertSlackNewJiraTicket:
         )
 
     def test_alert_slack_new_jira_ticket_with_incident_raises_error(self):
-        """Test that function raises ValueError for critical incidents."""
-        # Given - Create an incident and link it to the ticket
-        incident = IncidentFactory()
+        """Test that function raises ValueError for P1-P3 critical incidents."""
+        # Given - Create a P1 incident and link it to the ticket
+        p1_priority = Priority.objects.get_or_create(value=1, defaults={"name": "P1"})[
+            0
+        ]
+        incident = IncidentFactory(priority=p1_priority)
         self.jira_ticket.incident = incident
         self.jira_ticket.save()
 
@@ -550,3 +553,58 @@ class TestGetInternalAlertConversations:
 
         # Then
         assert conversation in result
+
+
+@pytest.mark.django_db
+class TestAlertSlackNewJiraTicketSlackApiError:
+    """Test SlackApiError handling in alert_slack_new_jira_ticket."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        """Set up test fixtures."""
+        self.user = UserFactory()
+        self.jira_user = JiraUser.objects.create(id="jira-slack-error", user=self.user)
+        self.jira_ticket = JiraTicket.objects.create(
+            id=88888,
+            key="SLACK-888",
+            summary="Slack error ticket",
+            reporter=self.jira_user,
+        )
+
+    @patch("firefighter.raid.forms.get_partner_alert_conversations")
+    @patch("firefighter.raid.forms.get_internal_alert_conversations")
+    @patch("firefighter.raid.forms.SlackMessageRaidCreatedIssue")
+    def test_alert_slack_new_jira_ticket_slack_api_error_on_channel_send(
+        self, mock_message_class, mock_get_internal, mock_get_partner, caplog
+    ):
+        """Test SlackApiError when sending to channel - should log exception and continue."""
+        # Given: Create a conversation that will fail to send
+        channel = Conversation.objects.create(
+            channel_id="C_FAIL_TEST",
+            name="fail-channel-test",
+            tag="raid_alert__test_fail",
+        )
+        mock_get_internal.return_value = Conversation.objects.filter(id=channel.id)
+        mock_get_partner.return_value = Conversation.objects.none()
+
+        # Mock message
+        mock_message = Mock()
+        mock_message_class.return_value = mock_message
+
+        # Mock channel.send_message_and_save to raise SlackApiError
+        with patch.object(
+            Conversation,
+            "send_message_and_save",
+            side_effect=SlackApiError(
+                message="channel_not_found",
+                response={"error": "channel_not_found"}
+            )
+        ):
+            # When
+            alert_slack_new_jira_ticket(self.jira_ticket)
+
+            # Then
+            # Should log exception about not being able to send
+            assert "Couldn't send message to channel" in caplog.text
+            assert str(self.jira_ticket.id) in caplog.text
+            # Function should continue and not raise

firefighter_tests/test_raid/test_raid_serializers.py

@@ -311,6 +311,53 @@ class TestLandbotIssueRequestSerializer(TestCase):
             result, reporter_user=user, reporter_email="test@external.com"
         )
 
+    @patch("firefighter.raid.serializers.alert_slack_new_jira_ticket")
+    @patch("firefighter.raid.serializers.get_reporter_user_from_email")
+    @patch("firefighter.raid.serializers.jira_client")
+    def test_create_with_zendesk_field(self, mock_jira_client, mock_get_reporter, mock_alert_slack):
+        """Test create method passes zendesk field to jira_client."""
+        # Setup mocks
+        user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-123", user=user)
+        mock_get_reporter.return_value = (user, jira_user, "manomano.com")
+        mock_alert_slack.return_value = None
+
+        mock_jira_client.create_issue.return_value = {
+            "id": "12345",
+            "key": "TEST-123",
+            "summary": "Test Issue",
+            "reporter": jira_user,
+        }
+
+        serializer = LandbotIssueRequestSerializer()
+        validated_data = {
+            "reporter_email": "test@manomano.com",
+            "issue_type": "Incident",
+            "summary": "Test Issue",
+            "description": "Test Description",
+            "labels": [],
+            "priority": 1,
+            "seller_contract_id": None,
+            "zoho": None,
+            "zendesk": "ZD-12345",  # Zendesk ticket ID
+            "platform": "FR",
+            "incident_category": None,
+            "business_impact": None,
+            "environments": ["PRD"],
+            "suggested_team_routing": "TEAM1",
+            "project": "SBI",
+            "attachments": None,
+        }
+
+        result = serializer.create(validated_data)
+
+        # Verify zendesk_ticket_id was passed to jira_client.create_issue
+        create_call = mock_jira_client.create_issue.call_args[1]
+        assert "zendesk_ticket_id" in create_call
+        assert create_call["zendesk_ticket_id"] == "ZD-12345"
+        assert isinstance(result, JiraTicket)
+        mock_alert_slack.assert_called_once()
+
 
 class TestJiraWebhookUpdateSerializer(TestCase):
     """Test JiraWebhookUpdateSerializer functionality."""

firefighter_tests/test_raid/test_zendesk_integration.py

@@ -0,0 +1,198 @@
+"""Comprehensive integration tests for zendesk field flow from API endpoint to Jira."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from firefighter.incidents.factories import UserFactory
+from firefighter.jira_app.models import JiraUser
+from firefighter.raid.client import RaidJiraClient
+from firefighter.raid.models import JiraTicket
+from firefighter.raid.serializers import LandbotIssueRequestSerializer
+
+
+@pytest.mark.django_db
+class TestZendeskFieldIntegration:
+    """Integration tests for zendesk field flow from serializer to Jira API."""
+
+    @pytest.fixture
+    def mock_jira_client(self):
+        """Create a mock RaidJiraClient with mocked Jira connection."""
+        with patch("firefighter.jira_app.client.JiraClient.__init__", return_value=None):
+            client = RaidJiraClient()
+            client.jira = Mock()
+            return client
+
+    @pytest.mark.parametrize(
+        ("zendesk_value", "should_be_in_jira"),
+        [
+            ("ZD-12345", True),  # Valid value - should be sent to Jira
+            ("", False),  # Empty string - should NOT be sent to Jira
+            (None, False),  # None - should NOT be sent to Jira
+            ("0", True),  # "0" is truthy in Python - should be sent
+        ],
+    )
+    def test_zendesk_field_mapping_edge_cases(
+        self, mock_jira_client, zendesk_value, should_be_in_jira
+    ):
+        """Test zendesk field mapping with various edge case values."""
+        mock_issue = Mock()
+        mock_issue.raw = {
+            "id": "12345",
+            "key": "TEST-123",
+            "fields": {
+                "summary": "Test",
+                "description": "Test",
+                "reporter": {"accountId": "reporter123"},
+                "issuetype": {"name": "Bug"},
+            },
+        }
+        mock_jira_client.jira.create_issue.return_value = mock_issue
+
+        # Call create_issue with zendesk value
+        result = mock_jira_client.create_issue(
+            issuetype="Bug",
+            summary="Test",
+            description="Test",
+            assignee=None,
+            reporter="test_reporter",
+            priority=1,
+            zendesk_ticket_id=zendesk_value,
+        )
+
+        # Check that the Jira API was called
+        assert mock_jira_client.jira.create_issue.called
+
+        # Verify customfield_10895 presence based on expected behavior
+        call_kwargs = mock_jira_client.jira.create_issue.call_args[1]
+
+        if should_be_in_jira:
+            assert "customfield_10895" in call_kwargs, (
+                f"customfield_10895 should be present for zendesk_value={zendesk_value!r}"
+            )
+            assert call_kwargs["customfield_10895"] == str(zendesk_value)
+        else:
+            assert "customfield_10895" not in call_kwargs, (
+                f"customfield_10895 should NOT be present for zendesk_value={zendesk_value!r}"
+            )
+
+        assert result["id"] == 12345
+
+    @pytest.mark.parametrize(
+        ("zendesk_value", "expected_param"),
+        [
+            ("ZD-12345", "ZD-12345"),  # Valid value
+            ("", ""),  # Empty string
+            (None, None),  # None
+        ],
+    )
+    @patch("firefighter.raid.serializers.alert_slack_new_jira_ticket")
+    @patch("firefighter.raid.serializers.get_reporter_user_from_email")
+    @patch("firefighter.raid.serializers.jira_client")
+    def test_serializer_to_client_zendesk_flow(
+        self,
+        mock_jira_client,
+        mock_get_reporter,
+        mock_alert_slack,
+        zendesk_value,
+        expected_param,
+    ):
+        """Test that serializer correctly passes zendesk value to jira_client."""
+        # Setup mocks
+        user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-123", user=user)
+        mock_get_reporter.return_value = (user, jira_user, "manomano.com")
+        mock_alert_slack.return_value = None
+
+        mock_jira_client.create_issue.return_value = {
+            "id": "12345",
+            "key": "TEST-123",
+            "summary": "Test",
+            "reporter": jira_user,
+        }
+
+        # Create serializer and validated_data
+        serializer = LandbotIssueRequestSerializer()
+        validated_data = {
+            "reporter_email": "test@manomano.com",
+            "issue_type": "Incident",
+            "summary": "Test",
+            "description": "Test",
+            "labels": [],
+            "priority": 1,
+            "seller_contract_id": None,
+            "zoho": None,
+            "zendesk": zendesk_value,
+            "platform": "FR",
+            "incident_category": None,
+            "business_impact": None,
+            "environments": ["PRD"],
+            "suggested_team_routing": "TEAM1",
+            "project": "SBI",
+            "attachments": None,
+        }
+
+        # Call create
+        result = serializer.create(validated_data)
+
+        # Verify jira_client.create_issue was called
+        assert mock_jira_client.create_issue.called
+
+        # Check zendesk_ticket_id parameter
+        create_call = mock_jira_client.create_issue.call_args[1]
+        assert "zendesk_ticket_id" in create_call
+        assert create_call["zendesk_ticket_id"] == expected_param
+
+        assert isinstance(result, JiraTicket)
+        mock_alert_slack.assert_called_once()
+
+    @patch("firefighter.raid.serializers.alert_slack_new_jira_ticket")
+    @patch("firefighter.raid.serializers.get_reporter_user_from_email")
+    @patch("firefighter.raid.serializers.jira_client")
+    def test_serializer_without_zendesk_field(
+        self, mock_jira_client, mock_get_reporter, mock_alert_slack
+    ):
+        """Test that serializer works when zendesk field is not provided."""
+        # Setup mocks
+        user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-456", user=user)
+        mock_get_reporter.return_value = (user, jira_user, "manomano.com")
+        mock_alert_slack.return_value = None
+
+        mock_jira_client.create_issue.return_value = {
+            "id": "12346",
+            "key": "TEST-124",
+            "summary": "Test",
+            "reporter": jira_user,
+        }
+
+        serializer = LandbotIssueRequestSerializer()
+        validated_data = {
+            "reporter_email": "test@manomano.com",
+            "issue_type": "Incident",
+            "summary": "Test without zendesk",
+            "description": "Test",
+            "labels": [],
+            "priority": 1,
+            "seller_contract_id": None,
+            "zoho": None,
+            # zendesk field NOT provided
+            "platform": "FR",
+            "incident_category": None,
+            "business_impact": None,
+            "environments": ["PRD"],
+            "suggested_team_routing": "TEAM1",
+            "project": "SBI",
+            "attachments": None,
+        }
+
+        result = serializer.create(validated_data)
+
+        # Verify zendesk_ticket_id parameter is None
+        create_call = mock_jira_client.create_issue.call_args[1]
+        assert "zendesk_ticket_id" in create_call
+        assert create_call["zendesk_ticket_id"] is None
+
+        assert isinstance(result, JiraTicket)

firefighter_tests/test_slack/test_conversation_tags.py

@@ -0,0 +1,344 @@
+"""Tests for Slack Conversation tags usage across the application.
+
+This module verifies that all documented conversation tags are properly used
+and that the logic for finding and using tagged channels works correctly.
+"""
+
+from __future__ import annotations
+
+import pytest
+from django.db import IntegrityError
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import (
+    IncidentCategoryFactory,
+    IncidentFactory,
+    UserFactory,
+)
+from firefighter.incidents.models.environment import Environment
+from firefighter.incidents.models.priority import Priority
+from firefighter.jira_app.models import JiraUser
+from firefighter.raid.forms import get_internal_alert_conversations
+from firefighter.raid.models import JiraTicket
+from firefighter.slack.models.conversation import Conversation
+from firefighter.slack.rules import (
+    should_publish_in_general_channel,
+    should_publish_in_it_deploy_channel,
+)
+
+
+@pytest.mark.django_db
+class TestTechIncidentsTag:
+    """Test the tech_incidents tag usage for general incident announcements."""
+
+    @pytest.fixture
+    def tech_incidents_channel(self):
+        """Create tech_incidents channel."""
+        return Conversation.objects.create(
+            name="tech-incidents",
+            channel_id="C_TECH_INCIDENTS",
+            tag="tech_incidents",
+        )
+
+    @pytest.fixture
+    def p1_prd_incident(self):
+        """Create P1 incident in PRD."""
+        p1 = Priority.objects.get_or_create(value=1, defaults={"name": "P1"})[0]
+        prd = Environment.objects.get_or_create(value="PRD", defaults={"value": "PRD"})[
+            0
+        ]
+        category = IncidentCategoryFactory()
+        return IncidentFactory(
+            priority=p1,
+            environment=prd,
+            incident_category=category,
+            status=IncidentStatus.OPEN,
+            private=False,
+        )
+
+    def test_tech_incidents_channel_can_be_found(
+        self, tech_incidents_channel  # noqa: ARG002 - fixture creates channel in DB
+    ):
+        """Test that tech_incidents channel can be retrieved by tag."""
+        channel = Conversation.objects.get_or_none(tag="tech_incidents")
+        assert channel is not None
+        assert channel.name == "tech-incidents"
+        assert channel.tag == "tech_incidents"
+
+    def test_should_publish_p1_prd_incident_in_tech_incidents(self, p1_prd_incident):
+        """Test that P1 PRD incidents should be published to tech_incidents."""
+        should_publish = should_publish_in_general_channel(
+            p1_prd_incident, incident_update=None
+        )
+        assert should_publish is True
+
+    def test_should_not_publish_p4_in_tech_incidents(self):
+        """Test that P4 incidents should NOT be published to tech_incidents."""
+        p4 = Priority.objects.get_or_create(value=4, defaults={"name": "P4"})[0]
+        prd = Environment.objects.get_or_create(value="PRD", defaults={"value": "PRD"})[
+            0
+        ]
+        category = IncidentCategoryFactory()
+        incident = IncidentFactory(
+            priority=p4,
+            environment=prd,
+            incident_category=category,
+            status=IncidentStatus.OPEN,
+            private=False,
+        )
+
+        should_publish = should_publish_in_general_channel(
+            incident, incident_update=None
+        )
+        assert should_publish is False
+
+    def test_should_not_publish_private_incident_in_tech_incidents(self):
+        """Test that private incidents should NOT be published to tech_incidents."""
+        p1 = Priority.objects.get_or_create(value=1, defaults={"name": "P1"})[0]
+        prd = Environment.objects.get_or_create(value="PRD", defaults={"value": "PRD"})[
+            0
+        ]
+        category = IncidentCategoryFactory()
+        incident = IncidentFactory(
+            priority=p1,
+            environment=prd,
+            incident_category=category,
+            status=IncidentStatus.OPEN,
+            private=True,  # Private incident
+        )
+
+        should_publish = should_publish_in_general_channel(
+            incident, incident_update=None
+        )
+        assert should_publish is False
+
+
+@pytest.mark.django_db
+class TestItDeployTag:
+    """Test the it_deploy tag usage for deployment warnings."""
+
+    @pytest.fixture
+    def it_deploy_channel(self):
+        """Create it_deploy channel."""
+        return Conversation.objects.create(
+            name="it-deploy", channel_id="C_IT_DEPLOY", tag="it_deploy"
+        )
+
+    @pytest.fixture
+    def deploy_warning_category(self):
+        """Create incident category with deploy_warning=True."""
+        return IncidentCategoryFactory(deploy_warning=True)
+
+    def test_it_deploy_channel_can_be_found(
+        self, it_deploy_channel  # noqa: ARG002 - fixture creates channel in DB
+    ):
+        """Test that it_deploy channel can be retrieved by tag."""
+        channel = Conversation.objects.get_or_none(tag="it_deploy")
+        assert channel is not None
+        assert channel.name == "it-deploy"
+        assert channel.tag == "it_deploy"
+
+    def test_should_publish_p1_deploy_warning_in_it_deploy(
+        self, deploy_warning_category
+    ):
+        """Test that P1 incidents with deploy_warning should be published to it_deploy."""
+        p1 = Priority.objects.get_or_create(value=1, defaults={"name": "P1"})[0]
+        prd = Environment.objects.get_or_create(value="PRD", defaults={"value": "PRD"})[
+            0
+        ]
+        incident = IncidentFactory(
+            priority=p1,
+            environment=prd,
+            incident_category=deploy_warning_category,
+            status=IncidentStatus.OPEN,
+            private=False,
+        )
+
+        should_publish = should_publish_in_it_deploy_channel(incident)
+        assert should_publish is True
+
+    def test_should_not_publish_p2_in_it_deploy(self, deploy_warning_category):
+        """Test that P2 incidents should NOT be published to it_deploy (P1 only)."""
+        p2 = Priority.objects.get_or_create(value=2, defaults={"name": "P2"})[0]
+        prd = Environment.objects.get_or_create(value="PRD", defaults={"value": "PRD"})[
+            0
+        ]
+        incident = IncidentFactory(
+            priority=p2,
+            environment=prd,
+            incident_category=deploy_warning_category,
+            status=IncidentStatus.OPEN,
+            private=False,
+        )
+
+        should_publish = should_publish_in_it_deploy_channel(incident)
+        assert should_publish is False
+
+    def test_should_not_publish_p1_without_deploy_warning_in_it_deploy(self):
+        """Test that P1 without deploy_warning should NOT be published to it_deploy."""
+        p1 = Priority.objects.get_or_create(value=1, defaults={"name": "P1"})[0]
+        prd = Environment.objects.get_or_create(value="PRD", defaults={"value": "PRD"})[
+            0
+        ]
+        category = IncidentCategoryFactory(deploy_warning=False)
+        incident = IncidentFactory(
+            priority=p1,
+            environment=prd,
+            incident_category=category,
+            status=IncidentStatus.OPEN,
+            private=False,
+        )
+
+        should_publish = should_publish_in_it_deploy_channel(incident)
+        assert should_publish is False
+
+
+@pytest.mark.django_db
+class TestInvitedForAllPublicP1Tag:
+    """Test the invited_for_all_public_p1 usergroup tag."""
+
+    @pytest.fixture
+    def p1_usergroup(self):
+        """Create P1 usergroup conversation (represents Slack usergroup)."""
+        return Conversation.objects.create(
+            name="leadership-p1",
+            channel_id="S_LEADERSHIP",  # S prefix for usergroup
+            tag="invited_for_all_public_p1",
+        )
+
+    def test_p1_usergroup_can_be_found(
+        self, p1_usergroup  # noqa: ARG002 - fixture creates usergroup in DB
+    ):
+        """Test that P1 usergroup can be retrieved by tag."""
+        usergroup = Conversation.objects.get_or_none(tag="invited_for_all_public_p1")
+        assert usergroup is not None
+        assert usergroup.tag == "invited_for_all_public_p1"
+
+    def test_p1_usergroup_tag_exists_in_code(
+        self, p1_usergroup  # noqa: ARG002 - fixture creates usergroup in DB
+    ):
+        """Test that P1 usergroup tag is referenced in codebase."""
+        # Just verify the tag can be found - the actual Slack integration
+        # is tested in the get_users tests
+        usergroup = Conversation.objects.get_or_none(tag="invited_for_all_public_p1")
+        assert usergroup is not None
+
+
+@pytest.mark.django_db
+class TestDevFirefighterTag:
+    """Test the dev_firefighter tag for support channel."""
+
+    @pytest.fixture
+    def support_channel(self):
+        """Create dev_firefighter support channel."""
+        return Conversation.objects.create(
+            name="firefighter-support",
+            channel_id="C_SUPPORT",
+            tag="dev_firefighter",
+        )
+
+    def test_support_channel_can_be_found(
+        self, support_channel  # noqa: ARG002 - fixture creates channel in DB
+    ):
+        """Test that support channel can be retrieved by tag."""
+        channel = Conversation.objects.get_or_none(tag="dev_firefighter")
+        assert channel is not None
+        assert channel.name == "firefighter-support"
+        assert channel.tag == "dev_firefighter"
+
+    def test_support_channel_used_in_templating(self, support_channel):
+        """Test that support channel tag is referenced in slack_templating module."""
+        # The support channel is retrieved in slack_templating.py:76
+        # Just verify it can be found
+        channel = Conversation.objects.get_or_none(tag="dev_firefighter")
+        assert channel is not None
+        assert channel == support_channel
+
+
+@pytest.mark.django_db
+class TestRaidAlertTags:
+    """Test RAID alert tags patterns (already tested in test_raid_alert_p4_p5.py).
+
+    These tests verify the tag patterns work correctly for P4-P5 incidents.
+    """
+
+    def test_raid_alert_sbi_normal_tag_format(self):
+        """Test that raid_alert__sbi_normal follows correct format."""
+        # Create channel
+        Conversation.objects.create(
+            name="incidents", channel_id="C_INC", tag="raid_alert__sbi_normal"
+        )
+
+        # Create ticket
+        jira_user = JiraUser.objects.create(id="test-jira", user=UserFactory())
+        ticket = JiraTicket.objects.create(
+            id=1,
+            key="SBI-1",
+            summary="Test",
+            project_key="SBI",
+            business_impact="N/A",
+            reporter=jira_user,
+        )
+
+        channels = list(get_internal_alert_conversations(ticket))
+        assert len(channels) == 1
+        assert channels[0].tag == "raid_alert__sbi_normal"
+
+    def test_raid_alert_sbi_high_tag_format(self):
+        """Test that raid_alert__sbi_high follows correct format."""
+        # Create channel
+        Conversation.objects.create(
+            name="incidents-high", channel_id="C_INC_H", tag="raid_alert__sbi_high"
+        )
+
+        # Create ticket with high impact
+        jira_user = JiraUser.objects.create(id="test-jira2", user=UserFactory())
+        ticket = JiraTicket.objects.create(
+            id=2,
+            key="SBI-2",
+            summary="Test",
+            project_key="SBI",
+            business_impact="High",
+            reporter=jira_user,
+        )
+
+        channels = list(get_internal_alert_conversations(ticket))
+        assert len(channels) == 1
+        assert channels[0].tag == "raid_alert__sbi_high"
+
+
+@pytest.mark.django_db
+class TestTagUniqueness:
+    """Test that tags are unique and constraints work."""
+
+    def test_cannot_create_duplicate_tags(self):
+        """Test that duplicate non-empty tags are rejected."""
+        Conversation.objects.create(
+            name="channel1", channel_id="C_001", tag="unique_tag"
+        )
+
+        with pytest.raises(IntegrityError):
+            Conversation.objects.create(
+                name="channel2", channel_id="C_002", tag="unique_tag"
+            )
+
+    def test_can_have_multiple_empty_tags(self):
+        """Test that multiple channels can have empty tags."""
+        conv1 = Conversation.objects.create(name="channel1", channel_id="C_001", tag="")
+        conv2 = Conversation.objects.create(name="channel2", channel_id="C_002", tag="")
+
+        assert conv1.tag == ""
+        assert conv2.tag == ""
+
+    def test_tag_case_sensitivity(self):
+        """Test that tags are case-sensitive."""
+        Conversation.objects.create(
+            name="channel1", channel_id="C_001", tag="tech_incidents"
+        )
+
+        # Different case should be allowed (but not recommended)
+        conv2 = Conversation.objects.create(
+            name="channel2", channel_id="C_002", tag="TECH_INCIDENTS"
+        )
+
+        assert conv2.tag == "TECH_INCIDENTS"