Test reports from a job's junit artifact (part 1) 0b203bbf7cc3

-- Test reports from OxygenFlow jobs (oxygenhub#114): a job's artifact

-- named `junit` (JUnit XML) is parsed when uploaded. The counts are kept

-- per report and every case with its status and time; a failure's message

-- and output are kept cut to a size a page can show.

CREATE TABLE test_reports (

    id          INTEGER PRIMARY KEY,

    repo_id     INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,

    run_id      INTEGER NOT NULL REFERENCES flow_runs(id) ON DELETE CASCADE,

    job_id      INTEGER NOT NULL UNIQUE,

    job         TEXT NOT NULL,

    run_number  INTEGER NOT NULL,

    bookmark    TEXT NOT NULL,

    state       TEXT NOT NULL,

    blob        TEXT NOT NULL,

    tests       INTEGER NOT NULL,

    passed      INTEGER NOT NULL,

    failed      INTEGER NOT NULL,

    errors      INTEGER NOT NULL,

    skipped     INTEGER NOT NULL,

    time_ms     INTEGER NOT NULL,

    created_ms  INTEGER NOT NULL

);

CREATE INDEX test_reports_bookmark ON test_reports (repo_id, bookmark, created_ms);

CREATE TABLE test_cases (

    report_id   INTEGER NOT NULL REFERENCES test_reports(id) ON DELETE CASCADE,

    idx         INTEGER NOT NULL,

    suite       TEXT NOT NULL,

    classname   TEXT NOT NULL,

    name        TEXT NOT NULL,

    status      TEXT NOT NULL,

    time_ms     INTEGER NOT NULL,

    message     TEXT NOT NULL,

    output      TEXT NOT NULL,

    PRIMARY KEY (report_id, idx)

);

CREATE INDEX test_cases_name ON test_cases (classname, name);

//! Test reports from OxygenFlow jobs (oxygenhub#114): a job's artifact

//! named `junit`, in JUnit XML as pytest `--junitxml`, cargo-nextest, Jest,

//! gotestsum and most runners write it, is parsed when it is uploaded and

//! kept per run: the counts, and every test case with its status and time.

//! A failure's message and output are kept, cut to a size a page can show.

use crate::db::{now_ms, Pool};

use crate::Shared;

use quick_xml::events::{BytesStart, Event};

use quick_xml::{Reader, XmlVersion};

/// The artifact name a job gives its JUnit report.

pub const ARTIFACT: &str = "junit";

/// Largest report read; a bigger one is noted in the job's log and skipped.

pub const MAX_REPORT: usize = 64 << 20;

/// Test cases kept from one report.

pub const MAX_CASES: usize = 50_000;

/// A failure's message, and its output, are cut to these many bytes.

const MAX_MESSAGE: usize = 2 << 10;

const MAX_OUTPUT: usize = 16 << 10;

/// One test case as the report gives it.

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

pub struct Case {

    /// The enclosing `<testsuite>`'s name, `/`-joined when suites nest.

    pub suite: String,

    pub classname: String,

    pub name: String,

    /// `passed`, `failed`, `error` or `skipped`.

    pub status: String,

    pub time_ms: i64,

    /// The failure's, error's or skip's `message`, else its first line.

    pub message: String,

    /// The failure's or error's text, then the case's stdout and stderr;

    /// empty for a passing case.

    pub output: String,

}

impl Case {

    /// `classname::name`, or the name alone.

    pub fn title(&self) -> String {

        if self.classname.is_empty() {

            self.name.clone()

        } else {

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

        }

    }

}

/// Cut `s` to at most `max` bytes on a character boundary, saying so.

fn cut(mut s: String, max: usize) -> String {

    if s.len() > max {

        let mut i = max;

        while !s.is_char_boundary(i) {

            i -= 1;

        }

        s.truncate(i);

        s.push_str("\n… (cut)");

    }

    s

}

fn attr(e: &BytesStart, name: &str) -> String {

    e.try_get_attribute(name)

        .ok()

        .flatten()

        .and_then(|a| a.normalized_value(XmlVersion::Implicit1_0).ok().map(|v| v.into_owned()))

        .unwrap_or_default()

}

/// Seconds as JUnit writes them (`1.25`, sometimes `1,250.5`) to ms.

fn secs_ms(s: &str) -> i64 {

    s.replace(',', "").trim().parse::<f64>().map(|v| (v * 1000.0).round().max(0.0) as i64).unwrap_or(0)

}

/// What the parser is collecting text for.

#[derive(PartialEq)]

enum Collect {

    Nothing,

    Detail,

    Out,

}

/// Parse a JUnit XML report: every `<testcase>`, in order, wherever its

/// `<testsuite>` nests. Counts come from the cases, not the attributes.

pub fn parse(text: &str) -> Result<Vec<Case>, String> {

    let mut r = Reader::from_str(text);

    r.config_mut().trim_text(false);

    let mut suites: Vec<String> = Vec::new();

    let mut cases = Vec::new();

    let mut case: Option<Case> = None;

    let mut detail = String::new();

    let mut out = String::new();

    let mut into = Collect::Nothing;

    let mut seen_root = false;

    loop {

        let ev = r.read_event().map_err(|e| format!("not JUnit XML: {e} (at byte {})", r.error_position()))?;

        match ev {

            Event::Start(ref e) | Event::Empty(ref e)

                if e.local_name().as_ref() == "testsuites" || e.local_name().as_ref() == "testsuite" =>

            {

                seen_root = true;

                if e.local_name().as_ref() == "testsuite" {

                    suites.push(attr(e, "name"));

                }

                // An empty `<testsuite/>` has no end event.

                if matches!(ev, Event::Empty(_)) && e.local_name().as_ref() == "testsuite" {

                    suites.pop();

                }

            }

            Event::Start(ref e) | Event::Empty(ref e) if e.local_name().as_ref() == "testcase" => {

                seen_root = true;

                let c = Case {

                    suite: suites.iter().filter(|s| !s.is_empty()).cloned().collect::<Vec<_>>().join("/"),

                    classname: attr(e, "classname"),

                    name: attr(e, "name"),

                    status: "passed".into(),

                    time_ms: secs_ms(&attr(e, "time")),

                    message: String::new(),

                    output: String::new(),

                };

                if matches!(ev, Event::Empty(_)) {

                    cases.push(c);

                } else {

                    case = Some(c);

                    detail.clear();

                    out.clear();

                }

            }

            Event::Start(ref e) | Event::Empty(ref e) if case.is_some() => {

                let tag = e.local_name().as_ref().to_string();

                let c = case.as_mut().unwrap();

                let status = match tag.as_str() {

                    "failure" | "flakyFailure" if c.status == "passed" => Some("failed"),

                    "error" | "flakyError" if c.status == "passed" => Some("error"),

                    "skipped" if c.status == "passed" => Some("skipped"),

                    _ => None,

                };

                // nextest's flaky retries passed in the end: the case passed.

                let flaky = tag.starts_with("flaky") || tag.starts_with("rerun");

                if let Some(s) = status.filter(|_| !flaky) {

                    c.status = s.into();

                    c.message = attr(e, "message");

                    if matches!(ev, Event::Start(_)) {

                        into = Collect::Detail;

                    }

                } else if matches!(ev, Event::Start(_)) && (tag == "system-out" || tag == "system-err") {

                    into = Collect::Out;

                }

            }

            Event::Text(t) => push_text(&mut into, &mut detail, &mut out, &t.xml10_content()),

            Event::CData(t) => push_text(&mut into, &mut detail, &mut out, &t.xml10_content()),

            Event::GeneralRef(g) => {

                let s = match g.resolve_char_ref() {

                    Ok(Some(ch)) => ch.to_string(),

                    _ => {

                        let name = g.xml10_content();

                        quick_xml::escape::resolve_predefined_entity(&name).map(str::to_string).unwrap_or_else(|| format!("&{name};"))

                    }

                };

                push_text(&mut into, &mut detail, &mut out, &s);

            }

            Event::End(e) => match e.local_name().as_ref() {

                "testsuite" => {

                    suites.pop();

                }

                "testcase" => {

                    if let Some(mut c) = case.take() {

                        if c.status != "passed" {

                            if c.message.is_empty() {

                                c.message = detail.lines().map(str::trim).find(|l| !l.is_empty()).unwrap_or("").to_string();

                            }

                            let mut o = detail.trim().to_string();

                            if !out.trim().is_empty() && c.status != "skipped" {

                                if !o.is_empty() {

                                    o.push_str("\n\n");

                                }

                                o.push_str(out.trim());

                            }

                            c.output = cut(o, MAX_OUTPUT);

                        }

                        c.message = cut(c.message, MAX_MESSAGE);

                        cases.push(c);

                        if cases.len() > MAX_CASES {

                            return Err(format!("more than {MAX_CASES} test cases"));

                        }

                    }

                    into = Collect::Nothing;

                }

                "failure" | "error" | "skipped" | "system-out" | "system-err" | "flakyFailure" | "flakyError" | "rerunFailure"

                | "rerunError" => into = Collect::Nothing,

                _ => {}

            },

            Event::Eof => break,

            _ => {}

        }

    }

    if !seen_root {

        return Err("not JUnit XML: no <testsuites>, <testsuite> or <testcase>".into());

    }

    Ok(cases)

}

fn push_text(into: &mut Collect, detail: &mut String, out: &mut String, s: &str) {

    let (buf, max) = match into {

        Collect::Detail => (detail, MAX_OUTPUT),

        Collect::Out => (out, MAX_OUTPUT),

        Collect::Nothing => return,

    };

    // Keep a little past the cut so `cut` can say it cut.

    if buf.len() <= max {

        buf.push_str(s);

    }

}

/// A run's kept report.

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

pub struct Report {

    pub id: i64,

    pub repo_id: i64,

    pub run_id: i64,

    pub job_id: i64,

    pub job: String,

    pub run_number: i64,

    pub bookmark: String,

    pub state: String,

    pub blob: String,

    pub tests: i64,

    pub passed: i64,

    pub failed: i64,

    pub errors: i64,

    pub skipped: i64,

    pub time_ms: i64,

    pub created_ms: i64,

}

impl Report {

    /// "630 tests: 2 failed, 3 skipped", or "630 passed".

    pub fn summary(&self) -> String {

        let mut bad = vec![];

        if self.failed > 0 {

            bad.push(format!("{} failed", self.failed));

        }

        if self.errors > 0 {

            bad.push(format!("{} errored", self.errors));

        }

        if self.skipped > 0 {

            bad.push(format!("{} skipped", self.skipped));

        }

        let tests = if self.tests == 1 { "1 test".to_string() } else { format!("{} tests", self.tests) };

        if bad.is_empty() {

            format!("{tests}, all passed")

        } else {

            format!("{tests}: {}", bad.join(", "))

        }

    }

    pub fn broken(&self) -> i64 {

        self.failed + self.errors

    }

}

/// What a run's report is kept with.

pub struct Origin<'a> {

    pub repo_id: i64,

    pub run_id: i64,

    pub run_number: i64,

    pub job_id: i64,

    pub job: &'a str,

    pub bookmark: &'a str,

    pub state: &'a str,

    pub blob: &'a str,

}

