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

firefighter_tests/test_firefighter/test_sso.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+from django.contrib.auth.models import Group
+
+from firefighter.firefighter.sso import link_auth_user
+from firefighter.incidents.factories import UserFactory
+
+
+@pytest.mark.django_db
+class TestLinkAuthUser:
+    """Test cases for the link_auth_user function."""
+
+    def test_link_auth_user_no_roles_claim(self) -> None:
+        """Test that function returns early when no roles in claim."""
+        user = UserFactory.create()
+        claim = {"some_other_field": "value"}
+
+        link_auth_user(user, claim)
+
+        # No changes should be made
+        assert list(user.groups.all()) == []
+
+    def test_link_auth_user_roles_not_list(self) -> None:
+        """Test that function returns early when roles is not a list."""
+        user = UserFactory.create()
+        claim = {"roles": "not_a_list"}
+
+        link_auth_user(user, claim)
+
+        # No changes should be made
+        assert list(user.groups.all()) == []
+
+    def test_link_auth_user_with_back_office_role(self) -> None:
+        """Test that back_office role grants staff status."""
+        user = UserFactory.create(is_staff=False)
+        claim = {"roles": ["back_office", "other_role"]}
+
+        # Create a group for testing
+        Group.objects.create(name="other_role")
+
+        link_auth_user(user, claim)
+
+        user.refresh_from_db()
+        assert user.is_staff is True
+        # back_office should be removed from group assignment
+        assert list(user.groups.values_list("name", flat=True)) == ["other_role"]
+
+    def test_link_auth_user_back_office_already_staff(self) -> None:
+        """Test that back_office role doesn't change already staff user."""
+        user = UserFactory.create(is_staff=True)
+        claim = {"roles": ["back_office"]}
+
+        with patch.object(user, "save") as mock_save:
+            link_auth_user(user, claim)
+            # save() should not be called since user is already staff
+            mock_save.assert_not_called()
+
+    def test_link_auth_user_clears_existing_groups(self) -> None:
+        """Test that existing groups are cleared before adding new ones."""
+        user = UserFactory.create()
+        old_group = Group.objects.create(name="old_group")
+        new_group = Group.objects.create(name="new_group")
+
+        # Add user to old group
+        user.groups.add(old_group)
+        assert old_group in user.groups.all()
+
+        claim = {"roles": ["new_group"]}
+
+        link_auth_user(user, claim)
+
+        # Old group should be removed, new group added
+        assert list(user.groups.all()) == [new_group]
+
+    def test_link_auth_user_with_existing_groups(self) -> None:
+        """Test that multiple existing groups are added correctly."""
+        user = UserFactory.create()
+        group1 = Group.objects.create(name="group1")
+        group2 = Group.objects.create(name="group2")
+
+        claim = {"roles": ["group1", "group2"]}
+
+        link_auth_user(user, claim)
+
+        user_groups = list(user.groups.all())
+        assert group1 in user_groups
+        assert group2 in user_groups
+        assert len(user_groups) == 2
+
+    def test_link_auth_user_nonexistent_group_logs_warning(self, caplog) -> None:
+        """Test that nonexistent groups log a warning."""
+        user = UserFactory.create()
+        claim = {"roles": ["nonexistent_group"]}
+
+        with caplog.at_level("WARNING"):
+            link_auth_user(user, claim)
+
+        assert "Group nonexistent_group from SSO does not exist" in caplog.text
+        assert list(user.groups.all()) == []
+
+    def test_link_auth_user_mixed_existing_and_nonexistent_groups(self, caplog) -> None:
+        """Test with mix of existing and nonexistent groups."""
+        user = UserFactory.create()
+        existing_group = Group.objects.create(name="existing_group")
+
+        claim = {"roles": ["existing_group", "nonexistent_group"]}
+
+        with caplog.at_level("WARNING"):
+            link_auth_user(user, claim)
+
+        # Should add existing group and log warning for nonexistent
+        assert list(user.groups.all()) == [existing_group]
+        assert "Group nonexistent_group from SSO does not exist" in caplog.text
+
+    def test_link_auth_user_empty_roles_list(self) -> None:
+        """Test with empty roles list."""
+        user = UserFactory.create()
+        old_group = Group.objects.create(name="old_group")
+        user.groups.add(old_group)
+
+        claim = {"roles": []}
+
+        link_auth_user(user, claim)
+
+        # Groups should be cleared
+        assert list(user.groups.all()) == []
+
+    def test_link_auth_user_back_office_with_other_roles(self) -> None:
+        """Test back_office role with other roles in comprehensive scenario."""
+        user = UserFactory.create(is_staff=False)
+        admin_group = Group.objects.create(name="admin")
+        editor_group = Group.objects.create(name="editor")
+
+        claim = {"roles": ["back_office", "admin", "editor"]}
+
+        link_auth_user(user, claim)
+
+        user.refresh_from_db()
+        assert user.is_staff is True
+
+        user_groups = set(user.groups.all())
+        expected_groups = {admin_group, editor_group}
+        assert user_groups == expected_groups

