whisper-nvidia-cli 0.1.0

One-shot agent-native local NVIDIA GPU speech-to-text CLI powered by whisper.cpp
Documentation
//! Drive the shipped binary. These tests prove the agent contract.

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}");
    }
}

/// Asking for no contract in particular lists them all.
///
/// The verb used to answer with the transcribe contract when no name was
/// given, which made the other twenty look like they did not exist.
#[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);
}

/// FR-005: the daily default is `small`, not `large-v3`, and the resolved
/// model is echoed back to the caller.
#[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());
    // The seeded model, not a hard-coded name: `--dry-run` exists to report
    // what a real run WOULD do, so this has to track the product default.
    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);
}

/// FR-014: `inspect` measures the media — here the sample rate — and finishes
/// without a transcript, so no model is ever loaded.
#[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(&[]);
}