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

firefighter_tests/test_incidents/test_forms/test_update_status_workflow.py

@@ -0,0 +1,343 @@
+"""Test the status workflow logic for update status form."""
+from __future__ import annotations
+
+import pytest
+from django.apps import apps
+from django.test import TestCase
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory
+from firefighter.incidents.forms.update_status import UpdateStatusForm
+from firefighter.incidents.models import Environment, Priority
+
+
+@pytest.mark.django_db
+class TestUpdateStatusWorkflow(TestCase):
+    """Test that status choices respect workflow rules."""
+
+    def test_p1_p2_cannot_skip_postmortem(self):
+        """P1/P2 incidents cannot go directly from Mitigated to Closed."""
+
+        # Get existing P1 or P2 priority that needs post-mortem
+        p1_priority = Priority.objects.filter(
+            value=1, needs_postmortem=True
+        ).first()
+
+        if not p1_priority:
+            # If P1 doesn't exist, try P2
+            p1_priority = Priority.objects.filter(
+                value=2, needs_postmortem=True
+            ).first()
+
+        if not p1_priority:
+            # Skip test if no priority needing postmortem exists
+            pytest.skip("No P1/P2 priority with needs_postmortem=True found in database")
+
+        # Get PRD environment (required for needs_postmortem to be True)
+        prd_env = Environment.objects.filter(value="PRD").first()
+        if not prd_env:
+            pytest.skip("No PRD environment found in database")
+
+        # Create an incident with P1/P2 priority in Mitigated status with PRD env
+        incident = IncidentFactory.create(
+            priority=p1_priority,
+            environment=prd_env,
+            _status=IncidentStatus.MITIGATED,
+        )
+
+        # Note: incident.needs_postmortem also requires firefighter.confluence to be installed
+        # For testing, we'll check the underlying conditions directly
+        if apps.is_installed("firefighter.confluence"):
+            assert incident.needs_postmortem, "Incident should need postmortem (P1/P2 + PRD)"
+
+        # Create form with the incident
+        form = UpdateStatusForm(incident=incident)
+
+        # Check that CLOSED is not in the choices
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.CLOSED not in status_choices
+        assert IncidentStatus.POST_MORTEM in status_choices
+
+    def test_p1_p2_can_close_from_postmortem(self):
+        """P1/P2 incidents can go from Post-mortem to Closed."""
+
+        # Get existing P1 or P2 priority that needs post-mortem
+        p2_priority = Priority.objects.filter(
+            value__in=[1, 2], needs_postmortem=True
+        ).first()
+
+        if not p2_priority:
+            pytest.skip("No P1/P2 priority with needs_postmortem=True found in database")
+
+        # Get PRD environment
+        prd_env = Environment.objects.filter(value="PRD").first()
+        if not prd_env:
+            pytest.skip("No PRD environment found in database")
+
+        # Create an incident with P1/P2 priority in Post-mortem status with PRD env
+        incident = IncidentFactory.create(
+            priority=p2_priority,
+            environment=prd_env,
+            _status=IncidentStatus.POST_MORTEM,
+        )
+
+        # Create form with the incident
+        form = UpdateStatusForm(incident=incident)
+
+        # Check that CLOSED is in the choices
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.CLOSED in status_choices
+
+    def test_p3_plus_can_skip_postmortem(self):
+        """P3+ incidents can go directly from Mitigated to Closed and should not have post-mortem."""
+        # Get existing P3+ priority that doesn't need post-mortem
+        p3_priority = Priority.objects.filter(
+            value__gte=3, needs_postmortem=False
+        ).first()
+
+        if not p3_priority:
+            # If no P3+ without postmortem, skip the test
+            pytest.skip("No P3+ priority with needs_postmortem=False found in database")
+
+        # Create an incident with P3+ priority in Mitigated status
+        incident = IncidentFactory.create(
+            priority=p3_priority,
+            _status=IncidentStatus.MITIGATED,
+        )
+
+        # Create form with the incident
+        form = UpdateStatusForm(incident=incident)
+
+        # Check that CLOSED is in the choices for P3+ but POST_MORTEM is NOT
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.CLOSED in status_choices
+        assert IncidentStatus.POST_MORTEM not in status_choices, "P3+ incidents should not have post-mortem status available"
+
+    def test_p1_p2_cannot_skip_postmortem_from_mitigating(self):
+        """P1/P2 incidents cannot go directly from Mitigating to Closed."""
+
+        # Get existing P1 or P2 priority that needs post-mortem
+        p1_priority = Priority.objects.filter(
+            value__in=[1, 2], needs_postmortem=True
+        ).first()
+
+        if not p1_priority:
+            pytest.skip("No P1/P2 priority with needs_postmortem=True found in database")
+
+        # Get PRD environment (required for needs_postmortem to be True)
+        prd_env = Environment.objects.filter(value="PRD").first()
+        if not prd_env:
+            pytest.skip("No PRD environment found in database")
+
+        # Create an incident with P1/P2 priority in MITIGATING (Mitigating) status with PRD env
+        incident = IncidentFactory.create(
+            priority=p1_priority,
+            environment=prd_env,
+            _status=IncidentStatus.MITIGATING,  # Test from MITIGATING (Mitigating), not MITIGATED
+        )
+
+        # Create form with the incident
+        form = UpdateStatusForm(incident=incident)
+
+        # Check that CLOSED and POST_MORTEM are not in the choices from MITIGATING status
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.CLOSED not in status_choices
+        assert IncidentStatus.POST_MORTEM not in status_choices, "P1/P2 should not be able to go to post-mortem from Mitigating"
+
+    def test_p3_can_skip_from_investigating_to_closed(self):
+        """P3+ incidents can go directly from Investigating to Closed."""
+        # Get existing P3+ priority that doesn't need post-mortem
+        p3_priority = Priority.objects.filter(
+            value__gte=3, needs_postmortem=False
+        ).first()
+
+        if not p3_priority:
+            pytest.skip("No P3+ priority with needs_postmortem=False found in database")
+
+        # Create an incident with P3+ priority in INVESTIGATING status
+        incident = IncidentFactory.create(
+            priority=p3_priority,
+            _status=IncidentStatus.INVESTIGATING,  # Test from INVESTIGATING
+        )
+
+        # Create form with the incident
+        form = UpdateStatusForm(incident=incident)
+
+        # Check that CLOSED is in the choices from INVESTIGATING status for P3+ but POST_MORTEM is NOT
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.CLOSED in status_choices
+        assert IncidentStatus.POST_MORTEM not in status_choices, "P3+ incidents should not have post-mortem status available"
+
+    def test_p1_p2_can_go_from_mitigated_to_postmortem(self):
+        """P1/P2 incidents can go from Mitigated to Post-mortem."""
+
+        # Get existing P1 or P2 priority that needs post-mortem
+        p1_priority = Priority.objects.filter(
+            value__in=[1, 2], needs_postmortem=True
+        ).first()
+
+        if not p1_priority:
+            pytest.skip("No P1/P2 priority with needs_postmortem=True found in database")
+
+        # Get PRD environment
+        prd_env = Environment.objects.filter(value="PRD").first()
+        if not prd_env:
+            pytest.skip("No PRD environment found in database")
+
+        # Create an incident with P1/P2 priority in Mitigated status with PRD env
+        incident = IncidentFactory.create(
+            priority=p1_priority,
+            environment=prd_env,
+            _status=IncidentStatus.MITIGATED,  # MITIGATED = "Mitigated"
+        )
+
+        # Create form with the incident
+        form = UpdateStatusForm(incident=incident)
+
+        # Check that POST_MORTEM is available but CLOSED is not
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.POST_MORTEM in status_choices, "P1/P2 should be able to go to Post-mortem from Mitigated"
+        assert IncidentStatus.CLOSED not in status_choices, "P1/P2 should NOT be able to skip Post-mortem"
+
+    def test_complete_workflow_transitions_p3_plus(self):
+        """Test the correct workflow for P3+: can close with reason from early statuses, normal close from Mitigated."""
+        # Get P3+ priority
+        p3_priority = Priority.objects.filter(
+            value__gte=3, needs_postmortem=False
+        ).first()
+
+        if not p3_priority:
+            pytest.skip("No P3+ priority found")
+
+        # Test workflow for P3+
+        test_cases = [
+            (IncidentStatus.OPEN, True),           # Can close with reason
+            (IncidentStatus.INVESTIGATING, True),  # Can close with reason
+            (IncidentStatus.MITIGATING, False),        # Cannot close from Mitigating (must go to Mitigated first)
+            (IncidentStatus.MITIGATED, True),          # Can close normally from Mitigated
+        ]
+
+        for current_status, should_have_closed in test_cases:
+            incident = IncidentFactory.create(
+                priority=p3_priority,
+                _status=current_status,
+            )
+
+            form = UpdateStatusForm(incident=incident)
+            status_choices = dict(form.fields["status"].choices)
+
+            if should_have_closed:
+                assert IncidentStatus.CLOSED in status_choices, f"P3+ should be able to go to Closed from {current_status.label}"
+            else:
+                assert IncidentStatus.CLOSED not in status_choices, f"P3+ should NOT be able to go to Closed from {current_status.label}"
+
+            # P3+ should NEVER have post-mortem available
+            assert IncidentStatus.POST_MORTEM not in status_choices, f"P3+ should NEVER have post-mortem available from {current_status.label}"
+
+    def test_closure_reason_required_from_early_statuses(self):
+        """Test that closure reason is required when closing from Opened or Investigating."""
+        # Test for both P1/P2 and P3+ priorities
+        priorities = [
+            Priority.objects.filter(value__in=[1, 2]).first(),  # P1/P2
+            Priority.objects.filter(value__gte=3).first(),       # P3+
+        ]
+
+        for priority in priorities:
+            if not priority:
+                continue
+
+            # Test from Opened and Investigating
+            for status in [IncidentStatus.OPEN, IncidentStatus.INVESTIGATING]:
+                incident = IncidentFactory.create(
+                    priority=priority,
+                    _status=status,
+                )
+
+                # Check that requires_closure_reason returns True
+                assert UpdateStatusForm.requires_closure_reason(
+                    incident, IncidentStatus.CLOSED
+                ), f"Should require closure reason from {status.label} for {priority.name}"
+
+            # Test from other statuses - should NOT require reason
+            for status in [IncidentStatus.MITIGATING, IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM]:
+                incident = IncidentFactory.create(
+                    priority=priority,
+                    _status=status,
+                )
+
+                # Check that requires_closure_reason returns False
+                assert not UpdateStatusForm.requires_closure_reason(
+                    incident, IncidentStatus.CLOSED
+                ), f"Should NOT require closure reason from {status.label} for {priority.name}"
+
+    def test_cannot_close_from_mitigating(self):
+        """Test that incidents cannot be closed directly from Mitigating status."""
+        # Test for all priority levels
+        priorities = Priority.objects.all()
+
+        for priority in priorities:
+            incident = IncidentFactory.create(
+                priority=priority,
+                _status=IncidentStatus.MITIGATING,  # Mitigating status
+            )
+
+            form = UpdateStatusForm(incident=incident)
+            status_choices = dict(form.fields["status"].choices)
+
+            # Should NOT have Closed option from Mitigating
+            assert IncidentStatus.CLOSED not in status_choices, f"Should NOT be able to close from Mitigating for {priority.name}"
+
+            # Should have Post-mortem option only for P1/P2 priorities that need postmortem
+            if priority.needs_postmortem:
+                # For P1/P2, should still NOT have post-mortem from MITIGATING (Mitigating)
+                assert IncidentStatus.POST_MORTEM not in status_choices, f"P1/P2 should NOT be able to go to Post-mortem from Mitigating for {priority.name}"
+            else:
+                # For P3+, should not have post-mortem at all
+                assert IncidentStatus.POST_MORTEM not in status_choices, f"P3+ should not have post-mortem available for {priority.name}"
+
+    def test_no_incident_shows_all_statuses(self):
+        """When no incident is provided, all statuses should be available."""
+        # Create form without incident
+        form = UpdateStatusForm()
+
+        # Check that all statuses including CLOSED are in the choices
+        status_choices = dict(form.fields["status"].choices)
+        assert IncidentStatus.CLOSED in status_choices
+        assert IncidentStatus.POST_MORTEM in status_choices
+
+    def test_requires_closure_reason_non_closed_status(self):
+        """Test requires_closure_reason with non-CLOSED target status."""
+        incident = IncidentFactory.create(_status=IncidentStatus.OPEN)
+
+        # Should not require reason for non-CLOSED statuses
+        assert not UpdateStatusForm.requires_closure_reason(incident, IncidentStatus.INVESTIGATING)
+        assert not UpdateStatusForm.requires_closure_reason(incident, IncidentStatus.MITIGATING)
+        assert not UpdateStatusForm.requires_closure_reason(incident, IncidentStatus.MITIGATED)
+        assert not UpdateStatusForm.requires_closure_reason(incident, IncidentStatus.POST_MORTEM)
+
+    def test_incident_status_edge_cases(self):
+        """Test edge cases for incident status transitions."""
+        # Test with incident in default fallback case
+        p1_priority = Priority.objects.filter(
+            value__in=[1, 2], needs_postmortem=True
+        ).first()
+
+        if not p1_priority:
+            pytest.skip("No P1/P2 priority found")
+
+        prd_env = Environment.objects.filter(value="PRD").first()
+        if not prd_env:
+            pytest.skip("No PRD environment found")
+
+        # Create incident with an undefined status (should hit default case)
+        incident = IncidentFactory.create(
+            priority=p1_priority,
+            environment=prd_env,
+            _status=IncidentStatus.CLOSED  # Already closed
+        )
+
+        form = UpdateStatusForm(incident=incident)
+        status_choices = dict(form.fields["status"].choices)
+
+        # Should use default choices_lte for unknown/closed status
+        assert IncidentStatus.CLOSED in status_choices

