365 lines
12 KiB
Rust
365 lines
12 KiB
Rust
//! CLI integration tests for the `mhash` binary.
|
|
|
|
use std::fs;
|
|
|
|
use assert_cmd::Command;
|
|
use predicates::prelude::*;
|
|
use serde_json::Value;
|
|
use tempfile::tempdir;
|
|
|
|
fn mhash_command() -> assert_cmd::Command {
|
|
Command::cargo_bin("mhash").unwrap_or_else(|error| {
|
|
panic!("failed to locate mhash binary: {error}");
|
|
})
|
|
}
|
|
|
|
#[test]
|
|
fn list_algorithms_includes_openhashtab_matrix() {
|
|
let mut command = mhash_command();
|
|
command.arg("list-algorithms").arg("--json");
|
|
command
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("parallelhash256-528"))
|
|
.stdout(predicate::str::contains("kangarootwelve-264"))
|
|
.stdout(predicate::str::contains("streebog-512"));
|
|
}
|
|
|
|
#[test]
|
|
fn hashes_file_as_json() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--algorithm")
|
|
.arg("sha256,blake3-256")
|
|
.arg("--json")
|
|
.arg(&file);
|
|
command
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains(
|
|
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
|
|
))
|
|
.stdout(predicate::str::contains("blake3-256"));
|
|
}
|
|
|
|
#[test]
|
|
fn hashes_file_as_jsonl() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--algorithm")
|
|
.arg("sha256,md5")
|
|
.arg("--format")
|
|
.arg("jsonl")
|
|
.arg(&file);
|
|
command
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("\"algorithm\":\"md5\""))
|
|
.stdout(predicate::str::contains("\"algorithm\":\"sha256\""));
|
|
}
|
|
|
|
#[test]
|
|
fn recursive_ignore_and_sum_format_hash_only_included_files() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let keep = directory.path().join("keep.txt");
|
|
let nested = directory.path().join("nested");
|
|
let ignored = nested.join("ignored.skip");
|
|
fs::create_dir(&nested).unwrap_or_else(|error| panic!("fixture dir failed: {error}"));
|
|
fs::write(&keep, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
fs::write(&ignored, b"ignored").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--algorithm")
|
|
.arg("sha256")
|
|
.arg("--recursive")
|
|
.arg("--ignore")
|
|
.arg("*.skip")
|
|
.arg("--format")
|
|
.arg("sum")
|
|
.arg(directory.path());
|
|
command
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains(
|
|
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
|
|
))
|
|
.stdout(predicate::str::contains("keep.txt"))
|
|
.stdout(predicate::str::contains("ignored.skip").not());
|
|
}
|
|
|
|
#[test]
|
|
fn uppercase_sum_output_uses_uppercase_hex() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--algorithm")
|
|
.arg("sha256")
|
|
.arg("--uppercase")
|
|
.arg("--format")
|
|
.arg("sum")
|
|
.arg(&file);
|
|
command.assert().success().stdout(predicate::str::contains(
|
|
"BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD",
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn stdin_lines_input_hashes_existing_paths() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--input-format")
|
|
.arg("lines")
|
|
.arg("--algorithm")
|
|
.arg("md5")
|
|
.arg("--format")
|
|
.arg("jsonl")
|
|
.write_stdin(format!("{}\n", file.display()));
|
|
command.assert().success().stdout(predicate::str::contains(
|
|
"\"digest\":\"900150983cd24fb0d6963f7d28e17f72\"",
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn stdin_jsonl_input_hashes_existing_paths() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
let input = format!(
|
|
"{{\"path\":\"{}\"}}\n",
|
|
file.display().to_string().replace('\\', "\\\\")
|
|
);
|
|
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--input-format")
|
|
.arg("jsonl")
|
|
.arg("--algorithm")
|
|
.arg("sha1")
|
|
.arg("--format")
|
|
.arg("jsonl")
|
|
.write_stdin(input);
|
|
command.assert().success().stdout(predicate::str::contains(
|
|
"\"digest\":\"a9993e364706816aba3e25717850c26c9cd0d89d\"",
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn help_and_json_hash_output_do_not_expose_backend_controls() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
mhash_command()
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("--backend").not());
|
|
|
|
let mut command = mhash_command();
|
|
let output = command
|
|
.arg("--algorithm")
|
|
.arg("sha256")
|
|
.arg("--io")
|
|
.arg("read")
|
|
.arg("--threads")
|
|
.arg("2")
|
|
.arg("--json")
|
|
.arg(&file)
|
|
.assert()
|
|
.success()
|
|
.get_output()
|
|
.stdout
|
|
.clone();
|
|
let records: Vec<Value> = serde_json::from_slice(&output)
|
|
.unwrap_or_else(|error| panic!("json parse failed: {error}"));
|
|
|
|
assert_eq!(records.len(), 1);
|
|
assert!(records[0].get("requested_backend").is_none());
|
|
assert!(records[0].get("backend").is_none());
|
|
assert!(records[0].get("io").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn backend_option_is_not_public_cli() {
|
|
let mut command = mhash_command();
|
|
command
|
|
.arg("--backend")
|
|
.arg("simd")
|
|
.arg("README.md")
|
|
.assert()
|
|
.code(2)
|
|
.stderr(predicate::str::contains("unsupported argument"));
|
|
}
|
|
|
|
#[test]
|
|
fn bench_accepts_threads_and_io_options_as_json_smoke() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
let output = command
|
|
.arg("bench")
|
|
.arg("--algorithm")
|
|
.arg("sha256")
|
|
.arg("--threads")
|
|
.arg("2")
|
|
.arg("--io")
|
|
.arg("read")
|
|
.arg("--format")
|
|
.arg("json")
|
|
.arg(&file)
|
|
.assert()
|
|
.success()
|
|
.get_output()
|
|
.stdout
|
|
.clone();
|
|
let records: Vec<Value> = serde_json::from_slice(&output)
|
|
.unwrap_or_else(|error| panic!("json parse failed: {error}"));
|
|
|
|
assert_eq!(records.len(), 1);
|
|
assert_eq!(records[0]["algorithm"], "sha256");
|
|
assert_eq!(records[0]["bytes"], 3);
|
|
assert!(records[0]["elapsed_ms"].as_f64().is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn bench_end_to_end_reports_repeat_warmup_and_mode() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abcdef").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
let output = command
|
|
.arg("bench")
|
|
.arg("--algorithm")
|
|
.arg("sha256")
|
|
.arg("--repeat")
|
|
.arg("2")
|
|
.arg("--warmup")
|
|
.arg("1")
|
|
.arg("--bench-mode")
|
|
.arg("e2e")
|
|
.arg("--io")
|
|
.arg("read")
|
|
.arg("--format")
|
|
.arg("json")
|
|
.arg(&file)
|
|
.assert()
|
|
.success()
|
|
.get_output()
|
|
.stdout
|
|
.clone();
|
|
let records: Vec<Value> = serde_json::from_slice(&output)
|
|
.unwrap_or_else(|error| panic!("json parse failed: {error}"));
|
|
|
|
assert_eq!(records.len(), 1);
|
|
assert_eq!(records[0]["algorithm"], "sha256");
|
|
assert_eq!(records[0]["bytes"], 6);
|
|
assert_eq!(records[0]["repeat"], 2);
|
|
assert_eq!(records[0]["warmup"], 1);
|
|
assert_eq!(records[0]["bench_mode"], "end-to-end");
|
|
assert!(records[0]["elapsed_ms"].as_f64().is_some());
|
|
assert!(records[0]["throughput_mib_s"].as_f64().is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn verifies_generated_manifest() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
let manifest = directory.path().join("checksums.jsonl");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut hash_command = mhash_command();
|
|
hash_command
|
|
.arg("--algorithm")
|
|
.arg("sha256")
|
|
.arg("--manifest")
|
|
.arg(&manifest)
|
|
.arg(&file);
|
|
hash_command.assert().success();
|
|
|
|
let mut verify_command = mhash_command();
|
|
verify_command.arg("verify").arg(&manifest).arg("--json");
|
|
verify_command
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("\"ok\":true"));
|
|
}
|
|
|
|
#[test]
|
|
fn verifies_multi_algorithm_manifest_for_one_path() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
let manifest = directory.path().join("checksums.jsonl");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut hash_command = mhash_command();
|
|
hash_command
|
|
.arg("--algorithm")
|
|
.arg("sha256,md5,xxh3-128")
|
|
.arg("--manifest")
|
|
.arg(&manifest)
|
|
.arg(&file);
|
|
hash_command.assert().success();
|
|
|
|
let mut verify_command = mhash_command();
|
|
let output = verify_command
|
|
.arg("verify")
|
|
.arg(&manifest)
|
|
.arg("--json")
|
|
.assert()
|
|
.success()
|
|
.get_output()
|
|
.stdout
|
|
.clone();
|
|
let records: Vec<Value> = serde_json::from_slice(&output)
|
|
.unwrap_or_else(|error| panic!("json parse failed: {error}"));
|
|
|
|
assert_eq!(records.len(), 3);
|
|
assert!(records.iter().all(|record| record["ok"] == true));
|
|
assert_eq!(records[0]["algorithm"], "md5");
|
|
assert_eq!(records[1]["algorithm"], "sha256");
|
|
assert_eq!(records[2]["algorithm"], "xxh3-128");
|
|
}
|
|
|
|
#[test]
|
|
fn mercury_output_json_is_honored() {
|
|
let directory = tempdir().unwrap_or_else(|error| panic!("tempdir failed: {error}"));
|
|
let file = directory.path().join("sample.txt");
|
|
fs::write(&file, b"abc").unwrap_or_else(|error| panic!("fixture write failed: {error}"));
|
|
|
|
let mut command = mhash_command();
|
|
command.env("MERCURY_OUTPUT", "json").arg(&file);
|
|
command
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::starts_with("[{"));
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_algorithm_exits_usage_error() {
|
|
let mut command = mhash_command();
|
|
command.arg("--algorithm").arg("sha999").arg("README.md");
|
|
command
|
|
.assert()
|
|
.code(2)
|
|
.stderr(predicate::str::contains("unsupported algorithm"));
|
|
}
|