use std::collections::HashMap;
use super::flow::ReportFlow;
use super::model::{ReportResult, ReportRow, RowRole};
use super::run::{RowSelection, RunContext, finalize, run_flow_raw_selected};
pub fn rerun_rows(
flow: &ReportFlow,
ctx: &RunContext,
paths: &[Vec<(usize, usize)>],
) -> ReportResult {
let selection = RowSelection::for_paths(flow, paths);
let mut fresh = run_flow_raw_selected(flow, ctx, Some(&selection));
finalize(&mut fresh, flow, ctx);
fresh
}
pub struct LiveRerun {
pub raw: ReportResult,
pub finished: ReportResult,
}
pub fn rerun_live(flow: &ReportFlow, ctx: &RunContext, paths: &[Vec<(usize, usize)>]) -> LiveRerun {
let selection = RowSelection::for_paths(flow, paths);
let raw = run_flow_raw_selected(flow, ctx, Some(&selection));
let mut finished = raw.clone();
finalize(&mut finished, flow, ctx);
LiveRerun { raw, finished }
}
pub fn resume(flow: &ReportFlow, ctx: &RunContext, prior: ReportResult) -> ReportResult {
let paths: Vec<Vec<(usize, usize)>> = prior
.pending
.iter()
.filter_map(|&r| prior.rows.get(r))
.map(|row| row.path.clone())
.collect();
let fresh = run_flow_raw_selected(flow, ctx, Some(&RowSelection::exact(&paths)));
let mut merged = prior;
let slot: HashMap<Vec<(usize, usize)>, usize> = merged
.rows
.iter()
.enumerate()
.map(|(i, row)| (row.path.clone(), i))
.collect();
for row in fresh.rows {
if let Some(&i) = slot.get(&row.path)
&& merged.pending.remove(&i)
{
merged.rows[i] = row;
}
}
for c in &fresh.column_order {
merged.note_column(c);
}
merged.timing_columns.extend(fresh.timing_columns);
merged.duration_columns.extend(fresh.duration_columns);
merged.errors.extend(fresh.errors);
merged.warnings.extend(fresh.warnings);
merged.skipped.extend(fresh.skipped);
for (written, got) in fresh.role_targets {
let seen = merged.role_targets.entry(written).or_default();
for g in got {
if !seen.contains(&g) {
seen.push(g);
}
}
}
if merged.pending.is_empty() {
merged.partial = None;
finalize(&mut merged, flow, ctx);
}
merged
}
pub fn splice_live(live: &mut ReportResult, fresh: &ReportResult) -> Vec<usize> {
let mut replaced = Vec::new();
for row in &fresh.rows {
let mut matches = live
.rows
.iter()
.enumerate()
.filter(|(i, r)| !live.pending.contains(i) && r.path == row.path && r.key == row.key)
.map(|(i, _)| i);
if let (Some(i), None) = (matches.next(), matches.next()) {
live.rows[i] = row.clone();
replaced.push(i);
}
}
replaced
}
pub fn splice(result: &mut ReportResult, fresh: &ReportResult, targets: &[usize]) -> Vec<usize> {
let mut replaced = Vec::new();
for &r in targets {
let Some(old) = result.rows.get(r) else {
continue;
};
let mut matches = fresh
.rows
.iter()
.enumerate()
.filter(|(_, row)| row.path == old.path && row.key == old.key)
.map(|(j, _)| j);
let (Some(j), None) = (matches.next(), matches.next()) else {
continue;
};
let old_claims = claims(result, r);
result.rows[r] = fresh.rows[j].clone();
rekey(&mut result.images, &fresh.images, r, j);
rekey(&mut result.verdicts, &fresh.verdicts, r, j);
rekey(&mut result.truths, &fresh.truths, r, j);
rekey(&mut result.trends, &fresh.trends, r, j);
move_entry(&mut result.baseline_rows, &fresh.baseline_rows, r, j);
move_entry(&mut result.baseline_errors, &fresh.baseline_errors, r, j);
reconcile_errors(result, r, &old_claims, &claims(result, r));
replaced.push(r);
}
if !replaced.is_empty() {
for c in &fresh.column_order {
result.note_column(c);
}
result
.timing_columns
.extend(fresh.timing_columns.iter().cloned());
result
.duration_columns
.extend(fresh.duration_columns.iter().cloned());
for w in &fresh.warnings {
if !result.warnings.contains(w) {
result.warnings.push(w.clone());
}
}
}
replaced
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RowRef {
path: Vec<(usize, usize)>,
key: Vec<String>,
role: RowRole,
comparison: Option<String>,
}
impl RowRef {
pub fn of(row: &ReportRow) -> Self {
RowRef {
path: row.path.clone(),
key: row.key.clone(),
role: row.role,
comparison: row.comparison.clone(),
}
}
pub fn is(&self, row: &ReportRow) -> bool {
self.path == row.path && self.key == row.key
}
}
pub fn rows_after_finalize(queued: &[RowRef], finished: &ReportResult) -> Vec<usize> {
let mut out: Vec<usize> = Vec::new();
for q in queued {
let survived = finished.rows.iter().position(|row| q.is(row));
let found: Vec<usize> = match survived {
Some(r) => vec![r],
None if q.role == RowRole::Baseline => finished
.rows
.iter()
.enumerate()
.filter(|(_, row)| {
row.role == RowRole::Candidate
&& row.key == q.key
&& row.comparison == q.comparison
})
.map(|(r, _)| r)
.collect(),
None => Vec::new(),
};
for r in found {
if !out.contains(&r) {
out.push(r);
}
}
}
out
}
fn claims(result: &ReportResult, r: usize) -> Vec<String> {
let mut out = result
.rows
.get(r)
.map(|row| row.errors.clone())
.unwrap_or_default();
if let Some(base) = result.baseline_errors.get(&r) {
out.extend(base.iter().cloned());
}
out
}
fn reconcile_errors(result: &mut ReportResult, r: usize, old: &[String], new: &[String]) {
let count = |list: &[String], e: &String| list.iter().filter(|x| *x == e).count();
let mut seen: Vec<&String> = Vec::new();
for e in old.iter().chain(new) {
if seen.contains(&e) {
continue;
}
seen.push(e);
let others: usize = (0..result.rows.len())
.filter(|&o| o != r)
.map(|o| count(&claims(result, o), e))
.sum();
reconcile_message(&mut result.errors, e, others, count(old, e), count(new, e));
}
}
pub(super) fn reconcile_message(
flat: &mut Vec<String>,
message: &str,
others: usize,
was: usize,
now: usize,
) {
let count = flat.iter().filter(|e| e.as_str() == message).count();
if count < others + was {
if now > 0 && count == 0 {
flat.push(message.into());
} else if now == 0 && others == 0 {
flat.retain(|e| e != message);
}
} else {
for _ in 0..was {
if let Some(at) = flat.iter().position(|e| e == message) {
flat.remove(at);
}
}
flat.extend(std::iter::repeat_n(message.to_owned(), now));
}
}
fn rekey<V: Clone>(
into: &mut HashMap<(usize, String), V>,
from: &HashMap<(usize, String), V>,
r: usize,
j: usize,
) {
into.retain(|(row, _), _| *row != r);
for ((row, col), v) in from {
if *row == j {
into.insert((r, col.clone()), v.clone());
}
}
}
fn move_entry<V: Clone>(
into: &mut HashMap<usize, V>,
from: &HashMap<usize, V>,
r: usize,
j: usize,
) {
match from.get(&j) {
Some(v) => {
into.insert(r, v.clone());
}
None => {
into.remove(&r);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::report::model::ReportRow;
fn row(path: usize, errors: &[&str]) -> ReportRow {
ReportRow {
path: vec![(0, path)],
errors: errors.iter().map(|e| e.to_string()).collect(),
..Default::default()
}
}
fn errors(list: &[&str]) -> Vec<String> {
list.iter().map(|e| e.to_string()).collect()
}
#[test]
fn a_message_several_rows_raised_loses_one_copy_per_fixed_row() {
let mut result = ReportResult {
rows: vec![
row(0, &["svc: reset"]),
row(1, &["svc: reset"]),
row(2, &["svc: reset"]),
],
errors: errors(&["svc: reset", "svc: reset", "svc: reset"]),
..Default::default()
};
let fresh = ReportResult {
rows: vec![row(0, &[]), row(1, &[]), row(2, &[])],
..Default::default()
};
splice(&mut result, &fresh, &[1]);
assert_eq!(result.errors.len(), 2);
splice(&mut result, &fresh, &[0]);
splice(&mut result, &fresh, &[2]);
assert!(result.errors.is_empty(), "{:?}", result.errors);
}
#[test]
fn an_inherited_message_stays_listed_once() {
let mut result = ReportResult {
rows: vec![row(0, &["login: 401"]), row(1, &["login: 401"])],
errors: errors(&["login: 401"]),
..Default::default()
};
let still_failing = ReportResult {
rows: vec![row(1, &["login: 401"])],
..Default::default()
};
splice(&mut result, &still_failing, &[1]);
assert_eq!(result.errors, errors(&["login: 401"]));
let fixed = ReportResult {
rows: vec![row(1, &[])],
..Default::default()
};
splice(&mut result, &fixed, &[1]);
assert_eq!(result.errors, errors(&["login: 401"]), "row 0 still has it");
}
#[test]
fn rows_sharing_a_path_are_told_apart_by_key_or_left_alone() {
let snap = |key: &str, v: &str| ReportRow {
key: vec![key.to_string()],
cells: [("v".to_string(), v.to_string())].into_iter().collect(),
..Default::default()
};
let mut result = ReportResult {
rows: vec![snap("4", "old"), snap("5", "old")],
..Default::default()
};
let fresh = ReportResult {
rows: vec![snap("4", "new"), snap("5", "new")],
..Default::default()
};
assert_eq!(splice(&mut result, &fresh, &[0]), vec![0]);
assert_eq!(result.rows[0].key, vec!["4".to_string()]);
assert_eq!(result.rows[0].cells["v"], "new");
assert_eq!(result.rows[1].cells["v"], "old");
let twins = ReportResult {
rows: vec![snap("5", "a"), snap("5", "b")],
..Default::default()
};
assert!(splice(&mut result, &twins, &[1]).is_empty());
assert_eq!(result.rows[1].cells["v"], "old");
}
#[test]
fn a_row_with_no_counterpart_is_left_alone() {
let mut result = ReportResult {
rows: vec![row(0, &["svc: reset"])],
errors: errors(&["svc: reset"]),
..Default::default()
};
let fresh = ReportResult {
rows: vec![row(9, &[])],
..Default::default()
};
assert!(splice(&mut result, &fresh, &[0]).is_empty());
assert_eq!(result.errors.len(), 1);
}
}