silicon-iam-cli 1.2.1

Command-line client for Silicon IAM, built on the silicon-iam-client crate.
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

//! One module per noun, matching the command grammar.

pub mod app;
pub mod approval;
pub mod auth;
pub mod carbon;
pub mod config;
pub mod env;
pub mod invite;
pub mod member;
pub mod org;
pub mod session;
pub mod silicon;
pub mod sso;
pub mod system;
pub mod tag;
pub mod trust;

use crate::{cli::Command, context::Context, error::Result};

/// Runs one command.
///
/// # Errors
///
/// Returns whatever the command reports.
pub async fn dispatch(context: &Context, command: Command) -> Result<()> {
    match command {
        Command::Login(args) => auth::login(context, args).await,
        Command::SiliconLogin(args) => auth::silicon_login(context, args).await,
        Command::Logout(args) => auth::logout(context, args).await,
        Command::Whoami => auth::whoami(context).await,
        Command::StepUp(args) => auth::step_up(context, args).await,
        Command::Signup(args) => auth::signup(context, args).await,
        Command::Carbon(command) => carbon::run(context, command).await,
        Command::Commands => crate::experience::print_commands(context.format),
        Command::Docs { topic, search } => {
            crate::manual::run(context.format, topic.as_deref(), search.as_deref())
        }
        Command::Org(command) => org::run(context, command).await,
        Command::Sso(command) => sso::run(context, command).await,
        Command::Member(command) => member::run(context, command).await,
        Command::Invite(command) => invite::run(context, command).await,
        Command::Tag(command) => tag::run(context, command).await,
        Command::Trust(command) => trust::run(context, command).await,
        Command::Approval(command) => approval::run(context, command).await,
        Command::Silicon(command) => silicon::run(context, command).await,
        Command::App(command) => app::run(context, command).await,
        Command::Env(command) => env::run(context, command).await,
        Command::Session(command) => session::run(context, command).await,
        Command::Config(command) => config::run(context, command),
        Command::System(command) => system::run(context, command).await,
    }
}

#[cfg(test)]
mod tests {
    use clap::CommandFactory as _;

    /// Every command the grammar declares is reachable from `dispatch`.
    ///
    /// The check is structural rather than behavioural: `dispatch` matches
    /// exhaustively on the command enum, so the compiler already refuses a
    /// missing arm. What this catches is a command declared and then never
    /// given a `run` at all -- a group whose subcommands exist only in help.
    #[test]
    fn every_group_has_subcommands_behind_it() {
        let command = crate::cli::Cli::command();
        let groups: Vec<_> = command
            .get_subcommands()
            .filter(|sub| {
                !sub.is_hide_set()
                    && !matches!(
                        sub.get_name(),
                        "login"
                            | "silicon-login"
                            | "logout"
                            | "whoami"
                            | "step-up"
                            | "signup"
                            | "commands"
                            | "docs"
                            | "help"
                    )
            })
            .collect();
        assert!(!groups.is_empty());
        for group in groups {
            assert!(
                group.get_subcommands().next().is_some(),
                "{} declares no subcommands",
                group.get_name()
            );
        }
    }

    #[test]
    fn every_command_carries_a_description() {
        fn walk(command: &clap::Command) {
            for sub in command.get_subcommands() {
                if sub.get_name() == "help" {
                    continue;
                }
                assert!(
                    sub.get_about().is_some(),
                    "{} has no description, so `iam commands` would list it blank",
                    sub.get_name()
                );
                walk(sub);
            }
        }
        walk(&crate::cli::Cli::command());
    }
}