distant 0.20.0

Operate on a remote computer through file and process manipulation
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

use rstest::*;

use crate::cli::scripts::*;
use crate::common::fixtures::*;
use crate::common::utils::regex_pred;

#[rstest]
#[test_log::test]
fn should_execute_program_and_return_exit_status(ctx: DistantManagerCtx) {
    // Windows prints out a message whereas unix prints nothing
    #[cfg(windows)]
    let stdout = regex_pred(".+");
    #[cfg(unix)]
    let stdout = "";

    // distant spawn -- {cmd} [args]
    ctx.cmd("spawn")
        .arg("--")
        .arg(SCRIPT_RUNNER.as_str())
        .arg(SCRIPT_RUNNER_ARG.as_str())
        .arg(EXIT_CODE.to_str().unwrap())
        .arg("0")
        .assert()
        .success()
        .stdout(stdout)
        .stderr("");
}

#[rstest]
#[test_log::test]
fn should_capture_and_print_stdout(ctx: DistantManagerCtx) {
    // distant spawn -- {cmd} [args]
    ctx.cmd("spawn")
        .arg("--")
        .arg(SCRIPT_RUNNER.as_str())
        .arg(SCRIPT_RUNNER_ARG.as_str())
        .arg(ECHO_ARGS_TO_STDOUT.to_str().unwrap())
        .arg("hello world")
        .assert()
        .success()
        .stdout(if cfg!(windows) {
            "hello world\r\n"
        } else {
            "hello world"
        })
        .stderr("");
}

#[rstest]
#[test_log::test]
fn should_capture_and_print_stderr(ctx: DistantManagerCtx) {
    // distant spawn -- {cmd} [args]
    ctx.cmd("spawn")
        .arg("--")
        .arg(SCRIPT_RUNNER.as_str())
        .arg(SCRIPT_RUNNER_ARG.as_str())
        .arg(ECHO_ARGS_TO_STDERR.to_str().unwrap())
        .arg("hello world")
        .assert()
        .success()
        .stdout("")
        .stderr(if cfg!(windows) {
            "hello world \r\n"
        } else {
            "hello world"
        });
}

// TODO: This used to work fine with the assert_cmd where stdin would close from our
//       process, which would in turn lead to the remote process stdin being closed
//       and then the process exiting. This may be a bug we've introduced with the
//       refactor and should be revisited some day.
#[rstest]
#[test_log::test]
fn should_forward_stdin_to_remote_process(ctx: DistantManagerCtx) {
    use std::io::{BufRead, BufReader, Write};

    // distant action proc-spawn {cmd} [args]
    let mut child = ctx
        .new_std_cmd(["spawn"])
        .arg("--")
        .arg(SCRIPT_RUNNER.as_str())
        .arg(SCRIPT_RUNNER_ARG.as_str())
        .arg(ECHO_STDIN_TO_STDOUT.to_str().unwrap())
        .spawn()
        .expect("Failed to spawn process");

    child
        .stdin
        .as_mut()
        .unwrap()
        .write_all(if cfg!(windows) {
            b"hello world\r\n"
        } else {
            b"hello world\n"
        })
        .expect("Failed to write to stdin of process");

    let mut stdout = BufReader::new(child.stdout.take().unwrap());
    let mut line = String::new();
    stdout.read_line(&mut line).expect("Failed to read line");
    assert_eq!(
        line,
        if cfg!(windows) {
            "hello world\r\n"
        } else {
            "hello world\n"
        }
    );

    child.kill().expect("Failed to kill spawned process");
}

#[rstest]
#[test_log::test]
fn reflect_the_exit_code_of_the_process(ctx: DistantManagerCtx) {
    // Windows prints out a message whereas unix prints nothing
    #[cfg(windows)]
    let stdout = regex_pred(".+");
    #[cfg(unix)]
    let stdout = "";

    // distant spawn -- {cmd} [args]
    ctx.cmd("spawn")
        .arg("--")
        .arg(SCRIPT_RUNNER.as_str())
        .arg(SCRIPT_RUNNER_ARG.as_str())
        .arg(EXIT_CODE.to_str().unwrap())
        .arg("99")
        .assert()
        .code(99)
        .stdout(stdout)
        .stderr("");
}

#[rstest]
#[test_log::test]
fn yield_an_error_when_fails(ctx: DistantManagerCtx) {
    // distant spawn -- {cmd} [args]
    ctx.cmd("spawn")
        .arg("--")
        .arg(DOES_NOT_EXIST_BIN.to_str().unwrap())
        .assert()
        .code(1)
        .stdout("")
        .stderr(regex_pred(".+"));
}