firefighter-incident 0.0.28__tar.gz → 0.0.30__tar.gz

{firefighter_incident-0.0.28 → firefighter_incident-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firefighter-incident
-Version: 0.0.28
+Version: 0.0.30
 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.28 → firefighter_incident-0.0.30}/firefighter/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.28'
-__version_tuple__ = version_tuple = (0, 0, 28)
+__version__ = version = '0.0.30'
+__version_tuple__ = version_tuple = (0, 0, 30)
 
 __commit_id__ = commit_id = None

{firefighter_incident-0.0.28 → firefighter_incident-0.0.30}/firefighter/incidents/forms/update_status.py

@@ -43,9 +43,14 @@ class UpdateStatusForm(forms.Form):
         ),
     )
 
-    def __init__(self, *args: Any, incident: Incident | None = None, **kwargs: Any) -> None:
+    def __init__(
+        self, *args: Any, incident: Incident | None = None, **kwargs: Any
+    ) -> None:
         super().__init__(*args, **kwargs)
 
+        # Store incident for later use in clean()
+        self.incident = incident
+
         # Dynamically adjust status choices based on incident requirements
         if incident:
             self._set_status_choices(incident)
@@ -62,8 +67,9 @@ class UpdateStatusForm(forms.Form):
             and incident.priority.needs_postmortem
             and incident.environment.value == "PRD"
         )
-
-        allowed_statuses = self._get_allowed_statuses(current_status, requires_postmortem=requires_postmortem)
+        allowed_statuses = self._get_allowed_statuses(
+            current_status, requires_postmortem=requires_postmortem
+        )
 
         # If we got a list of enum values, convert to choices and include current status
         if allowed_statuses:
@@ -72,10 +78,6 @@ class UpdateStatusForm(forms.Form):
             # Convert values to strings to match what Slack sends in form submissions
             choices = [(str(s.value), s.label) for s in allowed_statuses]
             status_field.choices = choices  # type: ignore[attr-defined]
