quotch 0.5.5

Fast cross-platform CLI for AI coding-agent usage limits
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! CLI integration tests that exercise the real built `quotch` binary.
//!
//! Every test scrubs HOME (so no real ~/.claude, ~/.codex,
//! ~/.config/github-copilot, ~/.gemini creds are found), XDG_CACHE_HOME (so
//! no real quotch cache is read/written), and CODEX_HOME (so codex's
//! CODEX_HOME override can't leak a real auth.json either). With all
//! providers' discover() finding nothing, no network call is ever made and
//! the tests are hermetic and deterministic, whether or not the machine
//! running them has real provider credentials configured.

use assert_cmd::Command;
use predicates::prelude::*;

/// Builds a `quotch` command with HOME/XDG_CACHE_HOME/CODEX_HOME pointed at
/// fresh, empty temp locations so every provider's `discover()` finds no
/// credentials and no network call is made.
fn scrubbed_cmd(home: &std::path::Path) -> Command {
    let mut cmd = Command::cargo_bin("quotch").unwrap();
    cmd.env("HOME", home)
        .env("XDG_CACHE_HOME", home.join("cache"))
        .env("CODEX_HOME", home.join("no-such-codex-home"));
    cmd
}

#[test]
fn version_flag_prints_name_and_version() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .arg("--version")
        .assert()
        .success()
        .stdout(predicate::str::contains("quotch"))
        .stdout(predicate::str::contains(env!("CARGO_PKG_VERSION")));
}

#[test]
fn help_flag_exits_zero() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .arg("-h")
        .assert()
        .success()
        .stdout(predicate::str::contains("Usage"));
}

#[test]
fn unknown_flag_exits_two() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .arg("--definitely-not-a-flag")
        .assert()
        .code(2)
        .stderr(predicate::str::contains("Usage"));
}

#[test]
fn json_empty_when_no_providers() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .arg("--json")
        .assert()
        .success()
        .stdout(predicate::str::contains("\"v\": 1"))
        .stdout(predicate::str::contains("\"snapshots\": []"));
}

#[test]
fn line_mode_empty_when_no_providers() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .assert()
        .success()
        .stdout(predicate::str::is_empty().or(predicate::str::is_match(r"^\s*$").unwrap()));
}

#[test]
fn skill_print_outputs_frontmatter() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .args(["skill", "print"])
        .assert()
        .success()
        .stdout(predicate::str::contains("name: quotch"))
        .stdout(predicate::str::contains("quotch --json"));
}

#[test]
fn skill_install_writes_file() {
    let home = tempfile::tempdir().unwrap();
    let install_dir = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .args([
            "skill",
            "install",
            "--dir",
            install_dir.path().to_str().unwrap(),
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("installed:"));

    let written = install_dir.path().join("quotch").join("SKILL.md");
    let contents = std::fs::read_to_string(&written)
        .unwrap_or_else(|e| panic!("expected {} to exist: {e}", written.display()));
    assert!(!contents.trim().is_empty());
}

#[test]
fn skill_bad_subcommand_exits_two() {
    let home = tempfile::tempdir().unwrap();
    scrubbed_cmd(home.path())
        .args(["skill", "nonsense"])
        .assert()
        .code(2);
}