/// Keep a parsed report, replacing an earlier one of the same job.

pub async fn keep(app: &Shared, o: &Origin<'_>, cases: &[Case]) -> sqlx::Result<i64> {

    let count = |s: &str| cases.iter().filter(|c| c.status == s).count() as i64;

    let mut tx = crate::db::begin_write(&app.db).await?;

    sqlx::query("DELETE FROM test_reports WHERE job_id = ?").bind(o.job_id).execute(&mut *tx).await?;

    let id: i64 = sqlx::query_scalar(

        "INSERT INTO test_reports (repo_id, run_id, job_id, job, run_number, bookmark, state, blob, \

         tests, passed, failed, errors, skipped, time_ms, created_ms) \

         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id",

    )

    .bind(o.repo_id)

    .bind(o.run_id)

    .bind(o.job_id)

    .bind(o.job)

    .bind(o.run_number)

    .bind(o.bookmark)

    .bind(o.state)

    .bind(o.blob)

    .bind(cases.len() as i64)

    .bind(count("passed"))

    .bind(count("failed"))

    .bind(count("error"))

    .bind(count("skipped"))

    .bind(cases.iter().map(|c| c.time_ms).sum::<i64>())

    .bind(now_ms())

    .fetch_one(&mut *tx)

    .await?;

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

        sqlx::query(

            "INSERT INTO test_cases (report_id, idx, suite, classname, name, status, time_ms, message, output) \

             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",

        )

        .bind(id)

        .bind(i as i64)

        .bind(&c.suite)

        .bind(&c.classname)

        .bind(&c.name)

        .bind(&c.status)

        .bind(c.time_ms)

        .bind(&c.message)

        .bind(&c.output)

        .execute(&mut *tx)

        .await?;

    }

    tx.commit().await?;

    Ok(id)

}

