Coverage / crates/hub/src/web/test_reports.rs 95.0%

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)

}

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

        match pass_rate(r) {

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

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

    }

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

        match pass_rate(r) {

            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()

            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 {

        }

        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}%"))

    }

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());

    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);

    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,

        &|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) },

        (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,

    }))

}

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

        crate::flow::human_ms(*ms)

    }

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 }],

        (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 }))

}