firefighter_tests/test_incidents/test_enums.py

@@ -0,0 +1,100 @@
+"""Test the incidents enums module."""
+from __future__ import annotations
+
+from firefighter.incidents.enums import ClosureReason, IncidentStatus
+
+
+class TestIncidentStatus:
+    """Test IncidentStatus enum and its methods."""
+
+    def test_enum_values(self):
+        """Test that enum values are correctly defined."""
+        assert IncidentStatus.OPEN.value == 10
+        assert IncidentStatus.INVESTIGATING.value == 20
+        assert IncidentStatus.MITIGATING.value == 30
+        assert IncidentStatus.MITIGATED.value == 40
+        assert IncidentStatus.POST_MORTEM.value == 50
+        assert IncidentStatus.CLOSED.value == 60
+
+    def test_enum_labels(self):
+        """Test that enum labels are correctly defined."""
+        assert IncidentStatus.OPEN.label == "Open"
+        assert IncidentStatus.INVESTIGATING.label == "Investigating"
+        assert IncidentStatus.MITIGATING.label == "Mitigating"
+        assert IncidentStatus.MITIGATED.label == "Mitigated"
+        assert IncidentStatus.POST_MORTEM.label == "Post-mortem"
+        assert IncidentStatus.CLOSED.label == "Closed"
+
+    def test_lt_method(self):
+        """Test the lt static method."""
+        result = IncidentStatus.lt(30)
+        expected = [IncidentStatus.OPEN, IncidentStatus.INVESTIGATING]
+        assert result == expected
+
+    def test_lte_method(self):
+        """Test the lte static method."""
+        result = IncidentStatus.lte(30)
+        expected = [IncidentStatus.OPEN, IncidentStatus.INVESTIGATING, IncidentStatus.MITIGATING]
+        assert result == expected
+
+    def test_gt_method(self):
+        """Test the gt static method."""
+        result = IncidentStatus.gt(30)
+        expected = [IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM, IncidentStatus.CLOSED]
+        assert result == expected
+
+    def test_gte_method(self):
+        """Test the gte static method."""
+        result = IncidentStatus.gte(30)
+        expected = [IncidentStatus.MITIGATING, IncidentStatus.MITIGATED, IncidentStatus.POST_MORTEM, IncidentStatus.CLOSED]
+        assert result == expected
+
+    def test_choices_lt_method(self):
+        """Test the choices_lt static method."""
+        result = IncidentStatus.choices_lt(30)
+        expected = [(10, "Open"), (20, "Investigating")]
+        assert result == expected
+
+    def test_choices_lte_method(self):
+        """Test the choices_lte static method."""
+        result = IncidentStatus.choices_lte(30)
+        expected = [(10, "Open"), (20, "Investigating"), (30, "Mitigating")]
+        assert result == expected
+
+    def test_choices_lte_skip_postmortem_method(self):
+        """Test the choices_lte_skip_postmortem static method."""
+        result = IncidentStatus.choices_lte_skip_postmortem(60)
+        expected = [(10, "Open"), (20, "Investigating"), (30, "Mitigating"), (40, "Mitigated"), (60, "Closed")]
+        assert result == expected
+
+        # Test that POST_MORTEM is excluded
+        assert (50, "Post-mortem") not in result
+
+
+class TestClosureReason:
+    """Test ClosureReason enum."""
+
+    def test_enum_values(self):
+        """Test that closure reason values are correctly defined."""
+        assert ClosureReason.RESOLVED.value == "resolved"
+        assert ClosureReason.DUPLICATE.value == "duplicate"
+        assert ClosureReason.FALSE_POSITIVE.value == "false_positive"
+        assert ClosureReason.SUPERSEDED.value == "superseded"
+        assert ClosureReason.EXTERNAL.value == "external"
+        assert ClosureReason.CANCELLED.value == "cancelled"
+
+    def test_enum_labels(self):
+        """Test that closure reason labels are correctly defined."""
+        assert ClosureReason.RESOLVED.label == "Resolved normally"
+        assert ClosureReason.DUPLICATE.label == "Duplicate incident"
+        assert ClosureReason.FALSE_POSITIVE.label == "False alarm - no actual issue"
+        assert ClosureReason.SUPERSEDED.label == "Superseded by another incident"
+        assert ClosureReason.EXTERNAL.label == "External dependency/known issue"
+        assert ClosureReason.CANCELLED.label == "Cancelled - no longer relevant"
+
+    def test_choices_available(self):
+        """Test that choices are available."""
+        choices = ClosureReason.choices
+        assert len(choices) == 6
+        assert ("resolved", "Resolved normally") in choices
+        assert ("duplicate", "Duplicate incident") in choices

