shep 0.24.2

The shep binary: a process manager that keeps a flock of long-running processes alive on macOS, Linux and Windows, with logs, watch and cron restarts, and webhook alerts
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

//! `shep enable` on a dog that already holds grants: a list written at
//! upgrade nobody has looked at, and permissions a newer build waits on.

use shep_core::paths::ShepPaths;
use shep_core::permissions::Grants;

use super::consent::Input;
use super::enable::enable_asking;
use super::test_support::streams;
use crate::commands::shep_toml::{GrantRecord, ShepToml};
use crate::exit::ExitCode;

fn typing(typed: Option<&'static str>) -> Input {
    Input::reading(
        typed.is_some(),
        std::io::Cursor::new(typed.unwrap_or("").as_bytes()),
    )
}

async fn enable(paths: &ShepPaths, yes: bool, mut input: Input) -> (ExitCode, String) {
    let mut out = Vec::new();
    let mut err = Vec::new();
    let code = enable_asking(
        &mut streams(&mut out, &mut err),
        paths,
        "bark",
        yes,
        &mut input,
    )
    .await;
    (code, String::from_utf8(err).unwrap())
}

fn declared() -> Grants {
    Grants::from_names(
        crate::dog::builtin_manifest("bark")
            .expect("bark declares itself")
            .permissions
            .into_iter()
            .map(|permission| permission.name),
    )
}

fn recorded(paths: &ShepPaths) -> Option<GrantRecord> {
    ShepToml::read_only(&paths.daemon_config)
        .unwrap()
        .grant_record("bark")
        .unwrap()
}

/// A home from before grants, with `bark` already enabled.
fn before_grants() -> (tempfile::TempDir, ShepPaths) {
    let dir = tempfile::tempdir().unwrap();
    let paths = ShepPaths::resolve(&|_| None, dir.path());
    std::fs::create_dir_all(&paths.home).unwrap();
    std::fs::write(
        &paths.daemon_config,
        "[daemon]\nenabled_dogs = [\"bark\"]\n",
    )
    .unwrap();
    (dir, paths)
}

/// A home where `bark` holds nothing and its build declares more.
fn waiting_on_everything() -> (tempfile::TempDir, ShepPaths) {
    let (dir, paths) = before_grants();
    ShepToml::try_edit(&paths.daemon_config, |cfg| {
        cfg.set_grant_record("bark", &GrantRecord::reviewed(Grants::default()))
    })
    .unwrap();
    (dir, paths)
}

#[tokio::test]
async fn a_list_written_at_upgrade_is_marked_reviewed_by_a_yes() {
    let (_dir, paths) = before_grants();

    let (code, said) = enable(&paths, false, typing(Some("y\n"))).await;

    assert_eq!(code, ExitCode::Success, "{said}");
    assert!(said.contains("granted at upgrade, not reviewed"), "{said}");
    assert_eq!(recorded(&paths), Some(GrantRecord::reviewed(declared())));
}

#[tokio::test]
async fn a_no_leaves_the_list_marked_and_the_dog_enabled_on_what_it_holds() {
    let (_dir, paths) = before_grants();

    let (code, said) = enable(&paths, false, typing(Some("n\n"))).await;

    assert_eq!(code, ExitCode::Success, "{said}");
    assert_eq!(recorded(&paths), Some(GrantRecord::at_upgrade(declared())));
}

#[tokio::test]
async fn with_no_terminal_the_dog_carries_on_and_the_mark_stays() {
    let (_dir, paths) = before_grants();

    let (code, said) = enable(&paths, false, typing(None)).await;

    assert_eq!(code, ExitCode::Success, "{said}");
    assert!(said.contains("no terminal to ask on"), "{said}");
    assert!(said.contains("--yes"), "{said}");
    assert_eq!(recorded(&paths), Some(GrantRecord::at_upgrade(declared())));
}

#[tokio::test]
async fn yes_approves_what_a_newer_build_waits_on() {
    let (_dir, paths) = waiting_on_everything();

    let (code, said) = enable(&paths, true, typing(None)).await;

    assert_eq!(code, ExitCode::Success, "{said}");
    assert_eq!(recorded(&paths), Some(GrantRecord::reviewed(declared())));
}

#[tokio::test]
async fn what_a_newer_build_waits_on_stays_waiting_without_a_yes() {
    let (_dir, paths) = waiting_on_everything();
    let waiting = GrantRecord {
        waiting: declared(),
        ..GrantRecord::reviewed(Grants::default())
    };

    let (code, said) = enable(&paths, false, typing(Some("n\n"))).await;

    assert_eq!(code, ExitCode::Success, "{said}");
    assert!(said.contains("waits on"), "{said}");
    assert_eq!(recorded(&paths), Some(waiting));
}

#[tokio::test]
async fn a_reviewed_dog_with_nothing_waiting_is_not_asked() {
    let (_dir, paths) = before_grants();
    ShepToml::try_edit(&paths.daemon_config, |cfg| {
        cfg.set_grant_record("bark", &GrantRecord::reviewed(declared()))
    })
    .unwrap();

    let (code, said) = enable(&paths, false, typing(None)).await;

    assert_eq!(code, ExitCode::Success, "{said}");
    assert!(!said.contains("not reviewed"), "{said}");
}