prcs 0.2.0

The Swiss Army knife for running processes
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

mod utils;

use std::io::Read;
use std::io::Write;
use std::path::Path;
use std::process::Child;
use std::process::{Command, Stdio};
use std::str::from_utf8;
use std::thread::sleep;
use std::time::Duration;
use utils::shell_command;

#[test]
fn does_not_rerun_if_status_does_not_match() {
    let stdout = Command::new(env!("CARGO_BIN_EXE_prcs"))
        .arg("-r=100")
        .args(&shell_command("echo text"))
        .output()
        .unwrap()
        .stdout;
    assert_eq!(
        from_utf8(&stdout).unwrap(),
        if cfg!(windows) { "text\r\n" } else { "text\n" }
    )
}

const EXPECTED_OUTPUT: &'static str = if cfg!(windows) {
    "text\r\nEND\r\n"
} else {
    "text\nEND\n"
};
fn run_consume_and_print_one_stdin_line(command: &mut Command) -> Child {
    if cfg!(windows) {
        command.args([
            "cscript",
            "/nologo",
            Path::new(file!())
                .join("../utils/consume-and-print-one-stdin-line.js")
                .to_str()
                .unwrap(),
        ]);
    } else {
        command.args(&shell_command(
            "(read line && echo $line) || (echo END && false)",
        ));
    }

    let mut child = command
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .spawn()
        .unwrap();
    child
        .stdin
        .as_mut()
        .unwrap()
        .write_all(if cfg!(windows) {
            b"text\r\n"
        } else {
            b"text\n"
        })
        .unwrap();
    child
}

#[test]
fn reruns_if_status_matches() {
    let mut command = Command::new(env!("CARGO_BIN_EXE_prcs"));
    command.arg("-r=0");

    let mut child = run_consume_and_print_one_stdin_line(&mut command);
    assert_eq!(child.wait().unwrap().code().unwrap(), 1);

    let mut output = vec![];
    child
        .stdout
        .take()
        .unwrap()
        .read_to_end(&mut output)
        .unwrap();

    assert_eq!(from_utf8(&output).unwrap(), EXPECTED_OUTPUT)
}

#[test]
fn reruns_before_stalling() {
    let mut command = Command::new(env!("CARGO_BIN_EXE_prcs"));
    command.arg("-r=0");
    command.arg("-s=1");

    let mut child = run_consume_and_print_one_stdin_line(&mut command);
    drop(child.stdin.take().unwrap());

    let mut output = [0; EXPECTED_OUTPUT.len()];
    child
        .stdout
        .take()
        .unwrap()
        .read_exact(&mut output)
        .unwrap();
    assert_eq!(from_utf8(&output).unwrap(), EXPECTED_OUTPUT);

    sleep(Duration::from_millis(100));
    assert!(child.try_wait().unwrap().is_none())
}