firefighter-incident 0.0.18__tar.gz → 0.0.20__tar.gz

{firefighter_incident-0.0.18 → firefighter_incident-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.18
+Version: 0.0.20
 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 → firefighter_incident-0.0.20}/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.20'
+__version_tuple__ = version_tuple = (0, 0, 20)
 
 __commit_id__ = commit_id = None

{firefighter_incident-0.0.18 → firefighter_incident-0.0.20}/firefighter/incidents/forms/select_impact.py

@@ -71,7 +71,7 @@ class SelectImpactForm(forms.Form):
                 if impact_name.impact_type.name == "Business Impact":
                     impact_value = impact_name.value
 
-        return LevelChoices(impact_value).label if impact_value else None
+        return str(LevelChoices(impact_value).label) if impact_value else None
 
     def save(self, incident: HasImpactProtocol) -> None:
         """Save the impact choices to the incident."""

{firefighter_incident-0.0.18 → firefighter_incident-0.0.20}/firefighter/jira_app/client.py

@@ -254,14 +254,24 @@ class JiraClient:
             ValueError: Empty issue id
 
         Returns:
-            list(JiraAPIUser): List of Jira users object
+            list(JiraAPIUser): List of Jira users object, or empty list if ticket doesn't exist
         """
-        watchers = self.jira.watchers(jira_issue_id).raw.get("watchers")
-        if len(watchers) == 0:
-            logger.warning(
-                "Watchers not found for jira_account_id '%s'.", jira_issue_id
-            )
-        return watchers
+        try:
+            watchers = self.jira.watchers(jira_issue_id).raw.get("watchers")
+        except exceptions.JIRAError as e:
+            if e.status_code == 404:
+                logger.warning(
+                    "Jira ticket %s not found or no permission to access it. Cannot fetch watchers.",
+                    jira_issue_id,
+                )
+                return []
+            raise
+        else:
+            if len(watchers) == 0:
+                logger.debug(
+                    "No watchers found for jira_issue_id '%s'.", jira_issue_id
+                )
+            return watchers
 
     @staticmethod
     def _create_user_from_jira_info(

{firefighter_incident-0.0.18 → firefighter_incident-0.0.20}/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_incident-0.0.18 → firefighter_incident-0.0.20}/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_incident-0.0.18 → firefighter_incident-0.0.20}/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.20/firefighter_tests/test_jira_app/__init__.py

@@ -0,0 +1 @@
+"""Tests for jira_app module."""

firefighter_incident-0.0.20/firefighter_tests/test_jira_app/conftest.py

@@ -0,0 +1,24 @@
+"""Fixtures for jira_app tests."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from firefighter.jira_app.client import JiraClient
+
+
+@pytest.fixture
+def mock_jira_api():
+    """Create a mock JIRA API object."""
+    return Mock()
+
+
+@pytest.fixture
+def jira_client(mock_jira_api):
+    """Create a JiraClient with mocked JIRA API."""
+    with patch("firefighter.jira_app.client.JIRA", return_value=mock_jira_api):
+        client = JiraClient()
+        client.jira = mock_jira_api
+        return client

firefighter_incident-0.0.20/firefighter_tests/test_jira_app/test_jira_client_watchers.py

