netsuke-build 0.1.0-beta2

A YAML-powered Ninja/Jinja hybrid build system.
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Generated invariants for manifest foreach expansion.
//!
//! The fixed cases pin specific regressions, while these properties vary
//! sequence values, filtering, variable collisions, and source key order.

use super::*;
use minijinja::Environment;
use proptest::prelude::*;

proptest! {
    /// Expansion preserves a leading non-object entry and expands each value.
    #[test]
    fn foreach_expands_generated_sequence_values(values in proptest::collection::vec(-100_i16..100, 1..8)) {
        let env = Environment::new();
        let yaml = format!(
            "targets:\n  - bare-string\n  - name: generated\n    foreach: {values:?}\n    command: echo {{{{ item }}}}"
        );
        let mut doc: ManifestValue = serde_saphyr::from_str(&yaml)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        expand_foreach(&mut doc, &env)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let expanded = targets(&doc).map_err(|error| TestCaseError::fail(error.to_string()))?;

        prop_assert_eq!(expanded.len(), values.len() + 1);
        prop_assert_eq!(expanded.first().and_then(ManifestValue::as_str), Some("bare-string"));
        for (index, (entry, value)) in expanded.iter().skip(1).zip(&values).enumerate() {
            let map = entry.as_object().ok_or_else(|| {
                TestCaseError::fail(format!("expanded entry {index} should be an object: {entry:?}"))
            })?;
            prop_assert!(!map.contains_key("foreach"));
            prop_assert_eq!(map.get("name").and_then(ManifestValue::as_str), Some("generated"));
            let vars = map.get("vars").and_then(ManifestValue::as_object).ok_or_else(|| {
                TestCaseError::fail(format!("expanded entry {index} should contain vars: {map:?}"))
            })?;
            prop_assert_eq!(vars.get("item").and_then(ManifestValue::as_i64), Some(i64::from(*value)));
            prop_assert_eq!(vars.get("index").and_then(ManifestValue::as_u64), Some(index as u64));
        }
    }

    /// Iteration values override colliding entry vars while other vars survive.
    #[test]
    fn foreach_generated_iteration_values_override_entry_vars(
        values in proptest::collection::vec("[a-z]{1,6}", 1..8),
        entry_item in "[a-z]{1,6}",
        other_value in "[a-z]{1,6}",
    ) {
        let env = Environment::new();
        let foreach = serde_json::to_string(&values)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let entry_item_json = serde_json::to_string(&entry_item)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let other = serde_json::to_string(&other_value)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let yaml = format!(
            "targets:\n  - name: variables\n    foreach: {foreach}\n    vars:\n      item: {entry_item_json}\n      other: {other}"
        );
        let mut doc: ManifestValue = serde_saphyr::from_str(&yaml)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        expand_foreach(&mut doc, &env)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let expanded = targets(&doc).map_err(|error| TestCaseError::fail(error.to_string()))?;

        prop_assert_eq!(expanded.len(), values.len());
        for (index, (entry, value)) in expanded.iter().zip(&values).enumerate() {
            let map = entry.as_object().ok_or_else(|| {
                TestCaseError::fail(format!("expanded entry {index} should be an object: {entry:?}"))
            })?;
            let vars = map.get("vars").and_then(ManifestValue::as_object).ok_or_else(|| {
                TestCaseError::fail(format!("expanded entry {index} should contain vars: {map:?}"))
            })?;
            prop_assert_eq!(vars.get("item").and_then(ManifestValue::as_str), Some(value.as_str()));
            prop_assert_eq!(vars.get("other").and_then(ManifestValue::as_str), Some(other_value.as_str()));
            prop_assert_eq!(vars.get("index").and_then(ManifestValue::as_u64), Some(index as u64));
        }
    }

    /// Filtering preserves original indexes for every generated input sequence.
    #[test]
    fn foreach_filters_generated_sequence_values(
        values in proptest::collection::vec(-20_i16..21, 0..8),
        threshold in -20_i16..21,
    ) {
        let env = Environment::new();
        let yaml = format!(
            "targets:\n  - name: filtered\n    foreach: {values:?}\n    when: 'item > {threshold}'"
        );
        let mut doc: ManifestValue = serde_saphyr::from_str(&yaml)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        expand_foreach(&mut doc, &env)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let expanded = targets(&doc).map_err(|error| TestCaseError::fail(error.to_string()))?;
        let expected: Vec<_> = values
            .iter()
            .enumerate()
            .filter(|(_, value)| **value > threshold)
            .collect();

        prop_assert_eq!(expanded.len(), expected.len());
        for (entry, (index, value)) in expanded.iter().zip(expected) {
            let map = entry.as_object().ok_or_else(|| {
                TestCaseError::fail(format!("filtered entry should be an object: {entry:?}"))
            })?;
            prop_assert!(!map.contains_key("foreach"));
            let vars = map.get("vars").and_then(ManifestValue::as_object).ok_or_else(|| {
                TestCaseError::fail(format!("filtered entry should contain vars: {map:?}"))
            })?;
            prop_assert_eq!(vars.get("item").and_then(ManifestValue::as_i64), Some(i64::from(*value)));
            prop_assert_eq!(vars.get("index").and_then(ManifestValue::as_u64), Some(index as u64));
        }
    }

    /// Expansion removes `foreach` without reordering user-specified map keys.
    #[test]
    fn foreach_preserves_generated_source_key_order(order in prop_oneof![
        Just(vec!["name", "vars", "after"]),
        Just(vec!["name", "after", "vars"]),
        Just(vec!["vars", "name", "after"]),
        Just(vec!["vars", "after", "name"]),
        Just(vec!["after", "name", "vars"]),
        Just(vec!["after", "vars", "name"]),
    ]) {
        let env = Environment::new();
        let mut yaml = String::from("targets:\n");
        for (index, key) in order.iter().enumerate() {
            yaml.push_str(if index == 0 { "  - " } else { "    " });
            match *key {
                "name" => yaml.push_str("name: ordered\n"),
                "vars" => yaml.push_str("vars:\n      static: keep\n"),
                "after" => yaml.push_str("after: done\n"),
                _ => return Err(TestCaseError::fail("property strategy produced an unknown key".to_owned())),
            }
        }
        yaml.push_str("    foreach: [value]");
        let mut doc: ManifestValue = serde_saphyr::from_str(&yaml)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        expand_foreach(&mut doc, &env)
            .map_err(|error| TestCaseError::fail(error.to_string()))?;
        let expanded = targets(&doc).map_err(|error| TestCaseError::fail(error.to_string()))?;

        prop_assert_eq!(expanded.len(), 1);
        let entry = expanded.first().ok_or_else(|| {
            TestCaseError::fail("expected one expanded target after length check".to_owned())
        })?;
        let map = entry.as_object().ok_or_else(|| {
            TestCaseError::fail(format!("expanded target should be an object: {entry:?}"))
        })?;
        let keys: Vec<_> = map.keys().map(String::as_str).collect();
        prop_assert_eq!(keys, order);
    }
}