use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{Receiver, TryRecvError};
use std::sync::{Arc, Mutex};
use std::thread;
use crate::hurl::{HurlEntry, RunOutput};
use crate::report::context::ReportRunInputs;
use crate::report::model::{ReportResult, ReportRow};
use crate::report::run::{
DryRunner, EntryRunner, LiveRunner, RowEvent, RunContext, finalize, run_flow_raw,
};
pub enum RunUpdate {
Skeleton(ReportResult),
RowStarted(Vec<(usize, usize)>),
Row(Box<ReportRow>),
Done(ReportResult),
Rerun {
rows: Vec<usize>,
fresh: ReportResult,
},
LiveRerun(Box<crate::report::rerun::LiveRerun>),
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum RowState {
Scheduled,
Running,
Finished,
Idle,
}
pub struct RunProgress {
pub states: Vec<RowState>,
pub index: HashMap<Vec<(usize, usize)>, usize>,
pub done: usize,
pub total: usize,
pub rerun: bool,
}
impl RunProgress {
pub fn rerun(total: usize, rows: &[usize]) -> Self {
let mut states = vec![RowState::Idle; total];
for &r in rows {
if let Some(s) = states.get_mut(r) {
*s = RowState::Running;
}
}
RunProgress {
states,
index: HashMap::new(),
done: 0,
total: rows.len(),
rerun: true,
}
}
}
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub enum RunKey {
Path(std::path::PathBuf),
Id(u64),
}
impl RunKey {
pub fn of(report: &crate::report::Report) -> Self {
match &report.path {
Some(p) => RunKey::Path(p.clone()),
None => RunKey::Id(report.id),
}
}
}
#[derive(Default)]
pub struct ParkedRun {
pub result: Option<ReportResult>,
pub progress: Option<RunProgress>,
pub run: Option<RunHandle>,
pub results_exported: bool,
pub last_export: Option<String>,
pub params: crate::report::params::ParamValues,
pub result_params: Vec<(String, String)>,
pub result_flow: Option<crate::report::flow::ReportFlow>,
pub result_run_params: crate::report::params::ParamValues,
pub queued_reruns: Vec<crate::report::rerun::RowRef>,
pub selected_rows: std::collections::BTreeSet<usize>,
pub view: Option<super::report_editor::EditorView>,
pub had_result: bool,
pub finished: Option<(usize, usize)>,
}
impl ParkedRun {
pub fn is_worth_keeping(&self) -> bool {
self.run.is_some() || self.result.is_some()
}
pub fn pump(&mut self) -> bool {
let Some(handle) = self.run.as_mut() else {
return false;
};
match drain(handle, &mut self.result, &mut self.progress) {
Drained::Disconnected => {
self.run = None;
return false;
}
Drained::Done { rows, errors } => self.finished = Some((rows, errors)),
Drained::Rerun { replaced, .. } if !replaced.is_empty() => {
self.results_exported = false;
self.last_export = None;
}
_ => {}
}
if handle.finished() {
self.run = None;
return false;
}
true
}
}
pub struct RunHandle {
cancel: Arc<AtomicBool>,
rx: Receiver<RunUpdate>,
finished: bool,
side: Vec<SideRerun>,
held: Vec<(Vec<crate::report::rerun::RowRef>, ReportResult)>,
}
struct SideRerun {
cancel: Arc<AtomicBool>,
rx: Receiver<RunUpdate>,
refs: Vec<crate::report::rerun::RowRef>,
marked: Vec<usize>,
}
impl RunHandle {
pub fn cancel(&self) {
self.cancel.store(true, Ordering::Relaxed);
for side in &self.side {
side.cancel.store(true, Ordering::Relaxed);
}
}
pub fn rerun_live(
&mut self,
inputs: ReportRunInputs,
paths: Vec<Vec<(usize, usize)>>,
refs: Vec<crate::report::rerun::RowRef>,
marked: Vec<usize>,
) {
let cancel = Arc::new(AtomicBool::new(false));
let (tx, rx) = std::sync::mpsc::channel();
spawn_live_rerun(inputs, paths, cancel.clone(), tx);
self.side.push(SideRerun {
cancel,
rx,
refs,
marked,
});
}
#[cfg(test)]
pub(crate) fn rerunning_live(&self) -> bool {
!self.side.is_empty()
}
#[cfg(test)]
pub(crate) fn side_for_test(
&mut self,
refs: Vec<crate::report::rerun::RowRef>,
marked: Vec<usize>,
) -> std::sync::mpsc::Sender<RunUpdate> {
let (tx, rx) = std::sync::mpsc::channel();
self.side.push(SideRerun {
cancel: Arc::new(AtomicBool::new(false)),
rx,
refs,
marked,
});
tx
}
#[cfg(test)]
pub(crate) fn cancel_flag_for_test(&self) -> Arc<AtomicBool> {
self.cancel.clone()
}
pub fn cancelled(&self) -> bool {
self.cancel.load(Ordering::Relaxed)
}
pub fn finished(&self) -> bool {
self.finished && self.side.is_empty()
}
}
impl Drop for RunHandle {
fn drop(&mut self) {
self.cancel();
}
}
#[cfg(test)]
pub(crate) fn test_handle() -> (RunHandle, std::sync::mpsc::Sender<RunUpdate>) {
let (tx, rx) = std::sync::mpsc::channel();
let handle = RunHandle {
cancel: Arc::new(AtomicBool::new(false)),
rx,
finished: false,
side: Vec::new(),
held: Vec::new(),
};
(handle, tx)
}
struct CancellableRunner<R: EntryRunner> {
inner: R,
cancel: Arc<AtomicBool>,
}
impl<R: EntryRunner> EntryRunner for CancellableRunner<R> {
fn run(&self, base: &HurlEntry, vars: &HashMap<String, String>) -> RunOutput {
if self.cancel.load(Ordering::Relaxed) {
return RunOutput {
generated: Default::default(),
entries: Vec::new(),
error: Some("cancelled".to_string()),
};
}
self.inner.run(base, vars)
}
}
pub fn spawn(inputs: ReportRunInputs) -> RunHandle {
let cancel = Arc::new(AtomicBool::new(false));
let cancel_worker = cancel.clone();
let (tx, rx) = std::sync::mpsc::channel();
thread::spawn(move || {
let ReportRunInputs {
flow,
entries,
helpers,
base_vars,
named_envs,
root,
file_root,
language,
params,
} = inputs;
let strings = crate::i18n::Strings::mapped(&language, super::icons::drawable);
let skeleton = {
let dry_ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars: base_vars.clone(),
named_envs: named_envs.clone(),
root: root.clone(),
runner: &DryRunner,
strings: &strings,
params: params.clone(),
sink: None,
shuffle: None,
cancel: None,
};
run_flow_raw(&flow, &dry_ctx)
};
if tx.send(RunUpdate::Skeleton(skeleton)).is_err() {
return; }
let runner = CancellableRunner {
inner: LiveRunner { file_root },
cancel: cancel_worker,
};
let row_tx = Mutex::new(tx.clone());
let sink = move |ev: RowEvent| {
if let Ok(tx) = row_tx.lock() {
let msg = match ev {
RowEvent::Started(path) => RunUpdate::RowStarted(path.to_vec()),
RowEvent::Completed { row, .. } => RunUpdate::Row(Box::new(row.clone())),
};
let _ = tx.send(msg);
}
};
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars,
named_envs,
root,
runner: &runner,
strings: &strings,
params: params.clone(),
sink: Some(&sink),
shuffle: None,
cancel: None,
};
let mut result = run_flow_raw(&flow, &ctx);
finalize(&mut result, &flow, &ctx);
let _ = tx.send(RunUpdate::Done(result));
});
RunHandle {
cancel,
rx,
finished: false,
side: Vec::new(),
held: Vec::new(),
}
}
pub fn spawn_rerun(
inputs: ReportRunInputs,
paths: Vec<Vec<(usize, usize)>>,
rows: Vec<usize>,
) -> RunHandle {
let cancel = Arc::new(AtomicBool::new(false));
let cancel_worker = cancel.clone();
let (tx, rx) = std::sync::mpsc::channel();
thread::spawn(move || {
let ReportRunInputs {
flow,
entries,
helpers,
base_vars,
named_envs,
root,
file_root,
language,
params,
} = inputs;
let strings = crate::i18n::Strings::mapped(&language, super::icons::drawable);
let runner = CancellableRunner {
inner: LiveRunner { file_root },
cancel: cancel_worker,
};
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars,
named_envs,
root,
runner: &runner,
strings: &strings,
params,
sink: None,
shuffle: None,
cancel: None,
};
let fresh = crate::report::rerun::rerun_rows(&flow, &ctx, &paths);
let _ = tx.send(RunUpdate::Rerun { rows, fresh });
});
RunHandle {
cancel,
rx,
finished: false,
side: Vec::new(),
held: Vec::new(),
}
}
pub fn spawn_resume(inputs: ReportRunInputs, prior: ReportResult) -> RunHandle {
let cancel = Arc::new(AtomicBool::new(false));
let cancel_worker = cancel.clone();
let (tx, rx) = std::sync::mpsc::channel();
thread::spawn(move || {
let ReportRunInputs {
flow,
entries,
helpers,
base_vars,
named_envs,
root,
file_root,
language,
params,
} = inputs;
let strings = crate::i18n::Strings::mapped(&language, super::icons::drawable);
let runner = CancellableRunner {
inner: LiveRunner { file_root },
cancel: cancel_worker,
};
let row_tx = Mutex::new(tx.clone());
let sink = move |ev: RowEvent| {
if let Ok(tx) = row_tx.lock() {
let msg = match ev {
RowEvent::Started(path) => RunUpdate::RowStarted(path.to_vec()),
RowEvent::Completed { row, .. } => RunUpdate::Row(Box::new(row.clone())),
};
let _ = tx.send(msg);
}
};
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars,
named_envs,
root,
runner: &runner,
strings: &strings,
params,
sink: Some(&sink),
shuffle: None,
cancel: None,
};
let result = crate::report::rerun::resume(&flow, &ctx, prior);
let _ = tx.send(RunUpdate::Done(result));
});
RunHandle {
cancel,
rx,
finished: false,
side: Vec::new(),
held: Vec::new(),
}
}
fn spawn_live_rerun(
inputs: ReportRunInputs,
paths: Vec<Vec<(usize, usize)>>,
cancel: Arc<AtomicBool>,
tx: std::sync::mpsc::Sender<RunUpdate>,
) {
#[cfg(test)]
{
let _ = (inputs, paths, cancel, tx);
}
#[cfg(not(test))]
thread::spawn(move || {
let ReportRunInputs {
flow,
entries,
helpers,
base_vars,
named_envs,
root,
file_root,
language,
params,
} = inputs;
let strings = crate::i18n::Strings::mapped(&language, super::icons::drawable);
let runner = CancellableRunner {
inner: LiveRunner { file_root },
cancel,
};
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars,
named_envs,
root,
runner: &runner,
strings: &strings,
params,
sink: None,
shuffle: None,
cancel: None,
};
let fresh = crate::report::rerun::rerun_live(&flow, &ctx, &paths);
let _ = tx.send(RunUpdate::LiveRerun(Box::new(fresh)));
});
}
pub enum Drained {
Idle,
Progress { done: usize, total: usize },
Done { rows: usize, errors: usize },
Rerun { replaced: Vec<usize>, errors: usize },
LiveRerun { replaced: Vec<usize>, errors: usize },
Disconnected,
}
pub fn drain(
handle: &mut RunHandle,
result: &mut Option<ReportResult>,
progress: &mut Option<RunProgress>,
) -> Drained {
let mut outcome = Drained::Idle;
let mut run_done: Option<Drained> = None;
loop {
match handle.rx.try_recv() {
Ok(update) => {
if let Some(step) = apply(handle, update, result, progress) {
if matches!(step, Drained::Done { .. }) {
run_done = Some(step);
} else {
outcome = step;
}
}
}
Err(TryRecvError::Empty) => break,
Err(TryRecvError::Disconnected) => {
if !handle.finished {
*progress = None;
return Drained::Disconnected;
}
break;
}
}
}
let mut i = 0;
while i < handle.side.len() {
match handle.side[i].rx.try_recv() {
Ok(RunUpdate::LiveRerun(fresh)) => {
let side = handle.side.remove(i);
if let Some(step) = land_live_rerun(handle, side, *fresh, result, progress) {
outcome = step;
}
}
Ok(_) | Err(TryRecvError::Empty) => i += 1,
Err(TryRecvError::Disconnected) => {
let side = handle.side.remove(i);
if handle.finished {
*progress = result
.as_ref()
.and_then(|res| progress_after_run(handle, res));
} else {
unmark(&side, progress);
}
}
}
}
run_done.unwrap_or(outcome)
}
fn unmark(side: &SideRerun, progress: &mut Option<RunProgress>) {
if let Some(p) = progress.as_mut() {
let settled = if p.rerun {
RowState::Idle
} else {
RowState::Finished
};
for &r in &side.marked {
if p.states.get(r) == Some(&RowState::Running) {
p.states[r] = settled;
}
}
}
}
fn progress_after_run(handle: &RunHandle, res: &ReportResult) -> Option<RunProgress> {
if handle.side.is_empty() {
return None;
}
let refs: Vec<_> = handle.side.iter().flat_map(|s| s.refs.clone()).collect();
let rows = crate::report::rerun::rows_after_finalize(&refs, res);
Some(RunProgress::rerun(res.rows.len(), &rows))
}
fn land_live_rerun(
handle: &mut RunHandle,
side: SideRerun,
fresh: crate::report::rerun::LiveRerun,
result: &mut Option<ReportResult>,
progress: &mut Option<RunProgress>,
) -> Option<Drained> {
if side.cancel.load(Ordering::Relaxed) {
return None;
}
let res = result.as_mut()?;
let errors_in = |res: &ReportResult, rows: &[usize]| -> usize {
rows.iter()
.map(|&r| res.rows[r].errors.len() + res.baseline_errors.get(&r).map_or(0, Vec::len))
.sum()
};
if res.finalized {
let rows = crate::report::rerun::rows_after_finalize(&side.refs, res);
let replaced = crate::report::rerun::splice(res, &fresh.finished, &rows);
let errors = errors_in(res, &replaced);
*progress = progress_after_run(handle, res);
return Some(Drained::Rerun { replaced, errors });
}
let replaced = crate::report::rerun::splice_live(res, &fresh.raw);
let errors = errors_in(res, &replaced);
unmark(&side, progress);
handle.held.push((side.refs, fresh.finished));
Some(Drained::LiveRerun { replaced, errors })
}
fn apply(
handle: &mut RunHandle,
update: RunUpdate,
result: &mut Option<ReportResult>,
progress: &mut Option<RunProgress>,
) -> Option<Drained> {
let cancelled = handle.cancelled();
match update {
RunUpdate::Skeleton(skeleton) => {
if cancelled {
return None;
}
let mut skeleton = skeleton;
let total = skeleton.rows.len();
skeleton.pending = (0..total).collect();
let index = skeleton
.rows
.iter()
.enumerate()
.map(|(i, row)| (row.path.clone(), i))
.collect();
*result = Some(skeleton);
*progress = Some(RunProgress {
states: vec![RowState::Scheduled; total],
index,
done: 0,
total,
rerun: false,
});
Some(Drained::Progress { done: 0, total })
}
RunUpdate::RowStarted(path) => {
if cancelled {
return None;
}
if let Some(prog) = progress.as_mut()
&& let Some(&ri) = prog.index.get(&path)
&& prog.states.get(ri) == Some(&RowState::Scheduled)
{
prog.states[ri] = RowState::Running;
}
None
}
RunUpdate::Row(row) => {
if cancelled {
return None;
}
let (Some(res), Some(prog)) = (result.as_mut(), progress.as_mut()) else {
return None;
};
if let Some(&ri) = prog.index.get(&row.path)
&& ri < res.rows.len()
{
res.rows[ri] = *row;
res.pending.remove(&ri);
if prog.states[ri] != RowState::Finished {
prog.states[ri] = RowState::Finished;
prog.done += 1;
}
}
Some(Drained::Progress {
done: prog.done,
total: prog.total,
})
}
RunUpdate::Done(finalized) => {
handle.finished = true;
*progress = None;
if cancelled {
return Some(Drained::Done {
rows: result.as_ref().map(|r| r.rows.len()).unwrap_or(0),
errors: result.as_ref().map(|r| r.errors.len()).unwrap_or(0),
});
}
let mut finalized = finalized;
for (refs, fresh) in std::mem::take(&mut handle.held) {
let rows = crate::report::rerun::rows_after_finalize(&refs, &finalized);
crate::report::rerun::splice(&mut finalized, &fresh, &rows);
}
let rows = finalized.rows.len();
let errors = finalized.errors.len();
*progress = progress_after_run(handle, &finalized);
*result = Some(finalized);
Some(Drained::Done { rows, errors })
}
RunUpdate::LiveRerun(_) => None,
RunUpdate::Rerun { rows, fresh } => {
handle.finished = true;
*progress = None;
if cancelled {
return Some(Drained::Rerun {
replaced: Vec::new(),
errors: 0,
});
}
let Some(res) = result.as_mut() else {
return Some(Drained::Rerun {
replaced: Vec::new(),
errors: 0,
});
};
let replaced = crate::report::rerun::splice(res, &fresh, &rows);
let errors = replaced
.iter()
.map(|&r| {
res.rows[r].errors.len() + res.baseline_errors.get(&r).map_or(0, Vec::len)
})
.sum();
Some(Drained::Rerun { replaced, errors })
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::report::model::{ReportResult, ReportRow};
fn row(path: Vec<(usize, usize)>, status: &str) -> ReportRow {
let mut r = ReportRow::default();
r.path = path;
r.cells.insert("status".to_string(), status.to_string());
r
}
fn skeleton(n: usize) -> ReportResult {
let mut res = ReportResult::default();
res.column_order = vec!["status".to_string()];
res.rows = (0..n).map(|i| row(vec![(0, i)], "")).collect();
res
}
#[test]
fn streamed_rows_fill_their_slots_by_path_and_advance_progress() {
let (mut handle, tx) = test_handle();
let mut result = None;
let mut progress = None;
tx.send(RunUpdate::Skeleton(skeleton(3))).unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::Progress { done: 0, total: 3 }
));
assert_eq!(progress.as_ref().unwrap().states.len(), 3);
assert!(
progress
.as_ref()
.unwrap()
.states
.iter()
.all(|s| *s == RowState::Scheduled)
);
tx.send(RunUpdate::RowStarted(vec![(0, 2)])).unwrap();
tx.send(RunUpdate::Row(Box::new(row(vec![(0, 2)], "200"))))
.unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::Progress { done: 1, total: 3 }
));
let res = result.as_ref().unwrap();
assert_eq!(
res.rows[2].cells.get("status").map(String::as_str),
Some("200")
);
assert_eq!(progress.as_ref().unwrap().states[2], RowState::Finished);
assert_eq!(progress.as_ref().unwrap().states[0], RowState::Scheduled);
}
#[test]
fn done_replaces_the_grid_and_clears_progress() {
let (mut handle, tx) = test_handle();
let mut result = Some(skeleton(2));
let mut progress = Some(RunProgress {
states: vec![RowState::Scheduled; 2],
index: Default::default(),
done: 0,
total: 2,
rerun: false,
});
let mut finalized = ReportResult::default();
finalized.column_order = vec!["status".to_string()];
finalized.rows = vec![row(vec![], "OK")];
tx.send(RunUpdate::Done(finalized)).unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::Done { rows: 1, errors: 0 }
));
assert!(progress.is_none());
assert!(handle.finished());
assert_eq!(result.as_ref().unwrap().rows.len(), 1);
}
#[test]
fn a_cancelled_run_keeps_its_partial_grid_and_ignores_late_rows() {
let (mut handle, tx) = test_handle();
let mut result = None;
let mut progress = None;
tx.send(RunUpdate::Skeleton(skeleton(2))).unwrap();
drain(&mut handle, &mut result, &mut progress);
tx.send(RunUpdate::Row(Box::new(row(vec![(0, 0)], "200"))))
.unwrap();
drain(&mut handle, &mut result, &mut progress);
handle.cancel();
tx.send(RunUpdate::Row(Box::new(row(vec![(0, 1)], "500"))))
.unwrap();
tx.send(RunUpdate::Done(ReportResult::default())).unwrap();
drain(&mut handle, &mut result, &mut progress);
let res = result.as_ref().unwrap();
assert_eq!(
res.rows[0].cells.get("status").map(String::as_str),
Some("200")
);
assert_eq!(
res.rows[1].cells.get("status").map(String::as_str),
Some("")
);
assert!(handle.finished());
}
fn side(key: &str, role: crate::report::model::RowRole, path: usize, v: &str) -> ReportRow {
ReportRow {
key: vec![key.to_string()],
role,
comparison: Some("c".to_string()),
path: vec![(0, 0), (1, path)],
cells: [("v".to_string(), v.to_string())].into_iter().collect(),
..Default::default()
}
}
#[test]
fn a_live_rerun_lands_now_and_outlives_the_runs_own_result() {
use crate::report::model::RowRole::{Baseline, Candidate};
use crate::report::rerun::{LiveRerun, RowRef};
let (mut handle, main) = test_handle();
let live = ReportResult {
rows: vec![
side("a", Baseline, 0, "old"),
side("a", Candidate, 1, "old"),
],
..Default::default()
};
let mut result = Some(live.clone());
let mut progress = Some(RunProgress {
states: vec![RowState::Running, RowState::Running],
index: Default::default(),
done: 2,
total: 2,
rerun: false,
});
let tx = handle.side_for_test(vec![RowRef::of(&live.rows[1])], vec![0, 1]);
assert!(!handle.finished(), "a re-run is out");
let finished_row = side("a", Candidate, 1, "new");
tx.send(RunUpdate::LiveRerun(Box::new(LiveRerun {
raw: ReportResult {
rows: vec![
side("a", Baseline, 0, "new"),
side("a", Candidate, 1, "new"),
],
..Default::default()
},
finished: ReportResult {
rows: vec![finished_row],
finalized: true,
..Default::default()
},
})))
.unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::LiveRerun { ref replaced, .. } if replaced.len() == 2
));
let res = result.as_ref().unwrap();
assert!(res.rows.iter().all(|r| r.cells["v"] == "new"));
assert_eq!(
progress.as_ref().unwrap().states,
vec![RowState::Finished, RowState::Finished]
);
main.send(RunUpdate::Done(ReportResult {
rows: vec![side("a", Candidate, 1, "old")],
finalized: true,
..Default::default()
}))
.unwrap();
drain(&mut handle, &mut result, &mut progress);
assert_eq!(result.as_ref().unwrap().rows[0].cells["v"], "new");
assert!(handle.finished());
assert!(progress.is_none());
}
#[test]
fn a_live_rerun_landing_after_the_run_goes_into_the_finished_result() {
use crate::report::model::RowRole::{Baseline, Candidate};
use crate::report::rerun::{LiveRerun, RowRef};
let (mut handle, main) = test_handle();
let live = ReportResult {
rows: vec![
side("a", Baseline, 0, "old"),
side("a", Candidate, 1, "old"),
],
..Default::default()
};
let mut result = Some(live.clone());
let mut progress = None;
let tx = handle.side_for_test(vec![RowRef::of(&live.rows[0])], vec![0, 1]);
main.send(RunUpdate::Done(ReportResult {
rows: vec![side("a", Candidate, 1, "old")],
finalized: true,
..Default::default()
}))
.unwrap();
drain(&mut handle, &mut result, &mut progress);
assert!(!handle.finished(), "the re-run is still out");
assert_eq!(
progress.as_ref().map(|p| p.states.clone()),
Some(vec![RowState::Running]),
"the baseline's re-run shows on the row it was folded into"
);
tx.send(RunUpdate::LiveRerun(Box::new(LiveRerun {
raw: ReportResult::default(),
finished: ReportResult {
rows: vec![side("a", Candidate, 1, "new")],
finalized: true,
..Default::default()
},
})))
.unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::Rerun { ref replaced, .. } if *replaced == vec![0]
));
assert_eq!(result.as_ref().unwrap().rows[0].cells["v"], "new");
assert!(handle.finished());
assert!(progress.is_none());
}
#[test]
fn a_runs_end_is_not_hidden_by_a_rerun_landing_beside_it() {
use crate::report::model::RowRole::{Baseline, Candidate};
use crate::report::rerun::{LiveRerun, RowRef};
let (mut handle, main) = test_handle();
let live = ReportResult {
rows: vec![
side("a", Baseline, 0, "old"),
side("a", Candidate, 1, "old"),
],
..Default::default()
};
let mut result = Some(live.clone());
let mut progress = None;
let tx = handle.side_for_test(vec![RowRef::of(&live.rows[1])], vec![0, 1]);
main.send(RunUpdate::Done(ReportResult {
rows: vec![side("a", Candidate, 1, "old")],
finalized: true,
..Default::default()
}))
.unwrap();
tx.send(RunUpdate::LiveRerun(Box::new(LiveRerun {
raw: ReportResult::default(),
finished: ReportResult {
rows: vec![side("a", Candidate, 1, "new")],
finalized: true,
..Default::default()
},
})))
.unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::Done { .. }
));
assert_eq!(result.as_ref().unwrap().rows[0].cells["v"], "new");
assert!(handle.finished());
}
#[test]
fn a_rerun_splices_its_row_into_the_finished_grid() {
let (mut handle, tx) = test_handle();
let finished = ReportResult {
column_order: vec!["status".to_string()],
rows: vec![row(vec![(0, 0)], "200"), row(vec![(0, 1)], "503")],
..Default::default()
};
let mut result = Some(finished);
let mut progress = Some(RunProgress::rerun(2, &[1]));
assert_eq!(
progress.as_ref().unwrap().states,
vec![RowState::Idle, RowState::Running]
);
let fresh = ReportResult {
rows: vec![row(vec![(0, 1)], "200")],
..Default::default()
};
tx.send(RunUpdate::Rerun {
rows: vec![1],
fresh,
})
.unwrap();
assert!(matches!(
drain(&mut handle, &mut result, &mut progress),
Drained::Rerun { ref replaced, errors: 0 } if *replaced == vec![1]
));
assert!(progress.is_none());
assert!(handle.finished());
let res = result.as_ref().unwrap();
assert_eq!(res.rows.len(), 2);
assert_eq!(
res.rows[1].cells.get("status").map(String::as_str),
Some("200")
);
}
}