airflow-pytest-plugin 0.3.1__tar.gz → 0.3.2__tar.gz

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airflow-pytest-plugin
-Version: 0.3.1
+Version: 0.3.2
 Summary: View airflow-pytest-operator results in the Airflow 3 web UI.
 Project-URL: Homepage, https://github.com/IKrysanov/airflow-pytest-plugin
 Project-URL: Repository, https://github.com/IKrysanov/airflow-pytest-plugin
@@ -102,7 +102,10 @@ toggles, run numbers, a carousel beyond 30 runs, an optional **pass-rate trend
 line** with a success-threshold gridline, and **tick runs in the list to filter
 the chart to just their trend**) beside a **flaky-tests panel** (with its own
 search and a quarantined-only toggle), KPI cards (including a clickable **unique
-tests** count), and Airflow-matched colours and font:
+tests** count), and Airflow-matched colours and font. The run list is **grouped by
+dag·task** by default (a checkbox toggles the flat list) — collapsible groups with
+run count, pass-rate, average duration and last status, each sortable on its own;
+select a whole group to chart its trend:
 
 ![Pytest Reports — overview](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/overview.png)
 
@@ -230,6 +233,7 @@ runtime. Endpoints (relative to the mount):
 | `GET /` | the single-page viewer (HTML) |
 | `GET /api/reports?dag_id=&run_id=` | summaries, newest first |
 | `GET /api/reports/{report_id}` | one report with per-case rows |
+| `GET /api/groups?dag_id=&task_id=` | runs aggregated by dag·task (count, pass-rate, avg duration, last status) |
 | `GET /api/failures?dag_id=&run_id=&task_id=` | failed/errored cases across the visible runs |
 | `GET /api/compare?base=&head=` | per-test diff between two runs (newly failed / fixed / …) |
 | `GET /api/flaky?dag_id=&task_id=&window=` | flaky tests with score, trend, and a quarantine flag |

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/README.md

@@ -58,7 +58,10 @@ toggles, run numbers, a carousel beyond 30 runs, an optional **pass-rate trend
 line** with a success-threshold gridline, and **tick runs in the list to filter
 the chart to just their trend**) beside a **flaky-tests panel** (with its own
 search and a quarantined-only toggle), KPI cards (including a clickable **unique
-tests** count), and Airflow-matched colours and font:
+tests** count), and Airflow-matched colours and font. The run list is **grouped by
+dag·task** by default (a checkbox toggles the flat list) — collapsible groups with
+run count, pass-rate, average duration and last status, each sortable on its own;
+select a whole group to chart its trend:
 
 ![Pytest Reports — overview](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/overview.png)
 
@@ -186,6 +189,7 @@ runtime. Endpoints (relative to the mount):
 | `GET /` | the single-page viewer (HTML) |
 | `GET /api/reports?dag_id=&run_id=` | summaries, newest first |
 | `GET /api/reports/{report_id}` | one report with per-case rows |
+| `GET /api/groups?dag_id=&task_id=` | runs aggregated by dag·task (count, pass-rate, avg duration, last status) |
 | `GET /api/failures?dag_id=&run_id=&task_id=` | failed/errored cases across the visible runs |
 | `GET /api/compare?base=&head=` | per-test diff between two runs (newly failed / fixed / …) |
 | `GET /api/flaky?dag_id=&task_id=&window=` | flaky tests with score, trend, and a quarantine flag |

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "airflow-pytest-plugin"
-version = "0.3.1"
+version = "0.3.2"
 description = "View airflow-pytest-operator results in the Airflow 3 web UI."
 readme = "README.md"
 requires-python = ">=3.10"

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/routes/common.py

@@ -51,3 +51,38 @@ def ref_from_token(token: str) -> ReportRef:
         return ReportRef.from_token(token)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+# -- OpenAPI helpers: real example payloads + status codes for Swagger --------
+# Endpoints return a raw JSONResponse, so FastAPI can't infer a schema (Swagger shows
+# an empty "string"). These attach a concrete example to the 200 and document the
+# error codes each route can return.
+
+
+def ok(example: Any, description: str = "Successful response") -> dict[int | str, Any]:
+    """A 200 response documented with a concrete JSON ``example``."""
+    return {
+        200: {
+            "description": description,
+            "content": {"application/json": {"example": example}},
+        }
+    }
+
+
+def _err(detail: str) -> dict[str, Any]:
+    return {"content": {"application/json": {"example": {"detail": detail}}}}
+
+
+#: Reusable error responses (FastAPI's HTTPException body is ``{"detail": "..."}``).
+ERR_400: dict[int | str, Any] = {
+    400: {"description": "Malformed report token.", **_err("malformed report token")}
+}
+ERR_403: dict[int | str, Any] = {
+    403: {
+        "description": "Forbidden — not authorized for this dag (RBAC).",
+        **_err("not authorized"),
+    }
+}
+ERR_404: dict[int | str, Any] = {
+    404: {"description": "Not found.", **_err("report not found")}
+}

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/routes/compare.py

@@ -21,7 +21,15 @@ from typing import Any
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import JSONResponse
 
-from .common import FAIL_OUTCOMES, RouteDeps, ref_from_token
+from .common import (
+    ERR_400,
+    ERR_403,
+    ERR_404,
+    FAIL_OUTCOMES,
+    RouteDeps,
+    ok,
+    ref_from_token,
+)
 
 TAG = "compare"
 
@@ -66,7 +74,39 @@ def build_router(deps: RouteDeps) -> APIRouter:
     read_auth = deps.read_auth
     user_dep = deps.user_dep
 
