artifactize-core 0.12.0

The library behind artifactize: Artifacts, evals, reviews, the monitor and review models, and the shared operations every interface calls.
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

//! A5: CLI launch selection is independent of cwd and never narrows the available catalog.
use super::*;

#[test]
fn a5_monitor_starts_on_all_from_any_cwd_and_paths_select_only_initial_scope() {
    const PROBE: &str = "ARTIFACTIZE_MONITOR_PROBE";
    if let Some(input) = crate::platform::environment::var(PROBE) {
        let args: Vec<String> = serde_json::from_str(&input.to_string_lossy()).unwrap();
        let screens = Screens {
            monitor: |_, initial, _| {
                Box::pin(async move {
                    let expected = crate::platform::environment::var("ARTIFACTIZE_MONITOR_EXPECT")
                        .filter(|value| !value.is_empty())
                        .map(PathBuf::from);
                    assert_eq!(initial, expected);
                    Ok(())
                })
            },
            review: |_, _, _, _, _| unreachable!("monitor never routes to review"),
        };
        let cli = Cli::try_parse_from(args).unwrap();
        let runtime = tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()
            .unwrap();
        assert_eq!(
            runtime.block_on(dispatch::execute(cli, screens)).unwrap(),
            0
        );
        return;
    }
    let root = crate::test_os::tempdir();
    let selected = root.path().join("selected");
    let unrelated = root.path().join("unrelated");
    std::fs::create_dir(&selected).unwrap();
    std::fs::create_dir(&unrelated).unwrap();
    for (cwd, tail, expected) in [
        (&selected, vec!["monitor".to_owned()], None),
        (&unrelated, vec!["monitor".to_owned()], None),
        (
            &selected,
            vec!["monitor".to_owned(), ".".to_owned()],
            Some(PathBuf::from(".")),
        ),
        (
            &unrelated,
            vec!["monitor".to_owned(), crate::platform::path_text(&selected)],
            Some(selected.clone()),
        ),
        (
            &unrelated,
            vec![
                "--repo".to_owned(),
                crate::platform::path_text(&selected),
                "monitor".to_owned(),
            ],
            Some(selected.clone()),
        ),
        (
            &unrelated,
            vec!["monitor".to_owned(), "--all".to_owned()],
            None,
        ),
    ] {
        let args = vec![
            "artifactize".to_owned(),
            "--state-dir".to_owned(),
            crate::platform::path_text(&root.path().join("state")),
        ]
        .into_iter()
        .chain(tail)
        .collect::<Vec<_>>();
        let output = crate::test_os::run_test_in(
            "cli::monitor_tests::a5_monitor_starts_on_all_from_any_cwd_and_paths_select_only_initial_scope",
            cwd,
            &[
                (PROBE, serde_json::to_string(&args).unwrap().into()),
                (
                    "ARTIFACTIZE_MONITOR_EXPECT",
                    expected
                        .as_deref()
                        .map(crate::platform::path_text)
                        .unwrap_or_default()
                        .into(),
                ),
            ],
        );
        assert!(
            output.status.success(),
            "{}{}",
            String::from_utf8_lossy(&output.stdout),
            String::from_utf8_lossy(&output.stderr)
        );
    }
    for args in [
        vec!["monitor", ".", "--repo", "."],
        vec!["monitor", ".", "--all"],
        vec!["monitor", "--all", "--repo", "."],
    ] {
        assert!(Cli::try_parse_from(std::iter::once("artifactize").chain(args)).is_err());
    }
}