bobr 0.2.2

A simple command multiplexer.
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
148
149
150
151
152
153
154
155

use std::path::PathBuf;

use anyhow::Result;
use args::{ManualFormat, StdoutFormat};
use multiplexer::Multiplexer;

pub mod args;
pub mod config;
pub mod multiplexer;
pub mod reference;

#[deny(unsafe_code)]
#[tokio::main]
async fn main() -> Result<()> {
    let cmd = crate::args::ClapArgumentLoader::load()?;

    match cmd.command {
        | crate::args::Command::Manual { path, format } => {
            let out_path = PathBuf::from(path);
            std::fs::create_dir_all(&out_path)?;
            match format {
                | ManualFormat::Manpages => {
                    reference::build_manpages(&out_path)?;
                },
                | ManualFormat::Markdown => {
                    reference::build_markdown(&out_path)?;
                },
            }
            Ok(())
        },
        | crate::args::Command::Autocomplete { path, shell } => {
            let out_path = PathBuf::from(path);
            std::fs::create_dir_all(&out_path)?;
            reference::build_shell_completion(&out_path, &shell)?;
            Ok(())
        },
        | crate::args::Command::Multiplex {
            program,
            stderr,
            stdout,
            commands,
            parallelism,
        } => {
            let parallelism = parallelism.unwrap_or(commands.len());
            let result = Multiplexer::new(program, stderr, commands, parallelism).run().await?;
            if let Some(v) = stdout {
                match v {
                    #[cfg(feature = "format+json")]
                    | StdoutFormat::Json => {
                        serde_json::to_writer(std::io::stdout(), &result)?;
                    },
                    #[cfg(feature = "format+yaml")]
                    | StdoutFormat::Yaml => {
                        serde_yml::to_writer(std::io::stdout(), &result)?;
                    },
                }
            }
            Ok(())
        },
    }
}

#[cfg(test)]
mod test {
    use anyhow::Result;
    use chrono::Duration;
    use clitest::CliTestSetup;

    use crate::multiplexer::MultiplexerResult;

    fn setup_test() -> CliTestSetup {
        let mut setup = CliTestSetup::new();
        setup.with_env("RUST_BACKTRACE", "0");
        setup
    }

    #[tokio::test]
    pub async fn test_smoke() -> Result<()> {
        let mut setup = setup_test();
        setup.with_cargo_flag("--features=\"format+toml\"");

        // run CLI with experimental flag, test file and stdout output (json formatted)
        let result = setup.run("-e -f ./test/example.toml --stdout=json")?;

        // assert program ran and completed successfully
        assert!(result.status.success());

        // smoke test parse stdout data
        let result_typed = serde_json::from_slice::<MultiplexerResult>(&result.stdout)?;

        // assert commands are run in parallel and reasonably fast
        let runtime = result_typed.metadata.ended - result_typed.metadata.started;
        assert!(runtime > Duration::milliseconds(1000));
        assert!(runtime <= Duration::milliseconds(1200));

        // assert stdout output of subcommands
        assert_eq!(3, result_typed.tasks.len());
        assert_eq!("", result_typed.tasks.get(&0).unwrap().stdout);
        assert_eq!("", result_typed.tasks.get(&1).unwrap().stdout);
        assert_eq!("test\n", result_typed.tasks.get(&2).unwrap().stdout);

        Ok(())
    }

    #[tokio::test]
    pub async fn test_cmd_exec_experimental_stdout() -> Result<()> {
        let setup = setup_test();
        // without experimental flag
        let result = setup.run("--stdout=json")?;
        assert!(!result.status.success()); // can not succeed

        let stderr = result.stderr_str();
        let stderr_last = stderr.lines().last().unwrap();
        assert_eq!("Error: experimental flag (stdout)", stderr_last);

        // with experimental flag
        let result = setup.run("-e --stdout=json")?;
        assert!(result.status.success()); // must succeed

        Ok(())
    }

    #[tokio::test]
    pub async fn test_cmd_exec_experimental_parallelism() -> Result<()> {
        let setup = setup_test();
        // without experimental flag
        let result = setup.run("-p4")?;
        assert!(!result.status.success()); // can not succeed

        let stderr = result.stderr_str();
        let stderr_last = stderr.lines().last().unwrap();
        assert_eq!("Error: experimental flag (parallelism)", stderr_last);

        // with experimental flag
        let result = setup.run("-e -p4")?;
        assert!(result.status.success()); // must succeed

        Ok(())
    }

    #[tokio::test]
    pub async fn test_feature_format_yaml() -> Result<()> {
        // run without feature
        let result = setup_test().run("-e --stdout=yaml")?;
        assert!(!result.status.success()); // can not succeed

        // run with format+yaml feature
        let result = setup_test()
            .with_cargo_flag("--features=\"format+yaml\"")
            .run("-e --stdout=yaml")?;
        assert!(result.status.success()); // must succeed

        Ok(())
    }
}