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

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