Tests: a test's history, and a tests check naming what broke (part 3) 3d5c825aebba

{% extends "base.html" %}

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

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

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

{% block content %}

<div class="head"><h1><code>{{ title }}</code></h1><p class="mute"><a href="{{ repo.url }}/tests?bookmark={{ bookmark }}">Tests</a> on <strong>{{ bookmark }}</strong> · the last {{ runs.len() }} runs: <span class="cov-good">{{ passed }} passed</span>{% if failed > 0 %}, <span class="cov-poor">{{ failed }} failed</span>{% endif %}</p></div>

{% if runs.len() > 1 %}<section class="panel"><h2>Time per run</h2>{{ time_chart|safe }}</section>{% endif %}

<section class="panel">

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

  <tr><th>Run</th><th>Job</th><th>Result</th><th class="num">Time</th><th>Message</th><th>When</th></tr>

  {% for r in runs %}<tr>

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

    <td>{{ r.job }}</td>

    <td>{% if r.status == "passed" %}<span class="cov-good">✓ passed</span>{% else if r.status == "skipped" %}<span class="mute">skipped</span>{% else %}<span class="cov-poor">✕ {{ r.status }}</span>{% endif %}</td>

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

    <td class="small mute">{{ r.message }}</td>

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

  </tr>{% endfor %}

  </table></div>

</section>

{% endblock %}

    // The `tests` check on the run's state: what fails, and which of those

    // passed in the same job's latest report on the default bookmark, so a

    // proposal names what it broke.

    let base = crate::junit::baseline(&app.db, &r, &row.default_bookmark).await.map_err(|e| format!("tests: {e}"))?;

    let newly = match &base {

        Some(b) if r.broken() > 0 => crate::junit::newly_failing(&app.db, r.id, b.id).await.map_err(|e| format!("tests: {e}"))?,

        _ => vec![],

    };

    let (status, summary) = if r.broken() == 0 {

        ("passed", format!("{} passed", r.passed))

    } else if let Some(b) = &base {

        let names: Vec<&str> = newly.iter().take(3).map(String::as_str).collect();

        let more = if newly.len() > 3 { format!(", +{}", newly.len() - 3) } else { String::new() };

        let new = if newly.is_empty() {

            format!("none new against {} run #{}", row.default_bookmark, b.run_number)

        } else {

            format!("{} new against {}: {}{more}", newly.len(), row.default_bookmark, names.join(", "))

        };

        ("failed", format!("{} failing; {new}", r.broken()))

    } else {

        ("failed", format!("{} failing", r.broken()))

    };

    let url = format!("{}/{}/{}/tests?report={}", app.config.base_url(), row.owner, row.name, r.id);

    if let Ok(c) = db::hooks::upsert_check(

        &app.db,

        row.id,

        db::hooks::CheckReport { state: &run.state, name: "tests", status, summary: &summary, url: &url, reporter: None, seal: "" },

    )

    .await

    {

        let api = crate::api::check_of(&c);

        app.events.proposal(row.id, hub_api::ProposalEvent { number: 0, kind: "check".into(), check: Some(api.clone()) });

        crate::hooks::emit(app, row, "check", "flow", serde_json::json!({ "check": api })).await;

    }

/// One test across a bookmark's reports, newest first.

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

pub struct Run {

    pub report_id: i64,

    pub run_number: i64,

    pub job: String,

    pub created_ms: i64,

    pub status: String,

    pub time_ms: i64,

    pub message: String,

}

pub async fn history(pool: &Pool, repo_id: i64, bookmark: &str, classname: &str, name: &str, limit: i64) -> sqlx::Result<Vec<Run>> {

    sqlx::query_as(

        "SELECT r.id AS report_id, r.run_number, r.job, r.created_ms, c.status, c.time_ms, c.message \

         FROM test_cases c JOIN test_reports r ON r.id = c.report_id \

         WHERE r.repo_id = ? AND r.bookmark = ? AND c.classname = ? AND c.name = ? \

         ORDER BY r.created_ms DESC, r.id DESC LIMIT ?",

    )

    .bind(repo_id)

    .bind(bookmark)

    .bind(classname)

    .bind(name)

    .bind(limit)

    .fetch_all(pool)

    .await

}

/// What a report is measured against: the same job's previous report on

/// the default bookmark for a run on it, its latest for any other.

pub async fn baseline(pool: &Pool, r: &Report, default_bookmark: &str) -> sqlx::Result<Option<Report>> {

    sqlx::query_as(

        "SELECT * FROM test_reports WHERE repo_id = ? AND bookmark = ? AND job = ? AND id != ? \

         AND (created_ms < ? OR (created_ms = ? AND id < ?)) ORDER BY created_ms DESC, id DESC LIMIT 1",

    )

    .bind(r.repo_id)

    .bind(default_bookmark)

    .bind(&r.job)

    .bind(r.id)

    .bind(if r.bookmark == default_bookmark { r.created_ms } else { i64::MAX })

    .bind(r.created_ms)

    .bind(if r.bookmark == default_bookmark { r.id } else { i64::MAX })

    .fetch_optional(pool)

    .await

}

/// Tests failing in `report` that passed in `base`, by title.

