use assert_cmd::Command;
use predicates::prelude::*;
use serde_json::Value;
use std::io::Write;
fn bin() -> Command {
Command::cargo_bin("whisper-nvidia-cli").expect("binary")
}
fn isolated() -> (tempfile::TempDir, Command) {
let dir = tempfile::tempdir().expect("tmpdir");
let mut cmd = bin();
cmd.arg("--config-dir")
.arg(dir.path())
.arg("--cache-dir")
.arg(dir.path());
(dir, cmd)
}
#[test]
fn version_is_stable() {
let (_d, mut a) = isolated();
let out1 = a
.arg("version")
.assert()
.success()
.get_output()
.stdout
.clone();
let (_d2, mut b) = isolated();
let out2 = b
.arg("version")
.assert()
.success()
.get_output()
.stdout
.clone();
let v1: Value = serde_json::from_slice(&out1).unwrap();
let v2: Value = serde_json::from_slice(&out2).unwrap();
assert_eq!(v1["version"], v2["version"]);
assert_eq!(v1["name"], "whisper-nvidia-cli");
assert_eq!(v1["version"], "0.1.0");
}
#[test]
fn commands_lists_mvp_verbs() {
let (_d, mut cmd) = isolated();
let out = cmd
.arg("commands")
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
let joined = v["commands"].to_string();
for verb in [
"transcribe",
"inspect",
"models",
"doctor",
"config",
"schema",
"commands",
"version",
] {
assert!(joined.contains(verb), "missing {verb}");
}
}
#[test]
fn schema_without_a_name_lists_every_contract() {
let (_d, mut cmd) = isolated();
let out = cmd
.arg("schema")
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).expect("json");
let names: Vec<&str> = v["schemas"]
.as_array()
.expect("schemas array")
.iter()
.filter_map(|n| n.as_str())
.collect();
for expected in ["transcribe", "doctor", "version", "error"] {
assert!(
names.contains(&expected),
"{expected} is not listed: {names:?}"
);
}
}
#[test]
fn schema_has_english_keys() {
let (_d, mut cmd) = isolated();
let out = cmd
.args(["schema", "--name", "transcribe"])
.assert()
.success()
.get_output()
.stdout
.clone();
let text = String::from_utf8_lossy(&out);
assert!(text.contains("schema_version"));
assert!(text.contains("correlation_id"));
assert!(text.contains("text"));
assert!(!text.contains("texto"));
}
#[test]
fn config_list_contains_required_keys() {
let (_d, mut cmd) = isolated();
let out = cmd
.arg("config")
.arg("list")
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
let keys: Vec<String> = v["keys"]
.as_array()
.unwrap()
.iter()
.map(|k| k["key"].as_str().unwrap().to_string())
.collect();
for required in [
"model",
"language",
"device",
"timeout",
"max-duration",
"beam",
"vad",
"concurrency",
"helper",
"helper-fallback",
"max-memory",
"locale",
] {
assert!(keys.iter().any(|k| k == required), "missing {required}");
}
}
#[test]
fn config_set_and_get_roundtrip() {
let dir = tempfile::tempdir().unwrap();
let mut set = bin();
set.args([
"--config-dir",
dir.path().to_str().unwrap(),
"--cache-dir",
dir.path().to_str().unwrap(),
])
.args(["config", "set", "model", "tiny"])
.assert()
.success();
let mut get = bin();
let out = get
.args([
"--config-dir",
dir.path().to_str().unwrap(),
"--cache-dir",
dir.path().to_str().unwrap(),
])
.args(["config", "get", "model"])
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
assert_eq!(v["value"], "tiny");
assert_eq!(v["target_source"], "argv");
assert_eq!(v["target_resolved"], "model");
}
#[test]
fn unknown_config_key_is_78() {
let (_d, mut cmd) = isolated();
cmd.args(["config", "set", "not-a-key", "x"])
.assert()
.failure()
.code(78);
}
#[test]
fn missing_file_is_66() {
let (_d, mut cmd) = isolated();
cmd.args(["transcribe", "/no/such/file.wav"])
.assert()
.failure()
.code(66);
}
#[test]
fn no_input_is_64() {
let (_d, mut cmd) = isolated();
cmd.args(["transcribe", "--no-input"])
.assert()
.failure()
.code(64);
}
#[test]
fn dry_run_valid_wav_exits_0_without_text() {
let dir = tempfile::tempdir().unwrap();
let wav = dir.path().join("tone.wav");
write_silence_wav(&wav, 16000, 1600);
let mut cmd = bin();
let out = cmd
.args([
"--config-dir",
dir.path().to_str().unwrap(),
"--cache-dir",
dir.path().to_str().unwrap(),
"transcribe",
"--dry-run",
wav.to_str().unwrap(),
])
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
assert_eq!(v["dry_run"], true);
assert_eq!(v["target_source"], "argv");
assert!(v.get("text").is_none());
assert_eq!(v["would_transcribe"]["model"], "large-v3");
}
#[test]
fn models_list_echoes_small_sha1() {
let (_d, mut cmd) = isolated();
let out = cmd
.arg("models")
.arg("list")
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
let small = v["models"]
.as_array()
.unwrap()
.iter()
.find(|m| m["name"] == "small")
.expect("small");
assert_eq!(small["sha1"], "55356645c2b361a969dfd0ef2c5a50d530afd8d5");
}
#[test]
fn remove_without_yes_is_78() {
let (_d, mut cmd) = isolated();
cmd.args(["models", "remove", "small"])
.assert()
.failure()
.code(78);
}
#[test]
fn inspect_wav_has_no_transcript() {
let dir = tempfile::tempdir().unwrap();
let wav = dir.path().join("tone.wav");
write_silence_wav(&wav, 16000, 1600);
let mut cmd = bin();
let out = cmd
.args([
"--config-dir",
dir.path().to_str().unwrap(),
"--cache-dir",
dir.path().to_str().unwrap(),
"inspect",
wav.to_str().unwrap(),
])
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
assert_eq!(v["sample_rate"], 16000);
assert!(v["text"].is_null());
assert_eq!(v["target_source"], "argv");
}
#[test]
fn select_projects_version_name() {
let (_d, mut cmd) = isolated();
let out = cmd
.args(["--select", "name,version", "version"])
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
assert_eq!(v["name"], "whisper-nvidia-cli");
assert_eq!(v["version"], "0.1.0");
assert!(v.get("correlation_id").is_none());
}
#[test]
fn malformed_filter_is_2() {
let (_d, mut cmd) = isolated();
cmd.args(["--filter", "nope", "version"])
.assert()
.failure()
.code(predicate::in_iter([2_i32]));
}
#[test]
fn licenses_mention_whisper() {
let (_d, mut cmd) = isolated();
cmd.arg("licenses")
.assert()
.success()
.stdout(predicate::str::contains("whisper"));
}
#[test]
fn completions_bash_not_empty() {
let (_d, mut cmd) = isolated();
let out = cmd
.args(["completions", "bash"])
.assert()
.success()
.get_output()
.stdout
.clone();
assert!(!out.is_empty());
}
#[test]
fn insecure_origin_refuses_set() {
let (_d, mut cmd) = isolated();
cmd.args(["config", "set", "origin-base", "http://example.invalid"])
.assert()
.failure();
}
#[test]
fn locale_pt_does_not_translate_keys() {
let (_d, mut cmd) = isolated();
let out = cmd
.args(["--lang", "pt-BR", "version"])
.assert()
.success()
.get_output()
.stdout
.clone();
let v: Value = serde_json::from_slice(&out).unwrap();
assert!(v.get("version").is_some());
assert!(v.get("versão").is_none());
}
fn write_silence_wav(path: &std::path::Path, rate: u32, samples: usize) {
let spec = hound::WavSpec {
channels: 1,
sample_rate: rate,
bits_per_sample: 16,
sample_format: hound::SampleFormat::Int,
};
let mut w = hound::WavWriter::create(path, spec).unwrap();
for _ in 0..samples {
w.write_sample(0i16).unwrap();
}
w.finalize().unwrap();
let _ = std::io::sink().write(&[]);
}