Tests tab: a bookmark's test results over its runs (part 2) 36e5a9c15a84

//! The Tests tab (oxygenhub#114): a bookmark's test results from its runs'

//! JUnit reports, their trend, what changed against the run before, the

//! slowest tests, and those that failed and passed across recent runs.

use super::coverage::{chart, compact, Point, Series};

use super::{filters, lookup, Error, Page, RepoShell, Shell};

use crate::auth::Viewer;

use crate::junit::{self, Case, Flaky, Report};

use crate::Shared;

use askama::Template;

use axum::extract::{Path, Query, State};

use serde::Deserialize;

/// Reports the charts and the recent list draw on.

const HISTORY: i64 = 200;

/// Runs listed under Recent runs.

const RECENT: usize = 10;

/// Runs a test must have failed and passed in to be listed as flaky.

const FLAKY_RUNS: usize = 30;

/// Rows of the slowest and flaky lists, and of the changed lists.

const LISTED: i64 = 15;

#[derive(Deserialize, Default)]

pub struct TestsQuery {

    /// A bookmark other than the default.

    bookmark: Option<String>,

    /// One report, by id.

    report: Option<i64>,

}

/// A run in the Recent runs list.

pub struct RecentRow {

    pub report: Report,

    /// Tests added against the report before it.

    pub delta: Option<i64>,

}

/// A test whose result changed against the run before.

pub struct Changed {

    pub title: String,

    pub status: String,

}

#[derive(Template)]

#[template(path = "tests.html")]

pub struct TestsPage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    bookmarks: Vec<String>,

    report: Option<Report>,

    previous: Option<Report>,

    /// Tests that fail now and passed in the run before.

    broke: Vec<Changed>,

    /// Tests that pass now and failed in the run before.

    fixed: Vec<Changed>,

    /// Tests new since the run before.

    added: usize,

    failures: Vec<Case>,

    slowest: Vec<Case>,

    flaky: Vec<Flaky>,

    flaky_runs: usize,

    rate_chart: String,

    count_chart: String,

    runs: usize,

    first_ms: Option<i64>,

    recent: Vec<RecentRow>,

}

/// Passed of the tests that ran (skipped ones left out), as a percentage.

pub fn pass_rate(r: &Report) -> Option<f64> {

    let ran = r.tests - r.skipped;

    (ran > 0).then(|| r.passed as f64 * 100.0 / ran as f64)

}

impl TestsPage {

    pub fn rate(&self, r: &Report) -> String {

        match pass_rate(r) {

            Some(p) if p >= 99.95 => "100%".into(),

            Some(p) => format!("{p:.1}%"),

            None => "–".into(),

        }

    }

    /// A colour class: all passing, a few failing, many.

    pub fn class_of(&self, r: &Report) -> &'static str {

        match pass_rate(r) {

            None => "cov-none",

            Some(_) if r.broken() == 0 => "cov-good",

            Some(p) if p >= 95.0 => "cov-low",

            Some(_) => "cov-poor",

        }

    }

    pub fn time(&self, ms: &i64) -> String {

        crate::flow::human_ms(*ms)

    }

    pub fn signed(&self, d: &i64) -> String {

        if *d == 0 {

            "±0".into()

        } else {

            format!("{d:+}")

        }

    }

    pub fn count_delta(&self) -> Option<i64> {

        Some(self.report.as_ref()?.tests - self.previous.as_ref()?.tests)

    }

    pub fn time_delta(&self) -> Option<String> {

        let (r, p) = (self.report.as_ref()?, self.previous.as_ref()?);

        if p.time_ms == 0 {

            return None;

        }

        let d = (r.time_ms - p.time_ms) as f64 * 100.0 / p.time_ms as f64;

        (d.abs() >= 1.0).then(|| format!("{d:+.0}%"))

    }

}

/// `GET /{owner}/{name}/tests`.

