osp-cli 1.5.1

CLI and REPL for querying and managing OSP infrastructure data
Documentation 
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

#![allow(missing_docs)]

use osp_cli::cli::{parse_command_text_with_aliases, parse_command_tokens_with_aliases};
use osp_cli::config::{ConfigLayer, ConfigResolver, ResolveOptions, ResolvedConfig};

fn make_config(entries: &[(&str, &str)]) -> ResolvedConfig {
    let mut defaults = ConfigLayer::default();
    defaults.set("profile.default", "default");
    for (key, value) in entries {
        defaults.set(*key, *value);
    }

    let mut resolver = ConfigResolver::default();
    resolver.set_defaults(defaults);
    resolver
        .resolve(ResolveOptions::default().with_terminal("repl"))
        .expect("test config should resolve")
}

#[test]
fn parse_allows_quick_pipe_segments() {
    let config = make_config(&[]);
    let parsed = parse_command_text_with_aliases("status | last | K foo", &config)
        .expect("quick pipes should parse");

    assert_eq!(parsed.tokens, vec!["status"]);
    assert_eq!(parsed.stages, vec!["last", "K foo"]);
}

#[test]
fn parse_preserves_quoted_pipe_inside_command_segment() {
    let config = make_config(&[]);
    let parsed = parse_command_text_with_aliases("ldap user 'foo|bar' | P uid", &config)
        .expect("quoted pipe command should parse");

    assert_eq!(parsed.tokens, vec!["ldap", "user", "foo|bar"]);
    assert_eq!(parsed.stages, vec!["P uid"]);
}

#[test]
fn parse_merges_orch_os_tokens_from_text() {
    let config = make_config(&[]);
    let parsed = parse_command_text_with_aliases("orch provision --os alma 9", &config)
        .expect("orch provision command should parse");

    assert_eq!(parsed.tokens, vec!["orch", "provision", "--os", "alma9"]);
}

#[test]
fn parse_merges_orch_os_tokens_from_cli_tokens() {
    let config = make_config(&[]);
    let tokens = ["orch", "provision", "--os", "alma", "9"]
        .into_iter()
        .map(str::to_string)
        .collect::<Vec<_>>();
    let parsed = parse_command_tokens_with_aliases(&tokens, &config)
        .expect("orch provision token list should parse");

    assert_eq!(parsed.tokens, vec!["orch", "provision", "--os", "alma9"]);
}

#[test]
fn parse_does_not_merge_outside_orch_provision() {
    let config = make_config(&[]);
    let parsed = parse_command_text_with_aliases("orch task create --os alma 9", &config)
        .expect("non-provision orch command should parse");

    assert_eq!(
        parsed.tokens,
        vec!["orch", "task", "create", "--os", "alma", "9"]
    );
}

#[test]
fn parse_does_not_merge_when_version_is_dash() {
    let config = make_config(&[]);
    let parsed = parse_command_text_with_aliases("orch provision --os alma -", &config)
        .expect("skip-marker orch provision command should parse");

    assert_eq!(
        parsed.tokens,
        vec!["orch", "provision", "--os", "alma", "-"]
    );
}

#[test]
fn parse_rejects_unknown_explicit_stage_from_text() {
    let config = make_config(&[]);
    let result = parse_command_text_with_aliases("status | X foo", &config);

    assert!(
        result.is_err(),
        "explicit single-letter unknown DSL stages should be rejected"
    );
}

#[test]
fn parse_accepts_quick_pipe_segments_from_cli_tokens() {
    let config = make_config(&[]);
    let tokens = ["status", "|", "last", "|", "K", "foo"]
        .into_iter()
        .map(str::to_string)
        .collect::<Vec<_>>();

    let parsed = parse_command_tokens_with_aliases(&tokens, &config)
        .expect("quick pipe tokens should parse");

    assert_eq!(parsed.tokens, vec!["status"]);
    assert_eq!(parsed.stages, vec!["last", "K foo"]);
}

#[test]
fn parse_cli_tokens_preserves_single_stage_argument_with_spaces() {
    let config = make_config(&[]);
    let tokens = ["status", "|", "K", "foo bar"]
        .into_iter()
        .map(str::to_string)
        .collect::<Vec<_>>();

    let parsed = parse_command_tokens_with_aliases(&tokens, &config)
        .expect("quoted-like token stage should parse");

    assert_eq!(parsed.tokens, vec!["status"]);
    assert_eq!(parsed.stages, vec!["K 'foo bar'"]);
}

#[test]
fn parse_rejects_unknown_explicit_stage_from_alias_pipe() {
    let config = make_config(&[("alias.bad", "status | X foo")]);
    let result = parse_command_text_with_aliases("bad", &config);

    assert!(
        result.is_err(),
        "alias-expanded pipes should be validated the same as user pipes"
    );
}

#[test]
fn parse_accepts_cli_help_stage_from_text() {
    let config = make_config(&[]);
    let parsed =
        parse_command_text_with_aliases("status | H F", &config).expect("help pipe should parse");

    assert_eq!(parsed.tokens, vec!["status"]);
    assert_eq!(parsed.stages, vec!["H F"]);
}

#[test]
fn parse_accepts_cli_help_stage_from_alias_pipe() {
    let config = make_config(&[("alias.helpme", "status | H G")]);
    let parsed = parse_command_text_with_aliases("helpme", &config)
        .expect("alias-expanded help pipe should parse");

    assert_eq!(parsed.tokens, vec!["status"]);
    assert_eq!(parsed.stages, vec!["H G"]);
}