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

firefighter/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.18'
-__version_tuple__ = version_tuple = (0, 0, 18)
+__version__ = version = '0.0.19'
+__version_tuple__ = version_tuple = (0, 0, 19)
 
 __commit_id__ = commit_id = None

firefighter/raid/client.py

@@ -72,6 +72,7 @@ class RaidJiraClient(JiraClient):
             extra_args["customfield_10896"] = str(zoho_desk_ticket_id)
         if zendesk_ticket_id:
             extra_args["customfield_10895"] = str(zendesk_ticket_id)
+
         if seller_contract_id:
             description_addendum.append(
                 f"Seller link to TOOLBOX: {TOOLBOX_URL}?seller_id={seller_contract_id}"
@@ -109,6 +110,7 @@ class RaidJiraClient(JiraClient):
             project = (
                 feature_team.jira_project_key if feature_team else RAID_JIRA_PROJECT_KEY
             )
+
         issue = self.jira.create_issue(
             project=project,
             summary=summary,

firefighter/raid/forms.py

@@ -107,8 +107,12 @@ def alert_slack_new_jira_ticket(
     reporter_user: User | None = None,
     reporter_email: str | None = None,
 ) -> None:
-    # These alerts are not for critical incidents
-    if hasattr(jira_ticket, "incident") and jira_ticket.incident:
+    # These alerts are for P4-P5 incidents only, not P1-P3 critical incidents
+    if (
+        hasattr(jira_ticket, "incident")
+        and jira_ticket.incident
+        and jira_ticket.incident.priority.value <= 3
+    ):
         raise ValueError("This is a critical incident, not a raid incident.")
 
     # Get the reporter's email and user from ticket if not provided

firefighter/raid/views/__init__.py

@@ -35,6 +35,7 @@ if TYPE_CHECKING:
                 "description": "Description test where you want to depict your issue",
                 "seller_contract_id": "12345678",
                 "zoho": "https://crmplus.zoho.eu/mycrmlink/index.do/cxapp/agent/mycompany/all/tickets/details/123456789",
+                "zendesk": "12345",
                 "platform": "FR",
                 "reporter_email": "john.doe@mycompany.com",
                 "incident_category": "Payment Processing",

{firefighter_incident-0.0.18.dist-info → firefighter_incident-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.18
+Version: 0.0.19
 Summary: Incident Management tool made for Slack using Django
 Project-URL: Repository, https://github.com/ManoManoTech/firefighter-incident
 Project-URL: Documentation, https://manomanotech.github.io/firefighter-incident/latest/

{firefighter_incident-0.0.18.dist-info → firefighter_incident-0.0.19.dist-info}/RECORD

@@ -6,7 +6,7 @@ gunicorn.conf.py,sha256=vHsTGjaKOr8FDMp6fTKYTX4AtokmPgYvvt5Mr0Q6APc,273
 main.py,sha256=CsbprHoOYhjCLpTJmq9Z_aRYFoFgWxoz2pDLuwm8Eqg,1558
 manage.py,sha256=5ivHGD13C6nJ8QvltKsJ9T9akA5he8da70HLWaEP3k8,689
 firefighter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-firefighter/_version.py,sha256=tzG3REjXftgEO32YP2rgLirgULNff34B-C5Yb8oweEc,706
+firefighter/_version.py,sha256=2t1q5JYEYkNwbHa29phdM-U8VWR1m6EwW48aFKWPj_w,706
 firefighter/api/__init__.py,sha256=JQW0Bv6xwGqy7ioxx3h6UGMzkkJ4DntDpbvV1Ncgi8k,136
 firefighter/api/admin.py,sha256=x9Ysy-GiYjb0rynmFdS9g56e6n24fkN0ouGy5QD9Yrc,4629
 firefighter/api/apps.py,sha256=P5uU1_gMrDfzurdMbfqw1Bnb2uNKKcMq17WBPg2sLhc,204
@@ -311,8 +311,8 @@ firefighter/pagerduty/views/oncall_trigger.py,sha256=LYHpWyEaR6O8NazmsTl5ydtw1XH
 firefighter/raid/__init__.py,sha256=nMNmvHCSkyLQsdhTow7myMU62vXk1e755gUntVfFFlY,154
 firefighter/raid/admin.py,sha256=WhIHaRAv7JPp2NH27w7_0JfvGHrvoyRJhYr3_WwedrA,1117
 firefighter/raid/apps.py,sha256=olDKua1rqhhIJUhCu6A2PnPWloW_jbeD4XWL94b2owo,1117
-firefighter/raid/client.py,sha256=ja_tiKAcBFpI5ZwbGxSVyf7_ETq2K1Qauq26pMR-Ze4,8124
-firefighter/raid/forms.py,sha256=gbbXDizCYDs8vz33ZFClTVZ_yM3jqZtWFMYRy3K3xuM,11863
+firefighter/raid/client.py,sha256=5PzW7Ub0rU4Z_gdGqPB42CMcM5TCUoWeOZRZZmnhJXg,8126
+firefighter/raid/forms.py,sha256=XivNADFHOl2ewNRXev17HthDIUvwt4pdH9t4So-BE-A,11968
 firefighter/raid/messages.py,sha256=e75kwi0hCe5ChwU4t-_6Q3Rcy22MLLdVSsYyjvG2SCM,5542
 firefighter/raid/models.py,sha256=29Smci739K1ZdcMu7uXYvoVEhgDpwLQoCzBbc5wvwhs,2211
 firefighter/raid/resources.py,sha256=39GhITs3OAWA1eSPZme-rLd818kuz7gwYzdN38zNz8Y,436
@@ -328,7 +328,7 @@ firefighter/raid/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 firefighter/raid/signals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 firefighter/raid/signals/incident_updated.py,sha256=5LYeqvgTrfINu_SOwkZa3hD6rvTsl8BL8Py-immqK3I,1374
 firefighter/raid/tasks/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
-firefighter/raid/views/__init__.py,sha256=noK-M1X4L46OMAp6S29jqajovzL6sIMSnIBv5l9vxIM,5174
+firefighter/raid/views/__init__.py,sha256=C3WhAJfEoUasi2afHPuLpKiuRYixK-tc3j0-2Rw_g3E,5210
 firefighter/slack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 firefighter/slack/admin.py,sha256=pNJbA-szxUUrghxv_Z0BNezu6lULDzFcOu_K5i4m7Cs,13963
 firefighter/slack/apps.py,sha256=gR0zWTtqT58tjPayBX22ZSzMkLiNpmoOvLShNvhJA6Q,664
@@ -464,17 +464,20 @@ firefighter_tests/test_incidents/test_utils/test_date_utils.py,sha256=ogP7qOEwIt
 firefighter_tests/test_incidents/test_views/test_incident_detail_view.py,sha256=gKKFWIZVrD_P4p6DJjeHCW5uGXBUBVlCd95gJJYDpWQ,680
 firefighter_tests/test_incidents/test_views/test_index_view.py,sha256=InpxbaWOFwRn4YWeIKZhj17vMymrQQf2p2LFhe2Bcdw,816
 firefighter_tests/test_raid/conftest.py,sha256=i_TOquYIMLDyVQ97uqxTqPJszVz4qq7L_Q7YJxTuS1o,4090
-firefighter_tests/test_raid/test_raid_client.py,sha256=8iRBR4bKewPPbtz33hCLOHiZDTELPQBOrQb7EdNDS4c,21227
+firefighter_tests/test_raid/test_raid_alert_p4_p5.py,sha256=rz9orbt1E1vJ5POQyVZ6-SEPvqB55-xhwIWHicdfgDg,9356
+firefighter_tests/test_raid/test_raid_client.py,sha256=KTqELERpWno7XhF9LpabpxkHoJiWWrryUg5LHi5Yfjo,22456
 firefighter_tests/test_raid/test_raid_client_users.py,sha256=9uma1wBhaiCoG75XAZHqpT8oGTnqFJRMCi7a3XctNtM,3631
-firefighter_tests/test_raid/test_raid_forms.py,sha256=y89ZqP6Wf9h3S2hegJHVfVdCuVbfL4SvT-kPVoAYyy8,19618
+firefighter_tests/test_raid/test_raid_forms.py,sha256=lLZvhczAge0Ftt3OdFEH2BcE1OMF6_vvy1ghHAe3HWM,19758
 firefighter_tests/test_raid/test_raid_models.py,sha256=nq-fVClB_P24W8WrZruOPt8wlHUVGYI7wxJR7tH6AnM,5042
-firefighter_tests/test_raid/test_raid_serializers.py,sha256=nejl4ceBPegOcks6z6B8_7Ekg8ef18j3i7C8Y8dS8v0,20665
+firefighter_tests/test_raid/test_raid_serializers.py,sha256=xkMK9npvDMAr2pUpP4mFbLszrR6qyTzsJRd-uNOzEhM,22560
 firefighter_tests/test_raid/test_raid_service.py,sha256=AqVyrRjW2tr0sfbXS4lGlJ7mcxB2ACEXAR8Bv0pXnj0,16755
 firefighter_tests/test_raid/test_raid_signals.py,sha256=twNxB3NQs58s8ZcP-wsZXG7iTHR4yKFC9x-zpq1ZuAo,7002
 firefighter_tests/test_raid/test_raid_transitions.py,sha256=mtmMKwukxmZSM-R619BQ3Z_2AB-qY6imvDgUF0A3_tw,4784
 firefighter_tests/test_raid/test_raid_utils.py,sha256=i6JBwim1G-qynwxprNZekxl9K7Vis4FFvNkw3wT2jTM,1016
 firefighter_tests/test_raid/test_raid_views.py,sha256=paAhh4k2EDlmG1ehwNhMuYIhr1okqrvM7xlkaTAo2V0,6825
+firefighter_tests/test_raid/test_zendesk_integration.py,sha256=RtHIKWog_YZ6g-uZSr37k5XjAGe0c8WEeBWqkt1ZNqk,7113
 firefighter_tests/test_slack/conftest.py,sha256=MCg04JFQ0iBeYUN_moEvvH4PVA3wE48Q6LkrIw7Bic0,2015
+firefighter_tests/test_slack/test_conversation_tags.py,sha256=nNqTZRRBfF6Z4wpFSYZ83DH7_mR9z9F9LAHSq8AHFN0,12744
 firefighter_tests/test_slack/test_signals_downgrade.py,sha256=mgl4H5vwr2kImf6g4IZbhv7YEPmMzbYSaVr8E6taL88,5420
 firefighter_tests/test_slack/test_slack_utils.py,sha256=9PLobMNXh3xDyFuwzcQFpKJhe4j__sIgf_WRHIpANJw,3957
 firefighter_tests/test_slack/messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -491,10 +494,10 @@ firefighter_tests/test_slack/views/modals/test_open.py,sha256=IzgG9le5NN_CvltehA
 firefighter_tests/test_slack/views/modals/test_opening_unified.py,sha256=OejtLyc_mehav2TDaLzUnhilMNvhCzc6T4FodCqfQPk,17406
 firefighter_tests/test_slack/views/modals/test_send_sos.py,sha256=_rE6jD-gOzcGyhlY0R9GzlGtPx65oOOguJYdENgxtLc,1289
 firefighter_tests/test_slack/views/modals/test_status.py,sha256=oQzPfwdg2tkbo9nfkO1GfS3WydxqSC6vy1AZjZDKT30,2226
-firefighter_tests/test_slack/views/modals/test_update_status.py,sha256=aqLQ_9TV4Zn-S2sSXL8VNqTMygcbgOIrxg4OUovgUrw,55630
+firefighter_tests/test_slack/views/modals/test_update_status.py,sha256=OVGqVSeim7aancl0RnGzqwM21Qs3ZVFlaryZiOWi_wM,55748
 firefighter_tests/test_slack/views/modals/test_utils.py,sha256=DJd2n9q6fFu8UuCRdiq9U_Cn19MdnC5c-ydLLrk6rkc,5218
-firefighter_incident-0.0.18.dist-info/METADATA,sha256=IoKMnbPTxFmn7Cfb2UIV6x77XIp1pY6WSrOhW2JxsFg,5541
-firefighter_incident-0.0.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-firefighter_incident-0.0.18.dist-info/entry_points.txt,sha256=c13meJbv7YNmYz7MipMOQwzQ5IeFOPXUBYAJ44XMQsM,61
-firefighter_incident-0.0.18.dist-info/licenses/LICENSE,sha256=krRiGp-a9-1nH1bWpBEdxyTKLhjLmn6DMVVoIb0zF90,1087
-firefighter_incident-0.0.18.dist-info/RECORD,,
+firefighter_incident-0.0.19.dist-info/METADATA,sha256=3oyEnmXZl2Ps9iciGESrGodxRAXbOJfiDcOaY2uh8NU,5541
+firefighter_incident-0.0.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+firefighter_incident-0.0.19.dist-info/entry_points.txt,sha256=c13meJbv7YNmYz7MipMOQwzQ5IeFOPXUBYAJ44XMQsM,61
+firefighter_incident-0.0.19.dist-info/licenses/LICENSE,sha256=krRiGp-a9-1nH1bWpBEdxyTKLhjLmn6DMVVoIb0zF90,1087
+firefighter_incident-0.0.19.dist-info/RECORD,,

firefighter_tests/test_raid/test_raid_alert_p4_p5.py

@@ -0,0 +1,255 @@
+"""Tests for RAID alert notifications for P4-P5 incidents with linked Incident objects.
+
+This module tests the alert_slack_new_jira_ticket() function behavior when called
+with P4-P5 JiraTickets that have associated Incident objects (since 0.0.17 unified workflow).
+
+Before 0.0.17: P4-P5 created only JiraTicket (no Incident) → alerts worked
+Since 0.0.17: P4-P5 create Incident + JiraTicket → alerts broken due to incorrect check
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from firefighter.incidents.factories import (
+    IncidentCategoryFactory,
+    IncidentFactory,
+    UserFactory,
+)
+from firefighter.incidents.models.priority import Priority
+from firefighter.jira_app.models import JiraUser
+from firefighter.raid.forms import (
+    alert_slack_new_jira_ticket,
+    get_internal_alert_conversations,
+)
+from firefighter.raid.models import JiraTicket
+from firefighter.slack.models.conversation import Conversation
+from firefighter.slack.models.user import SlackUser
+
+
+@pytest.mark.django_db
+class TestAlertSlackNewJiraTicketWithIncident:
+    """Test alert_slack_new_jira_ticket for P4-P5 with linked Incident (unified workflow)."""
+
+    @pytest.fixture
+    def p4_priority(self):
+        """Get or create P4 priority."""
+        priority, _ = Priority.objects.get_or_create(value=4, defaults={"name": "P4"})
+        return priority
+
+    @pytest.fixture
+    def p5_priority(self):
+        """Get or create P5 priority."""
+        priority, _ = Priority.objects.get_or_create(value=5, defaults={"name": "P5"})
+        return priority
+
+    @pytest.fixture
+    def incident_category(self):
+        """Create incident category."""
+        return IncidentCategoryFactory()
+
+    @pytest.fixture
+    def reporter_user_with_slack(self):
+        """Create user with Slack account."""
+        user = UserFactory(email="reporter@manomano.com")
+        jira_user = JiraUser.objects.create(id="jira-123", user=user)
+        slack_user = SlackUser.objects.create(user=user, slack_id="U12345")
+        return user, jira_user, slack_user
+
+    @pytest.fixture
+    def raid_alert_channel_sbi(self):
+        """Create the raid_alert__sbi_normal channel for SBI tickets."""
+        return Conversation.objects.create(
+            name="incidents",
+            channel_id="C_INCIDENTS",
+            tag="raid_alert__sbi_normal",
+        )
+
+    def test_alert_p4_incident_with_linked_incident_should_succeed(
+        self,
+        p4_priority,
+        incident_category,
+        reporter_user_with_slack,
+        raid_alert_channel_sbi,  # noqa: ARG002 - fixture creates channel in DB
+    ):
+        """Test that P4 JiraTicket with linked Incident can send raid_alert notifications.
+
+        This test reproduces the CURRENT BROKEN behavior since 0.0.17:
+        - UnifiedIncidentForm creates Incident + JiraTicket for P4-P5
+        - alert_slack_new_jira_ticket() raises ValueError because jira_ticket.incident exists
+        - Notifications to #incidents channel are never sent
+
+        Expected: Should send notifications (test will FAIL until bug is fixed)
+        """
+        user, jira_user, _ = reporter_user_with_slack
+
+        # Create P4 incident (simulating UnifiedIncidentForm behavior)
+        incident = IncidentFactory(
+            priority=p4_priority,
+            incident_category=incident_category,
+            created_by=user,
+        )
+
+        # Create JiraTicket linked to Incident (UNIFIED workflow since 0.0.17)
+        jira_ticket = JiraTicket.objects.create(
+            id=12345,
+            key="SBI-12345",
+            summary="P4 incident with linked Incident",
+            business_impact="N/A",
+            project_key="SBI",
+            reporter=jira_user,
+            incident=incident,  # ← This is what breaks alert_slack_new_jira_ticket()
+        )
+
+        # Mock Slack API to capture messages sent
+        with (
+            patch(
+                "firefighter.slack.models.user.SlackUser.send_private_message"
+            ) as mock_dm,
+            patch(
+                "firefighter.slack.models.conversation.Conversation.send_message_and_save"
+            ) as mock_channel_msg,
+        ):
+            # This should NOT raise ValueError and should send notifications
+            alert_slack_new_jira_ticket(
+                jira_ticket, reporter_user=user, reporter_email=user.email
+            )
+
+            # Verify DM was sent to reporter
+            assert mock_dm.called, "Should send DM to reporter"
+
+            # Verify message was sent to #incidents channel
+            assert (
+                mock_channel_msg.called
+            ), "Should send message to raid_alert channel"
+
+    def test_alert_p5_incident_with_linked_incident_should_succeed(
+        self,
+        p5_priority,
+        incident_category,
+        reporter_user_with_slack,
+        raid_alert_channel_sbi,  # noqa: ARG002 - fixture creates channel in DB
+    ):
+        """Test that P5 JiraTicket with linked Incident can send raid_alert notifications."""
+        user, jira_user, _ = reporter_user_with_slack
+
+        # Create P5 incident
+        incident = IncidentFactory(
+            priority=p5_priority,
+            incident_category=incident_category,
+            created_by=user,
+        )
+
+        # Create JiraTicket linked to Incident
+        jira_ticket = JiraTicket.objects.create(
+            id=12346,
+            key="SBI-12346",
+            summary="P5 incident with linked Incident",
+            business_impact="N/A",
+            project_key="SBI",
+            reporter=jira_user,
+            incident=incident,
+        )
+
+        # Mock Slack API
+        with (
+            patch(
+                "firefighter.slack.models.user.SlackUser.send_private_message"
+            ) as mock_dm,
+            patch(
+                "firefighter.slack.models.conversation.Conversation.send_message_and_save"
+            ) as mock_channel_msg,
+        ):
+            # Should succeed for P5 as well
+            alert_slack_new_jira_ticket(
+                jira_ticket, reporter_user=user, reporter_email=user.email
+            )
+
+            assert mock_dm.called
+            assert mock_channel_msg.called
+
+    def test_alert_p1_incident_should_fail(
+        self, incident_category, reporter_user_with_slack
+    ):
+        """Test that P1 JiraTicket with linked Incident correctly raises ValueError.
+
+        P1-P3 incidents should NOT use raid_alert notifications.
+        They have dedicated Slack channels and use different notification flow.
+        """
+        user, jira_user, _ = reporter_user_with_slack
+        p1_priority, _ = Priority.objects.get_or_create(value=1, defaults={"name": "P1"})
+
+        incident = IncidentFactory(
+            priority=p1_priority,
+            incident_category=incident_category,
+            created_by=user,
+        )
+
+        jira_ticket = JiraTicket.objects.create(
+            id=12347,
+            key="SBI-12347",
+            summary="P1 critical incident",
+            business_impact="High",
+            project_key="SBI",
+            reporter=jira_user,
+            incident=incident,
+        )
+
+        # P1 should correctly raise ValueError
+        with pytest.raises(
+            ValueError, match="This is a critical incident, not a raid incident"
+        ):
+            alert_slack_new_jira_ticket(
+                jira_ticket, reporter_user=user, reporter_email=user.email
+            )
+
+    def test_get_internal_alert_conversations_for_normal_impact(
+        self, raid_alert_channel_sbi  # noqa: ARG002 - fixture creates channel in DB
+    ):
+        """Test that get_internal_alert_conversations finds raid_alert__sbi_normal channel."""
+        # Create a JiraTicket with normal/N/A business impact for SBI project
+        jira_user = JiraUser.objects.create(id="jira-999", user=UserFactory())
+        jira_ticket = JiraTicket.objects.create(
+            id=99999,
+            key="SBI-99999",
+            summary="Test ticket",
+            business_impact="N/A",
+            project_key="SBI",
+            reporter=jira_user,
+        )
+
+        # Should find the raid_alert__sbi_normal channel
+        channels = get_internal_alert_conversations(jira_ticket)
+        channel_list = list(channels)
+
+        assert len(channel_list) == 1
+        assert channel_list[0].tag == "raid_alert__sbi_normal"
+        assert channel_list[0].name == "incidents"
+
+    def test_get_internal_alert_conversations_for_high_impact(self):
+        """Test that get_internal_alert_conversations finds raid_alert__sbi_high channel."""
+        # Create channel for high impact on SBI
+        Conversation.objects.create(
+            name="incidents-high-impact",
+            channel_id="C_INCIDENTS_HIGH",
+            tag="raid_alert__sbi_high",
+        )
+
+        # Create JiraTicket with High business impact for SBI
+        jira_user = JiraUser.objects.create(id="jira-998", user=UserFactory())
+        jira_ticket = JiraTicket.objects.create(
+            id=99998,
+            key="SBI-99998",
+            summary="Test high impact ticket",
+            business_impact="High",
+            project_key="SBI",
+            reporter=jira_user,
+        )
+
+        channels = get_internal_alert_conversations(jira_ticket)
+        channel_list = list(channels)
+
+        assert len(channel_list) == 1
+        assert channel_list[0].tag == "raid_alert__sbi_high"

firefighter_tests/test_raid/test_raid_client.py

@@ -368,6 +368,38 @@ class TestRaidJiraClientBasics:
                 priority=1,
             )
 
+    def test_create_issue_zendesk_field_mapping(self, mock_jira_client):
+        """Test that zendesk_ticket_id is correctly mapped to customfield_10895."""
+        mock_issue = Mock()
+        mock_issue.raw = {
+            "id": "12355",
+            "key": "TEST-130",
+            "fields": {
+                "summary": "Test zendesk mapping",
+                "description": "Test description",
+                "reporter": {"accountId": "reporter123"},
+                "issuetype": {"name": "Bug"},
+            },
+        }
+        mock_jira_client.jira.create_issue.return_value = mock_issue
+
+        result = mock_jira_client.create_issue(
+            issuetype="Bug",
+            summary="Test zendesk mapping",
+            description="Test description",
+            assignee=None,
+            reporter="test_reporter",
+            priority=1,
+            zendesk_ticket_id="ZD-98765",
+        )
+
+        # Verify create_issue was called with customfield_10895
+        call_kwargs = mock_jira_client.jira.create_issue.call_args[1]
+        assert "customfield_10895" in call_kwargs
+        assert call_kwargs["customfield_10895"] == "ZD-98765"
+        assert result["id"] == 12355
+        assert result["key"] == "TEST-130"
+
     def test_jira_object_static_method(self):
         """Test _jira_object static method."""
         test_issue = {

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

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"

firefighter_tests/test_slack/views/modals/test_update_status.py

@@ -331,28 +331,26 @@ class TestUpdateStatusModal:
         trigger_incident_workflow.assert_not_called()
 
     @staticmethod
-    def test_can_close_when_all_conditions_met(mocker: MockerFixture) -> None:
+    def test_can_close_when_all_conditions_met(mocker: MockerFixture, priority_factory, environment_factory) -> None:
         """Test that closing is allowed when all conditions are met for P3+ incidents."""
         # Create a user first
         user = UserFactory.build()
         user.save()
 
+        # Create P3 priority (needs_postmortem=False) and non-PRD environment
+        p3_priority = priority_factory(value=3, name="P3", needs_postmortem=False)
+        stg_environment = environment_factory(value="STG", name="Staging")
+
         # Create a P3+ incident in MITIGATED status with all conditions met
         incident = IncidentFactory.build(
             _status=IncidentStatus.MITIGATED,
             created_by=user,
+            priority=p3_priority,
+            environment=stg_environment,
         )
         # IMPORTANT: Save the incident so it has an ID for the form to reference
         incident.save()
 
-        # Mock needs_postmortem to return False (P3+ incident)
-        mocker.patch.object(
-            type(incident),
-            "needs_postmortem",
-            new_callable=PropertyMock,
-            return_value=False
-        )
-
         # Mock can_be_closed to return True (all conditions met)
         mocker.patch.object(
             type(incident),