argx 0.1.1

Expressive command-line parsing and configuration 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

//! Built-in output format and field-selection integration tests.

#[cfg(test)]
#[cfg(feature = "derive")]
mod tests {
    use argx::{Parser as _, argx};
    use serde::Serialize;
    use serde_json::json;

    #[derive(Debug, argx::Parser)]
    #[argx(schema)]
    struct Cli {
        #[argx(subcommand)]
        command: Command,
    }

    #[derive(Debug, argx::Subcommand)]
    #[argx(schema)]
    enum Command {
        Get(Get),
    }

    #[derive(Debug, argx::Args)]
    struct Get;

    #[derive(Debug, Serialize)]
    #[argx(schema)]
    struct Item {
        id: u64,
        name: String,
        nested: Nested,
    }

    #[derive(Debug, Serialize)]
    #[argx(schema)]
    struct Nested {
        value: String,
        ignored: bool,
    }

    #[derive(Debug, Serialize)]
    #[argx(schema)]
    struct HandlerError {
        message: String,
    }

    #[argx::argx(handler = run)]
    impl Get {
        fn run(self) -> Result<Item, HandlerError> {
            Ok(Item {
                id: 7,
                name: "example".to_owned(),
                nested: Nested { value: "kept".to_owned(), ignored: true },
            })
        }
    }

    #[test]
    fn output_and_fields_are_global_and_fields_are_comma_delimited_and_repeatable() {
        let invocation = Cli::try_parse_invocation_from([
            "tool",
            "get",
            "-O",
            "json",
            "-F",
            "id,nested.value",
            "--fields=name",
        ])
        .unwrap();

        assert_eq!(invocation.output.format(), argx::OutputFormat::Json);
        assert_eq!(invocation.output.fields(), ["id", "nested.value", "name"]);

        let Command::Get(command) = invocation.command.command;
        let value = command.run().unwrap();
        assert_eq!(
            invocation.output.value(&value).unwrap(),
            json!({"id": 7, "name": "example", "nested": {"value": "kept"}})
        );
    }

    #[test]
    fn output_defaults_to_text() {
        let invocation = Cli::try_parse_invocation_from(["tool", "get"]).unwrap();
        assert_eq!(invocation.output.format(), argx::OutputFormat::Text);
    }

    #[test]
    fn invalid_and_repeated_output_formats_are_rejected() {
        assert!(Cli::try_parse_invocation_from(["tool", "get", "-O", "yaml"]).is_err());
        let error =
            Cli::try_parse_invocation_from(["tool", "get", "--output", "json", "--output", "text"])
                .unwrap_err();
        assert!(matches!(error, argx::Error::DuplicateArgument { name } if name == "--output"));
    }

    #[test]
    fn fields_require_json_output() {
        let error = Cli::try_parse_invocation_from(["tool", "get", "-F", "id"]).unwrap_err();
        assert!(matches!(
            error,
            argx::Error::MissingRequirement { name, required_by }
                if name == "--output json" && required_by == "--fields"
        ));
    }

    #[test]
    fn invalid_field_is_rejected_before_handler_execution() {
        let error = Cli::try_parse_invocation_from(["tool", "get", "-O", "json", "-F", "missing"])
            .unwrap_err();
        assert!(matches!(error, argx::Error::InvalidOutputField { field } if field == "missing"));
    }

    #[test]
    fn built_in_output_options_appear_in_help() {
        let help = Cli::render_help();
        assert!(help.contains("-O, --output <FORMAT>"));
        assert!(help.contains("-F, --fields <FIELDS>"));
    }
}