/// A run's reports, one per job that kept one.

pub async fn for_run(pool: &Pool, run_id: i64) -> sqlx::Result<Vec<Report>> {

    sqlx::query_as("SELECT * FROM test_reports WHERE run_id = ? ORDER BY job").bind(run_id).fetch_all(pool).await

}

/// A report's failed and errored cases, in report order.

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

    sqlx::query_as(

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

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

    )

    .bind(report_id)

    .bind(limit)

    .fetch_all(pool)

    .await

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn pytest_nextest_and_jest_shapes() {

        // pytest: one suite, a failure with a message and text, a skip, an error.

        let py = r#"<?xml version="1.0" encoding="utf-8"?>

<testsuites><testsuite name="pytest" errors="1" failures="1" skipped="1" tests="4" time="3.5">

<testcase classname="tests.test_a" name="test_ok" time="0.010"/>

<testcase classname="tests.test_a" name="test_bad" time="1.25"><failure message="assert 1 == 2">def test_bad():

>       assert 1 == 2

E       assert 1 == 2</failure><system-out>printed &amp; kept</system-out></testcase>

<testcase classname="tests.test_b" name="test_skip" time="0"><skipped type="pytest.skip" message="no emulator"/></testcase>

<testcase classname="tests.test_b" name="test_err" time="0.5"><error message="fixture failed"><![CDATA[Traceback <here>]]></error></testcase>

</testsuite></testsuites>"#;

        let c = parse(py).unwrap();

        let st: Vec<(&str, &str)> = c.iter().map(|c| (c.name.as_str(), c.status.as_str())).collect();

        assert_eq!(st, [("test_ok", "passed"), ("test_bad", "failed"), ("test_skip", "skipped"), ("test_err", "error")]);

        assert_eq!(c[1].message, "assert 1 == 2");

        assert!(c[1].output.contains(">       assert 1 == 2") && c[1].output.contains("printed & kept"), "{}", c[1].output);

        assert_eq!((c[1].time_ms, c[0].time_ms), (1250, 10));

        assert_eq!(c[2].message, "no emulator");

        assert_eq!(c[3].output, "Traceback <here>");

        assert_eq!(c[1].suite, "pytest");

        assert_eq!(c[1].title(), "tests.test_a::test_bad");

        assert!(c[0].output.is_empty());

        // nextest: a flaky test that passed on retry is a pass.

        let nx = r#"<testsuites name="nextest-run"><testsuite name="oxy-core" tests="2">

<testcase name="repo::tests::a" classname="oxy-core::lib" time="0.2"><flakyFailure message="first try" type="test failure">boom</flakyFailure></testcase>

<testcase name="repo::tests::b" classname="oxy-core::lib" time="0.1"/></testsuite></testsuites>"#;

        let c = parse(nx).unwrap();

        assert_eq!(c.iter().filter(|c| c.status == "passed").count(), 2, "{c:?}");

        // Jest: nested suites, no wrapper on a single suite is fine too.

        let js = r#"<testsuite name="ui"><testsuite name="Button"><testcase classname="Button renders" name="renders" time="0.003"/></testsuite></testsuite>"#;

        let c = parse(js).unwrap();

        assert_eq!(c[0].suite, "ui/Button");

        assert!(parse("<html/>").is_err());

        assert!(parse("not xml <<<").is_err());

        assert!(parse("<testsuites/>").unwrap().is_empty());

    }

    #[test]

    fn long_output_is_cut() {

        let big = "x".repeat(MAX_OUTPUT * 3);

        let xml = format!(r#"<testsuite><testcase name="t"><failure>{big}</failure></testcase></testsuite>"#);

        let c = parse(&xml).unwrap();

        assert!(c[0].output.len() < MAX_OUTPUT + 32 && c[0].output.ends_with("(cut)"));

    }

}

 "quick-xml 0.42.0",