firefighter_tests/test_incidents/test_forms/conftest.py

@@ -0,0 +1,179 @@
+"""Fixtures for unified incident form tests."""
+from __future__ import annotations
+
+import pytest
+
+from firefighter.incidents.factories import (
+    IncidentCategoryFactory,
+    UserFactory,
+)
+from firefighter.incidents.models import Environment, Priority
+from firefighter.incidents.models.impact import ImpactLevel, ImpactType, LevelChoices
+from firefighter.jira_app.models import JiraUser
+
+
+@pytest.fixture
+def priority_factory(db):
+    """Factory to create Priority instances."""
+
+    def _create(**kwargs):
+        value = kwargs.get("value", 1)
+        name = kwargs.get("name", f"P{value}")
+        set_as_default = kwargs.get("default", False)
+
+        # If default=True, clear any other defaults first
+        if set_as_default:
+            Priority.objects.filter(default=True).update(default=False)
+
+        defaults = {
+            "emoji": "🔴",
+            "order": value,
+            "default": set_as_default,
+            "enabled_create": True,
+            "enabled_update": True,
+            "needs_postmortem": value <= 2,  # P1-P2 need postmortem
+        }
+        # Remove name and value from kwargs if present
+        kwargs_copy = kwargs.copy()
+        kwargs_copy.pop("name", None)
+        kwargs_copy.pop("value", None)
+        defaults.update(kwargs_copy)
+
+        priority, created = Priority.objects.get_or_create(
+            name=name,
+            value=value,
+            defaults=defaults,
+        )
+
+        # If already exists and we want it as default, just set that
+        if not created and set_as_default:
+            priority.default = True
+            priority.save(update_fields=["default"])
+
+        return priority
+
+    return _create
+
+
+@pytest.fixture
+def environment_factory(db):
+    """Factory to create Environment instances."""
+
+    def _create(**kwargs):
+        value = kwargs.get("value", "TST")
+        set_as_default = kwargs.get("default", False)
+
+        # If default=True, clear any other defaults first
+        if set_as_default:
+            Environment.objects.filter(default=True).update(default=False)
+
+        defaults = {
+            "description": f"Environment {value}",
+            "order": 1,
+            "default": set_as_default,
+        }
+        # Remove value and default from kwargs if present
+        kwargs_copy = kwargs.copy()
+        kwargs_copy.pop("value", None)
+        kwargs_copy.pop("default", None)
+        defaults.update(kwargs_copy)
+
+        environment, created = Environment.objects.get_or_create(
+            value=value,
+            defaults=defaults,
+        )
+
+        # If already exists and we want it as default, just set that
+        if not created and set_as_default:
+            environment.default = True
+            environment.save(update_fields=["default"])
+
+        return environment
+
+    return _create
+
+
+@pytest.fixture
+def impact_level_factory(db):
+    """Factory to create ImpactLevel instances."""
+
+    def _create(**kwargs):
+        # Handle impact__name syntax by extracting nested parameters
+        impact_type_data = {}
+        keys_to_remove = []
+        for key in list(kwargs.keys()):
+            if key.startswith("impact__"):
+                nested_key = key.split("__", 1)[1]
+                impact_type_data[nested_key] = kwargs[key]
+                keys_to_remove.append(key)
+        for key in keys_to_remove:
+            kwargs.pop(key)
+
+        # Create or get ImpactType
+        impact_type = kwargs.pop("impact_type", None)
+        if isinstance(impact_type, ImpactType):
+            pass  # Already have ImpactType instance
+        elif impact_type_data:
+            impact_type_name = impact_type_data.get("name", "Test Impact")
+            impact_type, _ = ImpactType.objects.get_or_create(name=impact_type_name, defaults={
+                "emoji": "📊",
+                "help_text": f"Test {impact_type_name} impact",
+                "value": impact_type_name.lower().replace(" ", "_"),
+                "order": 10,
+            })
+        else:
+            impact_type_name = "Test Impact"
+            impact_type, _ = ImpactType.objects.get_or_create(name=impact_type_name, defaults={
+                "emoji": "📊",
+                "help_text": "Test impact",
+                "value": "test_impact",
+                "order": 10,
+            })
+
+        # Handle value parameter
+        value = kwargs.pop("value", LevelChoices.LOW)
+
+        defaults = {
+            "impact_type": impact_type,
+            "value": value,
+            "name": value.label if hasattr(value, "label") else "Test Level",
+            "emoji": "📊",
+        }
+        defaults.update(kwargs)
+        return ImpactLevel.objects.create(**defaults)
+
+    return _create
+
+
+@pytest.fixture
+def incident_category_factory(db):
+    """Factory to create IncidentCategory instances."""
+
+    def _create(**kwargs):
+        return IncidentCategoryFactory(**kwargs)
+
+    return _create
+
+
+@pytest.fixture
+def user_factory(db):
+    """Factory to create User instances."""
+
+    def _create(**kwargs):
+        return UserFactory(**kwargs)
+
+    return _create
+
+
+@pytest.fixture
+def jira_user_factory(db):
+    """Factory to create JiraUser instances."""
+
+    def _create(**kwargs):
+        user = kwargs.pop("user", None)
+        if user is None:
+            user = UserFactory()
+        jira_id = kwargs.get("id", f"jira-{user.id}")
+        return JiraUser.objects.create(id=jira_id, user=user, **kwargs)
+
+    return _create

