: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
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.pyindex 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 formsfrom 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, renderfrom django.urls import path, reversefrom 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 Markerfrom products.data_modeling.backend.logic.tier_run_report import build_tier_runs, untargeted_nodesfrom 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.pynew file mode 100644index 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 markersdiff --git a/products/data_modeling/backend/logic/node_suspension_selection.py b/products/data_modeling/backend/logic/node_suspension_selection.pynew file mode 100644index 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.pyindex 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 dataclassfrom typing import Anyfrom uuid import UUIDfrom 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_markersRESUMED_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.htmlnew file mode 100644index 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>+ › <a href="{% url 'admin:data_modeling_dag_changelist' %}">DAGs</a>+ › 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.htmlnew file mode 100644index 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.pynew file mode 100644index 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 "<script>" 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()