-    @router.get("/api/compare", summary="Compare two runs")
+    @router.get(
+        "/api/compare",
+        summary="Compare two runs",
+        responses={
+            **ok(
+                {
+                    "newly_failed": [
+                        {
+                            "node_id": "tests/api.py::test_auth",
+                            "base": "passed",
+                            "head": "failed",
+                        }
+                    ],
+                    "fixed": [],
+                    "still_failing": [],
+                    "added": [],
+                    "removed": [
+                        {"node_id": "tests/api.py::test_legacy", "outcome": "passed"}
+                    ],
+                    "counts": {
+                        "newly_failed": 1,
+                        "fixed": 0,
+                        "still_failing": 0,
+                        "added": 0,
+                        "removed": 1,
+                    },
+                }
+            ),
+            **ERR_400,
+            **ERR_403,
+            **ERR_404,
+        },
+    )
     def compare(
         base: str,
         head: str,

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/routes/failures.py

@@ -21,7 +21,7 @@ from typing import Any
 from fastapi import APIRouter, Depends
 from fastapi.responses import JSONResponse
 
-from .common import RouteDeps
+from .common import RouteDeps, ok
 
 TAG = "failures"
 
@@ -36,7 +36,27 @@ def build_router(deps: RouteDeps) -> APIRouter:
     read_auth = deps.read_auth
     user_dep = deps.user_dep
 
-    @router.get("/api/failures", summary="Failed cases across runs")
+    @router.get(
+        "/api/failures",
+        summary="Failed cases across runs",
+        responses=ok(
+            {
+                "failures": [
+                    {
+                        "id": "YXBpX2dhdGV3YXl8...",
+                        "dag_id": "api_gateway",
+                        "task_id": "integration_tests",
+                        "run_id": "scheduled__2026-06-20",
+                        "created_at": "2026-06-20T07:00:00+00:00",
+                        "node_id": "tests/api.py::test_auth",
+                        "outcome": "failed",
+                    }
+                ],
+                "total": 1,
+                "capped": False,
+            }
+        ),
+    )
     def failures(
         dag_id: str | None = None,
         run_id: str | None = None,

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/routes/flaky.py

@@ -26,7 +26,7 @@ from ...config import (
     get_flaky_quarantine_score,
     get_flaky_window,
 )
-from .common import FAIL_OUTCOMES, RouteDeps
+from .common import FAIL_OUTCOMES, RouteDeps, ok
 
 TAG = "flaky"
 
@@ -102,7 +102,33 @@ def build_router(deps: RouteDeps) -> APIRouter:
     read_auth = deps.read_auth
     user_dep = deps.user_dep
 
-    @router.get("/api/flaky", summary="Flaky tests")
+    @router.get(
+        "/api/flaky",
+        summary="Flaky tests",
+        responses=ok(
+            {
+                "flaky": [
+                    {
+                        "dag_id": "api_gateway",
+                        "task_id": "integration_tests",
+                        "node_id": "tests/api.py::test_auth",
+                        "runs": 8,
+                        "fails": 4,
+                        "flips": 7,
+                        "score": 1.0,
+                        "trend": "flat",
+                        "quarantined": True,
+                        "recent": ["passed", "failed", "passed", "failed"],
+                    }
+                ],
+                "total": 1,
+                "capped": False,
+                "window": 30,
+                "quarantine_score": 0.5,
+                "min_score": 0.1,
+            }
+        ),
+    )
     def flaky(
         dag_id: str | None = None,
         task_id: str | None = None,

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/routes/monitoring.py

@@ -23,7 +23,7 @@ from fastapi.responses import JSONResponse
 
 from ...compat import airflow_auth_available
 from ...version import __version__
-from .common import RouteDeps
+from .common import RouteDeps, ok
 
 TAG = "monitoring"
 _DIST_NAME = "airflow-pytest-plugin"
@@ -34,7 +34,20 @@ def build_router(deps: RouteDeps) -> APIRouter:
     router = APIRouter(tags=[TAG])
     src = deps.src
 
-    @router.get("/api/health", summary="Health & readiness")
+    @router.get(
+        "/api/health",
+        summary="Health & readiness",
+        responses=ok(
+            {
+                "status": "ok",
+                "ready": True,
+                "reports_root": "/opt/airflow/pytest-reports",
+                "reports_root_exists": True,
+                "auth": "airflow",
+                "secure_xml": True,
+            }
+        ),
+    )
     def health() -> JSONResponse:
         """Liveness + readiness of the reader. No parameters, no report reads, no auth.
 
@@ -67,7 +80,11 @@ def build_router(deps: RouteDeps) -> APIRouter:
             }
         )
 
-    @router.get("/api/version", summary="Build info")
+    @router.get(
+        "/api/version",
+        summary="Build info",
+        responses=ok({"name": _DIST_NAME, "version": __version__}),
+    )
     def version() -> JSONResponse:
         """The plugin's distribution name and version (from package metadata)."""
         return JSONResponse({"name": _DIST_NAME, "version": __version__})

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/routes/reports.py

@@ -22,7 +22,7 @@ from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import JSONResponse, Response
 
 from ...config import get_success_threshold
-from .common import RouteDeps, ref_from_token
+from .common import ERR_400, ERR_403, ERR_404, RouteDeps, ok, ref_from_token
 
 TAG = "reports"
 
@@ -30,6 +30,84 @@ TAG = "reports"
 #: KPI can't trigger an unbounded scan of every archived run on each filter change.
 _UNIQUE_SCAN_CAP = 1000
 
+# -- OpenAPI examples (illustrative; Swagger shows these instead of a bare "string") --
+_EX_SUMMARY = {
+    "id": "ZXRsX2RhaWx5fHNjaGVkdWxlZF8yMDI2LTA2LTEwfHVuaXRfdGVzdHN8MXwtMQ",
+    "dag_id": "etl_daily",
+    "run_id": "scheduled__2026-06-10",
+    "task_id": "unit_tests",
+    "try_number": 1,
+    "map_index": -1,
+    "total": 4,
+    "passed": 3,
+    "failed": 1,
+    "skipped": 0,
+    "errors": 0,
+    "duration": 1.2,
+    "success": False,
+    "created_at": "2026-06-10T23:00:00+00:00",
+    "logical_date": None,
+    "has_allure": False,
+}
+_EX_CASE = {
+    "node_id": "tests/test_etl.py::test_load",
+    "name": "test_load",
+    "classname": "tests/test_etl.py",
+    "outcome": "failed",
+    "time": 0.3,
+    "message": "AssertionError: row count mismatch",
+}
+_EX_GROUP = {
+    "dag_id": "api_gateway",
+    "task_id": "integration_tests",
+    "runs": 8,
+    "passed": 2,
+    "pass_rate": 0.25,
+    "avg_duration": 1.6,
+    "last_status": "failed",
+    "last_created_at": "2026-06-20T07:00:00+00:00",
+}
+
+
+def summarize_groups(summaries: list[Any]) -> list[dict[str, Any]]:
+    """Aggregate run summaries by dag·task (pure).
+
+    One entry per dag·task with the run count, how many passed (per the configured
+    success threshold), the pass rate, the average run duration, and the newest run's
+    status/time. Sorted by most-recent activity. Lets a grouped view or dashboard read
+    group stats without shipping every run -- the basis for scaling past in-browser
+    grouping.
+    """
+    order: list[tuple[str, str]] = []
+    groups: dict[tuple[str, str], list[Any]] = {}
+    for s in summaries:
+        key = (s.ref.dag_id, s.ref.task_id)
+        if key not in groups:
+            groups[key] = []
+            order.append(key)
+        groups[key].append(s)
+
+    out: list[dict[str, Any]] = []
+    for dag, task in order:
+        runs = groups[(dag, task)]
+        newest = max(runs, key=lambda s: s.created_at or "")
+        passed = sum(1 for s in runs if s.success)
+        last = "passed" if newest.success else ("error" if newest.errors else "failed")
+        out.append(
+            {
+                "dag_id": dag,
+                "task_id": task,
+                "runs": len(runs),
+                "passed": passed,
+                "pass_rate": round(passed / len(runs), 3),
+                "avg_duration": round(sum(s.duration for s in runs) / len(runs), 3),
+                "last_status": last,
+                "last_created_at": newest.created_at,
+            }
+        )
+    out.sort(key=lambda g: g["last_created_at"] or "", reverse=True)
+    return out
+
 
 def build_router(deps: RouteDeps) -> APIRouter:
     """Routes tagged ``reports``."""
@@ -39,7 +117,11 @@ def build_router(deps: RouteDeps) -> APIRouter:
     delete_auth = deps.delete_auth
     user_dep = deps.user_dep
 
-    @router.get("/api/reports", summary="List runs")
+    @router.get(
+        "/api/reports",
+        summary="List runs",
+        responses=ok({"reports": [_EX_SUMMARY], "success_threshold": 0.85}),
+    )
     def list_reports(
         dag_id: str | None = None,
         run_id: str | None = None,
@@ -62,7 +144,41 @@ def build_router(deps: RouteDeps) -> APIRouter:
             }
         )
 
-    @router.get("/api/reports/{report_id}", summary="Get a run")
+    @router.get(
+        "/api/groups",
+        summary="Run groups by dag·task",
+        responses=ok({"groups": [_EX_GROUP], "total": 1}),
+    )
+    def groups(
+        dag_id: str | None = None,
+        task_id: str | None = None,
+        user: Any = Depends(user_dep),  # noqa: B008 - FastAPI dependency idiom
+    ) -> JSONResponse:
+        """Runs aggregated by dag·task: count, pass-rate, and the newest run's
+        status/time. Optional ``dag_id`` / ``task_id`` narrow by case-insensitive
+        substring; RBAC-filtered. Built for grouped views and dashboards so they can
+        show group stats without fetching every run (scales past in-browser grouping).
+        """
+        task_q = (task_id or "").lower()
+        visible = [
+            s
+            for s in src.list_summaries(dag_id=dag_id)
+            if (not task_q or task_q in s.ref.task_id.lower())
+            and read_auth(s.ref.dag_id, user)
+        ]
+        items = summarize_groups(visible)
+        return JSONResponse({"groups": items, "total": len(items)})
+
+    @router.get(
+        "/api/reports/{report_id}",
+        summary="Get a run",
+        responses={
+            **ok({**_EX_SUMMARY, "cases": [_EX_CASE]}),
+            **ERR_400,
+            **ERR_403,
+            **ERR_404,
+        },
+    )
     def get_report(
         report_id: str,
         user: Any = Depends(user_dep),  # noqa: B008 - FastAPI dependency idiom
@@ -82,7 +198,11 @@ def build_router(deps: RouteDeps) -> APIRouter:
             raise HTTPException(status_code=404, detail="report not found")
         return JSONResponse(detail.to_dict())
 
-    @router.delete("/api/reports/{report_id}", summary="Delete a run")
+    @router.delete(
+        "/api/reports/{report_id}",
+        summary="Delete a run",
+        responses={**ok({"deleted": True}), **ERR_400, **ERR_403, **ERR_404},
+    )
     def delete_report(
         report_id: str,
         user: Any = Depends(user_dep),  # noqa: B008 - FastAPI dependency idiom
@@ -104,7 +224,17 @@ def build_router(deps: RouteDeps) -> APIRouter:
         return JSONResponse({"deleted": True})
 
     @router.get(
-        "/api/reports/{report_id}/allure.zip", summary="Download Allure results"
+        "/api/reports/{report_id}/allure.zip",
+        summary="Download Allure results",
+        responses={
+            200: {
+                "description": "Allure results archive.",
+                "content": {"application/zip": {}},
+            },
+            **ERR_400,
+            **ERR_403,
+            **ERR_404,
+        },
     )
     def allure_zip(
         report_id: str,
@@ -132,7 +262,34 @@ def build_router(deps: RouteDeps) -> APIRouter:
             },
         )
 
-    @router.get("/api/test-history", summary="Test history")
+    @router.get(
+        "/api/test-history",
+        summary="Test history",
+        responses={
+            **ok(
+                {
+                    "node_id": "tests/test_etl.py::test_load",
+                    "dag_id": "etl_daily",
+                    "task_id": "unit_tests",
+                    "history": [
+                        {
+                            "run_id": "scheduled__2026-06-13",
+                            "created_at": "2026-06-13T23:00:00+00:00",
+                            "outcome": "passed",
+                            "duration": 0.3,
+                        },
+                        {
+                            "run_id": "scheduled__2026-06-12",
+                            "created_at": "2026-06-12T23:00:00+00:00",
+                            "outcome": "failed",
+                            "duration": 0.31,
+                        },
+                    ],
+                }
+            ),
+            **ERR_403,
+        },
+    )
     def test_history(
         dag_id: str,
         task_id: str,
@@ -178,7 +335,23 @@ def build_router(deps: RouteDeps) -> APIRouter:
             }
         )
 
-    @router.get("/api/unique-tests", summary="Unique tests")
+    @router.get(
+        "/api/unique-tests",
+        summary="Unique tests",
+        responses=ok(
+            {
+                "count": 189,
+                "capped": False,
+                "tests": [
+                    {
+                        "node_id": "tests/test_etl.py::test_load",
+                        "dag_id": "etl_daily",
+                        "task_id": "unit_tests",
+                    },
+                ],
+            }
+        ),
+    )
     def unique_tests(
         dag_id: str | None = None,
         task_id: str | None = None,

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/src/airflow_pytest_plugin/web/templates.py

@@ -245,7 +245,12 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   .fb-dagtask { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }
   .fb-meta { color: var(--muted); white-space: nowrap; font-variant-numeric: tabular-nums; flex: 0 0 auto; }
   .fb-empty { color: var(--muted); font-size: 12.5px; padding: 16px 2px; }
-  @media (max-width: 860px) { .board { flex-direction: column; } }
+  /* Stacked board: cards size to their content (the row layout's flex:1 1 0 would
+     collapse them to a sliver in a column, hiding the chart/flaky behind overflow). */
+  @media (max-width: 860px) {
+    .board { flex-direction: column; }
+    .board > .card { flex: 0 0 auto; }
+  }
   /* Unique-tests list: one wrapping column, so a long node id never forces a
      horizontal scrollbar (the dialog body scrolls vertically). */
   .uq-row { padding: 9px 4px; border-bottom: 1px solid var(--border); cursor: pointer;
@@ -322,21 +327,22 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   .bulk-del:focus-visible, .bulk-close:focus-visible { outline: 2px solid var(--ring); outline-offset: 1px; }
   /* Checkboxes styled like Airflow's (Chakra): rounded square, brand-blue + white tick when on. */
   .sel-cell { width: 1%; white-space: nowrap; padding-right: 0; }
-  .sel-cell input[type="checkbox"], #case-grp, #flk-qonly, #flk-board-qonly, #trend-toggle {
+  .sel-cell input[type="checkbox"], #case-grp, #flk-qonly, #flk-board-qonly, #trend-toggle, #list-grp {
     appearance: none; -webkit-appearance: none; margin: 0; width: 16px; height: 16px;
     cursor: pointer; vertical-align: middle; background: var(--surface);
     border: 1px solid var(--border); border-radius: 4px; flex: 0 0 auto;
     display: inline-grid; place-content: center; transition: background .12s, border-color .12s; }
   .sel-cell input[type="checkbox"]:hover, #case-grp:hover, #flk-qonly:hover,
-  #flk-board-qonly:hover, #trend-toggle:hover { border-color: var(--primary); }
+  #flk-board-qonly:hover, #trend-toggle:hover, #list-grp:hover { border-color: var(--primary); }
   .sel-cell input[type="checkbox"]:focus-visible, #case-grp:focus-visible, #flk-qonly:focus-visible,
-  #flk-board-qonly:focus-visible, #trend-toggle:focus-visible {
+  #flk-board-qonly:focus-visible, #trend-toggle:focus-visible, #list-grp:focus-visible {
     outline: 2px solid var(--ring); outline-offset: 1px; }
   .sel-cell input[type="checkbox"]:checked, #case-grp:checked, #flk-qonly:checked,
-  #flk-board-qonly:checked, #trend-toggle:checked, .sel-cell input[type="checkbox"]:indeterminate {
+  #flk-board-qonly:checked, #trend-toggle:checked, #list-grp:checked,
+  .sel-cell input[type="checkbox"]:indeterminate {
     background: var(--primary); border-color: var(--primary); }
   .sel-cell input[type="checkbox"]:checked::after, #case-grp:checked::after, #flk-qonly:checked::after,
-  #flk-board-qonly:checked::after, #trend-toggle:checked::after {
+  #flk-board-qonly:checked::after, #trend-toggle:checked::after, #list-grp:checked::after {
     content: ""; width: 4px; height: 8px; border: solid #fff; border-width: 0 2px 2px 0;
     transform: rotate(45deg) translate(-0.5px, -1px); }
   .sel-cell input[type="checkbox"]:indeterminate::after {
@@ -349,8 +355,8 @@ _INDEX_HTML = r"""<!DOCTYPE html>
     font-size: 12px; font-weight: 600; text-transform: uppercase; letter-spacing: .03em;
     border-bottom: 1px solid var(--border); user-select: none;
   }
-  th.sortable { cursor: pointer; }
-  th.sortable:hover { color: var(--fg); }
+  th.sortable, th.gsort, th.rsort { cursor: pointer; }
+  th.sortable:hover, th.gsort:hover, th.rsort:hover { color: var(--fg); }
   th .arrow { opacity: .9; margin-left: 4px; }
   tbody td { border-bottom: 1px solid var(--border); }
   tbody tr { transition: background .12s; }
@@ -422,7 +428,8 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   .case-table tr.case.clickable:hover > td:first-child,
   .case-table tr.case[aria-expanded="true"] > td:first-child { background: var(--surface-2); }
   .case-table thead th:first-child { z-index: 3; }
-  .chev { display: inline-flex; color: var(--muted); transition: transform .15s; }
+  .chev { display: inline-flex; width: 16px; justify-content: center; color: var(--muted);
+    transition: transform .15s; }
   .case[aria-expanded="true"] .chev { transform: rotate(90deg); }
   .case-exp > td { padding: 0 12px 12px; border-bottom: 1px solid var(--border); }
   .tb { margin: 0; padding: 2px 0 6px 12px; border-left: 2px solid var(--border);
@@ -480,6 +487,19 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   .case-table tr.grp > td { background: var(--surface-2); font-weight: 600; cursor: pointer;
     user-select: none; position: sticky; left: 0; }
   .case-table tr.grp .chev { transition: transform .15s; }
+  /* Run-list grouping by dag·task: toggle control + collapsible group headers. */
+  .list-ctrls { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; padding: 10px 12px; }
+  .list-grp-lbl { display: inline-flex; align-items: center; gap: 6px; font-size: 12.5px;
+    color: var(--muted); cursor: pointer; white-space: nowrap; }
+  #list .table-wrap > table { width: 100%; }
+  tr.lgrp > td { background: var(--surface-2); font-weight: 600; cursor: pointer; user-select: none; }
+  tr.lgrp .chev { transition: transform .15s; }
+  /* Align the grouped "DAG" header over the dag name (clears the chevron's footprint). */
+  th.gcol-dag { padding-left: 32px; }
+  /* A group's runs sit in their own full sub-table, marked by a left accent rather
+     than an indent gap (which looked off). */
+  tr.grp-runs > td { padding: 0; border-left: 2px solid var(--primary); background: var(--surface); }
+  tr.grp-more td { color: var(--muted); font-size: 12px; text-align: center; padding: 8px; }
 
   @media (max-width: 680px) {
     .header-inner { flex-direction: column; align-items: stretch; gap: 10px; padding: 10px 12px; }
@@ -749,7 +769,7 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       benchTitle: "Test durations (10s buckets)", uniqueTitle: "Unique tests",
       cId: "ID", cStatus: "Status", cDag: "DAG", cTask: "Task", cRun: "Run", cTry: "Try",
       cTotal: "Total", cPass: "Pass", cFail: "Fail", cErr: "Err", cSkip: "Skip",
-      cDuration: "Duration", cWhen: "When",
+      cDuration: "Duration", cWhen: "When", cRuns: "Runs", cPassRate: "Pass %", cAvgDur: "Avg time",
       kRuns: "Runs", kPassingRuns: "Passing runs", kTests: "Unique tests", kFailures: "Failures",
       kPassed: "Passed", kFailed: "Failed", kErrors: "Errors", kSkipped: "Skipped",
       sPass: "PASS", sFail: "FAIL", sError: "ERROR", success: "success",
@@ -781,6 +801,8 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       historyFail: "Failed to load history: ", noHistory: "No history for this test.",
       histDidntRun: "did not run",
       caseSearch: "filter tests…", caseGroup: "Group by module",
+      listGroup: "Group by dag·task", runsWord: "runs", selectGroup: "Select group",
+      groupMore: "Showing 100 of {n} runs — filter to this dag·task to see all.",
       failCapped: "Showing the first {n} failures.",
       loadFail: "Failed to load reports: ", reportFail: "Failed to load report: ",
       failuresFail: "Failed to load failures: ",
@@ -808,7 +830,7 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       benchTitle: "Время выполнения тестов (по 10с)", uniqueTitle: "Уникальные тесты",
       cId: "ID", cStatus: "Статус", cDag: "DAG", cTask: "Задача", cRun: "Запуск", cTry: "Попытка",
       cTotal: "Всего", cPass: "Усп", cFail: "Пров", cErr: "Ошиб", cSkip: "Проп",
-      cDuration: "Время", cWhen: "Когда",
+      cDuration: "Время", cWhen: "Когда", cRuns: "Прогоны", cPassRate: "Проход %", cAvgDur: "Ср. время",
       kRuns: "Прогонов", kPassingRuns: "Успешных прогонов", kTests: "Уникальные тесты", kFailures: "Падений",
       kPassed: "Пройдено", kFailed: "Провалено", kErrors: "Ошибки", kSkipped: "Пропущено",
       sPass: "OK", sFail: "СБОЙ", sError: "ОШИБКА", success: "успех",
@@ -841,6 +863,8 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       historyFail: "Не удалось загрузить историю: ", noHistory: "Истории по этому тесту нет.",
       histDidntRun: "не запускался",
       caseSearch: "фильтр тестов…", caseGroup: "Группировать по модулю",
+      listGroup: "Группировать по dag·task", runsWord: "прогонов", selectGroup: "Выбрать группу",
+      groupMore: "Показаны 100 из {n} прогонов — отфильтруйте по этому dag·task.",
       failCapped: "Показаны первые {n} падений.",
       loadFail: "Не удалось загрузить отчёты: ", reportFail: "Не удалось загрузить отчёт: ",
       failuresFail: "Не удалось загрузить падения: ",
@@ -902,6 +926,10 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
     });
   }
+  function debounce(fn, ms) {
+    var timer = null;
+    return function () { clearTimeout(timer); timer = setTimeout(fn, ms); };
+  }
   function fmtDur(s) { return (Number(s) || 0).toFixed(2) + "s"; }
   function fmtTime(s) {
     if (!s) return "—";
@@ -1028,7 +1056,8 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   var kpisEl = document.getElementById("kpis");
   var allReports = [];  // everything fetched
   var reports = [];     // the current filtered view
-  var sort = { key: "created_at", dir: -1 };
+  var sort = { key: "created_at", dir: -1 };       // run-level sort (flat list + within a group)
+  var groupSort = { key: "created_at", dir: -1 };  // order of the dag·task groups
 
   // Chart status series: [status key, report field, colour].
   var ORDER = [
@@ -1045,6 +1074,10 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   var chartScroll = null; // null => snap to newest; else a remembered scrollLeft (px)
   var chartDragged = false;
   var listPage = 0;
+  var listGroup = true;          // group the run list by dag·task (on by default; checkbox-toggled)
+  var listExpanded = {};         // group key -> expanded? (collapsed by default)
+  var groupRunSort = {};         // group key -> {key,dir} run-sort override for that group only
+  var GROUP_ROW_CAP = 100;       // max run rows rendered per expanded group (bounds the DOM)
   var selectedIds = new Set();   // report ids ticked for bulk delete
 
   var COLS = [
@@ -1413,17 +1446,20 @@ _INDEX_HTML = r"""<!DOCTYPE html>
     syncSelAll(); updateBulkBar(); renderChart();
   }
 
-  function sortReports() {
-    var col = COLS.filter(function (c) { return c.key === sort.key; })[0] || COLS[0];
+  // Comparator for a given run-sort state {key, dir} -- reused by the flat list and
+  // by each group (which may carry its own override).
+  function runComparator(s) {
+    var col = COLS.filter(function (c) { return c.key === s.key; })[0] || COLS[0];
     var getv = col.get || function (r) { return r[col.key]; };
-    reports.sort(function (a, b) {
+    return function (a, b) {
       var x = getv(a), y = getv(b);
       if (typeof x === "string") { x = x.toLowerCase(); y = String(y).toLowerCase(); }
-      if (x < y) return -1 * sort.dir;
-      if (x > y) return 1 * sort.dir;
+      if (x < y) return -1 * s.dir;
+      if (x > y) return 1 * s.dir;
       return 0;
-    });
+    };
   }
+  function sortReports() { reports.sort(runComparator(sort)); }
 
   function renderRows(rows) {
     return rows.map(function (r) {
@@ -1450,6 +1486,88 @@ _INDEX_HTML = r"""<!DOCTYPE html>
     return '<span class="arrow">' + (sort.dir === 1 ? "↑" : "↓") + "</span>";
   }
 
+  // Group the run list by dag·task: a checkbox toggles it (like the detail's
+  // group-by-module). Each header collapses/expands and its checkbox selects the whole
+  // group, which focuses the chart on it.
+  function groupReports(rows) {
+    var order = [], byKey = {};
+    rows.forEach(function (r) {
+      var key = JSON.stringify([r.dag_id, r.task_id]);
+      if (!byKey[key]) {
+        byKey[key] = { key: key, dag: r.dag_id, task: r.task_id, runs: [] };
+        order.push(byKey[key]);
+      }
+      byKey[key].runs.push(r);
+    });
+    // The newest run drives the group's status / when and the status/recency
+    // ordering -- independent of how runs are sorted within the group.
+    order.forEach(function (g) {
+      g.newest = g.runs.reduce(function (a, b) {
+        return String(a.created_at || "") >= String(b.created_at || "") ? a : b;
+      });
+      g.passed = g.runs.filter(function (r) { return r.success; }).length;
+      g.avgDur = g.runs.reduce(function (s, r) { return s + (+r.duration || 0); }, 0) / g.runs.length;
+    });
+    return order;
+  }
+  // Flat-list column headers -- sorted by the global run sort.
+  function headCells() {
+    return COLS.map(function (c) {
+      var asc = sort.key === c.key ? (sort.dir === 1 ? "ascending" : "descending") : "none";
+      return '<th class="sortable" data-key="' + c.key + '" aria-sort="' + asc + '">'
+        + esc(t(c.label)) + arrow(c.key) + "</th>";
+    }).join("");
+  }
+  // A group's full column header -- sorts the runs of THAT group only (class rsort,
+  // tagged with the group key); arrows reflect the group's effective sort `eff`.
+  function subHead(g, eff) {
+    var cells = COLS.map(function (c) {
+      var on = eff.key === c.key;
+      var ar = on ? '<span class="arrow">' + (eff.dir === 1 ? "↑" : "↓") + "</span>" : "";
+      return '<th class="rsort" data-key="' + c.key + '" data-gkey="' + esc(g.key)
+        + '" aria-sort="' + (on ? (eff.dir === 1 ? "ascending" : "descending") : "none") + '">'
+        + esc(t(c.label)) + ar + "</th>";
+    }).join("");
+    return '<th class="sel-cell"></th>' + cells + "<th></th>";
+  }
+  // A group-level column header (reorders the groups; uses the separate groupSort).
+  function gHeadCell(key, label, cls) {
+    var asc = groupSort.key === key ? (groupSort.dir === 1 ? "ascending" : "descending") : "none";
+    return '<th class="gsort' + (cls ? " " + cls : "") + '" data-key="' + key
+      + '" aria-sort="' + asc + '">' + esc(t(label)) + groupArrow(key) + "</th>";
+  }
+  function groupArrow(key) {
+    if (groupSort.key !== key) return "";
+    return '<span class="arrow">' + (groupSort.dir === 1 ? "↑" : "↓") + "</span>";
+  }
+  // A group's value for the active group-sort column.
+  function groupVal(g) {
+    if (groupSort.key === "dag_id") return g.dag.toLowerCase();
+    if (groupSort.key === "task_id") return g.task.toLowerCase();
+    if (groupSort.key === "runs") return g.runs.length;
+    if (groupSort.key === "pass_rate") return g.passed / g.runs.length;
+    if (groupSort.key === "avg_dur") return g.avgDur;
+    if (groupSort.key === "status") return g.newest.success ? 2 : (g.newest.errors ? 0 : 1);
+    return String(g.newest.created_at || "");  // created_at, and the default
+  }
+  function groupHeaderHtml(g) {
+    var exp = !!listExpanded[g.key];
+    var nSel = g.runs.filter(function (r) { return selectedIds.has(r.id); }).length;
+    var rate = Math.round(g.passed / g.runs.length * 100);
+    var st = statusOf(g.newest);
+    return '<tr class="lgrp" data-key="' + esc(g.key) + '">'
+      + '<td class="sel-cell"><input type="checkbox" class="gsel" data-key="' + esc(g.key) + '"'
+        + (nSel === g.runs.length ? " checked" : "") + ' aria-label="' + esc(t("selectGroup")) + '"></td>'
+      + '<td class="mono"><span class="chev"' + (exp ? ' style="transform:rotate(90deg)"' : "")
+        + ">" + CHEV + "</span> " + esc(g.dag) + "</td>"
+      + '<td class="mono">' + esc(g.task) + "</td>"
+      + '<td class="num">' + g.runs.length + "</td>"
+      + '<td class="num">' + rate + "%</td>"
+      + '<td class="num">' + fmtDur(g.avgDur) + "</td>"
+      + "<td>" + badge(st, statusLabel(st)) + "</td>"
+      + '<td class="muted">' + fmtTime(g.newest.created_at) + "</td></tr>";
+  }
+
   function renderList() {
     if (!reports.length) {
       listEl.innerHTML = '<div class="state">'
@@ -1458,27 +1576,63 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       return;
     }
     sortReports();
-    var pages = Math.ceil(reports.length / PAGE_SIZE);
-    listPage = Math.max(0, Math.min(listPage, pages - 1));
-    var pageRows = reports.slice(listPage * PAGE_SIZE, listPage * PAGE_SIZE + PAGE_SIZE);
-
-    var head = COLS.map(function (c) {
-      var asc = sort.key === c.key ? (sort.dir === 1 ? "ascending" : "descending") : "none";
-      return '<th class="sortable" data-key="' + c.key + '" aria-sort="' + asc + '">'
-        + esc(t(c.label)) + arrow(c.key) + "</th>";
-    }).join("");
-    var pager = pages > 1
-      ? '<div class="pager"><button type="button" class="nav-btn" id="pg-prev"'
-          + (listPage <= 0 ? " disabled" : "") + ' aria-label="' + esc(t("prevPage")) + '">‹</button>'
-        + "<span>" + esc(t("page")) + " " + (listPage + 1) + " / " + pages + "</span>"
-        + '<button type="button" class="nav-btn" id="pg-next"'
-          + (listPage >= pages - 1 ? " disabled" : "") + ' aria-label="' + esc(t("nextPage")) + '">›</button></div>'
-      : "";
+    var ctrls = '<div class="list-ctrls"><label class="list-grp-lbl"><input type="checkbox" id="list-grp"'
+      + (listGroup ? " checked" : "") + "> " + esc(t("listGroup")) + "</label></div>";
     var selAllTh = '<th class="sel-cell"><input type="checkbox" id="sel-all" aria-label="'
       + esc(t("selectAll")) + '"></th>';
-    listEl.innerHTML = '<div class="table-wrap"><table><thead><tr>' + selAllTh + head
-      + "<th></th></tr></thead><tbody>" + renderRows(pageRows) + "</tbody></table></div>" + pager;
 
+    var pages = 1, keyMap = {}, theadInner, body, pager = "";
+    if (listGroup) {
+      // The top header (gsort) reorders the GROUPS -- and, for run columns, the runs
+      // too (handled in the click). Each opened group's own header (rsort) sorts only
+      // that group's runs (groupRunSort override, else the global run sort).
+      theadInner = selAllTh + gHeadCell("dag_id", "cDag", "gcol-dag")
+        + gHeadCell("task_id", "cTask")
+        + gHeadCell("runs", "cRuns") + gHeadCell("pass_rate", "cPassRate")
+        + gHeadCell("avg_dur", "cAvgDur") + gHeadCell("status", "cStatus")
+        + gHeadCell("created_at", "cWhen");
+      var groups = groupReports(reports);
+      groups.forEach(function (g) { keyMap[g.key] = g; });
+      groups.sort(function (a, b) {
+        var x = groupVal(a), y = groupVal(b);
+        if (x < y) return -1 * groupSort.dir;
+        if (x > y) return 1 * groupSort.dir;
+        return 0;
+      });
+      body = groups.map(function (g) {
+        if (!listExpanded[g.key]) return groupHeaderHtml(g);
+        var eff = groupRunSort[g.key] || sort;  // this group's own run sort, else global
+        var runs = g.runs.slice().sort(runComparator(eff));
+        var more = g.runs.length > GROUP_ROW_CAP
+          ? '<tr class="grp-more"><td colspan="' + (COLS.length + 2) + '">'
+            + esc(t("groupMore").replace("{n}", String(g.runs.length))) + "</td></tr>"
+          : "";
+        return groupHeaderHtml(g)
+          + '<tr class="grp-runs"><td colspan="8"><div class="table-wrap">'
+          + '<table class="sub-table"><thead><tr>' + subHead(g, eff) + "</tr></thead><tbody>"
+          + renderRows(runs.slice(0, GROUP_ROW_CAP)) + more + "</tbody></table></div></td></tr>";
+      }).join("");
+    } else {
+      theadInner = selAllTh + headCells() + "<th></th>";
+      pages = Math.ceil(reports.length / PAGE_SIZE);
+      listPage = Math.max(0, Math.min(listPage, pages - 1));
+      body = renderRows(reports.slice(listPage * PAGE_SIZE, listPage * PAGE_SIZE + PAGE_SIZE));
+      pager = pages > 1
+        ? '<div class="pager"><button type="button" class="nav-btn" id="pg-prev"'
+            + (listPage <= 0 ? " disabled" : "") + ' aria-label="' + esc(t("prevPage")) + '">‹</button>'
+          + "<span>" + esc(t("page")) + " " + (listPage + 1) + " / " + pages + "</span>"
+          + '<button type="button" class="nav-btn" id="pg-next"'
+            + (listPage >= pages - 1 ? " disabled" : "") + ' aria-label="' + esc(t("nextPage")) + '">›</button></div>'
+        : "";
+    }
+    listEl.innerHTML = ctrls + '<div class="table-wrap"><table><thead><tr>' + theadInner
+      + "</tr></thead><tbody>" + body + "</tbody></table></div>" + pager;
+
+    var lg = document.getElementById("list-grp");
+    if (lg) lg.addEventListener("change", function () {
+      // Start the (re)entered view clean: folded, no stale per-group sort overrides.
+      listGroup = lg.checked; listExpanded = {}; groupRunSort = {}; listPage = 0; renderList();
+    });
     listEl.querySelectorAll("th.sortable").forEach(function (th) {
       th.addEventListener("click", function () {
         var k = th.getAttribute("data-key");
@@ -1487,9 +1641,48 @@ _INDEX_HTML = r"""<!DOCTYPE html>
         renderList();
       });
     });
+    listEl.querySelectorAll("th.gsort").forEach(function (th) {  // top header: groups + tests
+      th.addEventListener("click", function () {
+        var k = th.getAttribute("data-key");
+        if (groupSort.key === k) groupSort.dir *= -1; else { groupSort.key = k; groupSort.dir = 1; }
+        groupRunSort = {};  // drop per-group overrides -- the top header is the global control
+        // If the column maps to a run field, move the runs (in every group) too.
+        if (COLS.some(function (c) { return c.key === k; })) { sort.key = k; sort.dir = groupSort.dir; }
+        renderList();
+      });
+    });
+    listEl.querySelectorAll("th.rsort").forEach(function (th) {  // sort one group's runs only
+      th.addEventListener("click", function () {
+        var gk = th.getAttribute("data-gkey"), k = th.getAttribute("data-key");
+        var cur = groupRunSort[gk] || { key: sort.key, dir: sort.dir };
+        groupRunSort[gk] = cur.key === k ? { key: k, dir: -cur.dir } : { key: k, dir: 1 };
+        renderList();
+      });
+    });
     var pgPrev = document.getElementById("pg-prev"), pgNext = document.getElementById("pg-next");
     if (pgPrev) pgPrev.addEventListener("click", function () { if (listPage > 0) { listPage--; renderList(); } });
     if (pgNext) pgNext.addEventListener("click", function () { if (listPage < pages - 1) { listPage++; renderList(); } });
+    // Group headers: row toggles expand/collapse; its checkbox selects the whole group
+    // (selecting focuses the chart, and ticks the group even while collapsed).
+    listEl.querySelectorAll("tr.lgrp").forEach(function (tr) {
+      tr.addEventListener("click", function () {
+        var key = tr.getAttribute("data-key");
+        listExpanded[key] = !listExpanded[key];
+        renderList();
+      });
+    });
+    listEl.querySelectorAll(".gsel").forEach(function (cb) {
+      var g = keyMap[cb.getAttribute("data-key")];
+      var nSel = g.runs.filter(function (r) { return selectedIds.has(r.id); }).length;
+      cb.indeterminate = nSel > 0 && nSel < g.runs.length;
+      cb.addEventListener("click", function (e) { e.stopPropagation(); });
+      cb.addEventListener("change", function () {
+        g.runs.forEach(function (r) {
+          if (cb.checked) selectedIds.add(r.id); else selectedIds.delete(r.id);
+        });
+        renderChart(); renderList(); updateBulkBar();
+      });
+    });
     listEl.querySelectorAll(".row-del").forEach(function (b) {
       b.addEventListener("click", function (e) {
         e.stopPropagation();  // don't open the detail when deleting
@@ -1508,25 +1701,54 @@ _INDEX_HTML = r"""<!DOCTYPE html>
       cb.addEventListener("change", function () {
         var id = cb.getAttribute("data-id");
         if (cb.checked) selectedIds.add(id); else selectedIds.delete(id);
-        syncSelAll(); updateBulkBar(); renderChart();  // chart follows the selection
+        syncSelAll(); syncGroupChecks(); updateBulkBar(); renderChart();  // chart follows
       });
     });
     var selAll = document.getElementById("sel-all");
     if (selAll) selAll.addEventListener("change", function () {
-      listEl.querySelectorAll(".sel").forEach(function (cb) {
-        cb.checked = selAll.checked;
-        var id = cb.getAttribute("data-id");
-        if (selAll.checked) selectedIds.add(id); else selectedIds.delete(id);
-      });
+      if (listGroup) {
+        // Select every run across all groups (even collapsed) and tick the groups.
+        reports.forEach(function (r) {
+          if (selAll.checked) selectedIds.add(r.id); else selectedIds.delete(r.id);
+        });
+        listEl.querySelectorAll(".sel").forEach(function (cb) { cb.checked = selAll.checked; });
+        syncGroupChecks();
+      } else {
+        listEl.querySelectorAll(".sel").forEach(function (cb) {
+          cb.checked = selAll.checked;
+          var id = cb.getAttribute("data-id");
+          if (selAll.checked) selectedIds.add(id); else selectedIds.delete(id);
+        });
+      }
       selAll.indeterminate = false;
       updateBulkBar(); renderChart();
     });
     syncSelAll(); updateBulkBar();
   }
 
+  // Reflect the current selection onto the group checkboxes (incl. collapsed groups).
+  function syncGroupChecks() {
+    if (!listGroup) return;
+    var byKey = {};
+    groupReports(reports).forEach(function (g) { byKey[g.key] = g; });
+    listEl.querySelectorAll(".gsel").forEach(function (cb) {
+      var g = byKey[cb.getAttribute("data-key")];
+      if (!g) return;
+      var n = g.runs.filter(function (r) { return selectedIds.has(r.id); }).length;
+      cb.checked = n === g.runs.length;
+      cb.indeterminate = n > 0 && n < g.runs.length;
+    });
+  }
+
   function syncSelAll() {
     var selAll = document.getElementById("sel-all");
     if (!selAll) return;
+    if (listGroup) {  // count over all runs, since collapsed groups render no rows
+      var sn = reports.filter(function (r) { return selectedIds.has(r.id); }).length;
+      selAll.checked = reports.length > 0 && sn === reports.length;
+      selAll.indeterminate = sn > 0 && sn < reports.length;
+      return;
+    }
     var boxes = listEl.querySelectorAll(".sel"), n = 0;
     boxes.forEach(function (cb) { if (cb.checked) n++; });
     selAll.checked = boxes.length > 0 && n === boxes.length;
@@ -2589,8 +2811,13 @@ _INDEX_HTML = r"""<!DOCTYPE html>
   document.addEventListener("pointermove", chartDragMove);
   document.addEventListener("pointerup", chartDragEnd);
   document.addEventListener("pointercancel", chartDragEnd);
+  // Debounce the top filters: each keystroke otherwise re-renders the whole page
+  // (chart + list + KPIs + flaky) -- costly on large datasets. Call with no arg so it
+  // resets to page 1 / newest (binding the listener directly passes the Event as the
+  // keepPage flag, which wrongly preserved the page).
+  var debouncedFilter = debounce(function () { applyFilter(); }, 150);
   ["f-dag", "f-task", "f-run"].forEach(function (id) {
-    document.getElementById(id).addEventListener("input", applyFilter);
+    document.getElementById(id).addEventListener("input", debouncedFilter);
   });
   // Flaky-panel search + quarantined-only filter: client-side, re-render in place.
   var flkBoardQ = document.getElementById("flk-board-q");

{airflow_pytest_plugin-0.3.1 → airflow_pytest_plugin-0.3.2}/tests/test_web_app.py

@@ -147,6 +147,24 @@ def test_index_has_feature_markers(client):
         "trend-line",
         "trend-thresh",
         "trend-on",
+        'id="list-grp"',
+        "groupReports",
+        "listGroup",
+        "lgrp",
+        "gsel",
+        "grp-runs",
+        "syncGroupChecks",
+        "groupVal",
+        "groupMore",
+        "gHeadCell",
+        "gsort",
+        "groupArrow",
+        "headCells",
+        "cPassRate",
+        "rsort",
+        "groupRunSort",
+        "runComparator",
+        "cAvgDur",
         "fillCases",
         'id="case-q"',
         'id="links-btn"',
@@ -191,6 +209,7 @@ def test_openapi_and_docs_serve(client):
     doc = spec.json()
     paths = doc["paths"]
     assert "/api/flaky" in paths and "/api/test-history" in paths
+    assert "/api/groups" in paths and paths["/api/groups"]["get"]["tags"] == ["reports"]
     # Routes are grouped into the documented sections; the UI assets stay out of it.
     assert [t["name"] for t in doc["tags"]] == [
         "monitoring",
@@ -206,6 +225,24 @@ def test_openapi_and_docs_serve(client):
     assert "/icon.svg" not in paths and "/" not in paths  # icons + viewer hidden
     assert paths["/api/flaky"]["get"]["summary"]  # every method has a summary
 
+    # Responses are documented with a real JSON example (not a bare "string") ...
+    def ex(path, method):
+        return paths[path][method]["responses"]["200"]["content"]["application/json"][
+            "example"
+        ]
+
+    assert "reports" in ex("/api/reports", "get")
+    assert ex("/api/groups", "get")["groups"][0]["avg_duration"] is not None
+    assert "flaky" in ex("/api/flaky", "get")
+    # ... and the error status codes each route can return are declared.
+    for path, method in [
+        ("/api/reports/{report_id}", "get"),
+        ("/api/reports/{report_id}", "delete"),
+        ("/api/compare", "get"),
+    ]:
+        codes = set(paths[path][method]["responses"])
+        assert {"400", "403", "404"} <= codes, (path, method, codes)
+
 
 def test_icon_routes(client):
     for path in ("/icon.svg", "/icon-dark.svg"):
@@ -235,6 +272,63 @@ def test_reports_success_reflects_pass_rate_threshold(reports_root):
     assert body["success_threshold"] == 0.85
 
 
+def test_summarize_groups_aggregates_by_dag_task():
+    from airflow_pytest_plugin.models import ReportRef, ReportSummary
+    from airflow_pytest_plugin.web.routes.reports import summarize_groups
+
+    def mk(dag, task, run, created, *, success, errors=0, duration=0.1):
+        return ReportSummary(
+            ReportRef(dag, run, task, 1),
+            1,
+            1 if success else 0,
+            0 if success else 1,
+            0,
+            errors,
+            duration,
+            success,
+            created_at=created,
+        )
+
+    groups = summarize_groups(
+        [
+            mk("d", "t", "r1", "2026-06-01T00:00:00+00:00", success=True, duration=2.0),
+            mk(
+                "d", "t", "r2", "2026-06-03T00:00:00+00:00", success=False, duration=4.0
+            ),  # newest of d·t
+            mk("d", "u", "r3", "2026-06-02T00:00:00+00:00", success=True),
+            mk("d", "e", "r4", "2026-05-01T00:00:00+00:00", success=False, errors=1),
+        ]
+    )
+    by = {(g["dag_id"], g["task_id"]): g for g in groups}
+    assert by[("d", "t")]["runs"] == 2 and by[("d", "t")]["passed"] == 1
+    assert by[("d", "t")]["pass_rate"] == 0.5
+    assert by[("d", "t")]["avg_duration"] == 3.0  # (2.0 + 4.0) / 2
+    assert by[("d", "t")]["last_status"] == "failed"  # newest run (r2) failed
+    assert (
+        by[("d", "u")]["pass_rate"] == 1.0 and by[("d", "u")]["last_status"] == "passed"
+    )
+    assert by[("d", "e")]["last_status"] == "error"  # newest run errored
+    # Ordered by most-recent activity (d·t Jun 3, d·u Jun 2, d·e May 1).
+    assert [(g["dag_id"], g["task_id"]) for g in groups] == [
+        ("d", "t"),
+        ("d", "u"),
+        ("d", "e"),
+    ]
+
+
+def test_groups_endpoint_and_rbac(reports_root):
+    write_report(reports_root, ReportRef("dagA", "r1", "taskX", 1), passed=2)
+    write_report(reports_root, ReportRef("dagA", "r2", "taskX", 1), passed=1, failed=1)
+    write_report(reports_root, ReportRef("dagB", "r3", "taskY", 1), passed=3)
+    body = TestClient(make_app(reports_root)).get("/api/groups").json()
+    by = {(g["dag_id"], g["task_id"]): g for g in body["groups"]}
+    assert body["total"] == 2
+    assert by[("dagA", "taskX")]["runs"] == 2 and by[("dagB", "taskY")]["runs"] == 1
+    # RBAC: a reader denied dagB sees only its permitted group.
+    c = TestClient(make_app(reports_root, read_authorizer=lambda dag, u: dag == "dagA"))
+    assert {g["dag_id"] for g in c.get("/api/groups").json()["groups"]} == {"dagA"}
+
+
 def test_detail_endpoint_round_trips_token(client):
     token = client.get("/api/reports").json()["reports"][0]["id"]
     r = client.get(f"/api/reports/{token}")