Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(data-modeling): clear node suspensions in django admin (#124450)

Jovan Sakovicccb0e3f2db15
diff --git a/products/data_modeling/backend/admin.py b/products/data_modeling/backend/admin.py
index 5cdd27364e85..1ef2454a9b9c 100644
--- a/products/data_modeling/backend/admin.py
+++ b/products/data_modeling/backend/admin.py
@@ -1,16 +1,28 @@
+from uuid import uuid4
+
+from django import forms
from django.conf import settings
-from django.contrib import admin
-from django.http import Http404, HttpRequest
-from django.shortcuts import render
+from django.contrib import admin, messages
+from django.core.exceptions import PermissionDenied
+from django.db import transaction
+from django.http import Http404, HttpRequest, HttpResponse
+from django.shortcuts import redirect, render
from django.urls import path, reverse
from django.utils.html import format_html
+from products.data_modeling.backend.forms import ClearNodeSuspensionsForm
+from products.data_modeling.backend.logic.node_suspension import unsuspend_nodes
+from products.data_modeling.backend.logic.node_suspension_selection import Marker
from products.data_modeling.backend.logic.tier_run_report import build_tier_runs, untargeted_nodes
from products.data_modeling.backend.models.dag import DAG
+from products.data_modeling.backend.models.node import Node
+
+SUSPENSION_PREVIEW_SESSION_KEY = "data_modeling_suspension_preview"
@admin.register(DAG)
class DataModelingDAGAdmin(admin.ModelAdmin):
+ change_list_template = "admin/data_modeling/dag_change_list.html"
list_display = ("id", "name", "team_link", "sync_frequency_interval", "tiers_link")
list_display_links = ("id", "name")
list_select_related = ("team",)
@@ -29,6 +41,11 @@ class DataModelingDAGAdmin(admin.ModelAdmin):
def get_urls(self):
return [
+ path(
+ "clear-suspensions/",
+ self.admin_site.admin_view(self.clear_suspensions_view),
+ name="data_modeling_clear_node_suspensions",
+ ),
path(
"<path:object_id>/tiers/",
self.admin_site.admin_view(self.tiers_view),
@@ -37,6 +54,90 @@ class DataModelingDAGAdmin(admin.ModelAdmin):
*super().get_urls(),
]
+ def changelist_view(self, request: HttpRequest, extra_context: dict | None = None) -> HttpResponse:
+ return super().changelist_view(
+ request,
+ extra_context={
+ **(extra_context or {}),
+ "can_clear_suspensions": request.user.has_perm("data_modeling.change_node"),
+ },
+ )
+
+ def _clear_suspension_preview(self, request: HttpRequest) -> HttpResponse:
+ preview = request.session.get(SUSPENSION_PREVIEW_SESSION_KEY)
+ if not preview or request.POST.get("preview_token") != preview["token"]:
+ self.message_user(request, "Preview the suspensions again before clearing them.", messages.ERROR)
+ return redirect("admin:data_modeling_clear_node_suspensions")
+
+ del request.session[SUSPENSION_PREVIEW_SESSION_KEY]
+ resumed_by = preview.get("by", f"admin:{request.user.pk}")
+ cleared = 0
+ for item in preview["markers"]:
+ node = Node.objects.filter(pk=item["node_id"], team_id=item["team_id"]).first()
+ if node is None:
+ continue
+ marker = Marker(node=node, engine=item["engine"], at=item["at"], reason="")
+ # The reset and its audit entry commit together, so a failed log write cannot leave an unaudited reset.
+ with transaction.atomic():
+ if unsuspend_nodes([node], by=resumed_by, engine=marker.engine, only_if=marker.unchanged):
+ cleared += 1
+ self.log_change(request, node, f"Cleared {marker.engine} suspension. By / note: {resumed_by}")
+ skipped = len(preview["markers"]) - cleared
+ self.message_user(
+ request,
+ f"Cleared {cleared} suspension(s). Left {skipped} suspension(s) that changed or no longer exist.",
+ messages.SUCCESS,
+ )
+ return redirect("admin:data_modeling_clear_node_suspensions")
+
+ def clear_suspensions_view(self, request: HttpRequest) -> HttpResponse:
+ if not request.user.has_perm("data_modeling.change_node"):
+ raise PermissionDenied
+ if request.method == "POST" and request.POST.get("action") == "clear":
+ return self._clear_suspension_preview(request)
+
+ form = ClearNodeSuspensionsForm(request.POST if request.method == "POST" else None)
+ markers: list[Marker] | None = None
+ token = ""
+ resumed_by = f"admin:{request.user.pk}"
+ if request.method == "POST":
+ request.session.pop(SUSPENSION_PREVIEW_SESSION_KEY, None)
+ if form.is_valid():
+ try:
+ markers = form.matching_markers()
+ except forms.ValidationError as error:
+ form.add_error(None, error)
+ else:
+ token = str(uuid4())
+ resumed_by = form.cleaned_data["by"] or resumed_by
+ request.session[SUSPENSION_PREVIEW_SESSION_KEY] = {
+ "token": token,
+ "by": resumed_by,
+ "markers": [
+ {
+ "node_id": str(marker.node.pk),
+ "team_id": marker.node.team_id,
+ "engine": marker.engine,
+ "at": marker.at,
+ }
+ for marker in markers
+ ],
+ }
+
+ return render(
+ request,
+ "admin/data_modeling/clear_node_suspensions.html",
+ {
+ **self.admin_site.each_context(request),
+ "title": "Clear node suspensions",
+ "opts": self.model._meta,
+ "form": form,
+ "markers": markers,
+ "preview_token": token,
+ "resumed_by": resumed_by,
+ },
+ )
+
@admin.display(description="Team")
def team_link(self, dag: DAG):
return format_html(
diff --git a/products/data_modeling/backend/forms.py b/products/data_modeling/backend/forms.py
new file mode 100644
index 000000000000..72d4312d0fb0
--- /dev/null
+++ b/products/data_modeling/backend/forms.py
@@ -0,0 +1,89 @@
+from itertools import islice
+from uuid import UUID
+
+from django import forms
+
+from products.data_modeling.backend.logic.node_suspension_selection import (
+ Marker,
+ Selection,
+ matching_suspension_markers,
+)
+from products.data_modeling.backend.models.data_modeling_job import DataModelingJobEngine
+
+MAX_SUSPENSION_PREVIEW = 500
+
+
+class ClearNodeSuspensionsForm(forms.Form):
+ engine = forms.ChoiceField(
+ choices=[("", "All engines"), *DataModelingJobEngine.choices], required=False, initial="clickhouse"
+ )
+ reason_contains = forms.CharField(
+ label="Error text contains",
+ required=False,
+ widget=forms.Textarea(attrs={"rows": 3, "cols": 60}),
+ help_text="Case-sensitive. Enter one error text per line to match any of them.",
+ )
+ team_id = forms.IntegerField(label="Team ID", required=False, min_value=1)
+ node_ids = forms.CharField(label="Node IDs", required=False, help_text="Comma-separated UUIDs.")
+ saved_query_ids = forms.CharField(label="Saved query IDs", required=False, help_text="Comma-separated UUIDs.")
+ suspended_from = forms.DateTimeField(
+ required=False, help_text="Inclusive. Use an ISO date and time with a UTC offset."
+ )
+ suspended_to = forms.DateTimeField(
+ required=False, help_text="Exclusive. Use an ISO date and time with a UTC offset."
+ )
+ by = forms.CharField(
+ label="By / note",
+ required=False,
+ max_length=500,
+ widget=forms.Textarea(attrs={"rows": 2, "cols": 60}),
+ help_text="Optional. Explain why you are clearing these suspensions. Leave empty to use your admin user ID.",
+ )
+
+ def _uuid_list(self, field: str) -> list[UUID]:
+ try:
+ return [UUID(item.strip()) for item in self.cleaned_data[field].split(",") if item.strip()]
+ except ValueError:
+ raise forms.ValidationError("Enter valid comma-separated UUIDs.")
+
+ def clean_node_ids(self) -> list[UUID]:
+ return self._uuid_list("node_ids")
+
+ def clean_saved_query_ids(self) -> list[UUID]:
+ return self._uuid_list("saved_query_ids")
+
+ def clean(self) -> dict:
+ cleaned = super().clean()
+ assert cleaned is not None
+ reasons = tuple(line for line in cleaned.get("reason_contains", "").splitlines() if line.strip())
+ cleaned["reason_contains"] = reasons
+ if not (reasons or cleaned.get("node_ids") or cleaned.get("saved_query_ids")):
+ raise forms.ValidationError("Enter error text, node IDs, or saved query IDs to select suspensions.")
+ start, end = cleaned.get("suspended_from"), cleaned.get("suspended_to")
+ if start and end and start >= end:
+ raise forms.ValidationError("Suspended to must be after suspended from.")
+ return cleaned
+
+ def matching_markers(self) -> list[Marker]:
+ data = self.cleaned_data
+ markers = list(
+ islice(
+ matching_suspension_markers(
+ team_id=data["team_id"],
+ node_ids=data["node_ids"],
+ saved_query_ids=data["saved_query_ids"],
+ selection=Selection(
+ engine=data["engine"] or None,
+ reason_contains=data["reason_contains"],
+ suspended_from=data["suspended_from"],
+ suspended_to=data["suspended_to"],
+ ),
+ ),
+ MAX_SUSPENSION_PREVIEW + 1,
+ )
+ )
+ if len(markers) > MAX_SUSPENSION_PREVIEW:
+ raise forms.ValidationError(
+ f"More than {MAX_SUSPENSION_PREVIEW} suspensions match. Add filters and preview again."
+ )
+ return markers
diff --git a/products/data_modeling/backend/logic/node_suspension_selection.py b/products/data_modeling/backend/logic/node_suspension_selection.py
new file mode 100644
index 000000000000..d5a98f1c57af
--- /dev/null
+++ b/products/data_modeling/backend/logic/node_suspension_selection.py
@@ -0,0 +1,66 @@
+import datetime as dt
+from collections.abc import Iterator
+from uuid import UUID
+
+from posthog.dataclasses import frozen
+
+from products.data_modeling.backend.logic.node_suspension import suspension_state
+from products.data_modeling.backend.models.node import Node
+
+
+@frozen
+class Selection:
+ engine: str | None
+ reason_contains: tuple[str, ...]
+ suspended_from: dt.datetime | None
+ suspended_to: dt.datetime | None
+
+ def matches(self, engine: str, entry: dict) -> bool:
+ if self.engine is not None and engine != self.engine:
+ return False
+ reason = entry.get("reason") or ""
+ if self.reason_contains and not any(fragment in reason for fragment in self.reason_contains):
+ return False
+ if self.suspended_from is None and self.suspended_to is None:
+ return True
+ try:
+ at = dt.datetime.fromisoformat(entry.get("at") or "")
+ except ValueError:
+ return False # a window was asked for, and a marker with no readable time is outside it
+ if self.suspended_from is not None and at < self.suspended_from:
+ return False
+ return self.suspended_to is None or at < self.suspended_to
+
+
+@frozen
+class Marker:
+ node: Node
+ engine: str
+ at: str
+ reason: str
+
+ def unchanged(self, node: Node) -> bool:
+ """A model can re-suspend between the report and the write. A newer marker records a newer
+ failure the operator never saw, so it stays."""
+ return (suspension_state(node).get(self.engine) or {}).get("at") == self.at
+
+
+def matching_suspension_markers(
+ *,
+ team_id: int | None,
+ node_ids: list[UUID] | None,
+ saved_query_ids: list[UUID] | None,
+ selection: Selection,
+) -> Iterator[Marker]:
+ nodes = Node.objects.filter(properties__system__has_key="suspended")
+ if team_id is not None:
+ nodes = nodes.filter(team_id=team_id)
+ if node_ids:
+ nodes = nodes.filter(id__in=node_ids)
+ if saved_query_ids:
+ nodes = nodes.filter(saved_query_id__in=saved_query_ids)
+
+ for node in nodes.order_by("team_id", "id").iterator():
+ for engine, entry in suspension_state(node).items():
+ if isinstance(entry, dict) and selection.matches(engine, entry):
+ yield Marker(node=node, engine=engine, at=entry.get("at") or "", reason=entry.get("reason") or "")
diff --git a/products/data_modeling/backend/management/commands/clear_node_suspensions.py b/products/data_modeling/backend/management/commands/clear_node_suspensions.py
index 965679db5a55..07b81d6c68c9 100644
--- a/products/data_modeling/backend/management/commands/clear_node_suspensions.py
+++ b/products/data_modeling/backend/management/commands/clear_node_suspensions.py
@@ -16,15 +16,13 @@ clear the whole fleet by omission. Filters combine with AND. Region-agnostic - r
"""
import datetime as dt
-from collections.abc import Iterator
-from dataclasses import dataclass
from typing import Any
from uuid import UUID
from django.core.management.base import BaseCommand, CommandError, CommandParser
-from products.data_modeling.backend.logic.node_suspension import suspension_state, unsuspend_nodes
-from products.data_modeling.backend.models.node import Node
+from products.data_modeling.backend.logic.node_suspension import unsuspend_nodes
+from products.data_modeling.backend.logic.node_suspension_selection import Selection, matching_suspension_markers
RESUMED_BY = "operator"
@@ -40,43 +38,6 @@ def _aware_datetime(value: str) -> dt.datetime:
return parsed
-@dataclass(frozen=True, kw_only=True)
-class Selection:
- engine: str | None
- reason_contains: tuple[str, ...]
- suspended_from: dt.datetime | None
- suspended_to: dt.datetime | None
-
- def matches(self, engine: str, entry: dict) -> bool:
- if self.engine is not None and engine != self.engine:
- return False
- reason = entry.get("reason") or ""
- if self.reason_contains and not any(fragment in reason for fragment in self.reason_contains):
- return False
- if self.suspended_from is None and self.suspended_to is None:
- return True
- try:
- at = dt.datetime.fromisoformat(entry.get("at") or "")
- except ValueError:
- return False # a window was asked for, and a marker with no readable time is outside it
- if self.suspended_from is not None and at < self.suspended_from:
- return False
- return self.suspended_to is None or at < self.suspended_to
-
-
-@dataclass(frozen=True, kw_only=True)
-class Marker:
- node: Node
- engine: str
- at: str
- reason: str
-
- def unchanged(self, node: Node) -> bool:
- """A model can re-suspend between the report and the write. A newer marker records a newer
- failure the operator never saw, so it stays."""
- return (suspension_state(node).get(self.engine) or {}).get("at") == self.at
-
-
class Command(BaseCommand):
help = "Clear data modeling suspension markers on an operator-chosen set of nodes"
@@ -116,7 +77,11 @@ class Command(BaseCommand):
suspended_from=options["suspended_from"],
suspended_to=options["suspended_to"],
)
- markers = list(self._markers(options["team_id"], node_ids, saved_query_ids, selection))
+ markers = list(
+ matching_suspension_markers(
+ team_id=options["team_id"], node_ids=node_ids, saved_query_ids=saved_query_ids, selection=selection
+ )
+ )
for marker in markers:
self.stdout.write(
@@ -138,23 +103,3 @@ class Command(BaseCommand):
self.stdout.write(f"Cleared {cleared} marker(s).")
if cleared < len(markers):
self.stdout.write(f" {len(markers) - cleared} re-suspended or changed since the report; left alone.")
-
- def _markers(
- self,
- team_id: int | None,
- node_ids: list[UUID] | None,
- saved_query_ids: list[UUID] | None,
- selection: Selection,
- ) -> Iterator[Marker]:
- nodes = Node.objects.filter(properties__system__has_key="suspended")
- if team_id is not None:
- nodes = nodes.filter(team_id=team_id)
- if node_ids:
- nodes = nodes.filter(id__in=node_ids)
- if saved_query_ids:
- nodes = nodes.filter(saved_query_id__in=saved_query_ids)
-
- for node in nodes.order_by("team_id", "id").iterator():
- for engine, entry in suspension_state(node).items():
- if isinstance(entry, dict) and selection.matches(engine, entry):
- yield Marker(node=node, engine=engine, at=entry.get("at") or "", reason=entry.get("reason") or "")
diff --git a/products/data_modeling/backend/templates/admin/data_modeling/clear_node_suspensions.html b/products/data_modeling/backend/templates/admin/data_modeling/clear_node_suspensions.html
new file mode 100644
index 000000000000..7be186514c42
--- /dev/null
+++ b/products/data_modeling/backend/templates/admin/data_modeling/clear_node_suspensions.html
@@ -0,0 +1,77 @@
+{% extends "admin/base_site.html" %}
+{% block extrastyle %}
+ {{ block.super }}
+ <style>
+ .suspension-filters input, .suspension-filters textarea, .suspension-filters select { box-sizing: border-box; max-width: 100%; }
+ .suspension-preview { overflow-x: auto; }
+ .suspension-preview table { min-width: 1100px; }
+ .suspension-preview td { vertical-align: top; }
+ .suspension-preview code { white-space: nowrap; }
+ .suspension-preview .reason { min-width: 200px; max-width: 600px; white-space: pre-wrap; overflow-wrap: anywhere; }
+ </style>
+{% endblock %}
+{% block breadcrumbs %}
+ <div class="breadcrumbs">
+ <a href="{% url 'admin:index' %}">Home</a>
+ &rsaquo; <a href="{% url 'admin:data_modeling_dag_changelist' %}">DAGs</a>
+ &rsaquo; Clear node suspensions
+ </div>
+{% endblock %}
+{% block content %}
+ <p>
+ Select suspensions in this region and review the matches before clearing them.
+ Models can run on their next scheduled run. This action does not start a run.
+ </p>
+ <form method="post" class="suspension-filters js-disable-on-submit">
+ {% csrf_token %}
+ {{ form.as_p }}
+ <input type="submit" value="Preview suspensions" class="default" />
+ </form>
+ {% if markers != None %}
+ <h2>{{ markers|length }} matching suspension(s)</h2>
+ {% if markers %}
+ <p>New or changed suspensions will not be cleared. Other engines will keep their suspensions.</p>
+ <p><strong>By / note:</strong> {{ resumed_by }}</p>
+ <div class="suspension-preview">
+ <table>
+ <thead>
+ <tr>
+ <th>Team</th>
+ <th>Node</th>
+ <th>Saved query</th>
+ <th>Engine</th>
+ <th>Suspended at</th>
+ <th>Error</th>
+ </tr>
+ </thead>
+ <tbody>
+ {% for marker in markers %}
+ <tr>
+ <td><a href="{% url 'admin:posthog_team_change' marker.node.team_id %}">{{ marker.node.team_id }}</a></td>
+ <td>
+ {{ marker.node.name }}
+ <br />
+ <code>{{ marker.node.id }}</code>
+ </td>
+ <td>{{ marker.node.saved_query_id|default:"None" }}</td>
+ <td>{{ marker.engine }}</td>
+ <td>{{ marker.at }}</td>
+ <td class="reason">{{ marker.reason }}</td>
+ </tr>
+ {% endfor %}
+ </tbody>
+ </table>
+ </div>
+ <form method="post" class="js-disable-on-submit">
+ {% csrf_token %}
+ <input type="hidden" name="action" value="clear" />
+ <input type="hidden" name="preview_token" value="{{ preview_token }}" />
+ <p>
+ <input type="submit"
+ value="Clear {{ markers|length }} suspension(s)"
+ class="default" />
+ </p>
+ </form>
+ {% endif %}
+ {% endif %}
+{% endblock %}
diff --git a/products/data_modeling/backend/templates/admin/data_modeling/dag_change_list.html b/products/data_modeling/backend/templates/admin/data_modeling/dag_change_list.html
new file mode 100644
index 000000000000..3f236f2ef713
--- /dev/null
+++ b/products/data_modeling/backend/templates/admin/data_modeling/dag_change_list.html
@@ -0,0 +1,9 @@
+{% extends "admin/change_list.html" %}
+{% block object-tools-items %}
+ {{ block.super }}
+ {% if can_clear_suspensions %}
+ <li>
+ <a href="{% url 'admin:data_modeling_clear_node_suspensions' %}">Clear node suspensions</a>
+ </li>
+ {% endif %}
+{% endblock %}
diff --git a/products/data_modeling/backend/test/test_admin.py b/products/data_modeling/backend/test/test_admin.py
new file mode 100644
index 000000000000..63c62c71cf6b
--- /dev/null
+++ b/products/data_modeling/backend/test/test_admin.py
@@ -0,0 +1,156 @@
+from datetime import timedelta
+from uuid import uuid4
+
+from posthog.test.base import BaseTest
+from unittest.mock import patch
+
+from django.contrib.admin.models import LogEntry
+from django.test import override_settings
+from django.urls import reverse
+from django.utils import timezone
+
+from parameterized import parameterized
+
+from products.data_modeling.backend.logic.node_suspension import is_node_suspended, mark_node_suspended
+from products.data_modeling.backend.models.dag import DAG
+from products.data_modeling.backend.models.node import Node
+
+
+@override_settings(STORAGES={"staticfiles": {"BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage"}})
+class TestClearNodeSuspensionsAdmin(BaseTest):
+ def setUp(self) -> None:
+ super().setUp()
+ self.user.is_staff = True
+ self.user.save()
+ self.client.force_login(self.user)
+ self.url = reverse("admin:data_modeling_clear_node_suspensions")
+ self.dag = DAG.objects.create(team=self.team, name="Admin test")
+
+ def _node(self, reason: str = "TEST_QUERY_LIMIT", engine: str = "clickhouse") -> Node:
+ node = Node.objects.create(team=self.team, dag=self.dag, name=f"test_{uuid4().hex}")
+ mark_node_suspended(node, engine=engine, reason=reason, job_id=str(uuid4()))
+ node.save()
+ return node
+
+ @parameterized.expand([("default_actor", ""), ("operator_note", "Retry after the query limit was restored.")])
+ def test_preview_and_clear_only_reviewed_markers(self, _name: str, note: str) -> None:
+ selected = self._node()
+ mark_node_suspended(selected, engine="managed_warehouse", reason="TEST_QUERY_LIMIT", job_id=str(uuid4()))
+ selected.save()
+ unrelated = self._node(reason="TEST_INVALID_COLUMN")
+ old = self._node()
+ old.properties["system"]["suspended"]["clickhouse"]["at"] = (timezone.now() - timedelta(days=2)).isoformat()
+ old.save()
+
+ response = self.client.post(
+ self.url,
+ {
+ "engine": "clickhouse",
+ "reason_contains": "TEST_QUERY_LIMIT\nTEST_OTHER_LIMIT",
+ "team_id": self.team.pk,
+ "suspended_from": (timezone.now() - timedelta(days=1)).isoformat(),
+ "by": note,
+ },
+ )
+
+ assert response.status_code == 200
+ assert [marker.node.pk for marker in response.context["markers"]] == [selected.pk]
+ expected_by = note or f"admin:{self.user.pk}"
+ assert response.context["resumed_by"] == expected_by
+ selected.refresh_from_db()
+ assert is_node_suspended(selected, "clickhouse")
+ new = self._node()
+
+ result = self.client.post(
+ self.url,
+ {"action": "clear", "preview_token": response.context["preview_token"], "by": "Unreviewed note"},
+ )
+
+ assert result.status_code == 302
+ selected.refresh_from_db()
+ assert not is_node_suspended(selected, "clickhouse")
+ assert is_node_suspended(selected, "managed_warehouse")
+ assert selected.properties["system"]["suspension_reset"]["clickhouse"]["by"] == expected_by
+ log = LogEntry.objects.get(user=self.user, object_id=str(selected.pk))
+ assert expected_by in log.change_message
+ for node in (unrelated, old, new):
+ node.refresh_from_db()
+ assert is_node_suspended(node, "clickhouse")
+
+ replay = self.client.post(self.url, {"action": "clear", "preview_token": response.context["preview_token"]})
+ assert replay.status_code == 302
+ assert LogEntry.objects.filter(user=self.user, object_id=str(selected.pk)).count() == 1
+
+ def test_preserves_newer_suspension_after_preview(self) -> None:
+ node = self._node()
+ preview = self.client.post(self.url, {"engine": "clickhouse", "node_ids": str(node.pk)})
+ mark_node_suspended(node, engine="clickhouse", reason="TEST_NEW_FAILURE", job_id=str(uuid4()))
+ node.save()
+
+ self.client.post(self.url, {"action": "clear", "preview_token": preview.context["preview_token"]})
+
+ node.refresh_from_db()
+ assert is_node_suspended(node, "clickhouse")
+ assert not LogEntry.objects.filter(object_id=str(node.pk)).exists()
+
+ def test_failed_audit_entry_rolls_back_the_reset(self) -> None:
+ node = self._node()
+ preview = self.client.post(self.url, {"engine": "clickhouse", "node_ids": str(node.pk)})
+
+ with patch(
+ "products.data_modeling.backend.admin.DataModelingDAGAdmin.log_change", side_effect=RuntimeError("boom")
+ ):
+ with self.assertRaises(RuntimeError):
+ self.client.post(self.url, {"action": "clear", "preview_token": preview.context["preview_token"]})
+
+ node.refresh_from_db()
+ assert is_node_suspended(node, "clickhouse")
+
+ @parameterized.expand(
+ [
+ ({"engine": "clickhouse"}, "Enter error text"),
+ ({"reason_contains": " \n "}, "Enter error text"),
+ ({"node_ids": "invalid"}, "Enter valid comma-separated UUIDs"),
+ (
+ {
+ "reason_contains": "TEST",
+ "suspended_from": "2026-10-02T00:00:00Z",
+ "suspended_to": "2026-10-01T00:00:00Z",
+ },
+ "Suspended to must be after suspended from",
+ ),
+ ]
+ )
+ def test_invalid_selection_cannot_clear(self, data: dict, error: str) -> None:
+ node = self._node()
+ response = self.client.post(self.url, data)
+ assert response.status_code == 200
+ assert error in response.content.decode()
+ assert not response.context["preview_token"]
+ self.client.post(self.url, {"action": "clear", "preview_token": "invalid"})
+ node.refresh_from_db()
+ assert is_node_suspended(node, "clickhouse")
+
+ @parameterized.expand([("get",), ("post",)])
+ def test_requires_staff_access(self, method: str) -> None:
+ self.user.is_staff = False
+ self.user.save()
+ response = getattr(self.client, method)(self.url)
+ assert response.status_code == 302
+ assert "/admin/login/" in response.url
+
+ def test_preview_limit_requires_narrower_filters(self) -> None:
+ self._node()
+ self._node()
+ with patch("products.data_modeling.backend.forms.MAX_SUSPENSION_PREVIEW", 1):
+ response = self.client.post(self.url, {"reason_contains": "TEST_QUERY_LIMIT"})
+ assert "Add filters and preview again" in response.content.decode()
+ assert not response.context["preview_token"]
+
+ def test_preview_escapes_error_text_and_has_admin_entry_point(self) -> None:
+ self._node(reason="<script>alert('test')</script>")
+ response = self.client.post(self.url, {"reason_contains": "<script>"})
+ assert "&lt;script&gt;" in response.content.decode()
+ assert "<script>alert('test')</script>" not in response.content.decode()
+ changelist = self.client.get(reverse("admin:data_modeling_dag_changelist"))
+ assert self.url in changelist.content.decode()