openantares 0.1.1

OpenAntares CLI: validate and inspect .ant interchange files
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

//! CLI acceptance: exit contract (0 / 64 usage / 65 data / 66
//! no-input) and output shape, driven against the conformance goldens
//! — the same corpus the bindings' CLIs are proven on.

use std::path::PathBuf;
use std::process::{Command, Output};

/// `ANT_CONFORMANCE_GOLDEN` overrides the default in-repo location,
/// same as antares-format's conformance runner, so the test works in
/// checkouts that keep the goldens elsewhere.
fn golden(name: &str) -> PathBuf {
    let dir = match std::env::var_os("ANT_CONFORMANCE_GOLDEN") {
        Some(d) => PathBuf::from(d),
        None => {
            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../openantares/conformance/golden")
        }
    };
    dir.join(name)
}

fn run(args: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_openantares"))
        .args(args)
        .output()
        .expect("spawn openantares")
}

#[test]
fn no_args_is_usage_64() {
    let out = run(&[]);
    assert_eq!(out.status.code(), Some(64), "stderr: {}", text(&out.stderr));
    assert!(text(&out.stderr).contains("usage:"));
}

#[test]
fn unknown_command_is_usage_64() {
    let out = run(&["frobnicate", "x.ant"]);
    assert_eq!(out.status.code(), Some(64), "stderr: {}", text(&out.stderr));
}

#[test]
fn validate_ok_is_0_with_ok_line() {
    let p = golden("basic.ant");
    let out = run(&["validate", p.to_str().unwrap()]);
    assert_eq!(
        out.status.code(),
        Some(0),
        "stdout: {} stderr: {}",
        text(&out.stdout),
        text(&out.stderr)
    );
    let stdout = text(&out.stdout);
    assert!(stdout.contains(": OK"), "stdout: {stdout}");
    assert!(stdout.contains("version=0.3"), "stdout: {stdout}");
}

#[test]
fn validate_major_version_file_is_65() {
    // major_version.ant is the negative golden: a different MAJOR must
    // be refused (spec §2), which is EX_DATAERR for the CLI.
    let p = golden("major_version.ant");
    let out = run(&["validate", p.to_str().unwrap()]);
    assert_eq!(
        out.status.code(),
        Some(65),
        "stdout: {} stderr: {}",
        text(&out.stdout),
        text(&out.stderr)
    );
    assert!(text(&out.stderr).contains("FAIL"));
}

#[test]
fn validate_truncated_stream_is_65() {
    // Chop the tail off a valid golden: the zstd frame (or trailer)
    // is now broken and validation must fail with EX_DATAERR.
    let bytes = std::fs::read(golden("basic.ant")).unwrap();
    let dir = tempdir();
    let p = dir.join("truncated.ant");
    std::fs::write(&p, &bytes[..bytes.len() / 2]).unwrap();
    let out = run(&["validate", p.to_str().unwrap()]);
    assert_eq!(out.status.code(), Some(65), "stderr: {}", text(&out.stderr));
}

#[test]
fn validate_missing_file_is_66() {
    let out = run(&["validate", "/nonexistent/definitely-not-here.ant"]);
    assert_eq!(
        out.status.code(),
        Some(66),
        "stdout: {} stderr: {}",
        text(&out.stdout),
        text(&out.stderr)
    );
    assert!(text(&out.stderr).contains("FAIL"));
}

#[test]
fn validate_keeps_going_and_reports_most_severe() {
    // ok file + data-error file + missing file in one run: every file
    // gets a line, and the exit is the most severe (66).
    let ok = golden("basic.ant");
    let bad = golden("major_version.ant");
    let out = run(&[
        "validate",
        ok.to_str().unwrap(),
        bad.to_str().unwrap(),
        "/nonexistent/definitely-not-here.ant",
    ]);
    assert_eq!(out.status.code(), Some(66), "stderr: {}", text(&out.stderr));
    assert!(text(&out.stdout).contains(": OK"), "ok file still reported");
    assert_eq!(
        text(&out.stderr).matches("FAIL").count(),
        2,
        "both failing files reported: {}",
        text(&out.stderr)
    );
}

#[test]
fn info_reports_manifest_and_counts_matching_expected_json() {
    let p = golden("basic.ant");
    let out = run(&["info", p.to_str().unwrap()]);
    assert_eq!(out.status.code(), Some(0), "stderr: {}", text(&out.stderr));
    let stdout = text(&out.stdout);
    // Pinned against conformance/golden/expected.json for basic.ant.
    for needle in [
        "format:          antares",
        "tenant id:       1",
        "project id:      1",
        "records:         7",
        "vertices:          2",
        "edges:             1",
        "observations:      1",
        "evidence:          1",
        "beliefs:           1",
        "vectors:           1",
        "vertex tombstones: 0",
    ] {
        assert!(
            needle_in(&stdout, needle),
            "missing `{needle}` in:\n{stdout}"
        );
    }
    assert!(stdout.contains("0.3"), "format version shown: {stdout}");
}

#[test]
fn info_takes_exactly_one_file() {
    let p = golden("basic.ant");
    let out = run(&["info", p.to_str().unwrap(), p.to_str().unwrap()]);
    assert_eq!(out.status.code(), Some(64), "stderr: {}", text(&out.stderr));
}

fn text(b: &[u8]) -> String {
    String::from_utf8_lossy(b).into_owned()
}

fn needle_in(hay: &str, needle: &str) -> bool {
    hay.contains(needle)
}

fn tempdir() -> PathBuf {
    let d = std::env::temp_dir().join(format!("openantares-cli-test-{}", std::process::id()));
    std::fs::create_dir_all(&d).unwrap();
    d
}