scientific-workflow 0.7.2

Configuration-driven scientific tasks, typed state, and durable recordings
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

use std::fs;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};

use scientific_workflow::configuration::{
    ConfigurationError, ConfigurationSpace, ProjectPaths, ResolvedConfiguration,
};

static NEXT_DIRECTORY: AtomicU64 = AtomicU64::new(0);

fn configuration_directory(name: &str, fixed: &str, sweep: &str) -> PathBuf {
    let sequence = NEXT_DIRECTORY.fetch_add(1, Ordering::Relaxed);
    let directory = std::env::temp_dir().join(format!(
        "scientific-workflow-{name}-{}-{sequence}",
        std::process::id()
    ));
    fs::create_dir_all(&directory).unwrap();
    fs::write(directory.join("fixed.json"), fixed).unwrap();
    fs::write(directory.join("sweep.json"), sweep).unwrap();
    directory
}

#[test]
fn resolves_every_fixed_and_cartesian_sweep_combination() {
    let directory = configuration_directory(
        "cartesian",
        r#"{"solver":{"step":0.01},"seed":7}"#,
        r#"{"mode":"cartesian","axes":{"temperature":{"values":[280.0,300.0]},"size":{"values":[4,8]}}}"#,
    );
    let space = ConfigurationSpace::load(&directory).unwrap();

    assert_eq!(space.combination_count(), 4);
    let resolved = space
        .combinations()
        .map(|configuration| {
            let values: (f64, usize, u64, f64) = configuration
                .decode_values(("/temperature", "/size", "/seed", "/solver/step"))
                .unwrap();
            (configuration.ordinal(), values)
        })
        .collect::<Vec<_>>();
    assert_eq!(
        resolved,
        vec![
            (0, (280.0, 4, 7, 0.01)),
            (1, (280.0, 8, 7, 0.01)),
            (2, (300.0, 4, 7, 0.01)),
            (3, (300.0, 8, 7, 0.01)),
        ]
    );

    fs::remove_dir_all(directory).unwrap();
}

#[test]
fn resolves_explicit_cases_without_creating_tasks() {
    let directory = configuration_directory(
        "cases",
        r#"{"shared":true}"#,
        r#"{"mode":"cases","cases":[{"temperature":280.0,"seed":1},{"temperature":300.0,"seed":9}]}"#,
    );
    let combinations = ConfigurationSpace::load(&directory)
        .unwrap()
        .combinations()
        .collect::<Vec<ResolvedConfiguration>>();

    assert_eq!(combinations.len(), 2);
    assert_eq!(combinations[0].decode_value::<u64>("/seed").unwrap(), 1);
    assert_eq!(combinations[1].decode_value::<u64>("/seed").unwrap(), 9);

    fs::remove_dir_all(directory).unwrap();
}

#[test]
fn indexed_access_and_value_errors_retain_the_combination_ordinal() {
    let directory = configuration_directory(
        "indexed",
        r#"{"seed":7}"#,
        r#"{"mode":"cartesian","axes":{}}"#,
    );
    let space = ConfigurationSpace::load(&directory).unwrap();
    let configuration = space.combination(0).unwrap();

    assert!(matches!(
        configuration.decode_value::<String>("/seed"),
        Err(ConfigurationError::DecodeConfigurationValue { ordinal: 0, .. })
    ));
    assert!(matches!(
        space.combination(1),
        Err(ConfigurationError::CombinationOrdinalOutOfBounds {
            ordinal: 1,
            combination_count: 1
        })
    ));

    fs::remove_dir_all(directory).unwrap();
}

#[test]
fn project_paths_are_strict_ordered_and_resolve_lexically() {
    let root = std::env::temp_dir().join(format!(
        "scientific-workflow-paths-{}-{}",
        std::process::id(),
        NEXT_DIRECTORY.fetch_add(1, Ordering::Relaxed)
    ));
    let configuration = root.join("config");
    fs::create_dir_all(&configuration).unwrap();
    fs::write(
        configuration.join("paths.json"),
        r#"{"recordings":"results","input":"data/input.json"}"#,
    )
    .unwrap();

    let paths = ProjectPaths::load(&root).unwrap();
    assert_eq!(paths.keys().collect::<Vec<_>>(), ["recordings", "input"]);
    assert_eq!(
        paths.resolve_path("recordings").unwrap(),
        root.join("results")
    );
    assert_eq!(paths.to_json_value()["input"], "data/input.json");

    fs::write(
        configuration.join("paths.json"),
        r#"{"recordings":"first","recordings":"second"}"#,
    )
    .unwrap();
    assert!(matches!(
        ProjectPaths::load(&root),
        Err(ConfigurationError::DuplicateConfigurationKey { key, .. })
            if key == "recordings"
    ));

    fs::write(configuration.join("paths.json"), r#"{" ":"results"}"#).unwrap();
    assert!(matches!(
        ProjectPaths::load(&root),
        Err(ConfigurationError::InvalidConfigurationDocument { .. })
    ));
    fs::remove_dir_all(root).unwrap();
}