@@ -0,0 +1,135 @@
+"""Tests for JiraClient.get_watchers_from_jira_ticket method."""
+
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+import pytest
+from jira.exceptions import JIRAError
+
+
+@pytest.mark.django_db
+class TestGetWatchersFromJiraTicket:
+    """Test get_watchers_from_jira_ticket method."""
+
+    def test_get_watchers_success_with_watchers(self, jira_client, mock_jira_api):
+        """Test successful retrieval of watchers when watchers exist."""
+        # Given
+        mock_watchers_response = Mock()
+        mock_watchers_response.raw = {
+            "watchers": [
+                {"accountId": "user1", "displayName": "User One"},
+                {"accountId": "user2", "displayName": "User Two"},
+            ]
+        }
+        mock_jira_api.watchers.return_value = mock_watchers_response
+
+        # When
+        result = jira_client.get_watchers_from_jira_ticket(12345)
+
+        # Then
+        mock_jira_api.watchers.assert_called_once_with(12345)
+        assert len(result) == 2
+        assert result[0]["accountId"] == "user1"
+        assert result[1]["accountId"] == "user2"
+
+    def test_get_watchers_success_empty_list(
+        self, jira_client, mock_jira_api, caplog
+    ):
+        """Test successful retrieval when no watchers exist."""
+        # Given
+        mock_watchers_response = Mock()
+        mock_watchers_response.raw = {"watchers": []}
+        mock_jira_api.watchers.return_value = mock_watchers_response
+
+        # When
+        result = jira_client.get_watchers_from_jira_ticket(12345)
+
+        # Then
+        mock_jira_api.watchers.assert_called_once_with(12345)
+        assert result == []
+        # Should log debug message
+        assert "No watchers found for jira_issue_id '12345'" in caplog.text
+
+    def test_get_watchers_404_ticket_not_found(
+        self, jira_client, mock_jira_api, caplog
+    ):
+        """Test handling of 404 error when ticket doesn't exist."""
+        # Given
+        jira_error = JIRAError(
+            status_code=404,
+            text="Issue does not exist or you do not have permission to see it.",
+            url="https://jira.example.com/rest/api/2/issue/404295/watchers",
+        )
+        mock_jira_api.watchers.side_effect = jira_error
+
+        # When
+        result = jira_client.get_watchers_from_jira_ticket(404295)
+
+        # Then
+        mock_jira_api.watchers.assert_called_once_with(404295)
+        assert result == []
+        # Should log warning
+        assert (
+            "Jira ticket 404295 not found or no permission to access it"
+            in caplog.text
+        )
+
+    def test_get_watchers_404_no_permission(self, jira_client, mock_jira_api, caplog):
+        """Test handling of 404 error when bot has no permission."""
+        # Given
+        jira_error = JIRAError(
+            status_code=404,
+            text="Issue does not exist or you do not have permission to see it.",
+            url="https://jira.example.com/rest/api/2/issue/999999/watchers",
+        )
+        mock_jira_api.watchers.side_effect = jira_error
+
+        # When
+        result = jira_client.get_watchers_from_jira_ticket("999999")
+
+        # Then
+        assert result == []
+        assert "not found or no permission" in caplog.text
+
+    def test_get_watchers_other_jira_error_raised(self, jira_client, mock_jira_api):
+        """Test that non-404 JIRA errors are re-raised."""
+        # Given
+        jira_error = JIRAError(
+            status_code=500, text="Internal Server Error", url="https://jira.example.com"
+        )
+        mock_jira_api.watchers.side_effect = jira_error
+
+        # When / Then
+        with pytest.raises(JIRAError) as exc_info:
+            jira_client.get_watchers_from_jira_ticket(12345)
+
+        assert exc_info.value.status_code == 500
+
+    def test_get_watchers_403_error_raised(self, jira_client, mock_jira_api):
+        """Test that 403 (Forbidden) errors are re-raised."""
+        # Given
+        jira_error = JIRAError(
+            status_code=403, text="Forbidden", url="https://jira.example.com"
+        )
+        mock_jira_api.watchers.side_effect = jira_error
+
+        # When / Then
+        with pytest.raises(JIRAError) as exc_info:
+            jira_client.get_watchers_from_jira_ticket(12345)
+
+        assert exc_info.value.status_code == 403
+
+    def test_get_watchers_with_string_id(self, jira_client, mock_jira_api):
+        """Test get_watchers with string issue ID."""
+        # Given
+        mock_watchers_response = Mock()
+        mock_watchers_response.raw = {"watchers": [{"accountId": "user1"}]}
+        mock_jira_api.watchers.return_value = mock_watchers_response
+
+        # When
+        result = jira_client.get_watchers_from_jira_ticket("INCIDENT-123")
+
+        # Then
+        mock_jira_api.watchers.assert_called_once_with("INCIDENT-123")
+        assert len(result) == 1

firefighter_incident-0.0.20/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_incident-0.0.18 → firefighter_incident-0.0.20}/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_incident-0.0.18 → firefighter_incident-0.0.20}/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