pub async fn overview(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<TestsQuery>,

) -> Result<Page<TestsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/tests"), &viewer);

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let picked = match q.report {

        Some(id) => Some(junit::report(&app.db, row.id, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?),

        None => None,

    };

    let bookmark = picked.as_ref().map(|r| r.bookmark.clone()).or(q.bookmark.clone()).unwrap_or_else(|| row.default_bookmark.clone());

    let bookmarks = junit::bookmarks(&app.db, row.id).await.map_err(e)?;

    let history = junit::on_bookmark(&app.db, row.id, &bookmark, HISTORY).await.map_err(e)?;

    let report = picked.or_else(|| history.first().cloned());

    // The report before the one shown, of the same job on the bookmark.

    let previous = report.as_ref().and_then(|r| {

        history.iter().find(|h| h.job == r.job && (h.created_ms < r.created_ms || (h.created_ms == r.created_ms && h.id < r.id))).cloned()

    });

    let (mut broke, mut fixed, mut added) = (vec![], vec![], 0);

    let (mut failures, mut slowest) = (vec![], vec![]);

    if let Some(r) = &report {

        failures = junit::failures(&app.db, r.id, 50).await.map_err(e)?;

        slowest = junit::slowest(&app.db, r.id, LISTED).await.map_err(e)?;

        if let Some(p) = &previous {

            let now = junit::statuses(&app.db, r.id).await.map_err(e)?;

            let before = junit::statuses(&app.db, p.id).await.map_err(e)?;

            let bad = |s: &str| s == "failed" || s == "error";

            let title = |(c, n): &(String, String)| if c.is_empty() { n.clone() } else { format!("{c}::{n}") };

            for (k, s) in &now {

                match before.get(k) {

                    None => added += 1,

                    Some(b) if bad(s) && !bad(b) => broke.push(Changed { title: title(k), status: s.clone() }),

                    Some(b) if s == "passed" && bad(b) => fixed.push(Changed { title: title(k), status: s.clone() }),

                    _ => {}

                }

            }

            broke.sort_by(|a, b| a.title.cmp(&b.title));

            fixed.sort_by(|a, b| a.title.cmp(&b.title));

            broke.truncate(LISTED as usize);

            fixed.truncate(LISTED as usize);

        }

    }

    let recent_ids: Vec<i64> = history.iter().take(FLAKY_RUNS).map(|r| r.id).collect();

    let flaky = junit::flaky(&app.db, &recent_ids, LISTED).await.map_err(e)?;

    let repo = RepoShell::new(&app, &row, "tests").with_role(role);

    // Charts: oldest on the left.

    let oldest_first: Vec<&Report> = history.iter().rev().filter(|r| r.tests > 0).collect();

    let points: Vec<Point> = oldest_first

        .iter()

        .map(|r| Point {

            run: r.run_number,

            href: format!("{}/tests?report={}", repo.url, r.id),

            tip: format!("Run #{} · {} · {}", r.run_number, r.summary(), crate::flow::human_ms(r.time_ms)),

        })

        .collect();

    let rates: Vec<f64> = oldest_first.iter().map(|r| pass_rate(r).unwrap_or(0.0)).collect();

    let lo = (rates.iter().copied().fold(100.0, f64::min) - 2.0).floor().max(0.0);

    let rate_chart = chart(

        &format!("Tests passing on {bookmark} over the last {} runs", oldest_first.len()),

        &points,

        &[Series { values: rates, class: "cov", floor: None }],

        lo,

        100.0,

        &|v| format!("{v:.0}%"),

    );

    let passed: Vec<f64> = oldest_first.iter().map(|r| r.passed as f64).collect();

    let top = oldest_first.iter().map(|r| r.tests - r.skipped).max().unwrap_or(0) as f64;

    let count_chart = chart(

        &format!("Tests passing and failing on {bookmark}"),

        &points,

        &[

            Series { values: passed.clone(), class: "covered", floor: None },

            Series { values: oldest_first.iter().map(|r| (r.tests - r.skipped) as f64).collect(), class: "relevant", floor: Some(passed) },

        ],

        0.0,

        (top * 1.08).max(1.0),

        &compact,

    );

    let recent = history

        .iter()

        .enumerate()

        .take(RECENT)

        .map(|(i, r)| RecentRow { report: r.clone(), delta: history.get(i + 1).filter(|p| p.job == r.job).map(|p| r.tests - p.tests) })

        .collect();

    let first_ms = junit::first_ms(&app.db, row.id).await.map_err(e)?;

    Ok(Page(TestsPage {

        shell,

        repo,

        bookmark,

        bookmarks,

        report,

        previous,

        broke,

        fixed,

        added,

        failures,

        slowest,

        flaky,

        flaky_runs: recent_ids.len(),

        rate_chart,

        count_chart,

        runs: oldest_first.len(),

        first_ms,

        recent,

    }))

}

