wfe-core 1.9.2

Core traits, models, builder, and executor for the WFE workflow engine
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

use async_trait::async_trait;

use crate::models::{ExecutionResult, WorkflowInstance};
use crate::traits::step::StepExecutionContext;

/// Workflow-level middleware with default no-op implementations.
#[async_trait]
pub trait WorkflowMiddleware: Send + Sync {
    async fn pre_workflow(&self, _instance: &WorkflowInstance) -> crate::Result<()> {
        Ok(())
    }
    async fn post_workflow(&self, _instance: &WorkflowInstance) -> crate::Result<()> {
        Ok(())
    }
}

/// Step-level middleware with default no-op implementations.
#[async_trait]
pub trait StepMiddleware: Send + Sync {
    async fn pre_step(&self, _context: &StepExecutionContext<'_>) -> crate::Result<()> {
        Ok(())
    }
    async fn post_step(
        &self,
        _context: &StepExecutionContext<'_>,
        _result: &ExecutionResult,
    ) -> crate::Result<()> {
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::models::{ExecutionPointer, ExecutionResult, WorkflowInstance};

    struct NoOpWorkflowMiddleware;
    impl WorkflowMiddleware for NoOpWorkflowMiddleware {}

    struct NoOpStepMiddleware;
    impl StepMiddleware for NoOpStepMiddleware {}

    #[tokio::test]
    async fn workflow_middleware_default_pre_workflow() {
        let mw = NoOpWorkflowMiddleware;
        let instance = WorkflowInstance::new("wf", 1, serde_json::json!({}));
        mw.pre_workflow(&instance).await.unwrap();
    }

    #[tokio::test]
    async fn workflow_middleware_default_post_workflow() {
        let mw = NoOpWorkflowMiddleware;
        let instance = WorkflowInstance::new("wf", 1, serde_json::json!({}));
        mw.post_workflow(&instance).await.unwrap();
    }

    #[tokio::test]
    async fn step_middleware_default_pre_step() {
        use crate::models::WorkflowStep;
        let mw = NoOpStepMiddleware;
        let instance = WorkflowInstance::new("wf", 1, serde_json::json!({}));
        let pointer = ExecutionPointer::new(0);
        let step = WorkflowStep::new(0, "test_step");
        let ctx = StepExecutionContext {
            definition: None,
            item: None,
            execution_pointer: &pointer,
            persistence_data: None,
            step: &step,
            workflow: &instance,
            cancellation_token: tokio_util::sync::CancellationToken::new(),
            host_context: None,
            log_sink: None,
        };
        mw.pre_step(&ctx).await.unwrap();
    }

    #[tokio::test]
    async fn step_middleware_default_post_step() {
        use crate::models::WorkflowStep;
        let mw = NoOpStepMiddleware;
        let instance = WorkflowInstance::new("wf", 1, serde_json::json!({}));
        let pointer = ExecutionPointer::new(0);
        let step = WorkflowStep::new(0, "test_step");
        let ctx = StepExecutionContext {
            definition: None,
            item: None,
            execution_pointer: &pointer,
            persistence_data: None,
            step: &step,
            workflow: &instance,
            cancellation_token: tokio_util::sync::CancellationToken::new(),
            host_context: None,
            log_sink: None,
        };
        let result = ExecutionResult::next();
        mw.post_step(&ctx, &result).await.unwrap();
    }
}