comlexr 1.5.0

Dynamically build Command objects with conditional expressions
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

use core::panic;
use std::ffi::OsStr;

use comlexr::{cmd, pipe};
use tempfile::tempdir;

#[test]
fn pipe_status() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("out");
    let mut pipe = pipe!(cmd!("echo", "test") | cmd!("tee", &file));

    let status = pipe.status().unwrap();
    assert!(status.success());
}

#[test]
fn pipe_stdin_output() {
    let dir = tempdir().unwrap();
    let file = dir.path().join("out");
    let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|") | cmd!("tee", &file));
    println!("{}", file.display());

    let output = pipe.output().unwrap();
    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}

#[test]
fn pipe_stdin_output_single_command() {
    let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|"));

    let output = pipe.output().unwrap();
    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}

#[test]
fn pipe_expect_fail() {
    let mut pipe = pipe!(stdin = "test"; cmd!("false") | cmd!("sed", "s|e|oa|"));

    let error = pipe.output().unwrap_err();

    match error {
        comlexr::ExecutorError::FailedCommand { command, exit_code } => {
            assert_eq!(command.get_program(), OsStr::new("false"));
            assert_eq!(exit_code, 1);
        }
        err => panic!("Expected exit code, got: {err}"),
    }
}

#[test]
fn pipe_expect_fail_command_not_exist() {
    let mut pipe = pipe!(stdin = "test"; cmd!("no_command") | cmd!("sed", "s|e|oa|"));

    let error = pipe.output().unwrap_err();

    match error {
        comlexr::ExecutorError::Io(err) => assert_eq!(err.raw_os_error().unwrap(), 2),
        err => panic!("Expected IO Error, got: {err}"),
    }
}

#[test]
fn pipe_block() {
    let mut pipe = pipe!(stdin = "test"; {
        let c = cmd!("sed", "s|e|oa|");
        println!("{c:?}");
        c
    });

    let output = pipe.output().unwrap();
    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}

#[test]
fn pipe_ref() {
    let mut command = {
        let c = cmd!("sed", "s|e|oa|");
        println!("{c:?}");
        c
    };
    let mut pipe = pipe!(stdin = "test"; &mut command);

    let output = pipe.output().unwrap();
    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}

#[test]
fn pipe_fn() {
    let command = || {
        let c = cmd!("sed", "s|e|oa|");
        println!("{c:?}");
        c
    };
    let mut pipe = pipe!(stdin = "test"; command());

    let output = pipe.output().unwrap();
    assert!(output.status.success());
    assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
}