txtx-core 0.4.4

Primitives for parsing, analyzing and executing Txtx runbooks
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 txtx_addon_kit::types::{
    frontend::{
        ActionItemResponse, ActionItemResponseType, ActionItemStatus, ProvidedInputResponse,
        ReviewedInputResponse,
    },
    types::Value,
};
use txtx_addon_kit::{types::block_id::BlockId, Addon};
use txtx_test_utils::test_harness::setup_test;

use crate::std::StdAddon;

pub fn get_addon_by_namespace(namespace: &str) -> Option<Box<dyn Addon>> {
    let available_addons: Vec<Box<dyn Addon>> = vec![Box::new(StdAddon::new())];
    for addon in available_addons.into_iter() {
        if namespace.starts_with(&format!("{}", addon.get_namespace())) {
            return Some(addon);
        }
    }
    None
}

#[test]
fn test_ab_c_runbook_no_env() {
    // Load Runbook ab_c.tx
    let abc_tx = include_str!("./fixtures/ab_c.tx");

    let harness = setup_test("ab_c.tx", &abc_tx, get_addon_by_namespace);

    // runbook checklist assertions
    {
        let action_panel_data =
            harness.expect_action_panel(None, "runbook checklist", vec![vec![1]]);

        let validate_button = &action_panel_data.groups[0].sub_groups[0].action_items[0];

        let start_runbook = &action_panel_data.groups[0].sub_groups[0].action_items[0];
        // assert_eq!(start_runbook.action_status, ActionItemStatus::Success(None));
        assert_eq!(start_runbook.construct_instance_name.to_uppercase(), "START RUNBOOK");

        // Complete start_runbook action
        harness.send_and_expect_action_item_update(
            ActionItemResponse {
                action_item_id: start_runbook.id.clone(),
                payload: ActionItemResponseType::ValidateBlock,
            },
            vec![(&validate_button.id, Some(ActionItemStatus::Success(None)))],
        );
    }
    // Review inputs assertions
    {
        let inputs_panel_data =
            harness.expect_action_panel(None, "variables review", vec![vec![2, 1]]);

        let input_a_action = &inputs_panel_data.groups[0].sub_groups[0].action_items[0];
        let input_b_action = &inputs_panel_data.groups[0].sub_groups[0].action_items[1];

        assert_eq!(&input_a_action.internal_key, "check_input");
        assert_eq!(&input_b_action.internal_key, "provide_input");

        harness.send_and_expect_progress_bar_visibility_update(
            ActionItemResponse {
                action_item_id: input_a_action.id.clone(),
                payload: ActionItemResponseType::ReviewInput(ReviewedInputResponse {
                    value_checked: true,
                    input_name: "value".into(),
                    force_execution: false,
                }),
            },
            false,
        );
        // review input a and expect action item update
        harness.expect_action_item_update(
            None,
            vec![(&input_a_action.id, Some(ActionItemStatus::Success(None)))],
        );

        // Should be a no-op
        harness.expect_noop();

        // provide input b and expect no update
        harness.send(&ActionItemResponse {
            action_item_id: input_b_action.id.clone(),
            payload: ActionItemResponseType::ProvideInput(ProvidedInputResponse {
                updated_value: Value::integer(5),
                input_name: "value".into(),
            }),
        });
        // review input b and expect action item update
        harness.send_and_expect_action_item_update(
            ActionItemResponse {
                action_item_id: input_b_action.id.clone(),
                payload: ActionItemResponseType::ReviewInput(ReviewedInputResponse {
                    value_checked: true,
                    input_name: "value".into(),
                    force_execution: false,
                }),
            },
            vec![(&input_b_action.id, Some(ActionItemStatus::Success(None)))],
        );

        // our validate block button yields another action item update for input b, but it would be filtered
        // out from being propagated to the frontend... we should probably update tests to check this
        harness.send_and_expect_action_item_update(
            ActionItemResponse {
                action_item_id: BlockId::new(&vec![]),
                payload: ActionItemResponseType::ValidateBlock,
            },
            vec![(&input_b_action.id, Some(ActionItemStatus::Success(None)))],
        );
    }

    // assert output review
    {
        harness.expect_action_panel(None, "output review", vec![vec![1]]);
    }

    harness.expect_progress_bar_visibility_update(None, false);
    harness.expect_runbook_complete();
}