# JUnit XML test reports from Flow jobs (oxygenhub#114).

quick-xml = "0.42"

    let junit_bytes = (name == crate::junit::ARTIFACT).then(|| body.clone());

    // A test report (#114) likewise.

    if let Some(bytes) = junit_bytes {

        let said = match read_junit(&app, &row, &run, &job, &a.blob, bytes).await {

            Ok(text) | Err(text) => text,

        };

        let record = flow_core::api::Record { t: 0, stream: "flow".into(), text: said };

        fdb::append_log(&app.db, job.id, &[record], MAX_RECORDS as i64).await.ok();

    }

}

/// Parse and keep a job's JUnit report: what it says, or why not.

async fn read_junit(

    app: &Shared,

    row: &db::repos::RepoRow,

    run: &fdb::Run,

    job: &fdb::Job,

    blob: &str,

    bytes: axum::body::Bytes,

) -> Result<String, String> {

    if bytes.len() > crate::junit::MAX_REPORT {

        return Err(format!("tests: the report is {} MiB; at most {} MiB is read", bytes.len() >> 20, crate::junit::MAX_REPORT >> 20));

    }

    let text = String::from_utf8(bytes.to_vec()).map_err(|_| "tests: the report is not UTF-8 text (JUnit XML is expected)".to_string())?;

    let cases = tokio::task::spawn_blocking(move || crate::junit::parse(&text))

        .await

        .map_err(|e| format!("tests: {e}"))?

        .map_err(|e| format!("tests: {e}"))?;

    let origin = crate::junit::Origin {

        repo_id: row.id,

        run_id: run.id,

        run_number: run.number,

        job_id: job.id,

        job: &job.name,

        bookmark: &run.bookmark,

        state: &run.state,

        blob,

    };

    crate::junit::keep(app, &origin, &cases).await.map_err(|e| format!("tests: {e}"))?;

    let r = crate::junit::for_run(&app.db, run.id)

        .await

        .map_err(|e| format!("tests: {e}"))?

        .into_iter()

        .find(|r| r.job_id == job.id)

        .ok_or_else(|| "tests: the report was not kept".to_string())?;

    Ok(format!("tests: {} in {}", r.summary(), human_ms(r.time_ms)))

pub mod junit;

/// Failed tests a run page lists per job; the rest are counted.

const SHOWN_FAILURES: i64 = 50;

    /// The job's test report, when it uploaded one (#114), and its first

    /// failures.

    pub tests: Option<crate::junit::Report>,

    pub failures: Vec<crate::junit::Case>,

    let test_reports = crate::junit::for_run(&app.db, run.id).await.unwrap_or_default();

        let tests = test_reports.iter().find(|r| r.job_id == j.id).cloned();

        let failures = match &tests {

            Some(r) if r.broken() > 0 => crate::junit::failures(&app.db, r.id, SHOWN_FAILURES).await.unwrap_or_default(),

            _ => vec![],

        };

        logs.push(JobLog { duration: crate::flow::duration(j), j: j.clone(), artifacts, lines, last_seq, coverage, tests, failures });

    // A JUnit report (#114): parsed on upload, counted, failures listed.

    let xml = br#"<testsuites><testsuite name="pytest"><testcase classname="tests.test_io" name="test_read" time="0.5"/><testcase classname="tests.test_io" name="test_write" time="1.5"><failure message="disk full">E   OSError: disk full</failure></testcase></testsuite></testsuites>"#;

    let (st, text) = upload(&h.app, id, "junit", xml).await;

    assert!(page.contains("2 tests: 1 failed"), "counts beside the job");

    assert!(page.contains("tests.test_io::test_write") && page.contains("disk full") && page.contains("OSError"), "the failure");

    assert!(page.contains("tests: 2 tests: 1 failed in 2.0 s"), "said in the job's log");

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

- **Reports.** A job's artifact named `junit` in JUnit XML (pytest `--junitxml`, cargo-nextest, Jest's junit reporter, gotestsum) is read when the job uploads it, at most 64 MiB and 50 000 cases. Every `<testcase>` counts, wherever its `<testsuite>` nests; a case is `passed`, `failed` (`<failure>`), `error` (`<error>`) or `skipped`, and a nextest case that failed and then passed on a retry (`flakyFailure`) is a pass. Counts come from the cases, not the suites' attributes. The job's log says what was found (`tests: 630 tests: 2 failed in 3 min 4 s`), or why it could not be read; a bad report never fails the upload.

