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

firefighter_tests/test_incidents/test_forms/test_form_utils.py

@@ -6,8 +6,8 @@ from django.forms import Form
 
 from firefighter.incidents.enums import IncidentStatus
 from firefighter.incidents.forms.utils import EnumChoiceField, GroupedModelChoiceField
-from firefighter.incidents.models.component import Component
 from firefighter.incidents.models.group import Group
+from firefighter.incidents.models.incident_category import IncidentCategory
 
 
 class EnumChoiceFieldForm(Form):
@@ -15,8 +15,8 @@ class EnumChoiceFieldForm(Form):
 
 
 class GroupedModelChoiceFieldForm(Form):
-    component = GroupedModelChoiceField(
-        choices_groupby="group", queryset=Component.objects.all()
+    incident_category = GroupedModelChoiceField(
+        choices_groupby="group", queryset=IncidentCategory.objects.all()
     )
 
 
@@ -26,10 +26,10 @@ def group() -> Group:
 
 
 @pytest.fixture
-def components(group: Group):
+def incident_categories(group: Group):
     return [
-        Component.objects.create(name="Issue category 1", group=group, order=1),
-        Component.objects.create(name="Issue category 2", group=group, order=2),
+        IncidentCategory.objects.create(name="Issue category 1", group=group, order=1),
+        IncidentCategory.objects.create(name="Issue category 2", group=group, order=2),
     ]
 
 
@@ -47,27 +47,27 @@ def test_enum_choice_field_invalid() -> None:
 
 
 @pytest.mark.django_db
-def test_grouped_model_choice_field_valid(components: list[Component]):
-    form = GroupedModelChoiceFieldForm({"component": components[0].id})
+def test_grouped_model_choice_field_valid(incident_categories: list[IncidentCategory]):
+    form = GroupedModelChoiceFieldForm({"incident_category": incident_categories[0].id})
     assert form.is_valid()
-    assert form.cleaned_data["component"] == components[0]
+    assert form.cleaned_data["incident_category"] == incident_categories[0]
 
 
 def test_grouped_model_choice_field_invalid() -> None:
-    form = GroupedModelChoiceFieldForm({"component": "non-existent-id"})
+    form = GroupedModelChoiceFieldForm({"incident_category": "non-existent-id"})
     assert not form.is_valid()
-    assert "component" in form.errors
+    assert "incident_category" in form.errors
 
 
 @pytest.fixture(scope="module")
 def test_grouped_model_choice_field_grouping(
-    components: list[Component],
+    incident_categories: list[IncidentCategory],
 ):
     form = GroupedModelChoiceFieldForm()
     grouped_choices = list(
-        form.fields["component"].iterator(field=form.fields["component"])
+        form.fields["incident_category"].iterator(field=form.fields["incident_category"])
     )
     assert len(grouped_choices) == 2  # One for the empty choice, and one for the group
-    assert grouped_choices[0] == ("", form.fields["component"].empty_label)
-    assert grouped_choices[1][0] == components[0].group
+    assert grouped_choices[0] == ("", form.fields["incident_category"].empty_label)
+    assert grouped_choices[1][0] == incident_categories[0].group
     assert len(grouped_choices[1][1]) == 2  # Two components in the group

firefighter_tests/test_incidents/test_incident_urls.py

@@ -100,9 +100,9 @@ def test_incident_create_unauthorized(client: Client) -> None:
 
 @pytest.mark.django_db
 @pytest.mark.usefixtures("_debug")
-def test_component_list(client: Client) -> None:
-    """This test ensures that the component list is accessible."""
-    response = client.get(reverse("incidents:component-list"))
+def test_incident_category_list(client: Client) -> None:
+    """This test ensures that the incident category list is accessible."""
+    response = client.get(reverse("incidents:incident-category-list"))
 
     assert response.status_code == 302
 

firefighter_tests/test_incidents/test_models/test_incident_category.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from datetime import timedelta
+
+import pytest
+from django.utils import timezone
+
+from firefighter.incidents.factories import GroupFactory, IncidentCategoryFactory
+from firefighter.incidents.models.incident_category import (
+    IncidentCategory,
+    IncidentCategoryFilterSet,
+    IncidentCategoryManager,
+)
+
+
+@pytest.mark.django_db
+class TestIncidentCategoryManager:
+    def test_queryset_with_mtbf_date_to_in_future(self):
+        """Test that date_to is clamped to now() when it's in the future."""
+        # Given
+        IncidentCategoryFactory()
+        manager = IncidentCategoryManager()
+        manager.model = IncidentCategory
+
+        # Create dates where date_to is in the future
+        now = timezone.now()
+        date_from = now - timedelta(days=10)
+        date_to = now + timedelta(days=5)  # Future date
+
+        # When
+        result = manager.queryset_with_mtbf(date_from, date_to)
+
+        # Then
+        assert result is not None
+        assert list(result) == list(result)  # Should not fail to execute
+
+    def test_queryset_with_mtbf_with_custom_queryset(self):
+        """Test that custom queryset parameter is used."""
+        # Given
+        category1 = IncidentCategoryFactory()
+        category2 = IncidentCategoryFactory()
+
+        manager = IncidentCategoryManager()
+        manager.model = IncidentCategory
+
+        # Create a custom queryset that filters only category1
+        custom_queryset = IncidentCategory.objects.filter(id=category1.id)
+
+        date_from = timezone.now() - timedelta(days=10)
+        date_to = timezone.now() - timedelta(days=1)
+
+        # When
+        result = manager.queryset_with_mtbf(date_from, date_to, queryset=custom_queryset)
+
+        # Then
+        assert category1 in result
+        assert category2 not in result
+
+    def test_search_with_none_queryset(self):
+        """Test search method when queryset is None."""
+        # Given
+        category = IncidentCategoryFactory(name="Test Category")
+
+        # When
+        result, is_empty = IncidentCategoryManager.search(None, "Test")
+
+        # Then
+        assert is_empty is False
+        assert category in result
+
+    def test_search_with_empty_search_term(self):
+        """Test search method with empty/None search term."""
+        # Given
+        IncidentCategoryFactory(name="Category One")
+        IncidentCategoryFactory(name="Category Two")
+        queryset = IncidentCategory.objects.all()
+
+        # When - Test with None
+        result_none, is_empty_none = IncidentCategoryManager.search(queryset, None)
+
+        # When - Test with empty string
+        result_empty, is_empty_empty = IncidentCategoryManager.search(queryset, "")
+
+        # When - Test with whitespace
+        result_spaces, is_empty_spaces = IncidentCategoryManager.search(queryset, "   ")
+
+        # Then - All should return the original queryset
+        assert is_empty_none is False
+        assert is_empty_empty is False
+        assert is_empty_spaces is False
+
+        original_ids = set(queryset.values_list("id", flat=True))
+        assert set(result_none.values_list("id", flat=True)) == original_ids
+        assert set(result_empty.values_list("id", flat=True)) == original_ids
+        assert set(result_spaces.values_list("id", flat=True)) == original_ids
+
+    def test_search_with_valid_search_term(self):
+        """Test search method with valid search term."""
+        # Given
+        group = GroupFactory(name="Test Group", description="Group for testing")
+        category = IncidentCategoryFactory(
+            name="Infrastructure Issue",
+            description="Issues with infrastructure",
+            group=group
+        )
+        other_category = IncidentCategoryFactory(
+            name="Database Problem",
+            description="Database related issues"
+        )
+
+        # When - Search for "infrastructure"
+        result, is_empty = IncidentCategoryManager.search(None, "infrastructure")
+
+        # Then
+        assert is_empty is False
+        result_list = list(result)
+        assert category in result_list
+        # Note: other_category might also appear if search is broad
+
+        # When - Search for "database"
+        result_db, is_empty_db = IncidentCategoryManager.search(None, "database")
+
+        # Then
+        assert is_empty_db is False
+        result_db_list = list(result_db)
+        assert other_category in result_db_list
+
+
+@pytest.mark.django_db
+class TestIncidentCategoryFilterSet:
+    def test_incident_category_search(self):
+        """Test the incident_category_search filter method."""
+        # Given
+        category = IncidentCategoryFactory(name="Network Issues")
+        queryset = IncidentCategory.objects.all()
+
+        # When
+        result = IncidentCategoryFilterSet.incident_category_search(queryset, "search", "network")
+
+        # Then
+        assert category in result
+
+    def test_metrics_period_filter(self):
+        """Test the metrics period filter method."""
+        # Given
+        category = IncidentCategoryFactory()
+        queryset = IncidentCategory.objects.all()
+
+        # Create date range
+        now = timezone.now()
+        date_from = now - timedelta(days=30)
+        date_to = now
+        value = (date_from, date_to, None, None)
+
+        # When
+        result = IncidentCategoryFilterSet.metrics_period_filter(queryset, "metrics", value)
+
+        # Then
+        # Should return a queryset with mtbf annotation
+        assert result is not None
+        assert category in result
+
+        # Check that the mtbf annotation is present (will be None if no metrics)
+        category_with_mtbf = result.get(id=category.id)
+        assert hasattr(category_with_mtbf, "mtbf")

firefighter_tests/test_incidents/test_models/test_incident_model.py

@@ -20,8 +20,8 @@ class TestIncident(django.TestCase):
     @given(builds(IncidentFactory.build))
     def test_model_properties(self, instance: Incident) -> None:
         """Tests that instance can be saved and has correct representation."""
-        instance.component.group.save()
-        instance.component.save()
+        instance.incident_category.group.save()
+        instance.incident_category.save()
         instance.environment.save()
         instance.priority.save()
         instance.created_by.save()

firefighter_tests/test_raid/test_priority_mapping.py

@@ -0,0 +1,267 @@
+"""Test priority mapping from Impact to JIRA for all priority values including P5."""
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+from django.test import TestCase
+
+from firefighter.incidents.factories import (
+    IncidentFactory,
+    UserFactory,
+)
+from firefighter.incidents.models.priority import Priority
+from firefighter.jira_app.client import JiraAPIError, JiraUserNotFoundError
+from firefighter.jira_app.models import JiraUser
+from firefighter.raid.signals.incident_created import create_ticket
+from firefighter.slack.factories import IncidentChannelFactory
+
+
+class TestPriorityMapping(TestCase):
+    """Test priority mapping from Impact to JIRA including P5 support."""
+
+    def setUp(self):
+        """Set up test data."""
+        self.user = UserFactory()
+
+        # Create or get priorities P1-P5 (use get_or_create to avoid duplicates)
+        self.priority_p1, _ = Priority.objects.get_or_create(
+            value=1, defaults={"name": "Critical", "order": 1}
+        )
+        self.priority_p2, _ = Priority.objects.get_or_create(
+            value=2, defaults={"name": "High", "order": 2}
+        )
+        self.priority_p3, _ = Priority.objects.get_or_create(
+            value=3, defaults={"name": "Medium", "order": 3}
+        )
+        self.priority_p4, _ = Priority.objects.get_or_create(
+            value=4, defaults={"name": "Low", "order": 4}
+        )
+        self.priority_p5, _ = Priority.objects.get_or_create(
+            value=5, defaults={"name": "Lowest", "order": 5}
+        )
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_priority_p1_mapping(self, mock_get_jira_user, mock_client):
+        """Test P1 priority mapping to JIRA."""
+        self._test_priority_mapping(self.priority_p1, 1, mock_get_jira_user, mock_client)
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_priority_p2_mapping(self, mock_get_jira_user, mock_client):
+        """Test P2 priority mapping to JIRA."""
+        self._test_priority_mapping(self.priority_p2, 2, mock_get_jira_user, mock_client)
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_priority_p3_mapping(self, mock_get_jira_user, mock_client):
+        """Test P3 priority mapping to JIRA."""
+        self._test_priority_mapping(self.priority_p3, 3, mock_get_jira_user, mock_client)
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_priority_p4_mapping(self, mock_get_jira_user, mock_client):
+        """Test P4 priority mapping to JIRA."""
+        self._test_priority_mapping(self.priority_p4, 4, mock_get_jira_user, mock_client)
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_priority_p5_mapping(self, mock_get_jira_user, mock_client):
+        """Test P5 priority mapping to JIRA - this should now work with our fix."""
+        self._test_priority_mapping(self.priority_p5, 5, mock_get_jira_user, mock_client)
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_priority_invalid_value_fallback(self, mock_get_jira_user, mock_client):
+        """Test that invalid priority values fall back to P1."""
+        # Create a priority with an invalid value (>5)
+        invalid_priority, _ = Priority.objects.get_or_create(
+            value=6, defaults={"name": "Invalid", "order": 6}
+        )
+        self._test_priority_mapping(invalid_priority, 1, mock_get_jira_user, mock_client)  # Should fallback to 1
+
+    def _test_priority_mapping(self, priority: Priority, expected_jira_priority: int, mock_get_jira_user, mock_client):
+        """Helper method to test priority mapping."""
+        # Create a real JiraUser for testing
+        jira_user = JiraUser.objects.create(id="test-user-id", user=self.user)
+        mock_get_jira_user.return_value = jira_user
+
+        # Mock the create_issue return value (exclude watchers as it's a ManyToMany field)
+        mock_client.create_issue.return_value = {
+            "id": "123456",
+            "key": "TEST-123",
+            "assignee": None,
+            "reporter": jira_user,  # Return the actual JiraUser object
+            "issue_type": "Incident",
+            "project_key": "INCIDENT",
+            "description": "Test incident",
+            "summary": "Test Incident"
+        }
+        mock_client.get_jira_user_from_jira_id.return_value = jira_user
+        mock_client.jira.add_watcher = Mock()
+        mock_client.jira.remove_watcher = Mock()
+        mock_client.jira.add_simple_link = Mock()
+
+        # Create incident with the specific priority
+        incident = IncidentFactory(
+            priority=priority,
+            created_by=self.user,
+            title="Test Incident",
+            description="Test incident description"
+        )
+
+        # Create incident channel
+        channel = IncidentChannelFactory(incident=incident)
+        channel.add_bookmark = Mock()
+        channel.send_message_and_save = Mock()
+
+        # Call the create_ticket function
+        create_ticket(sender=None, incident=incident, channel=channel)
+
+        # Verify that create_issue was called with the expected priority
+        mock_client.create_issue.assert_called_once()
+        call_kwargs = mock_client.create_issue.call_args[1]
+
+        assert call_kwargs["priority"] == expected_jira_priority
+        assert call_kwargs["issuetype"] == "Incident"
+        assert call_kwargs["summary"] == "Test Incident"
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_create_ticket_no_issue_id_error(self, mock_get_jira_user, mock_client):
+        """Test error handling when create_issue returns no ID."""
+        test_user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-user-no-id", user=test_user)
+        mock_get_jira_user.return_value = jira_user
+
+        # Mock create_issue to return None ID (error case)
+        mock_client.create_issue.return_value = {
+            "id": None,  # This should trigger the error
+            "key": "TEST-123",
+            "summary": "Test Incident"
+        }
+
+        incident = IncidentFactory(
+            priority=self.priority_p1,
+            created_by=test_user,
+            title="Test Incident"
+        )
+        channel = IncidentChannelFactory(incident=incident)
+
+        # Should raise JiraAPIError
+        with pytest.raises(JiraAPIError):
+            create_ticket(sender=None, incident=incident, channel=channel)
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_create_ticket_jira_user_not_found_error(self, mock_get_jira_user, mock_client):
+        """Test error handling when default JIRA user is not found."""
+        test_user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-user-not-found", user=test_user)
+        mock_get_jira_user.return_value = jira_user
+
+        mock_client.create_issue.return_value = {
+            "id": "123456",
+            "key": "TEST-123",
+            "reporter": jira_user,
+            "summary": "Test Incident"
+        }
+
+        # Mock get_jira_user_from_jira_id to raise JiraUserNotFoundError
+        mock_client.get_jira_user_from_jira_id.side_effect = JiraUserNotFoundError("User not found")
+        mock_client.jira.add_watcher = Mock()
+        mock_client.jira.remove_watcher = Mock()
+        mock_client.jira.add_simple_link = Mock()
+
+        incident = IncidentFactory(
+            priority=self.priority_p1,
+            created_by=test_user,
+            title="Test Incident"
+        )
+        channel = IncidentChannelFactory(incident=incident)
+        channel.add_bookmark = Mock()
+        channel.send_message_and_save = Mock()
+
+        # Should complete without error despite the exception
+        create_ticket(sender=None, incident=incident, channel=channel)
+
+        # Verify the ticket was still created
+        mock_client.create_issue.assert_called_once()
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_create_ticket_add_watcher_error(self, mock_get_jira_user, mock_client):
+        """Test error handling when adding watcher fails."""
+        test_user = UserFactory()
+        default_user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-user-add-watcher", user=test_user)
+        default_jira_user = JiraUser.objects.create(id="default-user-add", user=default_user)
+        mock_get_jira_user.return_value = jira_user
+
+        mock_client.create_issue.return_value = {
+            "id": "123456",
+            "key": "TEST-123",
+            "reporter": jira_user,
+            "summary": "Test Incident"
+        }
+        mock_client.get_jira_user_from_jira_id.return_value = default_jira_user
+
+        # Mock add_watcher to raise JiraAPIError
+        mock_client.jira.add_watcher.side_effect = JiraAPIError("Cannot add watcher")
+        mock_client.jira.remove_watcher = Mock()
+        mock_client.jira.add_simple_link = Mock()
+
+        incident = IncidentFactory(
+            priority=self.priority_p1,
+            created_by=test_user,
+            title="Test Incident"
+        )
+        channel = IncidentChannelFactory(incident=incident)
+        channel.add_bookmark = Mock()
+        channel.send_message_and_save = Mock()
+
+        # Should complete without error despite the exception
+        create_ticket(sender=None, incident=incident, channel=channel)
+
+        # Verify remove_watcher was called as fallback
+        mock_client.jira.remove_watcher.assert_called_once()
+
+    @patch("firefighter.raid.signals.incident_created.client")
+    @patch("firefighter.raid.signals.incident_created.get_jira_user_from_user")
+    def test_create_ticket_remove_watcher_error(self, mock_get_jira_user, mock_client):
+        """Test error handling when removing default watcher fails."""
+        test_user = UserFactory()
+        default_user = UserFactory()
+        jira_user = JiraUser.objects.create(id="test-user-remove-watcher", user=test_user)
+        default_jira_user = JiraUser.objects.create(id="default-user-remove", user=default_user)
+        mock_get_jira_user.return_value = jira_user
+
+        mock_client.create_issue.return_value = {
+            "id": "123456",
+            "key": "TEST-123",
+            "reporter": jira_user,
+            "summary": "Test Incident"
+        }
+        mock_client.get_jira_user_from_jira_id.return_value = default_jira_user
+
+        # Mock both add_watcher and remove_watcher to raise JiraAPIError
+        mock_client.jira.add_watcher.side_effect = JiraAPIError("Cannot add watcher")
+        mock_client.jira.remove_watcher.side_effect = JiraAPIError("Cannot remove watcher")
+        mock_client.jira.add_simple_link = Mock()
+
+        incident = IncidentFactory(
+            priority=self.priority_p1,
+            created_by=test_user,
+            title="Test Incident"
+        )
+        channel = IncidentChannelFactory(incident=incident)
+        channel.add_bookmark = Mock()
+        channel.send_message_and_save = Mock()
+
+        # Should complete without error despite both exceptions
+        create_ticket(sender=None, incident=incident, channel=channel)
+
+        # Verify both operations were attempted
+        mock_client.jira.add_watcher.assert_called_once()
+        mock_client.jira.remove_watcher.assert_called_once()