ctl-core 0.0.2

Shared clap chassis for the *ctl CLIs
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

//! Flatten mixins: shorts, longs, `--preview`, `-c` ownership.
#![allow(missing_docs)]
#![cfg(feature = "cli")]

mod common;

use clap::Parser;
use common::{Toy, ToyCmd, parse};
use ctl_core::flags::{FormatArgs, switch};
use ctl_core::prelude::*;

#[test]
fn status_subcommand() {
    assert!(matches!(parse(&["status"]).command, ToyCmd::Status));
}

#[test]
fn format_short_and_long() {
    assert!(parse(&["-f", "json", "status"]).output.format.is_json());
    assert!(
        parse(&["--format", "json", "status"])
            .output
            .format
            .is_json()
    );
    assert!(
        !parse(&["--format", "pretty", "status"])
            .output
            .format
            .is_json()
    );
}

#[test]
fn color_short_long_and_negation() {
    assert_eq!(
        parse(&["-c", "never", "status"]).output.color(),
        ColorMode::Never
    );
    assert_eq!(
        parse(&["--color", "always", "status"]).output.color(),
        ColorMode::Always
    );
    assert_eq!(
        parse(&["--no-color", "status"]).output.color(),
        ColorMode::Never
    );
}

#[test]
fn quiet_and_dry_run() {
    assert!(parse(&["-q", "status"]).output.quiet);
    assert!(parse(&["--quiet", "status"]).output.quiet);
    assert!(parse(&["-n", "status"]).dry.dry_run);
    assert!(parse(&["--dry-run", "status"]).dry.dry_run);
    assert!(parse(&["--preview", "status"]).dry.dry_run);
}

#[test]
fn defaults() {
    let cli = parse(&["status"]);
    assert_eq!(cli.output.format, OutputFormat::Pretty);
    assert_eq!(cli.output.color(), ColorMode::Auto);
    assert!(!cli.output.quiet);
    assert!(!cli.dry.dry_run);
}

#[test]
fn all_long_and_all_short() {
    #[rustfmt::skip]
    let long = parse(&[
        "--format", "json",
        "--color", "never",
        "--quiet",
        "--dry-run",
        "status",
    ]);
    assert!(long.output.format.is_json() && long.output.quiet && long.dry.dry_run);
    assert_eq!(long.output.color(), ColorMode::Never);
    let short = parse(&["-f", "json", "-c", "never", "-q", "-n", "status"]);
    assert!(short.output.format.is_json() && short.output.quiet && short.dry.dry_run);
}

#[test]
fn help_and_version_are_clap_display() {
    for args in [["-h"], ["--help"], ["-V"], ["--version"]] {
        let err = Toy::try_parse_from(["toy"].into_iter().chain(args)).unwrap_err();
        assert!(matches!(
            err.kind(),
            clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion
        ));
    }
}

#[test]
fn missing_command_is_help() {
    let err = Toy::try_parse_from(["toy"]).unwrap_err();
    assert_eq!(
        err.kind(),
        clap::error::ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
    );
}

#[test]
fn parser_debug_assert() {
    ctl_core::parser::verify::<Toy>();
}

#[test]
fn switch_follows_the_on_flag() {
    assert!(switch(true, false));
    assert!(!switch(false, true));
}

#[test]
fn last_format_wins() {
    assert_eq!(
        parse(&["--format", "json", "--format", "pretty", "status"])
            .output
            .format,
        OutputFormat::Pretty
    );
}

#[test]
fn dry_run_preview_pair_still_parses() {
    assert!(parse(&["--dry-run", "--preview", "status"]).dry.dry_run);
    assert!(parse(&["--preview", "--dry-run", "status"]).dry.dry_run);
}

#[derive(Parser, Debug)]
struct Split {
    #[command(flatten)]
    format: FormatArgs,
    #[command(flatten)]
    color: ColorLong,
    #[arg(short = 'c', long)]
    config: Option<String>,
}

#[test]
fn color_long_leaves_short_c_for_config() {
    let cli = Split::parse_from(["x", "-c", "cfg.toml", "--color", "never", "-f", "json"]);
    assert_eq!(cli.config.as_deref(), Some("cfg.toml"));
    assert_eq!(cli.color.color(), ColorMode::Never);
    assert!(cli.format.format.is_json());
}