{% extends "base.html" %}

{% import "repo_tabs.html" as m %}

{% block title %}Tests · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block tabs %}{% call m::tabs(repo, "tests") %}{% endblock %}

{% block content %}

{% if let Some(r) = report %}

<section class="cov-hero">

  <div class="cov-hero-head">

    <div>

      <h1>Tests</h1>

      <div class="cov-sub">{% if bookmarks.len() > 1 %}<form class="inline" method="get" action="{{ repo.url }}/tests"><label for="t-bm" class="mute">bookmark</label> <select id="t-bm" name="bookmark" onchange="this.form.submit()">{% for b in bookmarks %}<option value="{{ b }}"{% if b.as_str() == bookmark.as_str() %} selected{% endif %}>{{ b }}</option>{% endfor %}</select> <noscript><button>Show</button></noscript></form>{% else %}<span class="mute">on</span> <strong>{{ bookmark }}</strong>{% endif %}

        · <a href="{{ repo.url }}/flow/{{ r.run_number }}">run #{{ r.run_number }}</a> · job {{ r.job }} · <time title="{{ r.created_ms|when_i }}">{{ r.created_ms|ago_i }}</time></div>

    </div>

    <div class="cov-score {{ self.class_of(r) }}">

      <div class="cov-big">{% if r.broken() > 0 %}{{ r.broken() }} failing{% else %}{{ self.rate(r) }}{% endif %}</div>

      <div class="cov-change same">{% if r.broken() > 0 %}{{ self.rate(r) }} of {{ r.tests - r.skipped }} passed{% else %}of {{ r.tests - r.skipped }} tests passed{% endif %}</div>

    </div>

  </div>

  {% if runs > 1 %}<div class="cov-hero-chart">{{ rate_chart|safe }}</div>{% endif %}

</section>

<section class="cov-facts">

  <div><span class="k">Tests</span><span class="v">{{ r.tests }}{% if let Some(d) = self.count_delta() %} <small>{{ self.signed(d) }}</small>{% endif %}</span></div>

  <div><span class="k">Passed</span><span class="v cov-good">{{ r.passed }}</span></div>

  <div><span class="k">Failed</span><span class="v{% if r.failed > 0 %} cov-poor{% endif %}">{{ r.failed }}</span></div>

  {% if r.errors > 0 %}<div><span class="k">Errored</span><span class="v cov-poor">{{ r.errors }}</span></div>{% endif %}

  <div><span class="k">Skipped</span><span class="v">{{ r.skipped }}</span></div>

  <div><span class="k">Test time</span><span class="v">{{ self.time(r.time_ms) }}{% if let Some(d) = self.time_delta() %} <small>{{ d }}</small>{% endif %}</span></div>

  {% if let Some(t) = first_ms %}<div><span class="k">Reporting since</span><span class="v small"><time title="{{ t|when_i }}">{{ t|ago_i }}</time></span></div>{% endif %}

</section>

