airflow-pytest-plugin 0.2.0__tar.gz → 0.3.0__tar.gz

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airflow-pytest-plugin
-Version: 0.2.0
+Version: 0.3.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
@@ -70,7 +70,9 @@ The operator runs a `pytest` suite as an Airflow task and parses the JUnit
 report into a structured result. This plugin archives each of those reports —
 keyed by `dag_id / run_id / task_id / try` — and serves a small web UI to browse
 them: pass/fail counts per run, durations, and the per-test breakdown (with
-failure messages) for any run.
+failure messages) for any run. On top of that it adds **cross-run analytics** —
+flaky-test detection, per-test history, run-to-run comparison, a duration
+histogram, and a searchable catalogue of unique tests.
 
 It has two halves that share one on-disk layout:
 
@@ -96,17 +98,34 @@ It has two halves that share one on-disk layout:
 ## Screenshots
 
 **Overview** — the run list with the historical chart (per-status legend
-toggles, run numbers, and a carousel beyond 30 runs), KPI cards, and Airflow-
+toggles, run numbers, and a carousel beyond 30 runs) beside a **flaky-tests
+panel**, KPI cards (including a clickable **unique tests** count), and Airflow-
 matched colours and font:
 
 ![Pytest Reports — overview](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/overview.png)
 
-**A single run** — a clickable success donut (pass-rate in the centre; click a
-slice to filter by status), the counts, and every test's captured output on
-expand:
+**A single run** — a clickable success donut (pass-rate over the test count;
+click a slice to filter by status), a **test-duration histogram** (10-second
+buckets, scrollable), case search / group-by-module, and every test's captured
+output on expand:
 
 ![Pytest Reports — a single run](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/detail.png)
 
+**Flaky tests & comparison** — from a run, *Flaky tests* lists the tests that
+both pass and fail across recent runs (with a recent-outcome strip), and
+*Compare to previous* diffs it against the prior 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)
+
+**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:
+
+![Pytest Reports — unique tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/unique.png)
+
+![Pytest Reports — failed tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/failures.png)
+
 ---
 
 ## Install
@@ -208,10 +227,16 @@ 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/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=` | tests that both pass and fail over 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`) |
 | `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` | `{"status": "ok"}` |
-| `GET /api/docs` | OpenAPI docs |
+| `GET /api/health` | liveness + readiness: `status`, `ready`, `reports_root`(+`_exists`), `auth`, `secure_xml` |
+| `GET /api/version` | `{"name": ..., "version": ...}` from package metadata |
+| `GET /api/docs` | OpenAPI docs (Swagger UI) |
 
 The reads (`GET`) and the delete are gated by Airflow RBAC — see below.
 
@@ -268,6 +293,26 @@ Download them from a report's detail view, or `GET
 | `AIRFLOW_PYTEST_REPORTS_ROOT` (env) | — | report root (highest precedence) |
 | `[pytest_reports] reports_root` (cfg) | — | report root |
 | built-in default | `/opt/airflow/pytest-reports` | fallback |
+| `AIRFLOW_PYTEST_PLUGIN_ENABLE` (env) | `True` | reader on/off — see below |
+| `AIRFLOW_PYTEST_SCAN_CACHE_TTL` (env) | `2.0` | seconds a directory scan is reused (`0` disables) |
+
+**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
+with Airflow; any other value, or leaving it unset, keeps it on (the default).
+This is a kill switch for the reader only — the producer-side
+`ArchivingResultParser` still archives reports regardless. It is read once at
+plugin discovery, so toggling it takes effect on the next API-server restart.
+
+```bash
+export AIRFLOW_PYTEST_PLUGIN_ENABLE=false   # hide the Pytest Reports UI + API
+```
+
+**Scan cache.** Loading the home page hits several summary-driven endpoints (the run
+list, the flaky panel, the unique-tests count), and the filter box queries as you
+type. To avoid walking the report tree once per call, the filesystem source reuses a
+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.
 
 ## Architecture (SOLID)
 

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/README.md

