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

use osp_cli::cli::parse_command_text_with_aliases;
use osp_cli::config::{ConfigLayer, ConfigResolver, ResolveOptions};
use osp_cli::core::output::OutputFormat;
use osp_cli::dsl::apply_pipeline;
use osp_cli::ports::LdapDirectory;
use osp_cli::ports::mock::MockLdapClient;
use osp_cli::ui::{RenderSettings, render_output};

fn make_config(entries: &[(&str, &str)]) -> osp_cli::config::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 alias_expands_internal_and_user_pipes() {
    let config = make_config(&[("alias.lsng", "ldap netgroup ${1} --value | P members")]);
    let parsed = parse_command_text_with_aliases("lsng ucore | VAL members", &config)
        .expect("alias expansion should succeed");

    assert_eq!(parsed.tokens, vec!["ldap", "netgroup", "ucore", "--value"]);
    assert_eq!(parsed.stages, vec!["P members", "VAL members"]);

    let ldap = MockLdapClient::default();
    let rows = ldap
        .netgroup("ucore", None, None)
        .expect("query should succeed");
    let transformed = apply_pipeline(rows, &parsed.stages).expect("pipeline should succeed");

    let settings = RenderSettings::test_plain(OutputFormat::Value);
    let output = render_output(&transformed, &settings);
    assert!(output.contains("oistes"));
}

#[test]
fn alias_resolves_config_placeholders_and_splat() {
    let config = make_config(&[
        ("user.name", "testuser"),
        ("alias.me", "ldap user ${user.name}"),
        ("alias.splat", "ldap user ${@}"),
        ("alias.with_default", "ldap user ${1:guest}"),
    ]);

    let parsed =
        parse_command_text_with_aliases("me", &config).expect("alias expansion should succeed");
    assert_eq!(parsed.tokens, vec!["ldap", "user", "testuser"]);

    let parsed = parse_command_text_with_aliases("splat \"foo bar\" baz", &config)
        .expect("alias expansion should succeed");
    assert_eq!(parsed.tokens, vec!["ldap", "user", "foo bar", "baz"]);

    let parsed = parse_command_text_with_aliases("with_default", &config)
        .expect("alias expansion should succeed");
    assert_eq!(parsed.tokens, vec!["ldap", "user", "guest"]);
}