<div class="cov-grid">

  <section class="panel cov-card">

    <h2>This run</h2>

    <ul class="cov-stats">

      <li><strong>{{ r.passed }}</strong> of <strong>{{ r.tests - r.skipped }}</strong> tests passed <span class="{{ self.class_of(r) }}">({{ self.rate(r) }})</span>{% if r.skipped > 0 %}, {{ r.skipped }} skipped{% endif %}</li>

      {% if let Some(p) = previous %}<li>Against <a href="{{ repo.url }}/tests?report={{ p.id }}">run #{{ p.run_number }}</a>: {{ broke.len() }} newly failing, {{ fixed.len() }} fixed{% if added > 0 %}, {{ added }} new tests{% endif %}</li>{% else %}<li>The first report of job {{ r.job }} here</li>{% endif %}

    </ul>

    {% if !broke.is_empty() %}<h3>Newly failing</h3>

    <ul class="t-list">{% for c in broke %}<li><span class="cov-poor">✕</span> <code>{{ c.title }}</code></li>{% endfor %}</ul>{% endif %}

    {% if !fixed.is_empty() %}<h3>Fixed</h3>

    <ul class="t-list">{% for c in fixed %}<li><span class="cov-good">✓</span> <code>{{ c.title }}</code></li>{% endfor %}</ul>{% endif %}

  </section>

  <section class="panel cov-card">

    <h2>Flaky <small class="mute">failed and passed in the last {{ flaky_runs }} runs</small></h2>

    {% if flaky.is_empty() %}<p class="mute small">None: every test kept its result.</p>{% else %}

    <table class="cov-moved">{% for f in flaky %}<tr><td><code>{{ f.title() }}</code></td><td class="num"><span class="cov-poor">{{ f.failed }} ✕</span> <span class="cov-good">{{ f.passed }} ✓</span></td></tr>{% endfor %}</table>{% endif %}

  </section>

</div>

{% if !failures.is_empty() %}<section class="panel">

  <h2>Failures <small class="mute">{{ r.broken() }} in run #{{ r.run_number }}{% if r.broken() > failures.len() as i64 %}, the first {{ failures.len() }} shown{% endif %}</small></h2>

  <div class="flow-tests">{% for f in failures %}<details class="tests-failure">

    <summary><span class="bad">{% if f.status == "error" %}!{% else %}✕{% endif %}</span> <code>{{ f.title() }}</code>{% if !f.message.is_empty() %} <span class="small mute">{{ f.message }}</span>{% endif %}</summary>

    {% if !f.output.is_empty() %}<pre class="flow-log">{{ f.output }}</pre>{% endif %}

  </details>{% endfor %}</div>

</section>{% endif %}

{% if runs > 1 %}<section class="panel">

  <h2>Tests run <small class="mute"><span class="cov-key covered">passed</span> <span class="cov-key relevant">failed</span></small></h2>

  {{ count_chart|safe }}

</section>{% endif %}

<section class="panel">

  <h2>Slowest tests <small class="mute">in run #{{ r.run_number }}</small></h2>

  <div class="table"><table class="cov-files">

  <tr><th>Test</th><th class="num">Time</th></tr>

  {% for c in slowest %}<tr><td><code>{{ c.title() }}</code>{% if c.status != "passed" %} <span class="cov-poor small">{{ c.status }}</span>{% endif %}</td><td class="num">{{ self.time(c.time_ms) }}</td></tr>{% endfor %}

  </table></div>

</section>

{% if recent.len() > 1 %}<section class="panel">

  <h2>Recent runs on {{ bookmark }}</h2>

  <div class="table"><table class="cov-runs">

  <tr><th>Run</th><th>Job</th><th>Passing</th><th class="num">Tests</th><th class="num">Failed</th><th class="num">Time</th><th>When</th></tr>

  {% for x in recent %}<tr{% if x.report.id == r.id %} class="on"{% endif %}>

    <td><a href="{{ repo.url }}/tests?report={{ x.report.id }}">#{{ x.report.run_number }}</a></td>

    <td>{{ x.report.job }}</td>

    <td><span class="cov-bar {{ self.class_of(x.report) }}"><span style="width: {% if let Some(p) = crate::web::test_reports::pass_rate(x.report) %}{{ p }}{% else %}0{% endif %}%"></span></span> {{ self.rate(x.report) }}</td>

    <td class="num">{{ x.report.tests }}{% if let Some(d) = x.delta %}{% if *d != 0 %} <small class="mute">{{ self.signed(d) }}</small>{% endif %}{% endif %}</td>

    <td class="num">{% if x.report.broken() > 0 %}<span class="cov-poor">{{ x.report.broken() }}</span>{% else %}0{% endif %}</td>

    <td class="num">{{ self.time(x.report.time_ms) }}</td>

    <td class="small"><time title="{{ x.report.created_ms|when_i }}">{{ x.report.created_ms|ago_i }}</time></td>

  </tr>{% endfor %}

  </table></div>

</section>{% endif %}

{% else %}

<div class="head"><h1>Tests <small>of {{ bookmark }}</small></h1></div>

