bijux-cli 0.3.6

Command-line runtime for automation, plugin-driven tools, and interactive workflows with structured output.
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

#![forbid(unsafe_code)]
//! Parser intent normalization tests.
//! `test_type`: flag-precedence-conflict

use bijux_cli::api::routing::parser::parse_intent;
use proptest as _;
use serde as _;
use serde_json as _;

use clap as _;
use schemars as _;
use semver as _;
use thiserror as _;

#[test]
fn parses_root_and_nested_paths_with_global_flags() {
    let argv = vec![
        "bijux".to_string(),
        "--quiet".to_string(),
        "status".to_string(),
        "--format".to_string(),
        "json".to_string(),
        "--log-level".to_string(),
        "debug".to_string(),
    ];

    let intent = parse_intent(&argv).expect("parse should succeed");
    assert_eq!(intent.command_path, vec!["status"]);
    assert_eq!(intent.normalized_path, vec!["status"]);
    assert!(intent.global_flags.quiet);
    assert!(intent.global_flags.output_format.is_some());
    assert!(intent.global_flags.log_level.is_some());
}

#[test]
fn conflicting_output_and_pretty_flags_normalize_deterministically() {
    let one = vec![
        "bijux".to_string(),
        "--format".to_string(),
        "json".to_string(),
        "--format".to_string(),
        "yaml".to_string(),
        "--pretty".to_string(),
        "--no-pretty".to_string(),
        "atlas".to_string(),
        "status".to_string(),
    ];
    let two = vec![
        "bijux".to_string(),
        "--no-pretty".to_string(),
        "--pretty".to_string(),
        "--format".to_string(),
        "yaml".to_string(),
        "--format".to_string(),
        "json".to_string(),
        "atlas".to_string(),
        "status".to_string(),
    ];
    let left = parse_intent(&one).expect("parse should succeed");
    let right = parse_intent(&two).expect("parse should succeed");
    assert_eq!(left.command_path, right.command_path);
    assert_eq!(left.normalized_path, right.normalized_path);
    assert_eq!(left.global_flags.output_format, right.global_flags.output_format);
    assert_eq!(left.global_flags.pretty_mode, right.global_flags.pretty_mode);
}

#[test]
fn completion_alias_normalizes_with_explicit_shell_selector() {
    let argv = vec![
        "bijux".to_string(),
        "completion".to_string(),
        "--shell".to_string(),
        "bash".to_string(),
    ];

    let intent = parse_intent(&argv).expect("parse should succeed");
    assert_eq!(intent.command_path, vec!["completion"]);
    assert_eq!(intent.normalized_path, vec!["cli", "completion"]);
}

#[test]
fn canonical_cli_completion_and_doctor_paths_parse_successfully() {
    let completion = parse_intent(&[
        "bijux".to_string(),
        "cli".to_string(),
        "completion".to_string(),
        "--shell".to_string(),
        "fish".to_string(),
    ])
    .expect("parse should succeed");
    assert_eq!(completion.command_path, vec!["cli", "completion"]);
    assert_eq!(completion.normalized_path, vec!["cli", "completion"]);

    let doctor = parse_intent(&["bijux".to_string(), "cli".to_string(), "doctor".to_string()])
        .expect("parse should succeed");
    assert_eq!(doctor.command_path, vec!["cli", "doctor"]);
    assert_eq!(doctor.normalized_path, vec!["cli", "doctor"]);
}