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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airflow-pytest-plugin
-Version: 0.3.2
+Version: 0.5.0
 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
@@ -37,6 +37,11 @@ Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
 Provides-Extra: secure-xml
 Requires-Dist: defusedxml>=0.7; extra == 'secure-xml'
+Provides-Extra: ui-test
+Requires-Dist: fastapi>=0.110; extra == 'ui-test'
+Requires-Dist: pytest-playwright>=0.5; extra == 'ui-test'
+Requires-Dist: pytest>=7.0; extra == 'ui-test'
+Requires-Dist: uvicorn>=0.23; extra == 'ui-test'
 Provides-Extra: web
 Requires-Dist: fastapi>=0.110; extra == 'web'
 Requires-Dist: uvicorn>=0.23; extra == 'web'
@@ -91,6 +96,7 @@ It has two halves that share one on-disk layout:
 - [HTTP API](#http-api)
 - [Access control (RBAC)](#access-control-rbac)
 - [Configuration](#configuration)
+- [Prometheus metrics](#prometheus-metrics)
 - [Architecture (SOLID)](#architecture-solid)
 - [Development](#development)
 - [License](#license)
@@ -124,9 +130,30 @@ run; expanding a case offers its full **history**:
 
 ![Pytest Reports — flaky tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/flaky.png)
 
+**Slow tests & duration regressions** — the *Slowdowns* KPI opens a panel of tests
+whose **execution time got slower** (recent-half average vs the older half, over a
+configurable window) alongside the **slowest tests** by average duration. A test
+that speeds back up drops off the list. Inside a run, the case table sorts by
+execution time (slowest first) so the heaviest tests surface immediately.
+
+![Pytest Reports — slow tests & regressions](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/slow.png)
+
+**Test×run heatmap** — the *Heatmap* button on a dag·task group (or a run's toolbar)
+opens a matrix of **tests (rows) × recent runs (columns)**, each cell coloured by that
+test's outcome (`did not run` is an empty dashed cell). Flaky tests read as alternating
+rows, a regression as a block of failures filling in on the right, and a run that broke
+the build as a red/error **column** — all at a glance. Rows sort most-broken first; click
+a cell to open that run, or a test name to open its history.
+
+![Pytest Reports — test×run heatmap](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/heatmap.png)
+
 **Unique tests & failures** — the *Unique tests* KPI opens the searchable,
-paginated catalogue of every distinct test; the *Failures* KPI lists every
-failed/errored case across the visible runs — a row jumps to that run:
+paginated catalogue of every distinct test (each with its runs / pass-fail-error-skip
+counts / average time); the *Failures* KPI shows what's broken **now** — failures in each
+dag·task's latest run, so the count shrinks as tests are fixed — grouped into **clusters
+by normalized error** (biggest first) so common root causes surface instead of
+per-failure spam. Expand a cluster to its tests, or open the same clusters scoped to one
+run via the detail's *Error clusters* button:
 
 ![Pytest Reports — unique tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/unique.png)
 
@@ -234,15 +261,19 @@ runtime. Endpoints (relative to the mount):
 | `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/failures?dag_id=&run_id=&task_id=&latest=` | failed/errored cases — each dag·task's latest run by default (`latest=0` for full history) |
+| `GET /api/failure-clusters?dag_id=&run_id=&task_id=&latest=` | failures grouped by normalized error signature (biggest first); latest-run-only by default |
 | `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 |
+| `GET /api/slow?dag_id=&task_id=&window=` | duration regressions (tests whose execution time got slower) + the slowest tests by average |
+| `GET /api/heatmap?dag_id=&task_id=&window=` | test×run outcome matrix for one dag·task (rows = tests sorted most-broken first, cells = `p`/`f`/`e`/`s`/`-` aligned to recent runs) |
 | `GET /api/test-history?dag_id=&task_id=&node_id=&limit=` | one test's outcome per run |
-| `GET /api/unique-tests?dag_id=&task_id=&run_id=&full=` | distinct test count (+ list when `full`) |
+| `GET /api/unique-tests?dag_id=&task_id=&run_id=&full=` | distinct test count (+ when `full`, each test's runs / passed / failed / errors / skipped / avg duration) |
 | `DELETE /api/reports/{report_id}` | delete a report (RBAC-gated) |
 | `GET /api/reports/{report_id}/allure.zip` | raw Allure results as a zip (if any) |
 | `GET /api/health` | liveness + readiness: `status`, `ready`, `reports_root`(+`_exists`), `auth`, `secure_xml` |
 | `GET /api/version` | `{"name": ..., "version": ...}` from package metadata |
+| `GET /api/metrics` | Prometheus exposition — opt-in, bearer-token (see [Prometheus metrics](#prometheus-metrics)) |
 | `GET /api/docs` | OpenAPI docs (Swagger UI) |
 
 The reads (`GET`) and the delete are gated by Airflow RBAC — see below.
@@ -308,7 +339,10 @@ Download them from a report's detail view, or `GET
 | `AIRFLOW_PYTEST_FLAKY_WINDOW` (env/cfg) | `30` | default recent runs the flaky detector scans |
 | `AIRFLOW_PYTEST_FLAKY_QUARANTINE_SCORE` (env/cfg) | `0.5` | flakiness score (0–1) that flags a test for quarantine |
 | `AIRFLOW_PYTEST_FLAKY_MIN_SCORE` (env/cfg) | `0.1` | flakiness score (0–1) below which a test is not counted as flaky |
+| `AIRFLOW_PYTEST_SLOW_FACTOR` (env/cfg) | `1.3` | how much slower (recent-half avg ÷ older half, ≥1) a test must get to count as a duration regression |
+| `AIRFLOW_PYTEST_SLOW_MIN_DELTA` (env/cfg) | `0.5` | minimum absolute slowdown in seconds for a regression to register (filters jittery fast tests) |
 | `AIRFLOW_PYTEST_SUCCESS_THRESHOLD` (env/cfg) | `0.85` | pass-rate (0–1) over executed tests at/above which a run counts as successful (*Passing runs*); `1.0` = strict, zero failures/errors |
+| `AIRFLOW_PYTEST_METRICS_TOKEN` (env/cfg) | — | bearer token that **enables** the Prometheus `/api/metrics` endpoint; unset = disabled (see [below](#prometheus-metrics)) |
 
 **Enable / disable the reader.** Set `AIRFLOW_PYTEST_PLUGIN_ENABLE` to a falsey
 value (`0`, `false`, `no`, `off`) to stop the plugin registering its UI and API
@@ -328,6 +362,34 @@ single scan for `AIRFLOW_PYTEST_SCAN_CACHE_TTL` seconds (default `2.0`; deletes
 invalidate it immediately). New runs therefore appear within a couple of seconds (or
 on **Refresh**); set it to `0` for no caching, or higher on a very large tree.
 
+## Prometheus metrics
+
+`GET /api/metrics` exposes per-dag·task gauges (from each dag·task's **latest** run)
+in the Prometheus text format — `airflow_pytest_latest_{passed,failed,errors,skipped,
+tests,pass_ratio,duration_seconds,success,run_timestamp_seconds}{dag_id,task_id}` and
+`airflow_pytest_dagtask_runs{dag_id,task_id}`, plus globals
+`airflow_pytest_{up,runs,dagtasks,latest_failures,series_truncated,build_info}` (all gauges).
+
+It's **disabled by default** and turns on only when you set a scrape token; requests must
+then present it as a bearer token (constant-time compared). The scrape is cheap and
+bounded — one cached directory scan, summary-derived (no per-run reads), capped at 2000
+series — so it's safe to poll frequently.
+
+```bash
+export AIRFLOW_PYTEST_METRICS_TOKEN="$(openssl rand -hex 16)"
+```
+
+```yaml
+# prometheus.yml
+scrape_configs:
+  - job_name: airflow-pytest
+    metrics_path: /pytest-reports/api/metrics   # the plugin's mount prefix
+    authorization:
+      credentials: "<AIRFLOW_PYTEST_METRICS_TOKEN>"
+    static_configs:
+      - targets: ["airflow-apiserver:8080"]
+```
+
 ## Retention (auto-cleanup)
 
 Reports accumulate forever unless you prune them. Set any of the

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

@@ -47,6 +47,7 @@ It has two halves that share one on-disk layout:
 - [HTTP API](#http-api)
 - [Access control (RBAC)](#access-control-rbac)
 - [Configuration](#configuration)
+- [Prometheus metrics](#prometheus-metrics)
 - [Architecture (SOLID)](#architecture-solid)
 - [Development](#development)
 - [License](#license)
@@ -80,9 +81,30 @@ run; expanding a case offers its full **history**:
 
 ![Pytest Reports — flaky tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/flaky.png)
 
+**Slow tests & duration regressions** — the *Slowdowns* KPI opens a panel of tests
+whose **execution time got slower** (recent-half average vs the older half, over a
+configurable window) alongside the **slowest tests** by average duration. A test
+that speeds back up drops off the list. Inside a run, the case table sorts by
+execution time (slowest first) so the heaviest tests surface immediately.
+
+![Pytest Reports — slow tests & regressions](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/slow.png)
+
+**Test×run heatmap** — the *Heatmap* button on a dag·task group (or a run's toolbar)
+opens a matrix of **tests (rows) × recent runs (columns)**, each cell coloured by that
+test's outcome (`did not run` is an empty dashed cell). Flaky tests read as alternating
+rows, a regression as a block of failures filling in on the right, and a run that broke
+the build as a red/error **column** — all at a glance. Rows sort most-broken first; click
+a cell to open that run, or a test name to open its history.
+
+![Pytest Reports — test×run heatmap](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/heatmap.png)
+
 **Unique tests & failures** — the *Unique tests* KPI opens the searchable,
-paginated catalogue of every distinct test; the *Failures* KPI lists every
-failed/errored case across the visible runs — a row jumps to that run:
+paginated catalogue of every distinct test (each with its runs / pass-fail-error-skip
+counts / average time); the *Failures* KPI shows what's broken **now** — failures in each
+dag·task's latest run, so the count shrinks as tests are fixed — grouped into **clusters
+by normalized error** (biggest first) so common root causes surface instead of
+per-failure spam. Expand a cluster to its tests, or open the same clusters scoped to one
+run via the detail's *Error clusters* button:
 
 ![Pytest Reports — unique tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/unique.png)
 
@@ -190,15 +212,19 @@ runtime. Endpoints (relative to the mount):
 | `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/failures?dag_id=&run_id=&task_id=&latest=` | failed/errored cases — each dag·task's latest run by default (`latest=0` for full history) |
+| `GET /api/failure-clusters?dag_id=&run_id=&task_id=&latest=` | failures grouped by normalized error signature (biggest first); latest-run-only by default |
 | `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 |
+| `GET /api/slow?dag_id=&task_id=&window=` | duration regressions (tests whose execution time got slower) + the slowest tests by average |
+| `GET /api/heatmap?dag_id=&task_id=&window=` | test×run outcome matrix for one dag·task (rows = tests sorted most-broken first, cells = `p`/`f`/`e`/`s`/`-` aligned to recent runs) |
 | `GET /api/test-history?dag_id=&task_id=&node_id=&limit=` | one test's outcome per run |
-| `GET /api/unique-tests?dag_id=&task_id=&run_id=&full=` | distinct test count (+ list when `full`) |
+| `GET /api/unique-tests?dag_id=&task_id=&run_id=&full=` | distinct test count (+ when `full`, each test's runs / passed / failed / errors / skipped / avg duration) |
 | `DELETE /api/reports/{report_id}` | delete a report (RBAC-gated) |
 | `GET /api/reports/{report_id}/allure.zip` | raw Allure results as a zip (if any) |
 | `GET /api/health` | liveness + readiness: `status`, `ready`, `reports_root`(+`_exists`), `auth`, `secure_xml` |
 | `GET /api/version` | `{"name": ..., "version": ...}` from package metadata |
+| `GET /api/metrics` | Prometheus exposition — opt-in, bearer-token (see [Prometheus metrics](#prometheus-metrics)) |
 | `GET /api/docs` | OpenAPI docs (Swagger UI) |
 
 The reads (`GET`) and the delete are gated by Airflow RBAC — see below.
@@ -264,7 +290,10 @@ Download them from a report's detail view, or `GET
 | `AIRFLOW_PYTEST_FLAKY_WINDOW` (env/cfg) | `30` | default recent runs the flaky detector scans |
 | `AIRFLOW_PYTEST_FLAKY_QUARANTINE_SCORE` (env/cfg) | `0.5` | flakiness score (0–1) that flags a test for quarantine |
 | `AIRFLOW_PYTEST_FLAKY_MIN_SCORE` (env/cfg) | `0.1` | flakiness score (0–1) below which a test is not counted as flaky |
+| `AIRFLOW_PYTEST_SLOW_FACTOR` (env/cfg) | `1.3` | how much slower (recent-half avg ÷ older half, ≥1) a test must get to count as a duration regression |
+| `AIRFLOW_PYTEST_SLOW_MIN_DELTA` (env/cfg) | `0.5` | minimum absolute slowdown in seconds for a regression to register (filters jittery fast tests) |
 | `AIRFLOW_PYTEST_SUCCESS_THRESHOLD` (env/cfg) | `0.85` | pass-rate (0–1) over executed tests at/above which a run counts as successful (*Passing runs*); `1.0` = strict, zero failures/errors |
+| `AIRFLOW_PYTEST_METRICS_TOKEN` (env/cfg) | — | bearer token that **enables** the Prometheus `/api/metrics` endpoint; unset = disabled (see [below](#prometheus-metrics)) |
 
 **Enable / disable the reader.** Set `AIRFLOW_PYTEST_PLUGIN_ENABLE` to a falsey
 value (`0`, `false`, `no`, `off`) to stop the plugin registering its UI and API
@@ -284,6 +313,34 @@ single scan for `AIRFLOW_PYTEST_SCAN_CACHE_TTL` seconds (default `2.0`; deletes
 invalidate it immediately). New runs therefore appear within a couple of seconds (or
 on **Refresh**); set it to `0` for no caching, or higher on a very large tree.
 
+## Prometheus metrics
+
+`GET /api/metrics` exposes per-dag·task gauges (from each dag·task's **latest** run)
+in the Prometheus text format — `airflow_pytest_latest_{passed,failed,errors,skipped,
+tests,pass_ratio,duration_seconds,success,run_timestamp_seconds}{dag_id,task_id}` and
+`airflow_pytest_dagtask_runs{dag_id,task_id}`, plus globals
+`airflow_pytest_{up,runs,dagtasks,latest_failures,series_truncated,build_info}` (all gauges).
+
+It's **disabled by default** and turns on only when you set a scrape token; requests must
+then present it as a bearer token (constant-time compared). The scrape is cheap and
+bounded — one cached directory scan, summary-derived (no per-run reads), capped at 2000
+series — so it's safe to poll frequently.
+
+```bash
+export AIRFLOW_PYTEST_METRICS_TOKEN="$(openssl rand -hex 16)"
+```
+
+```yaml
+# prometheus.yml
+scrape_configs:
+  - job_name: airflow-pytest
+    metrics_path: /pytest-reports/api/metrics   # the plugin's mount prefix
+    authorization:
+      credentials: "<AIRFLOW_PYTEST_METRICS_TOKEN>"
+    static_configs:
+      - targets: ["airflow-apiserver:8080"]
+```
+
 ## Retention (auto-cleanup)
 
 Reports accumulate forever unless you prune them. Set any of the

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "airflow-pytest-plugin"
-version = "0.3.2"
+version = "0.5.0"
 description = "View airflow-pytest-operator results in the Airflow 3 web UI."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -60,6 +60,14 @@ dev = [
     "mypy>=1.8",
     "ruff>=0.4",
 ]
+# Playwright UI regression suite (tests/ui, marker `ui`). Opt-in: heavy (real browser),
+# run locally + in a dedicated CI job. After install: `playwright install chromium`.
+ui-test = [
+    "pytest>=7.0",
+    "pytest-playwright>=0.5",
+    "fastapi>=0.110",
+    "uvicorn>=0.23",        # the standalone dev server the UI tests drive
+]
 
 [project.urls]
 Homepage = "https://github.com/IKrysanov/airflow-pytest-plugin"
@@ -83,6 +91,15 @@ include = ["src", "tests", "examples", "README.md", "LICENSE"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src"]
+# UI (Playwright) tests are opt-in and excluded by default so the unit suite stays fast
+# and browser-free. Run them explicitly: `pytest -m ui` (standalone dev server) or
+# `pytest -m ui_airflow` (embedded in a real Airflow api-server). Both need the
+# `ui-test` extra + browsers; `ui_airflow` also needs Airflow installed.
+addopts = ["-m", "not ui and not ui_airflow"]
+markers = [
+    "ui: Playwright UI regression test (opt-in; needs the 'ui-test' extra + browsers)",
+    "ui_airflow: Playwright UI test against a real Airflow api-server with the plugin embedded",
+]
 
 [tool.coverage.run]
 branch = true

{airflow_pytest_plugin-0.3.2 → airflow_pytest_plugin-0.5.0}/src/airflow_pytest_plugin/config.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import math
 import os
 
 from .compat import get_conf_value
@@ -149,6 +150,49 @@ def get_flaky_min_score() -> float:
     )
 
 
+#: Duration-regression detector. A test is flagged "slower" when its recent-half
+#: average duration is at least ``SLOW_FACTOR``× its older-half average AND the
+#: absolute increase clears ``SLOW_MIN_DELTA`` seconds (the delta filters noise on
+#: fast tests, where a tiny jitter can still beat the ratio). Shares the flaky window.
+SLOW_FACTOR_ENV = "AIRFLOW_PYTEST_SLOW_FACTOR"
+DEFAULT_SLOW_FACTOR = 1.3
+SLOW_MIN_DELTA_ENV = "AIRFLOW_PYTEST_SLOW_MIN_DELTA"
+DEFAULT_SLOW_MIN_DELTA = 0.5
+
+
+def _positive_float_setting(
+    env_var: str, conf_key: str, default: float, *, minimum: float
+) -> float:
+    """A float ≥ ``minimum`` from env, then cfg; default on missing/invalid/below."""
+    raw = os.environ.get(env_var)
+    if raw is None or not raw.strip():
+        raw = get_conf_value(CONF_SECTION, conf_key)
+    if raw is None or not str(raw).strip():
+        return default
+    try:
+        value = float(str(raw).strip())
+    except ValueError:
+        return default
+    # Reject NaN/inf: they'd serialize to non-spec JSON ("NaN"/"Infinity") downstream.
+    if not math.isfinite(value):
+        return default
+    return value if value >= minimum else default
+
+
+def get_slow_factor() -> float:
+    """Multiplier a test's recent-half avg duration must reach to count as a regression."""
+    return _positive_float_setting(
+        SLOW_FACTOR_ENV, "slow_factor", DEFAULT_SLOW_FACTOR, minimum=1.0
+    )
+
+
+def get_slow_min_delta() -> float:
+    """Minimum absolute slowdown (seconds) for a duration regression to register."""
+    return _positive_float_setting(
+        SLOW_MIN_DELTA_ENV, "slow_min_delta", DEFAULT_SLOW_MIN_DELTA, minimum=0.0
+    )
+
+
 #: Pass-rate (0–1) at/above which a run counts as successful ("Passing runs"). The
 #: rate is over executed tests, so a run can carry a few failures and still pass.
 #: At 1.0 a run is successful only with zero failures/errors (the strict default of
@@ -164,6 +208,20 @@ def get_success_threshold() -> float:
     )
 
 
+#: Opt-in bearer token for the Prometheus ``/api/metrics`` endpoint. Secure-by-default:
+#: unset = the endpoint is DISABLED (404). When set, a scrape must send
+#: ``Authorization: Bearer <token>``. Reads the env var, then the cfg key.
+METRICS_TOKEN_ENV = "AIRFLOW_PYTEST_METRICS_TOKEN"
+
+
+def get_metrics_token() -> str | None:
+    """The metrics scrape token, or ``None`` when the endpoint should stay disabled."""
+    raw = os.environ.get(METRICS_TOKEN_ENV)
+    if raw is None or not raw.strip():
+        raw = get_conf_value(CONF_SECTION, "metrics_token")
+    return raw.strip() if raw and raw.strip() else None
+
+
 def get_reports_root() -> str:
     """Resolve the report root directory (absolute path)."""
     env = os.environ.get(ENV_VAR)

{airflow_pytest_plugin-0.3.2 → airflow_pytest_plugin-0.5.0}/src/airflow_pytest_plugin/producer/archiving_parser.py

@@ -39,7 +39,10 @@ _log = logging.getLogger(__name__)
 META_SCHEMA_VERSION = 1
 
 
-class ArchivingResultParser(JUnitResultParser):  # type: ignore[misc]
+# The operator base is typed as Any when the operator package ships without type info (some
+# environments) and concretely typed in others -- so the misc subclass error only fires
+# sometimes. Listing `unused-ignore` keeps this quiet whether or not misc fires.
+class ArchivingResultParser(JUnitResultParser):  # type: ignore[misc, unused-ignore]
     """Archives each run under the reports layout: the operator's JUnit result
     plus (with ``allure=True``) the raw Allure results for TestOps export."""
 

{airflow_pytest_plugin-0.3.2 → airflow_pytest_plugin-0.5.0}/src/airflow_pytest_plugin/sources/filesystem.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import io
 import json
 import logging
+import math
 import os
 import shutil
 import threading
@@ -101,7 +102,17 @@ class FileSystemReportSource(ReportSource):
             if summary is not None:
                 out.append(summary)
         # Newest first: ISO-8601 created_at sorts chronologically; missing sorts last.
-        out.sort(key=lambda s: s.created_at or "", reverse=True)
+        # Tiebreak deterministically (try_number, run_id, map_index) so that on equal or
+        # missing created_at a stable "latest" run is chosen (e.g. a retry wins its try).
+        out.sort(
+            key=lambda s: (
+                s.created_at or "",
+                s.ref.try_number,
+                s.ref.run_id,
+                s.ref.map_index,
+            ),
+            reverse=True,
+        )
         return out
 
     def _all_summaries(self) -> list[ReportSummary]:
@@ -206,6 +217,10 @@ class FileSystemReportSource(ReportSource):
                         if len(row) > 2 and isinstance(row[2], int | float)
                         else 0.0
                     )
+                    # Guard NaN/Infinity from a corrupt meta so they can't reach a
+                    # JSON response (json.dumps would emit non-spec NaN/Infinity).
+                    if not math.isfinite(dur):
+                        dur = 0.0
                     out[str(row[0])] = {"outcome": str(row[1]), "duration": dur}
             return out
         # Older archive without the per-test map: parse junit.xml on demand.
@@ -217,12 +232,13 @@ class FileSystemReportSource(ReportSource):
         except Exception:
             _log.exception("Failed to parse JUnit report %s", report_path)
             return None
+
+        def _dur(c: Any) -> float:
+            d = float(getattr(c, "time", 0.0) or 0.0)
+            return d if math.isfinite(d) else 0.0
+
         return {
-            c.node_id: {
-                "outcome": c.outcome,
-                "duration": float(getattr(c, "time", 0.0) or 0.0),
-            }
-            for c in result.cases
+            c.node_id: {"outcome": c.outcome, "duration": _dur(c)} for c in result.cases
         }
 
     def delete(self, ref: ReportRef) -> bool:
@@ -366,18 +382,24 @@ class FileSystemReportSource(ReportSource):
             _log.warning("Skipping meta with missing/invalid identity: %r", meta)
             return None
 
-        summary = meta.get("summary") or {}
-        passed = int(summary.get("passed", 0))
-        failed = int(summary.get("failed", 0))
-        errors = int(summary.get("errors", 0))
+        # The counts/duration come from a semi-trusted sidecar (written by the test code
+        # the operator ran). A single corrupt value (non-numeric count, inf/NaN duration)
+        # must NOT crash the whole scan or leak non-spec JSON -- coerce defensively and
+        # keep the run, mirroring the identity skip above and test_outcomes' finite guard.
+        summary = meta.get("summary")
+        if not isinstance(summary, dict):
+            summary = {}
+        passed = _safe_int(summary.get("passed"))
+        failed = _safe_int(summary.get("failed"))
+        errors = _safe_int(summary.get("errors"))
         return ReportSummary(
             ref=ref,
-            total=int(summary.get("total", 0)),
+            total=_safe_int(summary.get("total")),
             passed=passed,
             failed=failed,
-            skipped=int(summary.get("skipped", 0)),
+            skipped=_safe_int(summary.get("skipped")),
             errors=errors,
-            duration=float(summary.get("duration", 0.0)),
+            duration=_safe_finite_float(summary.get("duration")),
             # success is reader-derived from the pass-rate threshold, not the stored flag.
             success=run_succeeds(passed, failed, errors, threshold),
             created_at=_opt_str(meta.get("created_at")),
@@ -388,3 +410,21 @@ class FileSystemReportSource(ReportSource):
 
 def _opt_str(value: Any) -> str | None:
     return str(value) if value is not None else None
+
+
+def _safe_int(value: Any) -> int:
+    """A summary count coerced to a non-negative int; ``0`` for anything unparseable."""
+    try:
+        return max(0, int(value))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _safe_finite_float(value: Any) -> float:
+    """A summary duration coerced to a finite float; ``0.0`` for bad/inf/NaN values
+    (non-finite floats are not JSON-spec and would 500 the serializer)."""
+    try:
+        f = float(value)
+    except (TypeError, ValueError):
+        return 0.0
+    return f if math.isfinite(f) else 0.0

{airflow_pytest_plugin-0.3.2 → airflow_pytest_plugin-0.5.0}/src/airflow_pytest_plugin/web/app.py

@@ -150,6 +150,11 @@ def create_app(
 
     @app.get("/", response_class=HTMLResponse, include_in_schema=False)
     def index() -> HTMLResponse:
-        return HTMLResponse(index_html())
+        # The whole single-page app (incl. all inline JS) lives in this HTML, so it must
+        # never be served stale -- otherwise a browser/Airflow cache keeps running old JS
+        # after an upgrade. no-store guarantees every load fetches the current build.
+        return HTMLResponse(
+            index_html(), headers={"Cache-Control": "no-store, must-revalidate"}
+        )
 
     return app