use std::process::Command;
fn bin() -> &'static str {
env!("CARGO_BIN_EXE_argenv-resolve-mock")
}
fn run(args: &[&str], env: &[(&str, &str)]) -> (bool, String, String) {
let mut cmd = Command::new(bin());
cmd.args(args);
for (k, v) in env {
cmd.env(k, v);
}
let out = cmd.output().expect("mock program runs");
(
out.status.success(),
String::from_utf8_lossy(&out.stdout).to_string(),
String::from_utf8_lossy(&out.stderr).to_string(),
)
}
#[test]
fn build_resolves_its_own_target_and_unique_and_shared_options() {
let (ok, stdout, _) = run(&["build", "app", "--release", "--jobs", "4"], &[]);
assert!(ok);
assert!(stdout.contains(r#"target=Some("app")"#));
assert!(stdout.contains("release=true"));
assert!(stdout.contains("jobs=Some(4)"));
}
#[test]
fn run_resolves_its_own_target_and_unique_and_shared_options() {
let (ok, stdout, _) = run(&["run", "app", "--jobs", "2", "--watch"], &[]);
assert!(ok);
assert!(stdout.contains(r#"target=Some("app")"#));
assert!(stdout.contains("watch=true"));
assert!(stdout.contains("jobs=Some(2)"));
}
#[test]
fn clean_takes_no_target_and_no_shared_or_unique_options() {
let (ok, stdout, _) = run(&["clean"], &[]);
assert!(ok);
assert_eq!(stdout.trim(), "clean verbose=false");
}
#[test]
fn global_verbose_flag_works_before_the_subcommand() {
let (ok, _, stderr) = run(&["--verbose", "build", "app"], &[]);
assert!(ok);
assert!(stderr.contains("config=None"));
}
#[test]
fn global_config_resolves_via_env_on_every_subcommand() {
let (ok, _, stderr) = run(
&["clean", "--verbose"],
&[("MOCK_CONFIG", "/etc/mock.toml")],
);
assert!(ok);
assert!(stderr.contains(r#"config=Some("/etc/mock.toml")"#));
}
#[test]
fn shared_jobs_env_resolves_under_build() {
let (ok, stdout, _) = run(&["build", "app"], &[("MOCK_JOBS", "8")]);
assert!(ok);
assert!(stdout.contains("jobs=Some(8)"));
}
#[test]
fn shared_jobs_env_resolves_under_run_too() {
let (ok, stdout, _) = run(&["run", "app"], &[("MOCK_JOBS", "8")]);
assert!(ok);
assert!(stdout.contains("jobs=Some(8)"));
}
#[test]
fn shared_jobs_env_does_not_leak_into_clean() {
let (ok, stdout, _) = run(&["clean"], &[("MOCK_JOBS", "8")]);
assert!(ok);
assert_eq!(stdout.trim(), "clean verbose=false");
}
#[test]
fn build_only_release_flag_is_absent_under_run() {
let (_, stdout, _) = run(&["run", "app", "--release"], &[]);
assert!(!stdout.contains("release=true"));
}
#[test]
fn watch_env_does_not_leak_into_build() {
let (ok, stdout, _) = run(&["build", "app"], &[("MOCK_WATCH", "1")]);
assert!(ok);
assert!(!stdout.contains("watch=true"));
}
#[test]
fn missing_subcommand_exits_nonzero_with_usage() {
let (ok, _, stderr) = run(&[], &[]);
assert!(!ok);
assert!(stderr.contains("usage:"));
}
#[test]
fn unknown_subcommand_is_rejected_with_a_clear_message() {
let (ok, _, stderr) = run(&["frobnicate"], &[]);
assert!(!ok);
assert!(stderr.contains("frobnicate"));
assert!(stderr.contains("invalid"));
}
#[test]
fn wrong_type_for_a_uint_option_is_rejected_not_silently_zero() {
let (ok, stdout, stderr) = run(&["build", "app", "--jobs", "notanumber"], &[]);
assert!(!ok);
assert!(stderr.contains("jobs"));
assert!(
stdout.is_empty(),
"must not print a result for a rejected invocation"
);
}
#[test]
fn a_misspelled_flag_stops_the_program_by_default() {
let (ok, stdout, stderr) = run(&["build", "app", "--bogus-flag"], &[]);
assert!(!ok, "a misspelled flag must be fatal by default");
assert!(
stderr.contains("--bogus-flag"),
"and it must say which flag: {stderr}"
);
assert!(
stdout.is_empty(),
"must not run the program for a rejected invocation"
);
}
#[test]
fn a_project_can_choose_to_carry_on_past_a_misspelled_flag() {
let (ok, stdout, stderr) = run(&["build", "app", "--bogus-flag"], &[("MOCK_LENIENT", "1")]);
assert!(ok, "a lenient project carries on");
assert!(
stderr.contains("--bogus-flag") && stderr.contains("warning"),
"but it is still surfaced, as a warning: {stderr}"
);
assert!(stdout.contains(r#"target=Some("app")"#));
}
#[test]
fn leniency_is_only_about_typos_a_bad_value_is_fatal_for_every_project() {
let (ok, _, stderr) = run(
&["build", "app", "--jobs", "many"],
&[("MOCK_LENIENT", "1")],
);
assert!(
!ok,
"a value that cannot be parsed has no usable reading: {stderr}"
);
}
#[test]
fn a_flag_that_belongs_to_another_subcommand_stops_the_program_by_default() {
let (ok, stdout, stderr) = run(&["run", "app", "--release"], &[]);
assert!(!ok, "must be fatal by default");
assert!(
stderr.contains("--release does not apply to `run`") && stderr.contains("build"),
"{stderr}"
);
assert!(stdout.is_empty(), "must not run the program: {stdout}");
}
#[test]
fn a_project_can_choose_to_let_it_through_with_a_warning() {
let (ok, _, stderr) = run(&["run", "app", "--release"], &[("MOCK_LENIENT", "1")]);
assert!(ok, "a lenient project carries on");
assert!(
stderr.contains("warning") && stderr.contains("--release"),
"{stderr}"
);
}
#[test]
fn a_shared_flag_is_not_out_of_scope_for_either_of_its_subcommands() {
assert!(run(&["build", "app", "--jobs", "4"], &[]).0);
assert!(run(&["run", "app", "--jobs", "4"], &[]).0);
}