astro-run 1.0.0

A highly customizable workflow orchestrator
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

use crate::{Result, UserActionStep, UserStep};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, fmt::Debug, sync::Arc};

#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct ActionSteps {
  pub pre: Option<UserStep>,
  pub run: UserStep,
  pub post: Option<UserStep>,
}

pub trait Action: Send + Sync {
  fn normalize(&self, step: UserActionStep) -> Result<ActionSteps>;
}

pub type SharedActionDriver = Arc<ActionDriver>;

#[derive(Clone)]
pub struct ActionDriver {
  actions: Arc<HashMap<String, Box<dyn Action>>>,
}

impl ActionDriver {
  pub fn new(actions: HashMap<String, Box<dyn Action>>) -> Self {
    Self {
      actions: Arc::new(actions),
    }
  }

  pub fn try_normalize(&self, step: UserActionStep) -> Result<Option<ActionSteps>> {
    if let Some(action) = &self.actions.get(&step.uses) {
      let normalized = action.normalize(step)?;

      Ok(Some(normalized))
    } else {
      Ok(None)
    }
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::UserCommandStep;

  #[test]
  fn test_normalize_step_actions() -> Result<()> {
    struct CacheAction {}

    impl Action for CacheAction {
      fn normalize(&self, _step: UserActionStep) -> Result<ActionSteps> {
        Ok(ActionSteps {
          pre: None,
          run: UserStep::Command(UserCommandStep {
            name: Some("Restore cache".to_string()),
            run: "restore cache".to_string(),
            ..Default::default()
          }),
          post: Some(UserStep::Command(UserCommandStep {
            name: Some("Save cache".to_string()),
            run: "save cache".to_string(),
            ..Default::default()
          })),
        })
      }
    }

    let mut actions = HashMap::new();

    actions.insert(
      "caches".to_string(),
      Box::new(CacheAction {}) as Box<dyn Action>,
    );

    let actions = ActionDriver::new(actions);

    let test_step = UserActionStep {
      uses: "caches".to_string(),
      ..Default::default()
    };

    let steps = actions.try_normalize(test_step)?.unwrap();

    assert!(steps.pre.is_none());

    if let UserStep::Command(step) = steps.run {
      assert_eq!(step.name, Some("Restore cache".to_string()));
      assert_eq!(step.run, "restore cache".to_string());
    } else {
      panic!("Should be command step");
    }

    if let Some(UserStep::Command(step)) = steps.post {
      assert_eq!(step.name, Some("Save cache".to_string()));
      assert_eq!(step.run, "save cache".to_string());
    } else {
      panic!("Should be command step");
    }

    Ok(())
  }

  #[test]
  fn test_not_exists_action() -> Result<()> {
    let actions = HashMap::new();

    let actions = ActionDriver::new(actions);

    let step = UserActionStep {
      uses: "not-exists-action".to_string(),
      ..Default::default()
    };

    let result = actions.try_normalize(step).unwrap();

    assert!(result.is_none(),);

    Ok(())
  }
}