imperat 0.1.0

Library to enable dependency injection and management of step-by-step flows.
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

use imperat::{BuilderError, prelude::*};
use std::sync::{
    LazyLock,
    atomic::{AtomicUsize, Ordering},
};
use thiserror::Error;

struct Database;
#[derive(Clone, Dependency)]
struct DeriveDataSource;

// ordered exec should run steps in order
#[tokio::test]
async fn test_ordered_exec() {
    async fn example_step() -> usize {
        println!("step");
        1
    }

    async fn example_step_dep(_db: Dep<Database>) -> usize {
        println!("step dep");
        2
    }

    let res = new_imperative_builder()
        .add_dep(Dep::new(Database))
        .add_step("example step", example_step)
        .add_step("example step with a dep", example_step_dep)
        .execute()
        .await
        .unwrap();

    assert_eq!(vec![1, 2], res);
}

// a derive Dependency struct should resolve fine
#[tokio::test]
async fn test_derive_dependency() {
    let b = new_imperative_builder().add_dep(DeriveDataSource).add_step(
        "step 1",
        async |_: DeriveDataSource| {
            println!("foo");
            1
        },
    );
    println!("{b:?}");

    let res = b.execute().await.unwrap();

    assert_eq!(vec![1], res);
}

// missing deps should error out.
#[tokio::test]
async fn test_missing_deps() {
    async fn missing_dep_step(_db: Dep<Database>) -> usize {
        println!("step dep");
        0
    }

    let e = new_imperative_builder()
        .add_step("example step", missing_dep_step)
        .execute()
        .await
        .expect_err("should have failed");
    assert!(matches!(e, BuilderError::DepResolution(_)), "{e:?}");
}

#[derive(Error, Debug, PartialEq, Eq)]
enum Error {
    #[error("uhoh")]
    TestOne,
}

impl IntoStepOutcome for Error {
    fn error(self) -> Option<Box<dyn std::error::Error + Send + Sync>> {
        Some(Box::new(self))
    }

    fn success(&self) -> bool {
        false
    }
}

// a step with an error should yield an error on execute
#[tokio::test]
async fn fail_step_yields_error() {
    async fn fail_step() -> std::result::Result<(), Error> {
        Err(Error::TestOne)
    }

    let name = "fatal step".to_string();
    let e = new_imperative_builder()
        .add_step(&name, fail_step)
        .execute()
        .await
        .expect_err("should have failed");

    match e {
        BuilderError::Step(msg, e) => {
            assert!(
                e.downcast::<Error>().ok() == Some(Box::new(Error::TestOne)),
                "error msg: {msg:?}",
            )
        }
        other => panic!("unexpected error: {other:?}"),
    }
}

// a step with an error should not execute other steps
#[tokio::test]
async fn fail_step_stops_execution() {
    static CNT: LazyLock<AtomicUsize> = LazyLock::new(|| AtomicUsize::new(0));
    new_imperative_builder()
        .add_step("one", async move || {
            CNT.fetch_add(1, Ordering::Relaxed);
            Ok(())
        })
        .add_step("two", async || Err(Error::TestOne))
        .add_step("three", async || {
            CNT.fetch_add(1, Ordering::Relaxed);
            Ok(())
        })
        .add_step("four", async || {
            CNT.fetch_add(1, Ordering::Relaxed);
            Ok(())
        })
        .execute()
        .await
        .expect_err("should have failed");

    assert_eq!(CNT.load(Ordering::Relaxed), 1);
}