firefighter_tests/test_incidents/test_forms/test_workflow_transitions.py

@@ -0,0 +1,167 @@
+"""Test complete workflow transitions according to the diagram.
+
+Workflow transitions:
+
+P1/P2:
+- OPEN → [INVESTIGATING, CLOSED (avec reason form)]
+- INVESTIGATING → [MITIGATING, CLOSED (avec reason form)]
+- MITIGATING → [MITIGATED]
+- MITIGATED → [POST_MORTEM]
+- POST_MORTEM → [CLOSED]
+
+P3/P4/P5:
+- OPEN → [INVESTIGATING, CLOSED (avec reason form)]
+- INVESTIGATING → [MITIGATING, CLOSED (avec reason form)]
+- MITIGATING → [MITIGATED]
+- MITIGATED → [CLOSED]
+"""
+from __future__ import annotations
+
+import pytest
+from django.test import TestCase
+
+from firefighter.incidents.enums import IncidentStatus
+from firefighter.incidents.factories import IncidentFactory
+from firefighter.incidents.forms.update_status import UpdateStatusForm
+from firefighter.incidents.models import Environment, Priority
+
+
+@pytest.mark.django_db
+class TestCompleteWorkflowTransitions(TestCase):
+    """Test that all workflow transitions are implemented correctly."""
+
+    def test_p1_p2_complete_workflow_transitions(self):
+        """Test all P1/P2 workflow transitions according to the diagram."""
+        # Get P1/P2 priority
+        p1_priority = Priority.objects.filter(
+            value__in=[1, 2], needs_postmortem=True
+        ).first()
+
+        if not p1_priority:
+            pytest.skip("No P1/P2 priority found")
+
+        prd_env = Environment.objects.filter(value="PRD").first()
+        if not prd_env:
+            pytest.skip("No PRD environment found")
+
+        # Test all transitions
+        transitions = [
+            # Test transitions from each status
+            (IncidentStatus.OPEN, [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]),
+            (IncidentStatus.INVESTIGATING, [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]),
+            (IncidentStatus.MITIGATING, [IncidentStatus.MITIGATED]),
+            (IncidentStatus.MITIGATED, [IncidentStatus.POST_MORTEM]),
+            (IncidentStatus.POST_MORTEM, [IncidentStatus.CLOSED]),
+        ]
+
+        for current_status, expected_statuses in transitions:
+            incident = IncidentFactory.create(
+                priority=p1_priority,
+                environment=prd_env,
+                _status=current_status,
+            )
+
+            form = UpdateStatusForm(incident=incident)
+            status_choices = dict(form.fields["status"].choices)
+            available_statuses = list(status_choices.keys())
+
+            # Remove current status from available (can't transition to same status)
+            if current_status in available_statuses:
+                available_statuses.remove(current_status)
+
+            for expected_status in expected_statuses:
+                assert expected_status in available_statuses, (
+                    f"P1/P2: From {current_status.label}, should be able to go to {expected_status.label}. "
+                    f"Available: {[IncidentStatus(s).label for s in available_statuses]}"
+                )
+
+            # Verify no unexpected statuses are available
+            unexpected_statuses = set(available_statuses) - set(expected_statuses)
+            assert not unexpected_statuses, (
+                f"P1/P2: From {current_status.label}, unexpected statuses available: "
+                f"{[IncidentStatus(s).label for s in unexpected_statuses]}"
+            )
+
+    def test_p3_plus_complete_workflow_transitions(self):
+        """Test all P3+ workflow transitions according to the diagram."""
+        # Get P3+ priority
+        p3_priority = Priority.objects.filter(
+            value__gte=3, needs_postmortem=False
+        ).first()
+
+        if not p3_priority:
+            pytest.skip("No P3+ priority found")
+
+        # Test all transitions
+        transitions = [
+            # Test transitions from each status
+            (IncidentStatus.OPEN, [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]),
+            (IncidentStatus.INVESTIGATING, [IncidentStatus.MITIGATING, IncidentStatus.CLOSED]),
+            (IncidentStatus.MITIGATING, [IncidentStatus.MITIGATED]),
+            (IncidentStatus.MITIGATED, [IncidentStatus.CLOSED]),
+        ]
+
+        for current_status, expected_statuses in transitions:
+            incident = IncidentFactory.create(
+                priority=p3_priority,
+                _status=current_status,
+            )
+
+            form = UpdateStatusForm(incident=incident)
+            status_choices = dict(form.fields["status"].choices)
+            available_statuses = list(status_choices.keys())
+
+            # Remove current status from available (can't transition to same status)
+            if current_status in available_statuses:
+                available_statuses.remove(current_status)
+
+            for expected_status in expected_statuses:
+                assert expected_status in available_statuses, (
+                    f"P3+: From {current_status.label}, should be able to go to {expected_status.label}. "
+                    f"Available: {[IncidentStatus(s).label for s in available_statuses]}"
+                )
+
+            # Verify no unexpected statuses are available (especially POST_MORTEM)
+            unexpected_statuses = set(available_statuses) - set(expected_statuses)
+            assert not unexpected_statuses, (
+                f"P3+: From {current_status.label}, unexpected statuses available: "
+                f"{[IncidentStatus(s).label for s in unexpected_statuses]}"
+            )
+
+            # Specifically verify POST_MORTEM is never available for P3+
+            assert IncidentStatus.POST_MORTEM not in available_statuses, (
+                f"P3+: POST_MORTEM should never be available, but found from {current_status.label}"
+            )
+
+    def test_closure_reason_requirements(self):
+        """Test that closure reason is required only from OPEN and INVESTIGATING."""
+        priorities = [
+            Priority.objects.filter(value__in=[1, 2]).first(),  # P1/P2
+            Priority.objects.filter(value__gte=3).first(),       # P3+
+        ]
+
+        for priority in priorities:
+            if not priority:
+                continue
+
+            # Should require reason from OPEN and INVESTIGATING
+            for status in [IncidentStatus.OPEN, IncidentStatus.INVESTIGATING]:
+                incident = IncidentFactory.create(
+                    priority=priority,
+                    _status=status,
+                )
+
+                assert UpdateStatusForm.requires_closure_reason(
+                    incident, IncidentStatus.CLOSED
+                ), f"Should require closure reason from {status.label} for {priority.name}"
+
+            # Should NOT require reason from other statuses
+            for status in [IncidentStatus.MITIGATING, IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM]:
+                incident = IncidentFactory.create(
+                    priority=priority,
+                    _status=status,
+                )
+
+                assert not UpdateStatusForm.requires_closure_reason(
+                    incident, IncidentStatus.CLOSED
+                ), f"Should NOT require closure reason from {status.label} for {priority.name}"

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