pub async fn newly_failing(pool: &Pool, report: i64, base: i64) -> sqlx::Result<Vec<String>> {

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

        "SELECT c.classname, c.name FROM test_cases c JOIN test_cases b \

         ON b.report_id = ? AND b.classname = c.classname AND b.name = c.name AND b.status = 'passed' \

         WHERE c.report_id = ? AND c.status IN ('failed', 'error') ORDER BY c.idx",

    )

    .bind(base)

    .bind(report)

    .fetch_all(pool)

    .await?;

    Ok(rows.into_iter().map(|(c, n)| if c.is_empty() { n } else { format!("{c}::{n}") }).collect())

}

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

#[derive(Deserialize)]

pub struct CaseQuery {

    #[serde(default)]

    classname: String,

    name: String,

    bookmark: Option<String>,

}

#[derive(Template)]

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

pub struct TestCasePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    title: String,

    runs: Vec<junit::Run>,

    passed: usize,

    failed: usize,

    time_chart: String,

}

impl TestCasePage {

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

        crate::flow::human_ms(*ms)

    }

}

/// `GET /{owner}/{name}/tests/case?classname=&name=`: one test across the

/// bookmark's last runs: its result, time and message in each.

pub async fn case(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<CaseQuery>,

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

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

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

    let bookmark = q.bookmark.unwrap_or_else(|| row.default_bookmark.clone());

    let runs =

        junit::history(&app.db, row.id, &bookmark, &q.classname, &q.name, HISTORY).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    if runs.is_empty() {

        return Err(Error::not_found(shell));

    }

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

    let passed = runs.iter().filter(|r| r.status == "passed").count();

    let failed = runs.iter().filter(|r| r.status == "failed" || r.status == "error").count();

    let oldest: Vec<&junit::Run> = runs.iter().rev().collect();

    let points: Vec<Point> = oldest

        .iter()

        .map(|r| Point {

            run: r.run_number,

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

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

        })

        .collect();

    let top = oldest.iter().map(|r| r.time_ms).max().unwrap_or(0) as f64;

    let time_chart = chart(

        "Time per run",

        &points,

        &[Series { values: oldest.iter().map(|r| r.time_ms as f64).collect(), class: "cov", floor: None }],

        0.0,

        (top * 1.1).max(1.0),

        &|v| crate::flow::human_ms(v as i64),

    );

    let title = if q.classname.is_empty() { q.name.clone() } else { format!("{}::{}", q.classname, q.name) };

    Ok(Page(TestCasePage { shell, repo, bookmark, title, runs, passed, failed, time_chart }))

}

    // The `tests` check names what broke against main.

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

    let check = |state: String| {

        let app = h.app.clone();

        async move { db::hooks::checks_for_state(&app.db, row.id, &state).await.unwrap().into_iter().find(|c| c.name == "tests").unwrap() }

    };

    let c = check(reports[1].state.clone()).await;

    assert_eq!((c.status.as_str(), c.summary.as_str()), ("failed", "1 failing; 1 new against main: t.suite::b"));

    let c = check(reports[0].state.clone()).await;

    assert_eq!((c.status.as_str(), c.summary.as_str()), ("passed", "4 passed"));

    // One test's history: b passed, failed, passed.

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

    assert!(

        tab.contains("/andy/t/tests/case?classname=t.suite&name=b") || tab.contains("/andy/t/tests/case?classname=t.suite&name=b"),

        "linked"

    );

    let (st, hist) = call(&h.app, "GET", "/andy/t/tests/case?classname=t.suite&name=b", None, None).await;

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

    assert!(hist.contains("2 passed") && hist.contains("1 failed") && hist.contains("b broke"), "{hist}");

    assert_eq!(call(&h.app, "GET", "/andy/t/tests/case?classname=t.suite&name=nope", None, None).await.0, StatusCode::NOT_FOUND);

### 13.7 Test reports (oxygenhub#114, done 2026-10-06)

- **A test's history.** `/tests/case?classname=&name=` shows one test across the bookmark's last 200 runs: its result, time (charted) and message in each; the Tests tab links each failure, slow test and flaky one to it.

- **The check.** Each report sets a `tests` check on its run's state: `630 passed`, or what fails and which of those passed in the same job's report on the default bookmark (its previous one for a run on it, its latest for a run elsewhere), as `2 failing; 1 new against main: tests.test_io::test_write`. A proposal shows it with its other checks, so it names what the proposal broke.

    <table class="cov-moved">{% for f in flaky %}<tr><td><a href="{{ repo.url }}/tests/case?classname={{ f.classname|urlencode }}&name={{ f.name|urlencode }}&bookmark={{ bookmark|urlencode }}"><code>{{ f.title() }}</code></a></td><td class="num"><span class="cov-poor">{{ f.failed }} ✕</span> <span class="cov-good">{{ f.passed }} ✓</span></td></tr>{% endfor %}</table>{% endif %}

    <summary><span class="bad">{% if f.status == "error" %}!{% else %}✕{% endif %}</span> <code>{{ f.title() }}</code> <a class="small" href="{{ repo.url }}/tests/case?classname={{ f.classname|urlencode }}&name={{ f.name|urlencode }}&bookmark={{ bookmark|urlencode }}">history</a>{% if !f.message.is_empty() %} <span class="small mute">{{ f.message }}</span>{% endif %}</summary>

  {% for c in slowest %}<tr><td><a href="{{ repo.url }}/tests/case?classname={{ c.classname|urlencode }}&name={{ c.name|urlencode }}&bookmark={{ bookmark|urlencode }}"><code>{{ c.title() }}</code></a>{% 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 %}