use std::collections::HashMap;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use crate::environment::{looks_like_env, parse_vars};
use crate::postman::{looks_like_postman, parse_collection};
use crate::report::flow::Header;
use crate::report::model::{OutputColumn, Partial, ReportRow};
use crate::report::params::{ParamValues, undeclared};
use crate::report::producers::resolve_path;
use crate::report::report::{expand_output_tokens, name_has_output_token};
use crate::report::run::{
Cancel, DryRunner, LiveRunner, RowEvent, RowSink, RunContext, finalize, run_flow_raw,
};
use crate::report::validate::{Context, Severity, validate};
use crate::report::writer::{OUTPUT_EXTENSIONS, writer_for_extension};
use crate::report::{CsvWriter, Report, ReportResult, ReportWriter};
use crate::shared_utils::sanitize_file_stem;
fn random_seed() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos() as u64)
.unwrap_or(1)
}
pub fn run(
collection_path: Option<String>,
env_paths: Vec<String>,
report_path: String,
outputs: Vec<String>,
dry_run: bool,
targets: Vec<String>,
shuffle: Option<Option<u64>>,
params: ParamValues,
progress_json: bool,
grace_secs: Option<u64>,
stop_on_stdin: bool,
) -> i32 {
let control = Control::new(grace_secs);
control.listen(stop_on_stdin);
run_with_progress(
collection_path,
env_paths,
report_path,
outputs,
dry_run,
targets,
shuffle,
params,
Progress::new(progress_json),
control,
)
}
#[allow(clippy::too_many_arguments)]
fn run_with_progress(
collection_path: Option<String>,
env_paths: Vec<String>,
report_path: String,
outputs: Vec<String>,
dry_run: bool,
targets: Vec<String>,
shuffle: Option<Option<u64>>,
params: ParamValues,
progress: Progress,
control: Control,
) -> i32 {
let progress_json = progress.on();
let to_stdout = outputs.iter().any(|o| o == "-");
let report = match Report::load_local(&report_path) {
Ok(r) => r,
Err(e) => {
return progress.setup_failed(vec![format!("cannot read report file: {e}")]);
}
};
let mut flow = match report.flow() {
Ok(f) => f,
Err(e) => {
return progress.setup_failed(vec![format!(
"report '{report_path}' has a syntax error: {e}"
)]);
}
};
let report_dir = report.path.as_deref().and_then(Path::parent);
let undeclared_params = undeclared(&flow.params(), ¶ms);
if !undeclared_params.is_empty() {
let declared = flow.params();
let known = if declared.is_empty() {
"it declares none".to_string()
} else {
format!(
"it declares: {}",
declared
.iter()
.map(|p| p.name.as_str())
.collect::<Vec<_>>()
.join(", ")
)
};
return progress.setup_failed(vec![format!(
"report '{report_path}' has no parameter named {} ({known})",
undeclared_params
.iter()
.map(|n| format!("'{n}'"))
.collect::<Vec<_>>()
.join(", ")
)]);
}
if let Err(e) = check_outputs(&outputs, &flow.header) {
return progress.setup_failed(vec![e]);
}
let embedded = flow.embedded_entries();
let collection_path = match collection_path {
Some(c) => Some(c),
None => match report.collection_ref() {
Some(c) => Some(resolve_path(report_dir, &c).to_string_lossy().into_owned()),
None if flow.requests.is_some() => None,
None => {
return progress.setup_failed(vec![format!(
"no collection to run against — pass -c/--collection, add a '# collection:' header to '{report_path}', or embed the requests in a REQUESTS section"
)]);
}
},
};
let col_content = match &collection_path {
Some(path) => match fs::read_to_string(path) {
Ok(c) => c,
Err(e) => {
return progress
.setup_failed(vec![format!("cannot read collection file '{path}': {e}")]);
}
},
None => String::new(),
};
let mut entries = match &collection_path {
Some(_) => parse_collection(&col_content),
None => Vec::new(),
};
let embedded_count = embedded.len();
entries.extend(embedded);
let collection_path = collection_path.unwrap_or_else(|| {
let s = if embedded_count == 1 { "" } else { "s" };
format!("(embedded: {embedded_count} request{s})")
});
if entries.is_empty() {
let embedded_why = flow
.requests
.as_deref()
.and_then(|t| crate::hurl::parse_hurl_error_from(t, flow.requests_line.max(1)));
let message = match embedded_why.or_else(|| {
(!looks_like_postman(&col_content))
.then(|| crate::hurl::parse_hurl_error(&col_content))
.flatten()
}) {
Some(why) => format!("no requests found in '{collection_path}' — {why}"),
None => format!("no requests found in '{collection_path}'"),
};
return progress.setup_failed(vec![message]);
}
let env_paths: Vec<String> = if env_paths.is_empty() {
match report.environment_ref() {
Some(e) => vec![resolve_path(report_dir, &e).to_string_lossy().into_owned()],
None => Vec::new(),
}
} else {
env_paths
};
let mut base_vars: HashMap<String, String> = HashMap::new();
let mut named_envs: HashMap<String, HashMap<String, String>> = HashMap::new();
let mut env_names_loaded: Vec<String> = Vec::new();
for env_path in &env_paths {
let env_content = match fs::read_to_string(env_path) {
Ok(c) => c,
Err(e) => {
return progress.setup_failed(vec![format!(
"cannot read environment file '{env_path}': {e}"
)]);
}
};
if !looks_like_env(&env_content) {
return progress.setup_failed(vec![format!(
"'{env_path}' is not a valid environment file (expected KEY=value lines)"
)]);
}
let name = crate::shared_utils::stem(env_path, "env");
if named_envs.contains_key(&name) {
return progress.setup_failed(vec![format!(
"duplicate environment name '{name}' (from '{env_path}') — each -e file must have a distinct stem so an ENVS clause can name it unambiguously"
)]);
}
let env = parse_vars(name.clone(), &env_content);
let flat: HashMap<String, String> = env
.vars
.iter()
.map(|v| (v.key.clone(), v.value.clone()))
.collect();
if env_names_loaded.is_empty() {
base_vars = flat.clone();
}
named_envs.insert(name.clone(), flat);
env_names_loaded.push(name);
}
let titles: Vec<String> = entries.iter().map(|e| e.title.clone()).collect();
let fields: Vec<(String, Vec<String>)> = entries
.iter()
.map(|e| {
(
e.title.clone(),
e.reports.iter().map(|(n, _)| n.clone()).collect(),
)
})
.collect();
let env_names: Vec<String> = named_envs.keys().cloned().collect();
let cli_strings = crate::i18n::Strings::for_language(&crate::i18n::Language::English);
let (helpers, helper_errors) = crate::report::context::load_helpers(
&[],
&flow,
Some(std::path::Path::new(&report_path)),
&cli_strings,
);
let root: Option<PathBuf> = match flow.header.root() {
Some(r) if !r.trim().is_empty() => Some(resolve_path(report_dir, r)),
_ => report_dir.map(Path::to_path_buf),
};
let base_var_names_owned: Vec<String> = env_names_loaded
.first()
.and_then(|first_name| named_envs.get(first_name))
.map(|m| {
let mut keys: Vec<String> = m.keys().cloned().collect();
keys.sort();
keys
})
.unwrap_or_default();
let mut all_env_var_names_owned: Vec<String> = named_envs
.values()
.flat_map(|m| m.keys().cloned())
.collect();
all_env_var_names_owned.sort();
all_env_var_names_owned.dedup();
let ctx = Context {
request_titles: Some(&titles),
env_names: Some(&env_names),
request_fields: Some(&fields),
root: root.as_deref(),
base_var_names: Some(&base_var_names_owned),
all_env_var_names: Some(&all_env_var_names_owned),
request_entries: Some(&entries),
helpers: &helpers,
helper_errors: &helper_errors,
strings: &cli_strings,
};
let diags = validate(&flow, &ctx);
let has_error = diags.iter().any(|d| d.severity == Severity::Error);
let mut setup_warnings: Vec<String> = Vec::new();
for d in &diags {
let tag = match d.severity {
Severity::Error => "error",
Severity::Warning => "warning",
};
if progress_json {
if d.severity == Severity::Warning {
setup_warnings.push(d.message.clone());
}
} else {
eprintln!("{tag}: {}", d.message);
}
}
if has_error && !dry_run {
let mut errors: Vec<String> = diags
.iter()
.filter(|d| progress_json && d.severity == Severity::Error)
.map(|d| d.message.clone())
.collect();
errors.push(
"the report has validation errors — fix them or use --dry-run to preview".to_string(),
);
return progress.setup_failed_with(errors, setup_warnings);
}
if !targets.is_empty()
&& let Err(errs) = crate::report::graph::prune_to_targets(
&mut flow,
&targets,
&entries,
&helpers,
&cli_strings,
)
{
return progress.setup_failed_with(errs, setup_warnings);
}
let file_root = Path::new(&collection_path).parent().map(Path::to_path_buf);
let live = LiveRunner {
file_root: file_root.clone(),
};
let dry = DryRunner;
let mut decor = Decor::new(to_stdout, progress_json);
decor.line(&format!("PaperBoy — report \"{}\"", report.name));
decor.line(&format!(" Collection : {collection_path}"));
if let [one] = env_names_loaded.as_slice() {
decor.line(&format!(" Environment: {one}"));
} else if !env_names_loaded.is_empty() {
decor.line(&format!(
" Environments: {} (base: {})",
env_names_loaded.join(", "),
env_names_loaded[0]
));
}
if dry_run {
decor.line(" Mode : DRY RUN (no requests sent)");
}
if !targets.is_empty() {
decor.line(&format!(" Targets : {}", targets.join(", ")));
}
if !params.is_empty() {
let mut supplied: Vec<String> = params
.iter()
.map(|(name, value)| format!("{name}={value}"))
.collect();
supplied.sort();
decor.line(&format!(" Parameters : {}", supplied.join(", ")));
}
let shuffle = shuffle.map(|s| s.unwrap_or_else(random_seed));
if let Some(seed) = shuffle {
decor.line(&format!(
" Shuffle : seed {seed} (replay with --shuffle={seed})"
));
}
if dry_run {
let lines = crate::report::graph::explain(&flow, &entries, &helpers, &cli_strings);
if !lines.is_empty() {
decor.line("");
for l in lines {
decor.line(&l);
}
decor.line("");
}
}
let projection = (!dry_run || progress_json).then(|| {
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars: base_vars.clone(),
named_envs: named_envs.clone(),
root: root.clone(),
runner: &dry,
strings: &cli_strings,
params: params.clone(),
sink: None,
shuffle,
cancel: None,
};
run_flow_raw(&flow, &ctx)
});
let (streamed_columns, withheld_columns) = split_streamed_columns(
projection
.as_ref()
.map(|p| p.resolved_columns(&flow.header))
.unwrap_or_default(),
);
let total = projection.as_ref().map_or(0, |p| p.rows.len());
let no_match = projection
.as_ref()
.map(|p| p.no_match_marker.clone())
.unwrap_or_default();
let slots = RowSlots::new(projection.as_ref().map_or(&[], |p| p.rows.as_slice()));
let shape = projection;
let done = std::sync::atomic::AtomicUsize::new(0);
let harvest = Mutex::new(Harvest::default());
let sink = |ev: RowEvent| {
if !dry_run && let RowEvent::Completed { row, errors } = &ev {
let mut held = harvest.lock().unwrap_or_else(|e| e.into_inner());
held.completed += 1;
held.rows.push((*row).clone());
held.errors
.extend(errors.iter().map(|e| (row.path.clone(), e.clone())));
}
if progress_json {
match ev {
RowEvent::Started(path) => progress.row_started(path, &slots),
RowEvent::Completed { row, errors } => {
progress.row_completed(row, errors, &streamed_columns, &no_match, &slots)
}
}
return;
}
if !matches!(ev, RowEvent::Completed { .. }) {
return;
}
let n = done.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
eprint!("\r running {n}/{total} ");
let _ = std::io::stderr().flush();
};
let sink: Option<&RowSink> = match (dry_run, progress_json) {
(true, false) => None,
_ => Some(&sink),
};
let result = if dry_run {
progress.plan(
&report.name,
total,
&streamed_columns,
&withheld_columns,
true,
);
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars,
named_envs,
root,
runner: &dry,
strings: &cli_strings,
params: params.clone(),
sink,
shuffle,
cancel: None,
};
let mut r = run_flow_raw(&flow, &ctx);
finalize(&mut r, &flow, &ctx);
decor.line(&format!(" Rows : {} projected", r.rows.len()));
r
} else {
decor.line(&format!(" Rows : {total}"));
progress.plan(
&report.name,
total,
&streamed_columns,
&withheld_columns,
false,
);
let ctx = RunContext {
entries: &entries,
helpers: &helpers,
base_vars,
named_envs,
root,
runner: &live,
strings: &cli_strings,
params,
sink,
shuffle,
cancel: Some(control.cancel.as_ref()),
};
let mut announced_stop = false;
let ending = std::thread::scope(|s| {
let (tx, rx) = std::sync::mpsc::channel();
let (flow_ref, ctx_ref) = (&flow, &ctx);
s.spawn(move || {
let mut r = run_flow_raw(flow_ref, ctx_ref);
finalize(&mut r, flow_ref, ctx_ref);
let _ = tx.send(r);
});
let mut deadline: Option<std::time::Instant> = None;
loop {
match rx.recv_timeout(STOP_POLL) {
Ok(r) => return Ending::Ran(r),
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => return Ending::Lost,
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
}
if control.cancel.stopped() && deadline.is_none() {
deadline = Some(std::time::Instant::now() + control.grace);
announced_stop = true;
progress.run_stopping(control.source(), control.grace);
if !progress_json {
eprintln!(
"\r stopping : no new rows; up to {}s for the rows in flight and CLEANUP",
grace_label(control.grace)
);
}
}
if deadline.is_some_and(|d| std::time::Instant::now() >= d) {
let mut r = abandoned_result(shape.as_ref(), &harvest, total, control.grace);
finalize(&mut r, &flow, &ctx);
let code = deliver(
&r,
&flow.header,
&report,
&outputs,
&mut decor,
&progress,
&setup_warnings,
);
(control.abandon)(code);
return Ending::Delivered(code);
}
}
});
match ending {
Ending::Ran(mut r) => {
if control.cancel.stopped() {
if !announced_stop {
progress.run_stopping(control.source(), control.grace);
}
r.partial = Some(Partial {
rows_completed: harvest.lock().unwrap_or_else(|e| e.into_inner()).completed,
rows_planned: total,
});
}
if !progress_json {
match &r.partial {
Some(p) => eprintln!(
"\r stopped : {} of {} rows ran ",
p.rows_completed, p.rows_planned
),
None => eprintln!("\r running {total}/{total} done"),
}
}
r
}
Ending::Delivered(code) => return code,
Ending::Lost => unreachable!("the scope re-raises the run thread's panic"),
}
};
deliver(
&result,
&flow.header,
&report,
&outputs,
&mut decor,
&progress,
&setup_warnings,
)
}
#[allow(clippy::too_many_arguments)]
fn deliver(
result: &ReportResult,
header: &Header,
report: &Report,
outputs: &[String],
decor: &mut Decor,
progress: &Progress,
setup_warnings: &[String],
) -> i32 {
let progress_json = progress.on();
if !result.warnings.is_empty() {
decor.line(&format!(" Warnings : {}", result.warnings.len()));
for w in &result.warnings {
decor.line(&format!(" ~ {w}"));
}
}
if !result.skipped.is_empty() {
decor.line(&format!(
" Skipped : {} ({})",
result.skipped.len(),
result.skipped.join(", ")
));
}
if !result.errors.is_empty() {
decor.line(&format!(" Errors : {}", result.errors.len()));
for e in &result.errors {
decor.line(&format!(" ! {e}"));
}
}
if let Some(partial) = &result.partial {
decor.line(&format!(
" Stopped : PARTIAL — {} of {} rows ran",
partial.rows_completed, partial.rows_planned
));
}
let requested: Vec<Option<&str>> = if outputs.is_empty() {
vec![None]
} else {
outputs.iter().map(|o| Some(o.as_str())).collect()
};
let mut write_failed = false;
for target in requested {
match write_output(&result, header, target, &report) {
Ok(OutputTarget::Stdout(format)) => {
progress.output_written("-", format, None);
}
Ok(OutputTarget::File(path)) => {
decor.line(&format!(" Output : {}", path.display()));
let fmt = output_extension_of(&path.to_string_lossy());
progress.output_written(&path.to_string_lossy(), &fmt, None);
}
Err(e) => {
if progress_json {
let path = target.unwrap_or("");
progress.output_written(path, &output_extension_of(path), Some(&e));
} else {
eprintln!("error: cannot write output: {e}");
}
write_failed = true;
}
}
}
let exit = if write_failed {
1
} else if result.partial.is_some() {
EXIT_INTERRUPTED
} else {
match (result.skipped.is_empty(), result.errors.is_empty()) {
(false, _) => EXIT_SKIPPED,
(true, false) => 1,
(true, true) => 0,
}
};
progress.run_finished(result, exit, setup_warnings);
exit
}
pub const EXIT_SKIPPED: i32 = 3;
pub const EXIT_INTERRUPTED: i32 = 4;
pub const EXIT_FORCED: i32 = 130;
pub const DEFAULT_GRACE_SECS: u64 = 30;
const STOP_POLL: std::time::Duration = std::time::Duration::from_millis(50);
pub struct Control {
cancel: std::sync::Arc<Cancel>,
grace: std::time::Duration,
source: std::sync::Arc<std::sync::Mutex<&'static str>>,
abandon: fn(i32),
}
impl Control {
pub fn new(grace_secs: Option<u64>) -> Self {
Control {
cancel: std::sync::Arc::new(Cancel::new()),
grace: std::time::Duration::from_secs(grace_secs.unwrap_or(DEFAULT_GRACE_SECS)),
source: std::sync::Arc::new(std::sync::Mutex::new("stop")),
abandon: |code| std::process::exit(code),
}
}
#[cfg(test)]
fn for_test() -> Self {
Control {
cancel: std::sync::Arc::new(Cancel::new()),
grace: std::time::Duration::from_secs(DEFAULT_GRACE_SECS),
source: std::sync::Arc::new(std::sync::Mutex::new("stop")),
abandon: |_| {},
}
}
#[cfg(test)]
fn switch(&self) -> std::sync::Arc<Cancel> {
self.cancel.clone()
}
#[cfg(test)]
fn with_grace(mut self, grace: std::time::Duration) -> Self {
self.grace = grace;
self
}
fn source(&self) -> &'static str {
*self.source.lock().unwrap_or_else(|e| e.into_inner())
}
fn listen(&self, stop_on_stdin: bool) {
let cancel = self.cancel.clone();
let source = self.source.clone();
let hits = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let signal_hits = hits.clone();
let _ = ctrlc::set_handler(move || {
if signal_hits.fetch_add(1, std::sync::atomic::Ordering::Relaxed) > 0 {
std::process::exit(EXIT_FORCED);
}
*source.lock().unwrap_or_else(|e| e.into_inner()) = "signal";
cancel.stop();
});
if !stop_on_stdin {
return;
}
let cancel = self.cancel.clone();
let source = self.source.clone();
std::thread::spawn(move || {
let mut line = String::new();
loop {
line.clear();
match std::io::stdin().read_line(&mut line) {
Ok(0) => {
if !cancel.stopped() {
*source.lock().unwrap_or_else(|e| e.into_inner()) = "eof";
}
cancel.stop();
return;
}
Ok(_) => {
if !line.trim().eq_ignore_ascii_case("stop") {
continue;
}
if hits.fetch_add(1, std::sync::atomic::Ordering::Relaxed) > 0 {
std::process::exit(EXIT_FORCED);
}
*source.lock().unwrap_or_else(|e| e.into_inner()) = "stdin";
cancel.stop();
}
Err(_) => return,
}
}
});
}
}
const CSV_EXTENSION: &str = "csv";
enum OutputTarget {
Stdout(&'static str),
File(PathBuf),
}
fn write_output(
result: &ReportResult,
header: &Header,
output: Option<&str>,
report: &Report,
) -> Result<OutputTarget, String> {
match output {
Some("-") => {
let bytes = CsvWriter.write(result, header)?;
std::io::stdout()
.write_all(&bytes)
.map_err(|e| e.to_string())?;
Ok(OutputTarget::Stdout(CSV_EXTENSION))
}
Some(path) => {
let ext = output_extension_of(path);
let writer = writer_for_extension(&ext).ok_or_else(|| unsupported_ext(&ext))?;
let bytes = writer.write(result, header)?;
fs::write(path, bytes).map_err(|e| format!("{path}: {e}"))?;
Ok(OutputTarget::File(PathBuf::from(path)))
}
None => {
let ext = output_extension_from_header(header)?;
let writer = writer_for_extension(&ext).ok_or_else(|| unsupported_ext(&ext))?;
let path = derived_output_path(report, &ext);
let bytes = writer.write(result, header)?;
fs::write(&path, bytes).map_err(|e| format!("{}: {e}", path.display()))?;
Ok(OutputTarget::File(path))
}
}
}
fn check_outputs(outputs: &[String], header: &Header) -> Result<(), String> {
if outputs.is_empty() {
output_extension_from_header(header)?;
return Ok(());
}
if outputs.iter().filter(|o| o.as_str() == "-").count() > 1 {
return Err("-o - was given more than once, but there is only one stdout".to_string());
}
let mut seen: Vec<&str> = Vec::new();
for out in outputs {
if out == "-" {
continue;
}
if seen.contains(&out.as_str()) {
return Err(format!("-o {out} was given more than once"));
}
seen.push(out);
let ext = output_extension_of(out);
if writer_for_extension(&ext).is_none() {
return Err(unsupported_ext(&ext));
}
}
Ok(())
}
fn output_extension_of(path: &str) -> String {
Path::new(path)
.extension()
.and_then(|e| e.to_str())
.unwrap_or("csv")
.to_ascii_lowercase()
}
fn output_extension_from_header(header: &Header) -> Result<String, String> {
let ext = header
.output()
.map(|f| f.trim().to_ascii_lowercase())
.filter(|f| !f.is_empty())
.unwrap_or_else(|| "csv".to_string());
if writer_for_extension(&ext).is_none() {
return Err(format!(
"unsupported '# output:' format '{ext}' (supported: {})",
OUTPUT_EXTENSIONS.join(", ")
));
}
Ok(ext)
}
fn unsupported_ext(ext: &str) -> String {
format!(
"unsupported output extension '.{ext}' (supported: {})",
OUTPUT_EXTENSIONS.join(", ")
)
}
fn derived_output_path(report: &Report, ext: &str) -> PathBuf {
if name_has_output_token(&report.name) {
let stem = sanitize_file_stem(&expand_output_tokens(&report.name));
let file = format!("{stem}.{ext}");
return match report.path.as_deref().and_then(Path::parent) {
Some(dir) => dir.join(file),
None => PathBuf::from(file),
};
}
if let Some(path) = &report.path {
return path.with_extension(ext);
}
PathBuf::from(format!("{}.{ext}", sanitize_file_stem(&report.name)))
}
struct Decor {
to_stderr: bool,
silent: bool,
}
impl Decor {
fn new(csv_to_stdout: bool, progress_json: bool) -> Self {
Decor {
to_stderr: csv_to_stdout,
silent: csv_to_stdout && progress_json,
}
}
fn line(&mut self, s: &str) {
if self.silent {
} else if self.to_stderr {
eprintln!("{s}");
} else {
println!("{s}");
}
}
}
const PROGRESS_SCHEMA: u32 = 1;
const PROGRESS_MAX_CELL: usize = 4096;
struct Progress {
out: Option<Box<dyn Fn(&str) + Sync + Send>>,
finished: std::sync::atomic::AtomicBool,
}
impl Progress {
fn new(on: bool) -> Self {
Progress {
finished: std::sync::atomic::AtomicBool::new(false),
out: on.then(|| {
Box::new(|line: &str| {
let mut err = std::io::stderr().lock();
let _ = err.write_all(line.as_bytes());
let _ = err.flush();
}) as Box<dyn Fn(&str) + Sync + Send>
}),
}
}
fn on(&self) -> bool {
self.out.is_some()
}
fn setup_failed(&self, errors: Vec<String>) -> i32 {
self.setup_failed_with(errors, Vec::new())
}
fn setup_failed_with(&self, errors: Vec<String>, warnings: Vec<String>) -> i32 {
if self.out.is_none() {
for message in &errors {
eprintln!("error: {message}");
}
return 1;
}
self.emit(
"run_finished",
serde_json::json!({
"ok": false,
"exit_code": 1,
"rows": 0,
"interrupted": false,
"partial": false,
"rows_completed": serde_json::Value::Null,
"rows_planned": serde_json::Value::Null,
"warnings": warnings,
"skipped": [],
"errors": errors,
}),
);
1
}
fn emit(&self, event: &str, fields: serde_json::Value) {
let Some(out) = &self.out else {
return;
};
if self.finished.load(std::sync::atomic::Ordering::Acquire) {
return;
}
let mut obj = serde_json::Map::new();
obj.insert("event".into(), serde_json::Value::String(event.into()));
obj.insert("schema".into(), serde_json::json!(PROGRESS_SCHEMA));
if let serde_json::Value::Object(map) = fields {
for (k, v) in map {
obj.insert(k, v);
}
}
out(&format!("{}\n", serde_json::Value::Object(obj)));
}
fn plan(
&self,
report_name: &str,
total: usize,
streamed: &[OutputColumn],
withheld: &[OutputColumn],
dry_run: bool,
) {
self.emit(
"plan",
serde_json::json!({
"report": report_name,
"dry_run": dry_run,
"total": total,
"columns": streamed.iter().map(|c| c.header.clone()).collect::<Vec<_>>(),
"withheld_columns": withheld.iter().map(|c| c.header.clone()).collect::<Vec<_>>(),
}),
);
}
fn row_started(&self, path: &[(usize, usize)], slots: &RowSlots) {
self.emit(
"row_started",
serde_json::json!({ "path": path_key(path), "row_index": slots.index_of(path) }),
);
}
fn row_completed(
&self,
row: &ReportRow,
errors: &[String],
columns: &[OutputColumn],
no_match: &str,
slots: &RowSlots,
) {
if self.out.is_none() {
return;
}
let mut cells = serde_json::Map::new();
let mut withheld: Vec<String> = Vec::new();
for col in columns {
let value = col.value(row, no_match);
if value.len() > PROGRESS_MAX_CELL {
withheld.push(col.header.clone());
continue;
}
cells.insert(col.header.clone(), serde_json::Value::String(value));
}
self.emit(
"row_completed",
serde_json::json!({
"path": path_key(&row.path),
"row_index": slots.index_of(&row.path),
"ok": errors.is_empty(),
"target": row.target,
"cells": serde_json::Value::Object(cells),
"errors": errors,
"withheld": withheld,
}),
);
}
fn output_written(&self, path: &str, format: &str, error: Option<&str>) {
self.emit(
"output_written",
serde_json::json!({
"path": path,
"format": format,
"ok": error.is_none(),
"error": error,
}),
);
}
fn run_finished(&self, result: &ReportResult, exit_code: i32, setup_warnings: &[String]) {
let warnings: Vec<&String> = setup_warnings
.iter()
.chain(result.warnings.iter())
.collect();
self.emit(
"run_finished",
serde_json::json!({
"ok": exit_code == 0,
"exit_code": exit_code,
"rows": result.rows.len(),
"interrupted": exit_code == EXIT_INTERRUPTED,
"partial": result.partial.is_some(),
"rows_completed": result.partial.map(|p| p.rows_completed),
"rows_planned": result.partial.map(|p| p.rows_planned),
"warnings": warnings,
"skipped": result.skipped,
"errors": result.errors,
}),
);
self.finished
.store(true, std::sync::atomic::Ordering::Release);
}
fn run_stopping(&self, source: &str, grace: std::time::Duration) {
self.emit(
"run_stopping",
serde_json::json!({
"source": source,
"grace_seconds": grace.as_secs(),
}),
);
}
}
fn grace_label(grace: std::time::Duration) -> String {
match grace.subsec_nanos() {
0 => grace.as_secs().to_string(),
_ => format!("{}", grace.as_secs_f64()),
}
}
#[derive(Default)]
struct Harvest {
rows: Vec<ReportRow>,
errors: Vec<(Vec<(usize, usize)>, String)>,
completed: usize,
}
enum Ending {
Ran(ReportResult),
Delivered(i32),
Lost,
}
fn abandoned_result(
shape: Option<&ReportResult>,
harvest: &Mutex<Harvest>,
planned: usize,
grace: std::time::Duration,
) -> ReportResult {
let held = harvest.lock().unwrap_or_else(|e| e.into_inner());
let mut result = shape.cloned().unwrap_or_default();
result.partial = Some(Partial {
rows_completed: held.completed,
rows_planned: planned,
});
let mut rows = held.rows.clone();
rows.sort_by(|a, b| a.path.cmp(&b.path));
result.rows = rows;
let mut errors = held.errors.clone();
errors.sort_by(|a, b| a.0.cmp(&b.0));
result.errors = errors.into_iter().map(|(_, e)| e).collect();
result.warnings = vec![format!(
"the run was stopped and did not wind down within {}s: rows still in flight were \
abandoned, and CLEANUP may not have run (check for leftover sessions or locks)",
grace_label(grace)
)];
result.skipped = Vec::new();
result.column_truths.clear();
result.column_images.clear();
result.truths.clear();
result.verdicts.clear();
result.images.clear();
result.pending.clear();
result
}
struct RowSlots {
order: HashMap<Vec<(usize, usize)>, usize>,
}
impl RowSlots {
fn new(projected: &[ReportRow]) -> Self {
let mut paths: Vec<Vec<(usize, usize)>> =
projected.iter().map(|r| r.path.clone()).collect();
paths.sort();
RowSlots {
order: paths.into_iter().enumerate().map(|(i, p)| (p, i)).collect(),
}
}
fn index_of(&self, path: &[(usize, usize)]) -> Option<usize> {
self.order.get(path).copied()
}
}
fn path_key(path: &[(usize, usize)]) -> String {
path.iter()
.map(|(node, iter)| format!("{node}.{iter}"))
.collect::<Vec<_>>()
.join(".")
}
fn split_streamed_columns(columns: Vec<OutputColumn>) -> (Vec<OutputColumn>, Vec<OutputColumn>) {
columns
.into_iter()
.partition(|c| !c.detail && c.image.is_none())
}
#[cfg(test)]
mod tests {
use super::*;
fn temp_dir(tag: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!(
"paperboy_report_cli_{tag}_{}",
uuid::Uuid::new_v4()
));
fs::create_dir_all(&dir).unwrap();
dir
}
#[test]
fn sanitize_file_stem_replaces_path_and_awkward_chars() {
assert_eq!(sanitize_file_stem("a/b:c"), "a_b_c");
assert_eq!(sanitize_file_stem("../escape"), "___escape");
assert_eq!(sanitize_file_stem(" keep me-1_2 "), "keep me-1_2");
assert_eq!(sanitize_file_stem(" "), "report");
}
#[test]
fn derived_output_path_uses_report_path_for_plain_name() {
let mut report = Report::from_text("nightly", "# name: nightly\n");
report.path = Some(PathBuf::from("/reports/nightly.trail"));
assert_eq!(
derived_output_path(&report, "csv"),
PathBuf::from("/reports/nightly.csv")
);
}
#[test]
fn derived_output_path_expands_time_token_next_to_report() {
let mut report = Report::from_text("run_{time}", "# name: run_{time}\n");
report.path = Some(PathBuf::from("/reports/nightly.trail"));
let out = derived_output_path(&report, "csv");
let name = out.file_name().unwrap().to_string_lossy();
assert!(name.starts_with("run_"), "unexpected name: {name}");
assert!(name.ends_with(".csv"), "unexpected name: {name}");
assert!(!name.contains("{time}"), "token not expanded: {name}");
assert_eq!(out.parent(), Some(Path::new("/reports")));
}
#[test]
fn derived_output_path_pathless_report_sanitizes_name() {
let report = Report::from_text("weird/name", "# name: weird/name\n");
assert_eq!(
derived_output_path(&report, "csv"),
PathBuf::from("weird_name.csv")
);
}
#[test]
fn dry_run_writes_projected_csv_to_file() {
let dir = temp_dir("dry");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: Ping.HttpStatus as Status\nREPORT REQUEST Ping\n",
)
.unwrap();
let out = dir.join("out.csv");
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 0, "dry run should succeed");
let csv = fs::read_to_string(&out).unwrap();
let mut lines = csv.lines();
assert_eq!(lines.next(), Some("Status"), "header row");
assert!(lines.next().is_some(), "one projected row expected");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_supplied_param_repoints_a_folders_loop() {
let dir = temp_dir("param");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let batch = dir.join("batch-07");
fs::create_dir_all(batch.join("case-a")).unwrap();
fs::create_dir_all(batch.join("case-b")).unwrap();
fs::create_dir_all(dir.join("empty")).unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nPARAM FOLDER CASES = \"./empty\"\n\
FOR CASE IN FOLDERS \"{{CASES}}\"\n REPORT CASE\n REPORT REQUEST Ping\nEND\n",
)
.unwrap();
let run_with = |params: ParamValues, out: &Path| {
run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
params,
false,
None,
false,
)
};
let default_out = dir.join("default.csv");
assert_eq!(run_with(ParamValues::new(), &default_out), 0);
let csv = fs::read_to_string(&default_out).unwrap();
assert!(
!csv.contains("case-a"),
"the declared default should still point at ./empty:\n{csv}"
);
let chosen_out = dir.join("chosen.csv");
let mut params = ParamValues::new();
params.insert("CASES".into(), batch.to_string_lossy().into_owned());
assert_eq!(run_with(params, &chosen_out), 0);
let csv = fs::read_to_string(&chosen_out).unwrap();
assert!(
csv.contains("case-a") && csv.contains("case-b"),
"both cases from the supplied folder expected:\n{csv}"
);
fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_param_the_report_does_not_declare_is_refused() {
let dir = temp_dir("badparam");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nPARAM FOLDER CASES = \"./empty\"\n\
# columns: Ping.HttpStatus as Status\nREPORT REQUEST Ping\n",
)
.unwrap();
let out = dir.join("out.csv");
let mut params = ParamValues::new();
params.insert("CASE_DIR".into(), "./whatever".into());
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true,
Vec::new(),
None,
params,
false,
None,
false,
);
assert_eq!(code, 1, "an undeclared parameter is a setup error");
assert!(!out.exists(), "nothing should be written for a refused run");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn one_run_writes_every_requested_format() {
let dir = temp_dir("multiout");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: Ping.HttpStatus as Status\n\
REPORT REQUEST Ping\n",
)
.unwrap();
let html = dir.join("out.html");
let json = dir.join("out.json");
let csv = dir.join("out.csv");
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![
html.to_string_lossy().into_owned(),
json.to_string_lossy().into_owned(),
csv.to_string_lossy().into_owned(),
],
true, Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 0, "a multi-output dry run should succeed");
let html_text = fs::read_to_string(&html).unwrap();
assert!(html_text.contains("<table"), "not HTML:\n{html_text}");
let json_text = fs::read_to_string(&json).unwrap();
assert!(
serde_json::from_str::<serde_json::Value>(&json_text).is_ok(),
"not JSON:\n{json_text}"
);
let csv_text = fs::read_to_string(&csv).unwrap();
assert!(csv_text.starts_with("Status"), "not CSV:\n{csv_text}");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn impossible_output_combinations_are_refused_before_the_run() {
let dir = temp_dir("badout");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: Ping.HttpStatus as Status\n\
REPORT REQUEST Ping\n",
)
.unwrap();
let go = |outs: Vec<String>| {
run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
outs,
true,
Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
)
};
assert_eq!(go(vec!["-".into(), "-".into()]), 1, "two stdouts");
let dup = dir.join("out.json").to_string_lossy().into_owned();
assert_eq!(go(vec![dup.clone(), dup.clone()]), 1, "duplicate path");
assert!(
!dir.join("out.json").exists(),
"a refused run writes nothing"
);
let good = dir.join("fine.csv");
assert_eq!(
go(vec![
good.to_string_lossy().into_owned(),
dir.join("out.docx").to_string_lossy().into_owned(),
]),
1,
"unsupported extension"
);
assert!(!good.exists(), "nothing is written for a refused run");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn stdout_and_a_file_can_be_asked_for_together() {
let dir = temp_dir("mixedout");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: Ping.HttpStatus as Status\n\
REPORT REQUEST Ping\n",
)
.unwrap();
let json = dir.join("out.json");
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec!["-".into(), json.to_string_lossy().into_owned()],
true,
Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 0);
assert!(json.exists(), "the file output still lands");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn multi_env_loads_every_env_and_runs_the_envs_loop() {
let dir = temp_dir("multienv");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
fs::write(dir.join("prod.vars"), "HOST=prod.test\n").unwrap();
fs::write(dir.join("staging.vars"), "HOST=staging.test\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nFOR TARGET IN ENVS \"prod\", \"staging\"\n REPORT TARGET\n REPORT REQUEST Ping\nEND\n",
)
.unwrap();
let out = dir.join("out.csv");
let code = run(
Some(coll.to_string_lossy().into_owned()),
vec![
dir.join("prod.vars").to_string_lossy().into_owned(),
dir.join("staging.vars").to_string_lossy().into_owned(),
],
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 0, "a multi-env dry run should succeed");
let csv = fs::read_to_string(&out).unwrap();
assert!(csv.contains("prod"), "prod env row missing:\n{csv}");
assert!(csv.contains("staging"), "staging env row missing:\n{csv}");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn duplicate_env_stem_is_rejected() {
let dir = temp_dir("dupenv");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let a = dir.join("a");
let b = dir.join("b");
fs::create_dir_all(&a).unwrap();
fs::create_dir_all(&b).unwrap();
fs::write(a.join("prod.vars"), "HOST=a.test\n").unwrap();
fs::write(b.join("prod.vars"), "HOST=b.test\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nREPORT REQUEST Ping\n",
)
.unwrap();
let code = run(
Some(coll.to_string_lossy().into_owned()),
vec![
a.join("prod.vars").to_string_lossy().into_owned(),
b.join("prod.vars").to_string_lossy().into_owned(),
],
report.to_string_lossy().into_owned(),
vec!["-".to_string()],
true,
Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 1, "a duplicate env stem is a fatal setup error");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn missing_collection_is_a_setup_error() {
let dir = temp_dir("nocoll");
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: missing.hurl\nREPORT REQUEST Ping\n",
)
.unwrap();
let code = run(
Some(dir.join("missing.hurl").to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec!["-".to_string()],
true,
Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 1, "a missing collection is a fatal setup error");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn unsupported_output_extension_is_rejected() {
let dir = temp_dir("badext");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nREPORT REQUEST Ping\n",
)
.unwrap();
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![dir.join("out.docx").to_string_lossy().into_owned()],
true,
Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 1, "an unsupported extension should fail");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn dry_run_writes_each_supported_output_format() {
let dir = temp_dir("fmts");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: Ping.HttpStatus as Status\nREPORT REQUEST Ping\n",
)
.unwrap();
for (ext, check) in [
(
"json",
&(|b: &[u8]| b.starts_with(b"{")) as &dyn Fn(&[u8]) -> bool,
),
(
"html",
&(|b: &[u8]| b.starts_with(b"<!DOCTYPE html>")) as &dyn Fn(&[u8]) -> bool,
),
(
"xlsx",
&(|b: &[u8]| b.starts_with(b"PK")) as &dyn Fn(&[u8]) -> bool,
),
(
"pdf",
&(|b: &[u8]| b.starts_with(b"%PDF-")) as &dyn Fn(&[u8]) -> bool,
),
] {
let out = dir.join(format!("out.{ext}"));
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 0, ".{ext} output should succeed");
let bytes = fs::read(&out).unwrap();
assert!(!bytes.is_empty(), ".{ext} is non-empty");
assert!(check(&bytes), ".{ext} has the expected magic/shape");
}
fs::remove_dir_all(&dir).ok();
}
#[test]
fn headers_supply_collection_and_environment_when_flags_omitted() {
let dir = temp_dir("hdrres");
let sub = dir.join("reports");
fs::create_dir_all(&sub).unwrap();
fs::write(
dir.join("api.hurl"),
"# Ping\nGET https://example.test/ping\nHTTP *\n",
)
.unwrap();
fs::write(dir.join("prod.vars"), "HOST=prod.test\n").unwrap();
let report = sub.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: ../api.hurl\n# environment: ../prod.vars\nREPORT HOST\nREPORT REQUEST Ping\n",
)
.unwrap();
let out = dir.join("out.csv");
let code = run(
None, Vec::new(), report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(code, 0, "header-resolved run should succeed");
let csv = fs::read_to_string(&out).unwrap();
assert!(csv.contains("prod.test"), "env not applied:\n{csv}");
fs::remove_dir_all(&dir).ok();
}
#[test]
fn missing_collection_and_no_header_is_a_setup_error() {
let dir = temp_dir("nohdr");
let report = dir.join("r.trail");
fs::write(&report, "# name: r\nREPORT REQUEST Ping\n").unwrap();
let code = run(
None,
Vec::new(),
report.to_string_lossy().into_owned(),
vec!["-".to_string()],
true,
Vec::new(),
None,
ParamValues::new(),
false,
None,
false,
);
assert_eq!(
code, 1,
"no collection flag and no header is a fatal setup error"
);
fs::remove_dir_all(&dir).ok();
}
fn capturing() -> (Progress, std::sync::Arc<std::sync::Mutex<Vec<String>>>) {
let log = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
let sink = std::sync::Arc::clone(&log);
(
Progress {
finished: std::sync::atomic::AtomicBool::new(false),
out: Some(Box::new(move |line: &str| {
sink.lock().unwrap().push(line.to_string())
})),
},
log,
)
}
fn col(header: &str) -> OutputColumn {
OutputColumn {
header: header.to_string(),
sources: vec![header.to_string()],
stats: Vec::new(),
image: None,
truth: None,
detail: false,
}
}
fn row(path: Vec<(usize, usize)>, cells: &[(&str, &str)]) -> ReportRow {
ReportRow {
cells: cells
.iter()
.map(|(k, v)| (k.to_string(), v.to_string()))
.collect(),
path,
..ReportRow::default()
}
}
#[test]
fn every_progress_event_is_one_versioned_json_object_per_line() {
let (progress, log) = capturing();
progress.plan("nightly", 2, &[col("Status")], &[col("Body")], false);
progress.row_started(&[(0, 1)], &RowSlots::new(&[]));
progress.row_completed(
&row(vec![(0, 1)], &[("Status", "200")]),
&[],
&[col("Status")],
"",
&RowSlots::new(&[]),
);
progress.output_written("out.json", "json", None);
progress.run_finished(&ReportResult::default(), 0, &[]);
let lines = log.lock().unwrap().clone();
let events: Vec<String> = lines
.iter()
.map(|l| {
assert!(l.ends_with('\n'), "each event is its own line: {l:?}");
assert_eq!(l.matches('\n').count(), 1, "one line per event: {l:?}");
let v: serde_json::Value = serde_json::from_str(l).expect("a line is one object");
assert_eq!(v["schema"], serde_json::json!(PROGRESS_SCHEMA));
v["event"].as_str().unwrap().to_string()
})
.collect();
assert_eq!(
events,
[
"plan",
"row_started",
"row_completed",
"output_written",
"run_finished"
]
);
}
#[test]
fn a_rows_path_is_a_dotted_string_on_every_event() {
assert_eq!(path_key(&[]), "");
assert_eq!(path_key(&[(0, 3)]), "0.3");
assert_eq!(path_key(&[(0, 3), (1, 2)]), "0.3.1.2");
let (progress, log) = capturing();
let slots = RowSlots::new(&[
row(vec![(0, 0)], &[]),
row(vec![(0, 3), (1, 2)], &[]),
row(vec![(9, 9)], &[]),
]);
progress.row_started(&[(0, 3), (1, 2)], &slots);
progress.row_completed(&row(vec![(0, 3), (1, 2)], &[]), &[], &[], "", &slots);
for line in log.lock().unwrap().iter() {
let v: serde_json::Value = serde_json::from_str(line).unwrap();
assert_eq!(v["path"], serde_json::json!("0.3.1.2"), "{line}");
assert_eq!(v["row_index"], serde_json::json!(1), "{line}");
}
assert_eq!(slots.index_of(&[(7, 7)]), None);
}
#[test]
fn row_completed_carries_the_errors_that_row_raised() {
let (progress, log) = capturing();
progress.row_completed(
&row(vec![(0, 0)], &[("Status", "500")]),
&["Ping: connection refused".to_string()],
&[col("Status")],
"",
&RowSlots::new(&[]),
);
let v: serde_json::Value = serde_json::from_str(&log.lock().unwrap()[0]).unwrap();
assert_eq!(v["ok"], serde_json::json!(false));
assert_eq!(v["errors"], serde_json::json!(["Ping: connection refused"]));
}
#[test]
fn detail_and_image_columns_are_withheld_from_the_stream() {
let mut detail = col("Raw: Response");
detail.detail = true;
let mut picture = col("Shot");
picture.image = Some(crate::report::flow::ImageSpec::default());
let (streamed, withheld) = split_streamed_columns(vec![col("Status"), detail, picture]);
assert_eq!(
streamed
.iter()
.map(|c| c.header.as_str())
.collect::<Vec<_>>(),
["Status"]
);
assert_eq!(
withheld
.iter()
.map(|c| c.header.as_str())
.collect::<Vec<_>>(),
["Raw: Response", "Shot"]
);
let (progress, log) = capturing();
progress.plan("r", 1, &streamed, &withheld, false);
let v: serde_json::Value = serde_json::from_str(&log.lock().unwrap()[0]).unwrap();
assert_eq!(v["columns"], serde_json::json!(["Status"]));
assert_eq!(
v["withheld_columns"],
serde_json::json!(["Raw: Response", "Shot"])
);
}
#[test]
fn an_oversized_cell_is_named_rather_than_streamed() {
let big = "x".repeat(PROGRESS_MAX_CELL + 1);
let (progress, log) = capturing();
progress.row_completed(
&row(vec![(0, 0)], &[("Status", "200"), ("Body", &big)]),
&[],
&[col("Status"), col("Body")],
"",
&RowSlots::new(&[]),
);
let v: serde_json::Value = serde_json::from_str(&log.lock().unwrap()[0]).unwrap();
assert_eq!(v["cells"]["Status"], serde_json::json!("200"));
assert!(
v["cells"].get("Body").is_none(),
"the giant cell is omitted"
);
assert_eq!(v["withheld"], serde_json::json!(["Body"]));
}
#[test]
fn without_the_flag_no_events_are_emitted() {
let progress = Progress::new(false);
assert!(progress.out.is_none());
progress.plan("r", 1, &[col("Status")], &[], false);
progress.row_started(&[(0, 0)], &RowSlots::new(&[]));
progress.row_completed(
&row(vec![(0, 0)], &[]),
&[],
&[col("Status")],
"",
&RowSlots::new(&[]),
);
progress.run_finished(&ReportResult::default(), 0, &[]);
}
#[test]
fn progress_json_does_not_disturb_the_report() {
let dir = temp_dir("progress");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: Ping.HttpStatus as Status\nREPORT REQUEST Ping\n",
)
.unwrap();
let out = dir.join("out.csv");
let code = run(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
ParamValues::new(),
true, None,
false,
);
assert_eq!(code, 0);
let csv = fs::read_to_string(&out).unwrap();
assert_eq!(csv.lines().next(), Some("Status"), "header row");
fs::remove_dir_all(&dir).ok();
}
fn events(log: &std::sync::Arc<std::sync::Mutex<Vec<String>>>) -> Vec<serde_json::Value> {
log.lock()
.unwrap()
.iter()
.map(|l| serde_json::from_str(l).expect("every line is one JSON object"))
.collect()
}
#[test]
fn a_streamed_rows_index_is_its_position_in_the_written_report() {
let dir = temp_dir("slots");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\n# columns: X, Y\n\
FOR X IN [\"a\", \"b\", \"c\"]\n FOR Y IN [\"1\", \"2\"]\n REPORT REQUEST Ping\n END\nEND\n",
)
.unwrap();
let out = dir.join("out.json");
let (progress, log) = capturing();
let code = run_with_progress(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
true, Vec::new(),
None,
ParamValues::new(),
progress,
Control::for_test(),
);
assert_eq!(code, 0);
let written: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&out).unwrap()).unwrap();
let rows = written["rows"].as_array().unwrap();
assert_eq!(rows.len(), 6, "three by two");
let streamed: Vec<serde_json::Value> = events(&log)
.into_iter()
.filter(|e| e["event"] == "row_completed")
.collect();
assert_eq!(streamed.len(), rows.len(), "one event per written row");
let plan = events(&log)
.into_iter()
.find(|e| e["event"] == "plan")
.unwrap();
assert_eq!(plan["total"], serde_json::json!(6));
let mut seen: Vec<usize> = Vec::new();
for ev in &streamed {
let index = ev["row_index"].as_u64().expect("a projected row is placed") as usize;
seen.push(index);
let written_row = &rows[index];
for key in ["X", "Y"] {
assert_eq!(
ev["cells"][key], written_row[key],
"row {index} disagrees on {key}: streamed {ev}, written {written_row}"
);
}
}
seen.sort();
assert_eq!(
seen,
(0..rows.len()).collect::<Vec<_>>(),
"every slot filled once"
);
fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_setup_failure_still_ends_the_stream_with_run_finished() {
let dir = temp_dir("setupfail");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nPARAM TEXT WHO = \"world\"\nREPORT REQUEST Ping\n",
)
.unwrap();
let mut params = ParamValues::new();
params.insert("WHOM".into(), "nobody".into());
let (progress, log) = capturing();
let code = run_with_progress(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![dir.join("out.csv").to_string_lossy().into_owned()],
true,
Vec::new(),
None,
params,
progress,
Control::for_test(),
);
assert_eq!(code, 1, "an undeclared parameter is a setup error");
let events = events(&log);
assert_eq!(
events.len(),
1,
"nothing ran, so only the verdict: {events:?}"
);
let last = &events[0];
assert_eq!(last["event"], "run_finished");
assert_eq!(last["exit_code"], serde_json::json!(1));
assert_eq!(last["ok"], serde_json::json!(false));
assert_eq!(last["rows"], serde_json::json!(0));
assert!(
last["errors"][0]
.as_str()
.unwrap()
.contains("no parameter named 'WHOM'"),
"the reason has to be *in* the stream: {last}"
);
fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_validation_failure_puts_every_diagnostic_in_the_stream() {
let dir = temp_dir("validfail");
let coll = dir.join("api.hurl");
fs::write(&coll, "# Ping\nGET https://example.test/ping\nHTTP *\n").unwrap();
let report = dir.join("r.trail");
fs::write(
&report,
"# name: r\n# collection: api.hurl\nREPORT REQUEST Ghost\n",
)
.unwrap();
let (progress, log) = capturing();
let code = run_with_progress(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![dir.join("out.csv").to_string_lossy().into_owned()],
false, Vec::new(),
None,
ParamValues::new(),
progress,
Control::for_test(),
);
assert_eq!(code, 1);
let events = events(&log);
assert_eq!(events.len(), 1, "blocked before the plan: {events:?}");
let errors = events[0]["errors"].as_array().unwrap();
assert!(
errors.iter().any(|e| e.as_str().unwrap().contains("Ghost")),
"the diagnostic itself, not just the summary: {errors:?}"
);
assert!(
errors
.iter()
.any(|e| e.as_str().unwrap().contains("validation errors")),
"{errors:?}"
);
fs::remove_dir_all(&dir).ok();
}
fn stopping_server(
cancel: std::sync::Arc<Cancel>,
stop_after: usize,
straggler_ms: u64,
row_delays: Vec<u64>,
) -> u16 {
use std::io::{Read, Write};
use std::net::TcpListener;
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let seen = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
std::thread::spawn(move || {
while let Ok((mut sock, _)) = listener.accept() {
let (cancel, seen, row_delays) = (cancel.clone(), seen.clone(), row_delays.clone());
std::thread::spawn(move || {
let mut buf = [0u8; 2048];
let read = sock.read(&mut buf).unwrap_or(0);
let req = String::from_utf8_lossy(&buf[..read]).into_owned();
let n = seen.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1;
if n >= stop_after {
cancel.stop();
}
let row = req
.split("/ping/r")
.nth(1)
.and_then(|rest| rest.split_whitespace().next())
.and_then(|i| i.parse::<usize>().ok());
match row.and_then(|i| row_delays.get(i).copied()) {
Some(ms) => std::thread::sleep(std::time::Duration::from_millis(ms)),
None if n > stop_after && straggler_ms > 0 => {
std::thread::sleep(std::time::Duration::from_millis(straggler_ms))
}
None => {}
}
let body = "{\"ok\":true}";
let resp = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = sock.write_all(resp.as_bytes());
let _ = sock.flush();
});
}
});
port
}
fn stop_fixture(
dir: &Path,
port: u16,
rows: usize,
parallel: Option<usize>,
) -> (PathBuf, PathBuf) {
let coll = dir.join("api.hurl");
fs::write(
&coll,
format!("# Ping\nGET http://127.0.0.1:{port}/ping/{{{{X}}}}\nHTTP *\n"),
)
.unwrap();
let items: Vec<String> = (0..rows).map(|i| format!("\"r{i}\"")).collect();
let head = match parallel {
Some(n) => format!("PARALLEL({n}) FOR"),
None => "FOR".to_string(),
};
let report = dir.join("r.trail");
fs::write(
&report,
format!(
"# name: r\n# collection: api.hurl\n# columns: X, Ping.HttpStatus as Status\n\
{head} X IN [{}]\n REPORT REQUEST Ping\nEND\n",
items.join(", ")
),
)
.unwrap();
(coll, report)
}
#[test]
fn a_stopped_run_writes_the_rows_that_finished_and_says_it_is_partial() {
let dir = temp_dir("stop");
let control = Control::for_test();
let port = stopping_server(control.switch(), 2, 0, Vec::new());
let (coll, report) = stop_fixture(&dir, port, 6, None);
let out = dir.join("out.json");
let (progress, log) = capturing();
let code = run_with_progress(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
false,
Vec::new(),
None,
ParamValues::new(),
progress,
control,
);
assert_eq!(
code, EXIT_INTERRUPTED,
"\"I was told to stop\" has a code of its own"
);
let written: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&out).unwrap()).unwrap();
assert_eq!(written["partial"], serde_json::json!(true));
assert_eq!(written["rows_completed"], serde_json::json!(2));
assert_eq!(written["rows_planned"], serde_json::json!(6));
assert_eq!(
written["rows"].as_array().unwrap().len(),
2,
"only the rows that really ran: {written}"
);
let events = events(&log);
let stopping = events.iter().find(|e| e["event"] == "run_stopping");
assert!(
stopping.is_some(),
"the stream says it is winding down: {events:?}"
);
let finished = events
.iter()
.find(|e| e["event"] == "run_finished")
.expect("a terminal event, always");
assert_eq!(finished["interrupted"], serde_json::json!(true));
assert_eq!(finished["partial"], serde_json::json!(true));
assert_eq!(finished["rows_completed"], serde_json::json!(2));
assert_eq!(finished["rows_planned"], serde_json::json!(6));
assert_eq!(finished["exit_code"], serde_json::json!(EXIT_INTERRUPTED));
assert!(
events.iter().any(|e| e["event"] == "output_written"),
"and the output it announced was written before it: {events:?}"
);
fs::remove_dir_all(&dir).ok();
}
#[test]
fn a_run_given_up_on_still_writes_what_it_had() {
let dir = temp_dir("abandon");
let control = Control::for_test().with_grace(std::time::Duration::ZERO);
let port = stopping_server(control.switch(), 1, 600, Vec::new());
let (coll, report) = stop_fixture(&dir, port, 6, Some(2));
let out = dir.join("out.json");
let (progress, log) = capturing();
let code = run_with_progress(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
false,
Vec::new(),
None,
ParamValues::new(),
progress,
control,
);
assert_eq!(code, EXIT_INTERRUPTED);
let written: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&out).unwrap()).unwrap();
assert_eq!(written["partial"], serde_json::json!(true));
assert_eq!(written["rows_planned"], serde_json::json!(6));
assert!(
written["rows"].as_array().unwrap().len() < 6,
"the run was abandoned: {written}"
);
let events = events(&log);
let finished = events
.iter()
.find(|e| e["event"] == "run_finished")
.expect("still one terminal event");
assert_eq!(finished["interrupted"], serde_json::json!(true));
let warnings = finished["warnings"].as_array().unwrap();
assert!(
warnings
.iter()
.any(|w| w.as_str().unwrap_or_default().contains("CLEANUP")),
"a report written over a run that never wound down has to say so: {warnings:?}"
);
assert_eq!(finished["exit_code"], serde_json::json!(EXIT_INTERRUPTED));
fs::remove_dir_all(&dir).ok();
}
#[test]
fn an_abandoned_parallel_report_is_still_in_report_order_and_ends_when_it_says_it_does() {
let dir = temp_dir("abandon_order");
let control = Control::for_test().with_grace(std::time::Duration::from_millis(250));
let port = stopping_server(control.switch(), 1, 0, vec![700, 60, 40, 20]);
let (coll, report) = stop_fixture(&dir, port, 4, Some(4));
let out = dir.join("out.json");
let (progress, log) = capturing();
let code = run_with_progress(
Some(coll.to_string_lossy().into_owned()),
Vec::new(),
report.to_string_lossy().into_owned(),
vec![out.to_string_lossy().into_owned()],
false,
Vec::new(),
None,
ParamValues::new(),
progress,
control,
);
assert_eq!(code, EXIT_INTERRUPTED);
let written: serde_json::Value =
serde_json::from_str(&fs::read_to_string(&out).unwrap()).unwrap();
let xs: Vec<String> = written["rows"]
.as_array()
.unwrap()
.iter()
.map(|r| r["X"].as_str().unwrap_or_default().to_string())
.collect();
assert!(
xs.len() > 1,
"the ordering only means something with several rows: {written}"
);
let mut sorted = xs.clone();
sorted.sort();
assert_eq!(
xs, sorted,
"an abandoned report is still a report: the same rows in the same order a \
sequential run would have written them"
);
let events = events(&log);
assert_eq!(
events.last().map(|e| e["event"].clone()),
Some(serde_json::json!("run_finished")),
"a straggler landing after the terminal event would break the one promise \
the stream makes: {events:#?}"
);
}
}