@@ -26,7 +26,9 @@ The operator runs a `pytest` suite as an Airflow task and parses the JUnit
 report into a structured result. This plugin archives each of those reports —
 keyed by `dag_id / run_id / task_id / try` — and serves a small web UI to browse
 them: pass/fail counts per run, durations, and the per-test breakdown (with
-failure messages) for any run.
+failure messages) for any run. On top of that it adds **cross-run analytics** —
+flaky-test detection, per-test history, run-to-run comparison, a duration
+histogram, and a searchable catalogue of unique tests.
 
 It has two halves that share one on-disk layout:
 
@@ -52,17 +54,34 @@ It has two halves that share one on-disk layout:
 ## Screenshots
 
 **Overview** — the run list with the historical chart (per-status legend
-toggles, run numbers, and a carousel beyond 30 runs), KPI cards, and Airflow-
+toggles, run numbers, and a carousel beyond 30 runs) beside a **flaky-tests
+panel**, KPI cards (including a clickable **unique tests** count), and Airflow-
 matched colours and font:
 
 ![Pytest Reports — overview](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/overview.png)
 
-**A single run** — a clickable success donut (pass-rate in the centre; click a
-slice to filter by status), the counts, and every test's captured output on
-expand:
+**A single run** — a clickable success donut (pass-rate over the test count;
+click a slice to filter by status), a **test-duration histogram** (10-second
+buckets, scrollable), case search / group-by-module, and every test's captured
+output on expand:
 
 ![Pytest Reports — a single run](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/detail.png)
 
+**Flaky tests & comparison** — from a run, *Flaky tests* lists the tests that
+both pass and fail across recent runs (with a recent-outcome strip), and
+*Compare to previous* diffs it against the prior 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)
+
+**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:
+
+![Pytest Reports — unique tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/unique.png)
+
+![Pytest Reports — failed tests](https://raw.githubusercontent.com/IKrysanov/airflow-pytest-plugin/main/docs/screenshots/failures.png)
+
 ---
 
 ## Install
@@ -164,10 +183,16 @@ 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/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=` | tests that both pass and fail over 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`) |
 | `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` | `{"status": "ok"}` |
-| `GET /api/docs` | OpenAPI docs |
+| `GET /api/health` | liveness + readiness: `status`, `ready`, `reports_root`(+`_exists`), `auth`, `secure_xml` |
+| `GET /api/version` | `{"name": ..., "version": ...}` from package metadata |
+| `GET /api/docs` | OpenAPI docs (Swagger UI) |
 
 The reads (`GET`) and the delete are gated by Airflow RBAC — see below.
 
@@ -224,6 +249,26 @@ Download them from a report's detail view, or `GET
 | `AIRFLOW_PYTEST_REPORTS_ROOT` (env) | — | report root (highest precedence) |
 | `[pytest_reports] reports_root` (cfg) | — | report root |
 | built-in default | `/opt/airflow/pytest-reports` | fallback |
+| `AIRFLOW_PYTEST_PLUGIN_ENABLE` (env) | `True` | reader on/off — see below |
+| `AIRFLOW_PYTEST_SCAN_CACHE_TTL` (env) | `2.0` | seconds a directory scan is reused (`0` disables) |
+
+**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
+with Airflow; any other value, or leaving it unset, keeps it on (the default).
+This is a kill switch for the reader only — the producer-side
+`ArchivingResultParser` still archives reports regardless. It is read once at
+plugin discovery, so toggling it takes effect on the next API-server restart.
+
+```bash
+export AIRFLOW_PYTEST_PLUGIN_ENABLE=false   # hide the Pytest Reports UI + API
+```
+
+**Scan cache.** Loading the home page hits several summary-driven endpoints (the run
+list, the flaky panel, the unique-tests count), and the filter box queries as you
+type. To avoid walking the report tree once per call, the filesystem source reuses a
+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.
 
 ## Architecture (SOLID)
 

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/pyproject.toml

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

airflow_pytest_plugin-0.3.0/src/airflow_pytest_plugin/config.py

