use super::{
Format, Outcome, adapted, args, format_of, prepared, sarif_misused,
sarif_refused, verb_of,
};
use crate::cli::testkit::argv;
fn format(words: &[&str]) -> Result<Format, String> {
format_of(&args::parse(&argv(words))?)
}
#[test]
fn the_three_outcomes_stay_distinct() {
assert_ne!(Outcome::Ok, Outcome::Violation);
assert_ne!(Outcome::Violation, Outcome::Usage);
assert_ne!(Outcome::Ok, Outcome::Usage);
}
#[test]
fn a_failed_guard_is_broken_and_never_usage() {
let failed = adapted(Err(String::from("hook input is not JSON")));
assert_eq!(failed, Outcome::Broken);
assert_eq!(adapted(Ok(String::new())), Outcome::Ok);
assert_ne!(Outcome::Broken, Outcome::Usage);
}
#[test]
fn a_verb_is_the_first_word() {
assert_eq!(verb_of(&argv(&["check"])), Some("check"));
assert_eq!(verb_of(&argv(&[])), None);
}
#[test]
fn json_is_asked_for_by_name() {
assert_eq!(format(&["check"]), Ok(Format::Human));
assert_eq!(format(&["check", "--format", "json"]), Ok(Format::Json));
}
#[test]
fn sarif_is_asked_for_by_name() {
let asked = format(&["check", "--format", "sarif"]);
assert_eq!(asked, Ok(Format::Sarif));
}
#[test]
fn an_unknown_format_is_refused() {
let refused = format(&["check", "--format", "jsn"]);
let choices = "choose human, json or sarif";
assert!(
refused.is_err_and(|why| why.contains("jsn") && why.contains(choices))
);
}
#[test]
fn a_config_error_names_the_flag_as_typed() {
let asked = argv(&["check", "--no-files", "--rule", "*.nomatch asci"]);
let why = prepared("check", &asked).err().unwrap_or_default();
assert!(why.starts_with("--rule '*.nomatch asci': "), "{why}");
assert!(why.ends_with("(did you mean 'ascii'?)"), "{why}");
assert!(!why.contains("argv["), "{why}");
}
#[test]
fn sarif_is_refused_for_every_verb_but_check() {
assert!(!sarif_misused("check", Format::Sarif));
for verb in ["fix", "stats", "explain", "sets"] {
assert!(sarif_misused(verb, Format::Sarif), "{verb}");
assert!(!sarif_misused(verb, Format::Human), "{verb}");
let asked = argv(&[verb, "--format", "sarif"]);
let why = prepared(verb, &asked).err().unwrap_or_default();
assert_eq!(why, sarif_refused(verb));
}
}
#[test]
fn an_unknown_flag_stops_the_run() {
let asked = argv(&["check", "--stirct"]);
let why = prepared("check", &asked).err().unwrap_or_default();
assert!(why.contains("--stirct"), "{why}");
}
#[test]
fn a_path_the_verb_would_ignore_is_refused() {
let refused = |words: &[&str]| {
let verb = words.first().copied().unwrap_or_default();
prepared(verb, &argv(words)).err().unwrap_or_default()
};
assert!(refused(&["explain", "a.md", "b.txt"]).contains("`b.txt`"));
let as_args = ["explain", "--as", "args", "a.md", "b.txt"];
assert!(refused(&as_args).contains("`b.txt`"));
assert!(prepared("explain", &argv(&["explain", "a.md"])).is_ok());
assert!(prepared("check", &argv(&["check", "a", "b"])).is_ok());
}
#[test]
fn a_broken_config_of_any_kind_stops_every_verb() {
let broken = [
["--map", "U+ZZZZ x y z"],
["--map", "U+2014 -\nU+2013 -"],
["--set", "house U+2261\nmore U+2262"],
["--rule", "* ascii\n* box"],
];
for verb in ["check", "explain", "sets", "fix", "stats"] {
for [flag, value] in broken {
let asked = argv(&[verb, flag, value]);
assert!(prepared(verb, &asked).is_err(), "{verb} {value}");
}
}
}
#[test]
fn a_sarif_check_keeps_the_verdict_and_names_the_file() {
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("ctrm-sarif-fixture");
let written = std::fs::create_dir_all(&root)
.and_then(|()| std::fs::write(root.join("a.md"), "a\u{2014}b\n"));
if written.is_err() {
return;
}
let asked = [String::from("a.md")];
let config = crate::cli::config::discovered(&root);
let report = super::check::run(&config, &asked, Format::Sarif);
let report = report.unwrap_or_else(|why| unreachable!("{why}"));
assert_eq!(report.code, 1);
let at = r#""uri":"a.md"},"region":{"startLine":1,"startColumn":2"#;
assert!(report.text.contains(at), "{}", report.text);
}
#[test]
fn a_bare_word_json_is_a_path_and_not_a_format() {
assert_eq!(format(&["check", "json"]), Ok(Format::Human));
let read = args::parse(&argv(&["check", "json"]));
assert_eq!(read.map(|a| a.paths), Ok(vec![String::from("json")]));
}
#[test]
fn paths_are_the_words_that_are_not_flags_or_their_values() {
let words = ["check", "src", "--format", "json", "docs"];
let read = args::parse(&argv(&words)).map(|a| a.paths);
let both = vec![String::from("src"), String::from("docs")];
assert_eq!(read, Ok(both));
}
fn asks(words: &[&str]) -> bool {
args::parse(&argv(words)).is_ok_and(|read| super::asks_help(&read))
}
#[test]
fn help_is_a_flag_and_only_a_flag() {
let cases: [(&[&str], bool); 6] = [
(&["check", "--help"], true),
(&["stats", "src", "-h"], true),
(&["check", "--rule", "--help"], false),
(&["check", "--", "--help"], false),
(&["check", "--stirct", "--help"], false),
(&["--help", "--bogus"], false),
];
for (words, expected) in cases {
assert_eq!(asks(words), expected, "{words:?}");
}
let asked = argv(&["check", "--hepl"]);
assert!(prepared("check", &asked).is_err());
}
#[test]
fn an_unknown_verb_is_named_with_the_nearest_one() {
let said = crate::cli::usage::unknown_verb("chek");
let first = said.lines().next().unwrap_or_default();
assert_eq!(first, "unknown verb 'chek' (did you mean 'check'?)");
assert_eq!(said.lines().count(), 2);
let far = crate::cli::usage::unknown_verb("deploy");
assert!(far.starts_with("unknown verb 'deploy'\n"), "{far}");
}