scientific-workflow 0.11.9

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

//! Public observation declaration contract.

use scientific_workflow::prelude::*;

#[test]
fn ordinary_declarations_infer_the_common_case() {
    let _all_fields = ObservationPlan::all_fields();
    let _selected = ObservationPlan::fields(["position", "velocity"]).unwrap();
    let _multi_stream = ObservationPlan::streams([
        ObservationStream::fields("signal", ["position"]).unwrap(),
        ObservationStream::all_fields("checkpoint")
            .unwrap()
            .every_iterations(10)
            .unwrap(),
    ])
    .unwrap()
    .with_iteration_unit("step")
    .unwrap()
    .with_physical_time_unit("s")
    .unwrap();
}

#[test]
fn declaration_errors_are_reported_before_study_binding() {
    assert!(matches!(
        ObservationPlan::streams([]),
        Err(ObservationError::EmptyPlan)
    ));
    assert!(matches!(
        ObservationPlan::streams([
            ObservationStream::all_fields("same").unwrap(),
            ObservationStream::all_fields(" same ").unwrap(),
        ]),
        Err(ObservationError::DuplicateStreamName { .. })
    ));
    assert!(matches!(
        ObservationStream::fields("signal", std::iter::empty::<String>()),
        Err(ObservationError::EmptyFieldSelection { .. })
    ));
    assert!(matches!(
        ObservationStream::all_fields("signal")
            .unwrap()
            .every_iterations(0),
        Err(ObservationError::InvalidSamplingInterval { .. })
    ));
    assert!(matches!(
        ObservationPlan::all_fields().with_iteration_unit("  "),
        Err(ObservationError::EmptyAxisUnit { axis: "iteration" })
    ));
}

#[test]
fn module_root_exposes_declarations_without_binding_plumbing() {
    fn accepts_plan(_: ObservationPlan) {}
    fn accepts_stream(_: ObservationStream) {}
    fn accepts_error(_: Option<ObservationError>) {}

    accepts_plan(ObservationPlan::all_fields());
    accepts_stream(ObservationStream::all_fields("state").unwrap());
    accepts_error(None);
}