-            logger.debug(
-                f"Set status choices for incident #{incident.id}: {choices} "
-                f"(current_status={current_status}, requires_postmortem={requires_postmortem})"
-            )
 
     def _get_allowed_statuses(
         self, current_status: IncidentStatus, *, requires_postmortem: bool
@@ -84,19 +86,17 @@ class UpdateStatusForm(forms.Form):
 
         Returns None if choices should be set directly (for default fallback cases).
         """
-        status_field = self.fields["status"]
-
         # For incidents requiring post-mortem (P1/P2 in PRD)
         if requires_postmortem:
-            return self._get_postmortem_allowed_statuses(current_status, status_field)
+            return self._get_postmortem_allowed_statuses(current_status)
 
         # For P3+ incidents (no post-mortem needed)
-        return self._get_no_postmortem_allowed_statuses(current_status, status_field)
+        return self._get_no_postmortem_allowed_statuses(current_status)
 
     def _get_postmortem_allowed_statuses(
-        self, current_status: IncidentStatus, status_field: Any
+        self, current_status: IncidentStatus
     ) -> list[IncidentStatus] | None:
-        """Get allowed statuses for incidents requiring postmortem."""
+        """Get allowed statuses for incidents requiring postmortem (P1/P2)."""
         if current_status == IncidentStatus.OPEN:
             return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
         if current_status == IncidentStatus.INVESTIGATING:
@@ -104,18 +104,22 @@ class UpdateStatusForm(forms.Form):
         if current_status == IncidentStatus.MITIGATING:
             return [IncidentStatus.MITIGATED]
         if current_status == IncidentStatus.MITIGATED:
-            return [IncidentStatus.POST_MORTEM]
+            # P1/P2 can: go to POST_MORTEM (required) OR reopen to INVESTIGATING/MITIGATING (with reason)
+            return [
+                IncidentStatus.POST_MORTEM,      # Required next step
+                IncidentStatus.INVESTIGATING,   # Reopen option (with reason)
+                IncidentStatus.MITIGATING,      # Reopen option (with reason)
+            ]
         if current_status == IncidentStatus.POST_MORTEM:
             return [IncidentStatus.CLOSED]
 
-        # Default: all statuses up to closed
-        self._set_default_choices(status_field, current_status, IncidentStatus.choices_lte(IncidentStatus.CLOSED))
+        # For any other status, return None to use the default choices
         return None
 
     def _get_no_postmortem_allowed_statuses(
-        self, current_status: IncidentStatus, status_field: Any
+        self, current_status: IncidentStatus
     ) -> list[IncidentStatus] | None:
-        """Get allowed statuses for incidents not requiring postmortem."""
+        """Get allowed statuses for incidents not requiring postmortem (P3/P4/P5)."""
         if current_status == IncidentStatus.OPEN:
             return [IncidentStatus.INVESTIGATING, IncidentStatus.CLOSED]
         if current_status == IncidentStatus.INVESTIGATING:
@@ -123,12 +127,14 @@ class UpdateStatusForm(forms.Form):
         if current_status == IncidentStatus.MITIGATING:
             return [IncidentStatus.MITIGATED]
         if current_status == IncidentStatus.MITIGATED:
-            return [IncidentStatus.CLOSED]
-
-        # Default fallback
-        self._set_default_choices(
-            status_field, current_status, IncidentStatus.choices_lte_skip_postmortem(IncidentStatus.CLOSED)
-        )
+            # P3/P4/P5 can: go to CLOSED (normal next step) OR reopen to INVESTIGATING/MITIGATING (with reason)
+            return [
+                IncidentStatus.CLOSED,          # Normal next step for P3+
+                IncidentStatus.INVESTIGATING,   # Reopen option (with reason)
+                IncidentStatus.MITIGATING,      # Reopen option (with reason)
+            ]
+
+        # For any other status, return None to use the default choices
         return None
 
     def _set_default_choices(
@@ -136,14 +142,21 @@ class UpdateStatusForm(forms.Form):
     ) -> None:
         """Set status field choices to default, ensuring current status is included."""
         # Convert default_choices to string keys to match Slack form submissions
-        status_field.choices = [(str(choice[0]), choice[1]) for choice in default_choices]
+        status_field.choices = [
+            (str(choice[0]), choice[1]) for choice in default_choices
+        ]
         existing_values = {choice[0] for choice in status_field.choices}
         if str(current_status.value) not in existing_values:
             # Insert current status at the beginning
-            status_field.choices = [(str(current_status.value), current_status.label), *status_field.choices]
+            status_field.choices = [
+                (str(current_status.value), current_status.label),
+                *status_field.choices,
+            ]
 
     @staticmethod
-    def requires_closure_reason(incident: Incident, target_status: IncidentStatus) -> bool:
+    def requires_closure_reason(
+        incident: Incident, target_status: IncidentStatus
+    ) -> bool:
         """Check if closing this incident to the target status requires a closure reason.
 
         Based on the workflow diagram:
@@ -155,4 +168,39 @@ class UpdateStatusForm(forms.Form):
         current_status = incident.status
 
         # Require reason if closing from Opened or Investigating (for any priority)
-        return current_status.value in {IncidentStatus.OPEN, IncidentStatus.INVESTIGATING}
+        return current_status.value in {
+            IncidentStatus.OPEN,
+            IncidentStatus.INVESTIGATING,
+        }
+
+    def clean_message(self) -> str:
+        """Validate message field, ensuring reopening from MITIGATED has sufficient justification."""
+        message = self.cleaned_data.get("message", "").strip()
+
+        # Get the incident and status from form data/initialization
+        incident = getattr(self, "incident", None)
+        status_value = self.data.get("status")  # Use raw form data as cleaned_data may not be ready yet
+
+        if incident and status_value:
+            current_status = incident.status
+
+            # Convert status value to enum if it's a string/number
+            try:
+                if isinstance(status_value, str):
+                    status = IncidentStatus(int(status_value))
+                else:
+                    status = IncidentStatus(status_value)
+            except (ValueError, TypeError):
+                # Invalid status value, let other validation handle it
+                return message
+
+            # If reopening from MITIGATED to earlier phases, require substantial justification
+            if (current_status == IncidentStatus.MITIGATED and
+                status in {IncidentStatus.INVESTIGATING, IncidentStatus.MITIGATING} and
+                len(message) < 10):
+                raise forms.ValidationError(
+                    "A detailed justification (minimum 10 characters) is required when reopening "
+                    "an incident from MITIGATED status."
+                )
+
+        return message

{firefighter_incident-0.0.28 → firefighter_incident-0.0.30}/firefighter/incidents/views/views.py

@@ -82,7 +82,9 @@ class IncidentStatisticsView(FilterView):
     filterset_class = IncidentFilterSet
     model = Incident
     queryset = (
-        Incident.objects.select_related("priority", "incident_category__group", "environment")
+        Incident.objects.select_related(
+            "priority", "incident_category__group", "environment"
+        )
         .all()
         .order_by("-id")
     )
@@ -123,7 +125,9 @@ class DashboardView(generic.ListView[Incident]):
     )
     queryset = (
         Incident.objects.filter(_status__lt=IncidentStatus.CLOSED)
-        .select_related("priority", "incident_category__group", "environment", "created_by")
+        .select_related(
+            "priority", "incident_category__group", "environment", "created_by"
+        )
         .order_by("_status", "priority__value")
         .annotate(latest_event_ts=Subquery(sub.values("event_ts")))
     )