@@ -0,0 +1,79 @@
+# Copyright 2026 the airflow-pytest-plugin contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Resolve the report root (env, then Airflow config, then default)."""
+
+from __future__ import annotations
+
+import os
+
+from .compat import get_conf_value
+
+ENV_VAR = "AIRFLOW_PYTEST_REPORTS_ROOT"
+CONF_SECTION = "pytest_reports"
+CONF_KEY = "reports_root"
+DEFAULT_ROOT = "/opt/airflow/pytest-reports"
+
+#: Toggles whether the reader plugin (UI + API) registers with Airflow. Default on.
+ENABLE_ENV_VAR = "AIRFLOW_PYTEST_PLUGIN_ENABLE"
+_FALSEY = frozenset({"0", "false", "no", "off", "n", "f"})
+
+
+def is_plugin_enabled() -> bool:
+    """Whether the reader plugin should register with Airflow.
+
+    Reads ``AIRFLOW_PYTEST_PLUGIN_ENABLE`` -- ``True`` (the default when unset/empty)
+    registers the UI + API; a falsey value (``0``/``false``/``no``/``off``) disables
+    it. Only gates the reader; the producer-side parser is unaffected.
+    """
+    raw = os.environ.get(ENABLE_ENV_VAR)
+    if raw is None or not raw.strip():
+        return True
+    return raw.strip().lower() not in _FALSEY
+
+
+#: How long (seconds) the filesystem source may reuse a directory scan. A short
+#: window lets the several summary-driven endpoints on one page load (list + flaky +
+#: unique-tests, plus filter typing) share one tree walk instead of rescanning each.
+SCAN_TTL_ENV_VAR = "AIRFLOW_PYTEST_SCAN_CACHE_TTL"
+DEFAULT_SCAN_TTL = 2.0
+
+
+def get_scan_cache_ttl() -> float:
+    """Resolve the directory-scan cache TTL in seconds (``0`` disables caching).
+
+    Reads ``AIRFLOW_PYTEST_SCAN_CACHE_TTL``; falls back to ``DEFAULT_SCAN_TTL``.
+    A malformed or negative value falls back to the default.
+    """
+    raw = os.environ.get(SCAN_TTL_ENV_VAR)
+    if raw is None or not raw.strip():
+        return DEFAULT_SCAN_TTL
+    try:
+        ttl = float(raw.strip())
+    except ValueError:
+        return DEFAULT_SCAN_TTL
+    return ttl if ttl >= 0 else DEFAULT_SCAN_TTL
+
+
+def get_reports_root() -> str:
+    """Resolve the report root directory (absolute path)."""
+    env = os.environ.get(ENV_VAR)
+    if env and env.strip():
+        return os.path.abspath(env.strip())
+
+    conf = get_conf_value(CONF_SECTION, CONF_KEY)
+    if conf and conf.strip():
+        return os.path.abspath(conf.strip())
+
+    return os.path.abspath(DEFAULT_ROOT)

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/src/airflow_pytest_plugin/plugin.py

@@ -20,6 +20,7 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from .compat import get_airflow_plugin_base
+from .config import ENABLE_ENV_VAR, is_plugin_enabled
 
 _log = logging.getLogger(__name__)
 
@@ -73,9 +74,16 @@ else:
         _Base = object
 
 
+#: Kill switch: when AIRFLOW_PYTEST_PLUGIN_ENABLE is falsey the reader registers
+#: nothing (no app, no nav link), so the UI/API are unavailable.
+_ENABLED = is_plugin_enabled()
+if not _ENABLED:
+    _log.info("Pytest Reports reader disabled via %s; not registering.", ENABLE_ENV_VAR)
+
+
 class PytestReportsPlugin(_Base):
-    """Exposes the Pytest Reports UI to Airflow."""
+    """Exposes the Pytest Reports UI to Airflow (unless disabled via the env var)."""
 
     name = "pytest_reports"
-    fastapi_apps = _build_fastapi_apps()
-    external_views = _build_external_views()
+    fastapi_apps = _build_fastapi_apps() if _ENABLED else []
+    external_views = _build_external_views() if _ENABLED else []

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/src/airflow_pytest_plugin/producer/archiving_parser.py

@@ -163,6 +163,9 @@ class ArchivingResultParser(JUnitResultParser):  # type: ignore[misc]
             "report_file": REPORT_FILENAME,
             "allure": self._archive_allure(out_dir, ref),
             "summary": result.to_xcom(),