- **Failing jobs.** Declare the artifact with `when "always"` (OxygenFlow spec §5.2) so a failing suite still sends its report; it is then outside the job's receipt, and the run page says so.

- **Stored.** `test_reports` keeps the counts and summed test time per report with its run, job, bookmark and state; `test_cases` every case with its status and time, and for a failure or error its message (2 KiB) and its text with the case's output (16 KiB).

- **Run page.** Beside each job its counts, linked to a block above its log: passed, failed, errored and skipped, then the first 50 failures, failures first in report order, each collapsible to its message and output.

- **Next:** a Tests tab (the default bookmark's counts over time, the slowest tests, flaky ones, a test's history), and proposals naming the tests that pass on the target and fail on the proposal.

  <summary><span class="flow-glyph st-{{ l.j.status }}" data-glyph>{{ crate::web::flow::glyph(l.j.status) }}</span> <strong>{{ l.j.name }}</strong> <span class="small mute" data-meta>{{ l.j.status }}{% if let Some(c) = l.j.exit_code %} · exit {{ c }}{% endif %} · {{ l.duration }}{% if !l.j.runner.is_empty() %} · on {{ l.j.runner }}{% endif %}</span>{% if !l.j.receipt_attest.is_empty() %} <span class="small mute">· <a href="{{ repo.url }}/receipts/{{ l.j.receipt_attest }}" title="Receipt {{ l.j.receipt_hash }}, kept in the repository; check it with oxy receipt verify">signed receipt</a> by {{ l.j.receipt_signer }}</span>{% else if !l.j.receipt_note.is_empty() %} <span class="small warn" title="{{ l.j.receipt_note }}">· receipt not kept: {{ l.j.receipt_note }}</span>{% else if !l.j.receipt_hash.is_empty() %} <span class="small mute">· unsigned receipt <code title="{{ l.j.receipt_hash }}">{{ l.j.receipt_hash|short }}</code></span>{% endif %}{% if !l.artifacts.is_empty() %} <span class="small mute">· {{ l.artifacts.len()|plural("artifact", "artifacts") }}</span>{% endif %}{% if let Some(t) = l.tests %} <span class="small{% if t.broken() > 0 %} warn{% endif %}">· <a href="#tests-{{ l.j.id }}">{{ t.summary() }}</a></span>{% endif %}{% if let Some((cid, pct)) = l.coverage %} <span class="small">· <a href="{{ repo.url }}/coverage?report={{ cid }}">coverage {{ pct }}</a></span>{% endif %}</summary>

  {% if let Some(t) = l.tests %}<div class="flow-tests" id="tests-{{ l.j.id }}">

    <p class="small"><span class="tests-count ok">{{ t.passed }} passed</span>{% if t.failed > 0 %} · <span class="tests-count bad">{{ t.failed }} failed</span>{% endif %}{% if t.errors > 0 %} · <span class="tests-count bad">{{ t.errors }} errored</span>{% endif %}{% if t.skipped > 0 %} · <span class="tests-count mute">{{ t.skipped }} skipped</span>{% endif %} <span class="mute">· {{ crate::flow::human_ms(*t.time_ms) }} of test time</span></p>

    {% for f in l.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 %}

    {% if t.broken() > l.failures.len() as i64 %}<p class="small mute">and {{ t.broken() - l.failures.len() as i64 }} more failures; the junit artifact has them all.</p>{% endif %}

  </div>{% endif %}

.flow-tests { padding: 6px 12px; border-top: 1px solid var(--line); }

.flow-tests > p { margin: 0 0 4px; }

.flow-tests .tests-count.ok { color: var(--ok); }

.flow-tests .tests-count.bad, .flow-tests .bad { color: var(--bad); font-weight: 600; }

.tests-failure { border-left: 3px solid var(--bad); margin: 4px 0; padding: 2px 8px; }

.tests-failure summary { cursor: pointer; overflow-wrap: anywhere; }

.tests-failure pre.flow-log { padding: 6px 8px; margin: 4px 0; white-space: pre-wrap; word-break: break-word; max-height: 24em; overflow: auto; }