@@ -148,10 +152,22 @@ class IncidentDetailView(CustomDetailView[Incident]):
         "conversation",
         "created_by",
     ]
-    if settings.ENABLE_CONFLUENCE:
-        select_related.append("postmortem_for")
-    if getattr(settings, "ENABLE_JIRA_POSTMORTEM", False):
-        select_related.append("jira_postmortem_for")
+
+    # Always load post-mortem relationships to display existing data
+    # even if creation is disabled
+    try:
+        # Only add if confluence app is installed
+        if "firefighter.confluence" in settings.INSTALLED_APPS:
+            select_related.append("postmortem_for")
+    except ImportError:
+        pass
+
+    try:
+        # Only add if jira_app is installed
+        if "firefighter.jira_app" in settings.INSTALLED_APPS:
+            select_related.append("jira_postmortem_for")
+    except ImportError:
+        pass
     queryset = Incident.objects.select_related(*select_related).prefetch_related(
         Prefetch(
             "incidentupdate_set",

{firefighter_incident-0.0.28 → firefighter_incident-0.0.30}/firefighter/slack/messages/slack_messages.py

@@ -124,7 +124,10 @@ class SlackMessageIncidentPostMortemReminder(SlackMessageSurface):
                     ),
                 )
             )
-        elif hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+        elif (
+            hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for
+        ):
             jira_pm = self.incident.jira_postmortem_for
             blocks.append(
                 SectionBlock(
@@ -138,28 +141,30 @@ class SlackMessageIncidentPostMortemReminder(SlackMessageSurface):
             )
 
         # Continue with remaining steps
-        blocks.extend([
-            SectionBlock(
-                text=f"3. Submit the key events to {APP_DISPLAY_NAME}",
-                **accessory_kwargs,
-            ),
-            SectionBlock(
-                text="4. Once everything has been submitted, close the incident",
-                accessory=ButtonElement(
-                    text="Close incident",
-                    value=str(self.incident.id),
-                    action_id=CloseModal.open_action,
+        blocks.extend(
+            [
+                SectionBlock(
+                    text=f"3. Submit the key events to {APP_DISPLAY_NAME}",
+                    **accessory_kwargs,
                 ),
-            ),
-            DividerBlock(),
-            ContextBlock(
-                elements=[
-                    MarkdownTextObject(
-                        text=":bulb: Updating the status and creating a post-mortem is crucial for the Platform Operations Report presented during the Tech Weekly."
-                    )
-                ]
-            ),
-        ])
+                SectionBlock(
+                    text="4. Once everything has been submitted, close the incident",
+                    accessory=ButtonElement(
+                        text="Close incident",
+                        value=str(self.incident.id),
+                        action_id=CloseModal.open_action,
+                    ),
+                ),
+                DividerBlock(),
+                ContextBlock(
+                    elements=[
+                        MarkdownTextObject(
+                            text=":bulb: Updating the status and creating a post-mortem is crucial for the Platform Operations Report presented during the Tech Weekly."
+                        )
+                    ]
+                ),
+            ]
+        )
 
         if POSTMORTEM_HELP_URL:
             blocks.insert(
@@ -223,11 +228,7 @@ class SlackMessageIncidentFixedNextActions(SlackMessageSurface):
                 postmortem_text += " on Jira."
 
             blocks.append(
-                ContextBlock(
-                    elements=[
-                        MarkdownTextObject(text=postmortem_text)
-                    ]
-                )
+                ContextBlock(elements=[MarkdownTextObject(text=postmortem_text)])
             )
 
         return blocks
@@ -261,11 +262,17 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
         if hasattr(self.incident, "custom_fields") and self.incident.custom_fields:
             custom_fields = self.incident.custom_fields
             if custom_fields.get("zendesk_ticket_id"):
-                fields.append(f":ticket: *Zendesk Ticket:* {custom_fields['zendesk_ticket_id']}")
+                fields.append(
+                    f":ticket: *Zendesk Ticket:* {custom_fields['zendesk_ticket_id']}"
+                )
             if custom_fields.get("seller_contract_id"):
-                fields.append(f":memo: *Seller Contract:* {custom_fields['seller_contract_id']}")
+                fields.append(
+                    f":memo: *Seller Contract:* {custom_fields['seller_contract_id']}"
+                )
             if custom_fields.get("zoho_desk_ticket_id"):
-                fields.append(f":ticket: *Zoho Desk Ticket:* {custom_fields['zoho_desk_ticket_id']}")
+                fields.append(
+                    f":ticket: *Zoho Desk Ticket:* {custom_fields['zoho_desk_ticket_id']}"
+                )
             if custom_fields.get("is_key_account") is True:
                 fields.append(":star: *Key Account*")
             if custom_fields.get("is_seller_in_golden_list") is True:
@@ -296,10 +303,17 @@ class SlackMessageIncidentDeclaredAnnouncement(SlackMessageSurface):
         pm_fields = []
 
         if hasattr(self.incident, "postmortem_for") and self.incident.postmortem_for:
-            pm_fields.append(f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-mortem*>")
+            pm_fields.append(
+                f":confluence: <{self.incident.postmortem_for.page_url}|*Confluence Post-mortem*>"
+            )
 
-        if hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
-            pm_fields.append(f":jira_new: <{self.incident.jira_postmortem_for.issue_url}|*Jira Post-mortem ({self.incident.jira_postmortem_for.jira_issue_key})*>")
+        if (
+            hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for
+        ):
+            pm_fields.append(
+                f":jira_new: <{self.incident.jira_postmortem_for.issue_url}|*Jira Post-mortem ({self.incident.jira_postmortem_for.jira_issue_key})*>"
+            )
 
         if not pm_fields:
             return []
@@ -582,7 +596,8 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
                                 value=str(self.incident.id),
                                 action_id=UpdateStatusModal.open_action,
                             )
-                            if self.in_channel and self.incident.status != IncidentStatus.CLOSED
+                            if self.in_channel
+                            and self.incident.status != IncidentStatus.CLOSED
                             else None
                         ),
                     ),
@@ -600,6 +615,32 @@ class SlackMessageIncidentStatusUpdated(SlackMessageSurface):
                     ]
                 )
             )
