fli 1.2.2

The commander.js like CLI Parser for rust
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

use crate::error::FliError;

#[test]
fn test_command_mismatch_error() {
    let error = FliError::CommandMismatch {
        expected: "serve".to_string(),
        actual: "run".to_string(),
    };

    assert_eq!(
        error.to_string(),
        "Command mismatch: expected 'serve', got 'run'"
    );
}

#[test]
fn test_unknown_command_error() {
    let error = FliError::UnknownCommand(
        "serv".to_string(),
        vec!["serve".to_string(), "start".to_string()],
    );

    let error_msg = error.to_string();
    assert!(error_msg.contains("Unknown command: 'serv'"));
}

#[test]
fn test_unknown_option_error() {
    let error = FliError::UnknownOption("--verbos".to_string());

    assert_eq!(
        error.to_string(),
        "Unknown option: '--verbos'. Run with --help to see available options"
    );
}

#[test]
fn test_missing_value_error() {
    let error = FliError::MissingValue {
        option: "--output".to_string(),
    };

    assert_eq!(
        error.to_string(),
        "Missing required value for option '--output'"
    );
}

#[test]
fn test_unexpected_value_error() {
    let error = FliError::UnexpectedValue {
        option: "--verbose".to_string(),
        value: "yes".to_string(),
    };

    assert_eq!(
        error.to_string(),
        "Option '--verbose' does not accept values, but 'yes' was provided"
    );
}

#[test]
fn test_value_count_mismatch_error() {
    let error = FliError::ValueCountMismatch {
        option: "--files".to_string(),
        expected: 3,
        actual: 2,
    };

    assert_eq!(
        error.to_string(),
        "Option '--files' expected 3 value(s), got 2"
    );
}

#[test]
fn test_invalid_value_error() {
    let error = FliError::InvalidValue {
        option: "--port".to_string(),
        value: "abc".to_string(),
        reason: "not a valid integer".to_string(),
    };

    assert_eq!(
        error.to_string(),
        "Invalid value 'abc' for option '--port': not a valid integer"
    );
}

#[test]
fn test_invalid_flag_format_error() {
    let error = FliError::InvalidFlagFormat {
        flag: "verbose".to_string(),
    };

    assert_eq!(
        error.to_string(),
        "Invalid flag format: 'verbose'. Flags must start with '-' or '--'"
    );
}

#[test]
fn test_option_not_found_error() {
    let error = FliError::OptionNotFound("--config".to_string());

    assert_eq!(error.to_string(), "Option '--config' not found in parser");
}

#[test]
fn test_parser_not_prepared_error() {
    let error = FliError::ParserNotPrepared;

    assert_eq!(
        error.to_string(),
        "Parser must be prepared before use. Call prepare() first"
    );
}

#[test]
fn test_internal_error() {
    let error = FliError::Internal("Something went wrong".to_string());

    assert_eq!(error.to_string(), "Internal error: Something went wrong");
}

#[test]
fn test_error_helper_functions() {
    let error = FliError::command_mismatch("expected", "actual");
    assert!(matches!(error, FliError::CommandMismatch { .. }));

    let error = FliError::missing_value("--name");
    assert!(matches!(error, FliError::MissingValue { .. }));
}