pend 0.1.0

do now, wait later – tiny job runner
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

use assert_cmd::prelude::*;
use predicates::prelude::*;
use std::env;
use std::process::Command;
use tempfile::TempDir;

fn pend_bin() -> Command {
    Command::cargo_bin("pend").expect("binary exists")
}

/// Helper to create a new temporary jobs directory and return it *plus* a
/// configured Command builder pointing at `pend` with that environment set.
fn pend_with_tempdir() -> (TempDir, Command) {
    let tmp = TempDir::new().expect("create tempdir");
    let mut cmd = pend_bin();
    cmd.env("PEND_DIR", tmp.path());
    (tmp, cmd)
}

#[test]
fn simple_success_flow() {
    let (tmp, mut cmd) = pend_with_tempdir();

    // `pend do okjob <pend> --version` runs quickly and exits 0.
    let pend_path = assert_cmd::cargo::cargo_bin("pend");

    cmd.args(["do", "okjob", pend_path.to_str().unwrap(), "--version"])
        .assert()
        .success();

    // Wait must reproduce version string and exit 0.
    pend_bin()
        .env("PEND_DIR", tmp.path())
        .args(["wait", "okjob"])
        .assert()
        .stdout(predicate::str::contains(env!("CARGO_PKG_VERSION")))
        .success();
}

#[test]
fn propagates_failure_exit_code() {
    let (tmp, mut cmd) = pend_with_tempdir();

    let pend_path = assert_cmd::cargo::cargo_bin("pend");

    cmd.args([
        "do",
        "failjob",
        pend_path.to_str().unwrap(),
        "--invalid-flag",
    ])
    .assert()
    .success();

    pend_bin()
        .env("PEND_DIR", tmp.path())
        .args(["wait", "failjob"])
        .assert()
        .code(2)
        .failure();
}

#[test]
fn dir_flag_overrides_env() {
    // Provide both PEND_DIR env and --dir flag; flag should take precedence.
    let env_dir = TempDir::new().unwrap();
    let flag_dir = TempDir::new().unwrap();

    let pend_path = assert_cmd::cargo::cargo_bin("pend");

    // do
    Command::new(&pend_path)
        .env("PEND_DIR", env_dir.path())
        .args([
            "--dir",
            flag_dir.path().to_str().unwrap(),
            "do",
            "flagjob",
            "bash",
            "-c",
            "echo fromflag",
        ])
        .assert()
        .success();

    // wait – rely on PEND_DIR env to *not* find job; should only exist in flag_dir.
    Command::new(&pend_path)
        .env("PEND_DIR", env_dir.path())
        .args([
            "--dir",
            flag_dir.path().to_str().unwrap(),
            "wait",
            "flagjob",
        ])
        .assert()
        .success()
        .stdout(predicate::str::contains("fromflag"));

    // Verify artifacts exist in flag_dir, not env_dir.
    assert!(flag_dir.path().join("flagjob.out").exists());
    assert!(!env_dir.path().join("flagjob.out").exists());
}

/// Spawn two background jobs that finish at different times and wait for both
/// of them simultaneously. The helper should replay *both* job logs and exit
/// with the non-zero status code of the first failing job that finishes.
#[test]
fn multi_job_interleaved_wait() {
    // Dedicated temporary jobs directory for test isolation.
    let (tmp, _) = pend_with_tempdir();

    let pend_path = assert_cmd::cargo::cargo_bin("pend");

    // Start a fast-failing job (exit 2).
    Command::new(&pend_path)
        .env("PEND_DIR", tmp.path())
        .args([
            "do",
            "failfast",
            "bash",
            "-c",
            "echo failfast-start && exit 2",
        ])
        .assert()
        .success();

    // Start a slower succeeding job.
    Command::new(&pend_path)
        .env("PEND_DIR", tmp.path())
        .args([
            "do",
            "slowok",
            "bash",
            "-c",
            "echo slowok-start && sleep 0.2 && echo slowok-end",
        ])
        .assert()
        .success();

    // Wait on *both* jobs at once. Disable ANSI colors for predictable output.
    Command::new(&pend_path)
        .env("PEND_DIR", tmp.path())
        .args(["--no-color", "wait", "failfast", "slowok"])
        .assert()
        // Expect the combined output from both jobs.
        .stdout(predicate::str::contains("failfast-start"))
        .stdout(predicate::str::contains("slowok-start"))
        .stdout(predicate::str::contains("slowok-end"))
        // The overall exit code must reflect the non-zero result of the
        // failing job.
        .code(2)
        .failure();
}