+
+        # Add post mortem reminder if incident is back to MITIGATED and a post mortem already exists
+        if (self.incident.status == IncidentStatus.MITIGATED
+            and hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for):
+            jira_pm = self.incident.jira_postmortem_for
+            blocks.extend([
+                DividerBlock(),
+                SectionBlock(
+                    text=(
+                        f":memo: *Reminder:* This incident already has an existing post mortem:\n"
+                        f"• Jira: <{jira_pm.issue_url}|{jira_pm.jira_issue_key}>\n\n"
+                        f"Please update it with any new findings from this reopening."
+                    )
+                ),
+                SectionBlock(
+                    text="Need guidance on how to fill Post-Mortems in Jira?",
+                    accessory=ButtonElement(
+                        text="Open documentation",
+                        url="https://manomano.atlassian.net/wiki/spaces/TC/pages/5639635000/How+to+fill+Post-Mortems+in+Jira",
+                        value="jira_postmortem_documentation",
+                        action_id="open_link",
+                    ),
+                )
+            ])
+
         return blocks
 
     def get_metadata(self) -> Metadata:
@@ -636,16 +677,12 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
 
         # Add Confluence link if available
         if hasattr(self.incident, "postmortem_for"):
-            parts.append(
-                f"• Confluence: {self.incident.postmortem_for.page_url}"
-            )
+            parts.append(f"• Confluence: {self.incident.postmortem_for.page_url}")
 
         # Add Jira link if available
         if hasattr(self.incident, "jira_postmortem_for"):
             jira_pm = self.incident.jira_postmortem_for