+            # Compact per-test outcomes [node_id, outcome, duration] so cross-run
+            # views (compare/flaky/history) need not re-parse junit.xml.
+            "tests": _test_rows(result),
         }
         # Atomic write: a reader scanning concurrently never sees a half file.
         tmp = os.path.join(out_dir, f".{META_FILENAME}.{uuid.uuid4().hex}.tmp")
@@ -229,6 +232,18 @@ def _first_int(*values: Any, default: int) -> int:
     return default
 
 
+def _test_rows(result: TestRunResult) -> list[list[Any]]:
+    """Compact ``[node_id, outcome, duration]`` rows for cross-run views."""
+    rows: list[list[Any]] = []
+    for c in getattr(result, "cases", ()) or ():
+        try:
+            dur = round(float(getattr(c, "time", 0.0) or 0.0), 3)
+        except (TypeError, ValueError):
+            dur = 0.0
+        rows.append([c.node_id, c.outcome, dur])
+    return rows
+
+
 def _logical_date(context: dict[str, Any] | None) -> str | None:
     if not context:
         return None

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/src/airflow_pytest_plugin/sources/base.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from typing import Any
 
 from ..models import ReportDetail, ReportRef, ReportSummary
 
@@ -50,3 +51,11 @@ class ReportSource(ABC):
         Optional capability (default: unsupported) for exporting to Allure TestOps.
         """
         return None
+
+    def test_outcomes(self, ref: ReportRef) -> dict[str, dict[str, Any]] | None:
+        """Map ``node_id -> {"outcome", "duration"}`` for one run, or ``None``.
+
+        Powers cross-run views (compare/flaky/history). Optional capability
+        (default: unsupported).
+        """
+        return None

{airflow_pytest_plugin-0.2.0 → airflow_pytest_plugin-0.3.0}/src/airflow_pytest_plugin/sources/filesystem.py

@@ -21,22 +21,28 @@ import json
 import logging
 import os
 import shutil
+import threading
+import time
 import zipfile
 from pathlib import Path
 from typing import Any
 
 from airflow_pytest_operator import JUnitResultParser
 
-from ..config import get_reports_root
+from ..config import get_reports_root, get_scan_cache_ttl
 from ..layout import ALLURE_DIRNAME, META_FILENAME, REPORT_FILENAME, ReportLayout
 from ..models import CaseView, ReportDetail, ReportRef, ReportSummary
 from .base import ReportSource
 
 try:  # prefer the hardened parser when present (matches the operator)
     from defusedxml.ElementTree import parse as _xml_parse
+
+    _SECURE_XML = True
 except Exception:  # pragma: no cover - fallback path
     from xml.etree.ElementTree import parse as _xml_parse
 
+    _SECURE_XML = False
+
 _log = logging.getLogger(__name__)
 
 #: Cap one case's captured output so a pathological report can't bloat a response.
@@ -52,42 +58,81 @@ class FileSystemReportSource(ReportSource):
         report_root: str | None = None,
         layout: ReportLayout | None = None,
         parser: JUnitResultParser | None = None,
+        scan_cache_ttl: float | None = None,
     ) -> None:
         self._report_root = os.path.abspath(report_root or get_reports_root())
         self._layout = layout or ReportLayout()
         self._parser = parser or JUnitResultParser()
+        self._scan_ttl = (
+            get_scan_cache_ttl() if scan_cache_ttl is None else scan_cache_ttl
+        )
+        # (monotonic_timestamp, summaries); guarded so concurrent requests on a cold
+        # cache do a single tree walk rather than one each (single-flight).
+        self._scan_cache: tuple[float, list[ReportSummary]] | None = None
+        self._scan_lock = threading.Lock()
 
     @property
     def report_root(self) -> str:
         return self._report_root
 
-    def list_summaries(
-        self,
-        *,
-        dag_id: str | None = None,
-        run_id: str | None = None,
-    ) -> list[ReportSummary]:
+    @property
+    def secure_xml(self) -> bool:
+        """Whether JUnit XML is parsed with the hardened ``defusedxml`` parser."""
+        return _SECURE_XML
+
+    def _scan_disk(self) -> list[ReportSummary]:
+        """Walk the tree and build every summary, newest first (uncached)."""
         root = Path(self._report_root)
         if not root.is_dir():
             return []
-
-        summaries: list[ReportSummary] = []
+        out: list[ReportSummary] = []
         for meta_file in root.rglob(META_FILENAME):
             meta = self._load_meta(meta_file)
             if meta is None:
                 continue
             summary = self._summary_from_meta(meta)
-            if summary is None:
-                continue
-            if dag_id and dag_id.lower() not in summary.ref.dag_id.lower():
-                continue
-            if run_id and run_id.lower() not in summary.ref.run_id.lower():
-                continue
-            summaries.append(summary)
-
+            if summary is not None:
+                out.append(summary)
         # Newest first: ISO-8601 created_at sorts chronologically; missing sorts last.
-        summaries.sort(key=lambda s: s.created_at or "", reverse=True)
-        return summaries
+        out.sort(key=lambda s: s.created_at or "", reverse=True)
+        return out
+
+    def _all_summaries(self) -> list[ReportSummary]:
+        """The full scan, reused within the TTL so a page's several summary-driven
+        endpoints share one tree walk. ``ttl <= 0`` disables caching."""
+        if self._scan_ttl <= 0:
+            return self._scan_disk()
+        cached = self._scan_cache
+        if cached is not None and (time.monotonic() - cached[0]) < self._scan_ttl:
+            return cached[1]
+        with self._scan_lock:
+            # Re-check: another thread may have refreshed while we waited on the lock.
+            cached = self._scan_cache
+            if cached is not None and (time.monotonic() - cached[0]) < self._scan_ttl:
+                return cached[1]
+            fresh = self._scan_disk()
+            self._scan_cache = (time.monotonic(), fresh)
+            return fresh
+
+    def _invalidate_scan(self) -> None:
+        self._scan_cache = None
+
+    def list_summaries(
+        self,
+        *,
+        dag_id: str | None = None,
+        run_id: str | None = None,
+    ) -> list[ReportSummary]:
+        d = dag_id.lower() if dag_id else None
+        r = run_id.lower() if run_id else None
+        summaries = self._all_summaries()
+        # Filter into a fresh list -- never hand back (or sort) the cached one.
+        return [
+            s
+            for s in summaries
+            if (not d or d in s.ref.dag_id.lower())
+            and (not r or r in s.ref.run_id.lower())
+        ]
 
     def get_detail(self, ref: ReportRef) -> ReportDetail | None:
         # Token is attacker-controlled: bound the directory before reading.
@@ -136,6 +181,40 @@ class FileSystemReportSource(ReportSource):
         )
         return ReportDetail(summary=summary, cases=cases)
 
+    def test_outcomes(self, ref: ReportRef) -> dict[str, dict[str, Any]] | None:
+        report_dir = self._safe_dir(ref)
+        if report_dir is None:
+            return None
+        meta = self._load_meta(Path(os.path.join(report_dir, META_FILENAME)))
+        rows = meta.get("tests") if isinstance(meta, dict) else None
+        if isinstance(rows, list):
+            out: dict[str, dict[str, Any]] = {}
+            for row in rows:
+                if isinstance(row, (list, tuple)) and len(row) >= 2 and row[0]:
+                    dur = (
+                        float(row[2])
+                        if len(row) > 2 and isinstance(row[2], int | float)
+                        else 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.
+        report_path = os.path.join(report_dir, REPORT_FILENAME)
+        if not os.path.isfile(report_path):
+            return None
+        try:
+            result = self._parser.parse(report_path)
+        except Exception:
+            _log.exception("Failed to parse JUnit report %s", report_path)
+            return None
+        return {
+            c.node_id: {
+                "outcome": c.outcome,
+                "duration": float(getattr(c, "time", 0.0) or 0.0),
+            }
+            for c in result.cases
+        }
+
     def delete(self, ref: ReportRef) -> bool:
         target = self._safe_dir(ref)
         if target is None or not os.path.isdir(target):
@@ -145,6 +224,7 @@ class FileSystemReportSource(ReportSource):
         self._prune_empty_parents(
             os.path.dirname(target), os.path.realpath(self._report_root)
         )
+        self._invalidate_scan()  # the deleted run must drop out of the list at once
         _log.info("Deleted report %s", target)
         return True