<section class="panel">

  <p>No test report for <strong>{{ bookmark }}</strong> yet.</p>

  <p>Give a job in <code>.flow/pipeline.kdl</code> an artifact named <code>junit</code> holding a JUnit XML report, kept with <code>when "always"</code> so a failing run still sends it. For pytest:</p>

<pre>job "test" {

    sandbox "python"

    exec "pytest" "--junitxml=/src/out/junit.xml"

    output {

        artifact "junit" {

            path "/src/out/junit.xml"

            when "always"

        }

    }

}</pre>

  <p class="small mute">cargo-nextest (a <code>junit</code> profile), Jest's junit reporter and gotestsum write JUnit XML too.</p>

</section>

{% endif %}

{% endblock %}

    mark(app, o.repo_id);

/// Which repositories have test reports, for the Tests tab; keyed by data

/// directory as well, for tests running several hubs in one process.

static HAS: std::sync::Mutex<Option<std::collections::HashSet<String>>> = std::sync::Mutex::new(None);

fn key(app: &Shared, repo_id: i64) -> String {

    format!("{}#{repo_id}", app.repos.root().display())

}

pub fn has_reports(app: &Shared, repo_id: i64) -> bool {

    HAS.lock().unwrap_or_else(|p| p.into_inner()).as_ref().is_some_and(|s| s.contains(&key(app, repo_id)))

}

fn mark(app: &Shared, repo_id: i64) {

    HAS.lock().unwrap_or_else(|p| p.into_inner()).get_or_insert_with(Default::default).insert(key(app, repo_id));

}

/// At start: which repositories have reports.

pub async fn load(app: &Shared) -> sqlx::Result<()> {

    let ids: Vec<(i64,)> = sqlx::query_as("SELECT DISTINCT repo_id FROM test_reports").fetch_all(&app.db).await?;

    for (id,) in ids {

        mark(app, id);

    }

    Ok(())

}

pub async fn report(pool: &Pool, repo_id: i64, id: i64) -> sqlx::Result<Option<Report>> {

    sqlx::query_as("SELECT * FROM test_reports WHERE id = ? AND repo_id = ?").bind(id).bind(repo_id).fetch_optional(pool).await

}

/// The newest reports on a bookmark, newest first.

pub async fn on_bookmark(pool: &Pool, repo_id: i64, bookmark: &str, limit: i64) -> sqlx::Result<Vec<Report>> {

    sqlx::query_as("SELECT * FROM test_reports WHERE repo_id = ? AND bookmark = ? ORDER BY created_ms DESC, id DESC LIMIT ?")

        .bind(repo_id)

        .bind(bookmark)

        .bind(limit)

        .fetch_all(pool)

        .await

}

/// Bookmarks with reports, the most recently reported first.