firefighter_tests/test_incidents/test_forms/test_closure_reason.py

@@ -0,0 +1,91 @@
+"""Test the closure reason form."""
+from __future__ import annotations
+
+import pytest
+from django.test import TestCase
+
+from firefighter.incidents.enums import ClosureReason
+from firefighter.incidents.forms.closure_reason import IncidentClosureReasonForm
+
+
+@pytest.mark.django_db
+class TestIncidentClosureReasonForm(TestCase):
+    """Test the IncidentClosureReasonForm."""
+
+    def test_form_initialization(self):
+        """Test that the form initializes correctly."""
+        form = IncidentClosureReasonForm()
+
+        # Check that all required fields are present
+        assert "closure_reason" in form.fields
+        assert "closure_reference" in form.fields
+        assert "message" in form.fields
+
+    def test_closure_reason_field_choices(self):
+        """Test that closure reason field has correct choices."""
+        form = IncidentClosureReasonForm()
+        closure_reason_field = form.fields["closure_reason"]
+
+        # Check that closure reasons are available (except RESOLVED which is excluded)
+        choices = dict(closure_reason_field.choices)
+        assert "resolved" not in choices  # RESOLVED is excluded
+        assert "duplicate" in choices
+        assert "false_positive" in choices
+        assert "superseded" in choices
+        assert "external" in choices
+        assert "cancelled" in choices
+
+    def test_valid_form_submission(self):
+        """Test form with valid data."""
+        data = {
+            "closure_reason": ClosureReason.DUPLICATE,  # Use a valid choice (not RESOLVED)
+            "closure_reference": "Fixed by restarting service",
+            "message": "The incident has been resolved by restarting the affected service."
+        }
+        form = IncidentClosureReasonForm(data=data)
+        assert form.is_valid(), f"Form errors: {form.errors}"
+
+    def test_form_with_minimal_data(self):
+        """Test form with minimal required data."""
+        data = {
+            "closure_reason": ClosureReason.DUPLICATE,
+            "message": "Duplicate of incident #123"
+        }
+        form = IncidentClosureReasonForm(data=data)
+        assert form.is_valid(), f"Form errors: {form.errors}"
+
+    def test_form_missing_closure_reason(self):
+        """Test form validation when closure_reason is missing."""
+        data = {
+            "message": "Test message"
+        }
+        form = IncidentClosureReasonForm(data=data)
+        assert not form.is_valid()
+        assert "closure_reason" in form.errors
+
+    def test_form_missing_message(self):
+        """Test form validation when message is missing."""
+        data = {
+            "closure_reason": ClosureReason.DUPLICATE
+        }
+        form = IncidentClosureReasonForm(data=data)
+        assert not form.is_valid()
+        assert "message" in form.errors
+
+    def test_message_field_constraints(self):
+        """Test message field length constraints."""
+        # Test valid message (no length constraints defined in the form)
+        data = {
+            "closure_reason": ClosureReason.DUPLICATE,
+            "message": "This is a valid message that meets the requirements."
+        }
+        form = IncidentClosureReasonForm(data=data)
+        assert form.is_valid(), f"Form errors: {form.errors}"
+
+    def test_form_excludes_resolved_reason(self):
+        """Test that RESOLVED is excluded from choices."""
+        form = IncidentClosureReasonForm()
+        choices = dict(form.fields["closure_reason"].choices)
+
+        # RESOLVED should be excluded for early closure forms
+        assert "resolved" not in choices

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