-            parts.append(
-                f"• Jira: {jira_pm.issue_url} ({jira_pm.jira_issue_key})"
-            )
+            parts.append(f"• Jira: {jira_pm.issue_url} ({jira_pm.jira_issue_key})")
 
         return "\n".join(parts)
 
@@ -653,7 +690,10 @@ class SlackMessageIncidentPostMortemCreated(SlackMessageSurface):
         blocks: list[Block] = [SectionBlock(text=self.get_text())]
 
         # Add documentation link if Jira post-mortem exists
-        if hasattr(self.incident, "jira_postmortem_for") and self.incident.jira_postmortem_for:
+        if (
+            hasattr(self.incident, "jira_postmortem_for")
+            and self.incident.jira_postmortem_for
+        ):
             blocks.append(
                 SectionBlock(
                     text="Need guidance on how to fill Post-Mortems in Jira? See our documentation",
@@ -707,7 +747,9 @@ class SlackMessageIncidentPostMortemCreatedAnnouncement(SlackMessageSurface):
             SectionBlock(
                 text=f"📔 *Post-mortem created for incident #{self.incident.id}*"
             ),
-            SectionBlock(text=f"*{shorten(self.incident.title, 2995, placeholder='...')}*"),
+            SectionBlock(
+                text=f"*{shorten(self.incident.title, 2995, placeholder='...')}*"
+            ),
             DividerBlock(),
             SectionBlock(fields=fields),
         ]
@@ -770,17 +812,19 @@ class SlackMessagePostMortemReminder5Days(SlackMessageSurface):
             blocks.append(ActionsBlock(elements=pm_links))
 
         # Add action buttons
-        blocks.extend([
-            DividerBlock(),
-            SectionBlock(
-                text="Update the incident status or close it once the post-mortem is complete.",
-                accessory=ButtonElement(
-                    text="Update status",
-                    value=str(self.incident.id),
-                    action_id=UpdateStatusModal.open_action,
+        blocks.extend(
+            [
+                DividerBlock(),
+                SectionBlock(
+                    text="Update the incident status or close it once the post-mortem is complete.",
+                    accessory=ButtonElement(
+                        text="Update status",
+                        value=str(self.incident.id),
+                        action_id=UpdateStatusModal.open_action,
+                    ),
                 ),
-            ),
-        ])
+            ]
+        )
 
         return blocks
 

firefighter_incident-0.0.30/firefighter_tests/test_incidents/test_forms/test_mitigated_reopening.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import uuid
+
+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
+
+
+def create_unique_priority(value: int, *, needs_postmortem: bool = False) -> Priority:
+    """Create a Priority with unique constraints handled properly."""
+    return Priority.objects.create(
+        value=value,
+        name=f"Priority-{value}-{uuid.uuid4().hex[:8]}",
+        order=value,
+        needs_postmortem=needs_postmortem,
+        description=f"Test priority {value}"
+    )
+
+
+def create_unique_environment(value: str, *, exact_value: bool = False) -> Environment:
+    """Create an Environment with unique constraints handled properly.
+
+    Args:
+        value: Base value for the environment
+        exact_value: If True, use the value exactly and get_or_create (for testing specific logic)
+    """
+    if exact_value:
+        # For testing specific environment logic, use exact value with get_or_create
+        # This handles the case where fixtures already created an environment with this value
+        unique_suffix = uuid.uuid4().hex[:8]
+        environment, _ = Environment.objects.get_or_create(
+            value=value,  # Exact value needed for logic testing
+            defaults={
+                "name": f"Environment {value} {unique_suffix}",
+                "description": f"Test environment {value} {unique_suffix}"
+            }
+        )
+        return environment
+
+    # Default case: create unique environment
+    unique_suffix = uuid.uuid4().hex[:8]
+    return Environment.objects.create(
+        value=f"{value}-{unique_suffix}",
+        name=f"Environment {value} {unique_suffix}",
+        description=f"Test environment {value} {unique_suffix}"
+    )
+
+
+@pytest.mark.django_db
+class TestMitigatedReopeningWorkflow(TestCase):
+    """Test the new workflow allowing reopening from MITIGATED status."""
+
+    def test_p1_mitigated_allows_reopening_and_postmortem(self):
+        """P1 incidents should be able to go to POST_MORTEM OR reopen to INVESTIGATING/MITIGATING."""
+        # Create P1 priority with needs_postmortem=True
+        priority = create_unique_priority(value=1001, needs_postmortem=True)
+        # IMPORTANT: Use exact "PRD" value for environment since requires_postmortem logic checks for exact match
+        environment = create_unique_environment("PRD", exact_value=True)
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+        form = UpdateStatusForm(incident=incident)
+
+        # Get available statuses
+        status_choices = dict(form.fields["status"].choices)
+        available_statuses = {IncidentStatus(int(k)) for k in status_choices}
+
+        # P1 incidents should have POST_MORTEM (required for P1/P2)
+        assert IncidentStatus.POST_MORTEM in available_statuses
+        # P1 incidents should ALSO have direct reopening options (NEW behavior)
+        assert IncidentStatus.INVESTIGATING in available_statuses
+        assert IncidentStatus.MITIGATING in available_statuses
+
+    def test_can_reopen_from_mitigated_to_mitigating_p3(self):
+        """P3 incidents can return from MITIGATED to MITIGATING."""
+        priority = create_unique_priority(value=3001, needs_postmortem=False)
+        environment = create_unique_environment("STG")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+        form = UpdateStatusForm(incident=incident)
+
+        # Get available statuses
+        status_choices = dict(form.fields["status"].choices)
+        available_statuses = {IncidentStatus(int(k)) for k in status_choices}
+
+        # Should include both return options and CLOSED
+        assert IncidentStatus.INVESTIGATING in available_statuses
+        assert IncidentStatus.MITIGATING in available_statuses
+        assert IncidentStatus.CLOSED in available_statuses
+        # P3 should not include POST_MORTEM
+        assert IncidentStatus.POST_MORTEM not in available_statuses
+
+    def test_form_validation_requires_message_for_reopening(self):
+        """Form validation requires message when reopening from MITIGATED."""
+        priority = create_unique_priority(value=5001, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+
+        # Test without message - should fail
+        form_data = {
+            "status": str(IncidentStatus.INVESTIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "",  # Empty message should cause validation error
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is False, f"Form should be invalid but got valid=True, errors={form.errors}"
+        assert "message" in form.errors
+
+    def test_form_validation_requires_minimum_message_length(self):
+        """Form validation requires minimum message length for reopening."""
+        priority = create_unique_priority(value=5002, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+
+        # Test with message too short - should fail
+        form_data = {
+            "status": str(IncidentStatus.INVESTIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "short",  # Less than 10 chars
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is False
+        assert "message" in form.errors
+
+    def test_form_validation_accepts_valid_reopening_message(self):
+        """Form validation accepts valid message for reopening."""
+        priority = create_unique_priority(value=5003, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.MITIGATED,
+            priority=priority,
+            environment=environment
+        )
+
+        # Test with valid message - should pass
+        form_data = {
+            "status": str(IncidentStatus.INVESTIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "Investigation revealed additional issues requiring further analysis",
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is True
+
+    def test_form_validation_normal_transitions_unaffected(self):
+        """Normal transitions not from MITIGATED should be unaffected."""
+        priority = create_unique_priority(value=5004, needs_postmortem=False)
+        environment = create_unique_environment("INT")
+
+        # Test from INVESTIGATING to MITIGATING (normal flow)
+        incident = IncidentFactory.create(
+            _status=IncidentStatus.INVESTIGATING,
+            priority=priority,
+            environment=environment
+        )
+
+        form_data = {
+            "status": str(IncidentStatus.MITIGATING.value),
+            "priority": str(incident.priority.id),
+            "incident_category": str(incident.incident_category.id),
+            "message": "",  # Empty message should be OK for normal transitions
+        }
+        form = UpdateStatusForm(data=form_data, incident=incident)
+
+        assert form.is_valid() is True