sagiegurari / cargo-make
1
use super::*;
2

3
use envmnt;
4

5
#[test]
6
#[should_panic]
7 8
fn decode_invoke_empty() {
8 8
    invoke(&vec![]);
9 0
}
10

11
#[test]
12 8
fn decode_invoke_only_source_not_found() {
13 8
    envmnt::remove("TEST_DECODE_ONLY_SOURCE_NOT_DEFINED");
14

15 8
    let output = invoke(&vec!["TEST_DECODE_ONLY_SOURCE_NOT_DEFINED".to_string()]);
16

17 8
    assert_eq!(output.len(), 0);
18 8
}
19

20
#[test]
21 8
fn decode_invoke_only_source_found_empty() {
22 8
    envmnt::set("TEST_DECODE_ONLY_SOURCE_DEFINED_EMPTY", "");
23

24 8
    let output = invoke(&vec!["TEST_DECODE_ONLY_SOURCE_DEFINED_EMPTY".to_string()]);
25

26 8
    assert_eq!(output.len(), 0);
27 8
}
28

29
#[test]
30 8
fn decode_invoke_only_source_found_value() {
31 8
    envmnt::set("TEST_DECODE_ONLY_SOURCE_DEFINED_VALUE", "test");
32

33 8
    let output = invoke(&vec!["TEST_DECODE_ONLY_SOURCE_DEFINED_VALUE".to_string()]);
34

35 8
    assert_eq!(output, vec!["test"]);
36 8
}
37

38
#[test]
39 8
fn decode_invoke_only_default_empty() {
40 8
    envmnt::set("TEST_DECODE_ONLY_DEFAULT_EMPTY", "test");
41

42 8
    let output = invoke(&vec![
43 8
        "TEST_DECODE_ONLY_DEFAULT_EMPTY".to_string(),
44 8
        "".to_string(),
45 2
    ]);
46

47 8
    assert_eq!(output.len(), 0);
48 8
}
49

50
#[test]
51 8
fn decode_invoke_only_default_value() {
52 8
    envmnt::set("TEST_DECODE_ONLY_DEFAULT_VALUE", "test");
53

54 8
    let output = invoke(&vec![
55 8
        "TEST_DECODE_ONLY_DEFAULT_VALUE".to_string(),
56 8
        "default".to_string(),
57 2
    ]);
58

59 8
    assert_eq!(output, vec!["default"]);
60 8
}
61

62
#[test]
63 8
fn decode_invoke_only_default_eval_value() {
64 8
    envmnt::set("TEST_DECODE_ONLY_DEFAULT_EVAL_VALUE", "test");
65 8
    envmnt::set("TEST_DECODE_ONLY_DEFAULT_EVAL_VALUE_RESULT", "result");
66

67 8
    let output = invoke(&vec![
68 8
        "TEST_DECODE_ONLY_DEFAULT_EVAL_VALUE".to_string(),
69 8
        "${TEST_DECODE_ONLY_DEFAULT_EVAL_VALUE_RESULT}-test".to_string(),
70 2
    ]);
71

72 8
    assert_eq!(output, vec!["result-test"]);
73 8
}
74

75
#[test]
76 8
fn decode_invoke_mappings_not_found_use_source() {
77 8
    envmnt::set("TEST_DECODE_MAPPINGS_NOT_FOUND_USE_SOURCE", "source");
78

79 8
    let output = invoke(&vec![
80 8
        "TEST_DECODE_MAPPINGS_NOT_FOUND_USE_SOURCE".to_string(),
81 8
        "key1".to_string(),
82 8
        "value1".to_string(),
83 8
        "key2".to_string(),
84 8
        "value2".to_string(),
85 2
    ]);
86

87 8
    assert_eq!(output, vec!["source"]);
88 8
}
89

90
#[test]
91 8
fn decode_invoke_mappings_not_found_use_default() {
92 8
    envmnt::set("TEST_DECODE_MAPPINGS_NOT_FOUND_USE_DEFAULT", "source");
93

94 8
    let output = invoke(&vec![
95 8
        "TEST_DECODE_MAPPINGS_NOT_FOUND_USE_DEFAULT".to_string(),
96 8
        "key1".to_string(),
97 8
        "value1".to_string(),
98 8
        "key2".to_string(),
99 8
        "value2".to_string(),
100 8
        "default".to_string(),
101 2
    ]);
102

103 8
    assert_eq!(output, vec!["default"]);
104 8
}
105

106
#[test]
107 8
fn decode_invoke_mappings_found_no_default() {
108 8
    envmnt::set("TEST_DECODE_MAPPINGS_FOUND_NO_DEFAULT", "key2");
109

110 8
    let output = invoke(&vec![
111 8
        "TEST_DECODE_MAPPINGS_FOUND_NO_DEFAULT".to_string(),
112 8
        "key1".to_string(),
113 8
        "value1".to_string(),
114 8
        "key2".to_string(),
115 8
        "value2".to_string(),
116 2
    ]);
117

118 8
    assert_eq!(output, vec!["value2"]);
119 8
}
120

121
#[test]
122 8
fn decode_invoke_mappings_found_with_default() {
123 8
    envmnt::set("TEST_DECODE_MAPPINGS_FOUND_WITH_DEFAULT", "key2");
124

125 8
    let output = invoke(&vec![
126 8
        "TEST_DECODE_MAPPINGS_FOUND_WITH_DEFAULT".to_string(),
127 8
        "key1".to_string(),
128 8
        "value1".to_string(),
129 8
        "key2".to_string(),
130 8
        "value2".to_string(),
131 8
        "default".to_string(),
132 2
    ]);
133

134 8
    assert_eq!(output, vec!["value2"]);
135 8
}
136

137
#[test]
138 8
fn decode_invoke_mappings_found_eval_output() {
139 8
    envmnt::set("TEST_DECODE_MAPPINGS_FOUND_EVAL_OUTPUT", "key2");
140 8
    envmnt::set("TEST_DECODE_MAPPINGS_FOUND_EVAL_OUTPUT_VALUE", "value2");
141

142 8
    let output = invoke(&vec![
143 8
        "TEST_DECODE_MAPPINGS_FOUND_EVAL_OUTPUT".to_string(),
144 8
        "key1".to_string(),
145 8
        "value1".to_string(),
146 8
        "key2".to_string(),
147 8
        "${TEST_DECODE_MAPPINGS_FOUND_EVAL_OUTPUT_VALUE}-output".to_string(),
148 8
        "default".to_string(),
149 2
    ]);
150

151 8
    assert_eq!(output, vec!["value2-output"]);
152 8
}

Read our documentation on viewing source code .

Loading