koban-cli 0.3.1

A Rust CLI for Invoice Ninja, built for humans and AI agents
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

use super::*;

#[test]
fn generic_payload_accepts_json_files_and_guided_fields() {
    let raw = generic_payload(
        GenericPayloadArgs {
            data: Some(r#"{"name":"Acme"}"#.to_string()),
            ..GenericPayloadArgs::default()
        },
        true,
    )
    .expect("raw JSON");
    assert_eq!(raw["name"], "Acme");

    let tempdir = tempfile::tempdir().expect("tempdir");
    let file = tempdir.path().join("payload.json");
    std::fs::write(&file, r#"{"number":"001"}"#).expect("write payload");
    let from_file = generic_payload(
        GenericPayloadArgs {
            data_file: Some(file),
            ..GenericPayloadArgs::default()
        },
        true,
    )
    .expect("file JSON");
    assert_eq!(from_file["number"], "001");

    let guided = generic_payload(
        GenericPayloadArgs {
            fields: vec![
                "client.name=Ada".to_string(),
                "amount=42.5".to_string(),
                "active=true".to_string(),
            ],
            ..GenericPayloadArgs::default()
        },
        true,
    )
    .expect("guided fields");
    assert_eq!(guided["client"]["name"], "Ada");
    assert_eq!(guided["amount"], 42.5);
    assert_eq!(guided["active"], true);

    let forced_string = generic_payload(
        GenericPayloadArgs {
            fields: vec!["number=\"1000\"".to_string()],
            ..GenericPayloadArgs::default()
        },
        true,
    )
    .expect("quoted scalar");
    assert_eq!(forced_string["number"], "1000");
}

#[test]
fn generic_payload_reports_invalid_sources_and_fields() {
    let mixed = generic_payload(
        GenericPayloadArgs {
            data: Some("{}".to_string()),
            fields: vec!["name=Acme".to_string()],
            ..GenericPayloadArgs::default()
        },
        true,
    )
    .expect_err("mixed raw and guided");
    assert!(matches!(mixed, KobanError::InvalidPayload { .. }));

    let missing = generic_payload(GenericPayloadArgs::default(), true).expect_err("missing");
    assert!(missing.to_string().contains("write command requires"));

    let malformed =
        object_from_fields(vec!["missing_separator".to_string()]).expect_err("missing separator");
    assert!(malformed.to_string().contains("key=value"));

    let bad_path =
        object_from_fields(vec!["bad..path=value".to_string()]).expect_err("bad dotted path");
    assert!(bad_path.to_string().contains("must not be empty"));
}

#[test]
fn resource_payload_rejects_raw_json_with_line_items() {
    let mut args = empty_resource_payload_args();
    args.data = Some(r#"{"line_items":[]}"#.to_string());
    args.line_items
        .push("product_key=Consulting,quantity=1,cost=100".to_string());

    let error = resource_payload(args, true).expect_err("raw plus line items");
    assert!(matches!(error, KobanError::InvalidPayload { .. }));
    assert!(error.to_string().contains("--line-item"), "got: {error}");
}