pub async fn bookmarks(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<String>> {

    let rows: Vec<(String,)> =

        sqlx::query_as("SELECT bookmark FROM test_reports WHERE repo_id = ? GROUP BY bookmark ORDER BY MAX(created_ms) DESC")

            .bind(repo_id)

            .fetch_all(pool)

            .await?;

    Ok(rows.into_iter().map(|(b,)| b).collect())

}

pub async fn first_ms(pool: &Pool, repo_id: i64) -> sqlx::Result<Option<i64>> {

    sqlx::query_scalar("SELECT MIN(created_ms) FROM test_reports WHERE repo_id = ?").bind(repo_id).fetch_one(pool).await

}

/// A report's slowest cases.

pub async fn slowest(pool: &Pool, report_id: i64, limit: i64) -> sqlx::Result<Vec<Case>> {

    sqlx::query_as(

        "SELECT suite, classname, name, status, time_ms, message, '' AS output FROM test_cases \

         WHERE report_id = ? AND status != 'skipped' ORDER BY time_ms DESC, idx LIMIT ?",

    )

    .bind(report_id)

    .bind(limit)

    .fetch_all(pool)

    .await

}

/// Every case of a report as `(classname, name) -> status`.

pub async fn statuses(pool: &Pool, report_id: i64) -> sqlx::Result<std::collections::HashMap<(String, String), String>> {

    let rows: Vec<(String, String, String)> =

        sqlx::query_as("SELECT classname, name, status FROM test_cases WHERE report_id = ?").bind(report_id).fetch_all(pool).await?;

    Ok(rows.into_iter().map(|(c, n, s)| ((c, n), s)).collect())

}

/// A test that both failed and passed across some reports.

#[derive(Clone, Debug, sqlx::FromRow)]

pub struct Flaky {

    pub classname: String,

    pub name: String,

    pub failed: i64,

    pub passed: i64,

}

impl Flaky {

    pub fn title(&self) -> String {

        if self.classname.is_empty() {

            self.name.clone()

        } else {

            format!("{}::{}", self.classname, self.name)

        }

    }

}

/// Tests that failed in some of `reports` and passed in others, the most

/// often failing first: flaky, or broken and fixed again.

pub async fn flaky(pool: &Pool, reports: &[i64], limit: i64) -> sqlx::Result<Vec<Flaky>> {

    if reports.is_empty() {

        return Ok(vec![]);

    }

    let ids = reports.iter().map(|i| i.to_string()).collect::<Vec<_>>().join(",");

    sqlx::query_as(&format!(

        "SELECT classname, name, SUM(status IN ('failed', 'error')) AS failed, SUM(status = 'passed') AS passed \

         FROM test_cases WHERE report_id IN ({ids}) GROUP BY classname, name \

         HAVING failed > 0 AND passed > 0 ORDER BY failed DESC, classname, name LIMIT ?"

    ))

    .bind(limit)

    .fetch_all(pool)

    .await

}

    junit::load(&app).await?;

pub(super) fn compact(v: f64) -> String {

pub(super) struct Series<'a> {

    pub values: Vec<f64>,

    pub class: &'a str,

    pub floor: Option<Vec<f64>>,

/// A run on a chart: its number, where a click goes, what a hover says.

pub(super) struct Point {

    pub run: i64,

    pub href: String,

    pub tip: String,

}

pub(super) fn chart(label: &str, runs: &[Point], series: &[Series], lo: f64, hi: f64, fmt: &dyn Fn(f64) -> String) -> String {

            r#"<a href="{href}"><rect class="hit" x="{rx:.1}" y="{top}" width="{col:.1}" height="{ph}"><title>{t}</title></rect></a>"#,

            href = r.href,

            t = r.tip,

            first = runs[0].run,

            last = runs[n - 1].run,

    let points: Vec<Point> = oldest_first

        .iter()

        .map(|r| Point { run: r.run_number, href: format!("{}/coverage?report={}", repo.url, r.id), tip: tip(r) })

        .collect();

        &points,

        &points,

pub mod test_reports;

        .route("/{owner}/{name}/tests", get(test_reports::overview))

    /// Whether it has test reports, for the Tests tab (#114).

    pub tests: bool,

            tests: crate::junit::has_reports(app, row.id),

/// The Tests tab (#114): three runs' JUnit reports on a bookmark; a test

/// breaks in the second and is fixed in the third.

#[tokio::test(flavor = "multi_thread")]

async fn junit_reports_make_a_tests_tab() {

    let h = hub().await;

    create(&h.app, "andy", "t").await;

    let url = format!("{}/andy/t", h.base);

    let work = tempfile::tempdir().unwrap();

    let c = client(&url, work.path());

    write(

        work.path(),

        ".flow/pipeline.kdl",

        &format!(

            "schema-version 1\nsandbox \"alpine\" {{\n    rootfs \"cas://blob/{ROOTFS}\"\n}}\njob \"test\" {{\n    sandbox \"alpine\"\n    exec \"make\" \"test\"\n    output {{\n        artifact \"junit\" {{\n            path \"/src/junit.xml\"\n        }}\n    }}\n}}\n"

        ),

    );

    assert!(!call(&h.app, "GET", "/andy/t", None, None).await.1.contains(">Tests</a>"));

    let case = |name: &str, ok: bool, secs: &str| {

        if ok {

            format!(r#"<testcase classname="t.suite" name="{name}" time="{secs}"/>"#)

        } else {

            format!(

                r#"<testcase classname="t.suite" name="{name}" time="{secs}"><failure message="{name} broke">AssertionError</failure></testcase>"#

            )

        }

    };

    let runs = [

        vec![case("a", true, "0.1"), case("b", true, "2.5"), case("c", true, "0.2")],

        vec![case("a", true, "0.1"), case("b", false, "2.6"), case("c", true, "0.2"), case("d", true, "0.3")],

        vec![case("a", true, "0.1"), case("b", true, "2.4"), case("c", true, "0.2"), case("d", true, "0.3")],

    ];

    for (i, cases) in runs.iter().enumerate() {

        write(work.path(), "n.txt", &i.to_string());

        c.snapshot("test").unwrap();

        c.commit(&format!("Run {i}"), &[]).unwrap();

        assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

        // The run is made after the push answers.

        let mut a = None;

        for _ in 0..100 {

            a = claim(&h.app).await;

            if a.is_some() {

                break;

            }

            tokio::time::sleep(std::time::Duration::from_millis(50)).await;

        }

        let a = a.expect("a job to claim");

        let id = a["job_id"].as_i64().unwrap();

        let xml = format!("<testsuites><testsuite name=\"t\">{}</testsuite></testsuites>", cases.concat());

        assert_eq!(upload(&h.app, id, "junit", xml.as_bytes()).await.0, StatusCode::OK);

        let failed = cases.iter().any(|c| c.contains("<failure"));

        let mut r = receipt("test", a["pipeline_hash"].as_str().unwrap(), failed as u32);

        if !failed {

            r["outputs"] = serde_json::json!([oxy_core::repo::Repo::blob_ref(xml.as_bytes()).to_hex()]);

        }

        let code = failed as i32;

        assert_eq!(

            finish(&h.app, id, serde_json::json!({ "exit_code": code, "duration_ms": 700, "receipt": r })).await,

            StatusCode::NO_CONTENT

        );

    }

    let (st, page) = call(&h.app, "GET", "/andy/t/tests", None, None).await;

    assert_eq!(st, StatusCode::OK, "{page}");

    if let Some(out) = std::env::var_os("OXYHUB_DUMP_TESTS_PAGE") {

        std::fs::write(out, &page).unwrap();

    }

    assert!(page.contains(">Tests</a>"), "the tab");

    assert!(page.contains("100%") && page.contains("of 4 tests passed"), "the latest run passes");

    assert!(page.contains("1 fixed") && page.contains("t.suite::b"), "b fixed against the run before");

    assert!(page.contains("1 ✕") && page.contains("2 ✓"), "b is flaky: {page}");

    assert!(page.contains("<svg class=\"cov-chart\""), "charts");

    // The slowest first.

    let slow = page.find("Slowest tests").unwrap();

    assert!(page[slow..].find("t.suite::b").unwrap() < page[slow..].find("t.suite::d").unwrap());

    // The second run, picked: b newly failing, its failure listed.

    let row = db::repos::get(&h.app.db, "andy", "t").await.unwrap().unwrap();

    let second = oxygenhub::junit::on_bookmark(&h.app.db, row.id, "main", 10).await.unwrap()[1].id;

    let (_, page) = call(&h.app, "GET", &format!("/andy/t/tests?report={second}"), None, None).await;

    assert!(page.contains("1 failing") && page.contains("Newly failing") && page.contains("b broke"), "{page}");

    assert!(page.contains("1 new tests"), "d is new");

}

### 13.7 Test reports (oxygenhub#114, first two parts done 2026-10-05)

- **Tests tab.** Shown once a repository has a report: the bookmark's latest pass rate (or how many fail) over a chart of up to 200 runs, the counts and test time against the run before, the tests newly failing and fixed against that job's previous report, tests that both failed and passed in the last 30 reports (flaky), the run's failures, a passed-and-failed chart, the slowest tests and recent runs. `?report=` shows any report, `?bookmark=` another bookmark.

- **Next:** a test's history across runs, and proposals naming the tests that pass on the target and fail on the proposal.

    {% if repo.tests %}<a href="{{ repo.url }}/tests"{% if tab == "tests" %} class="on" aria-current="page"{% endif %}>Tests</a>{% endif %}

.t-list { list-style: none; padding: 0; margin: 0; line-height: 1.7; overflow-wrap: anywhere; }