ito-core 0.1.29

Core functionality and business logic for Ito
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::orchestrate::plan::PlannedGate;
use crate::orchestrate::types::GatePolicy;

pub(crate) const GATE_APPLY_COMPLETE: &str = "apply-complete";
pub(crate) const GATE_FORMAT: &str = "format";
pub(crate) const GATE_LINT: &str = "lint";
pub(crate) const GATE_TESTS: &str = "tests";
pub(crate) const GATE_STYLE: &str = "style";
pub(crate) const GATE_CODE_REVIEW: &str = "code-review";
pub(crate) const GATE_SECURITY_REVIEW: &str = "security-review";

/// Default orchestrator gate order.
pub fn default_gate_order() -> Vec<String> {
    vec![
        GATE_APPLY_COMPLETE.to_string(),
        GATE_FORMAT.to_string(),
        GATE_LINT.to_string(),
        GATE_TESTS.to_string(),
        GATE_STYLE.to_string(),
        GATE_CODE_REVIEW.to_string(),
        GATE_SECURITY_REVIEW.to_string(),
    ]
}

/// Minimal remediation payload constructed after a gate failure.
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct RemediationPacket {
    /// Canonical change id.
    pub change_id: String,
    /// Gate that failed.
    pub failed_gate: String,
    /// Error payload captured from the gate.
    pub error: String,
    /// Gate names to rerun (failed gate + downstream run gates).
    pub rerun_gates: Vec<String>,
}

/// Construct a remediation packet for a specific gate failure.
pub fn remediation_packet_for_failure(
    change_id: &str,
    gates: &[PlannedGate],
    failed_gate: &str,
    error: &str,
) -> RemediationPacket {
    let mut rerun = Vec::new();
    let mut found = false;
    for gate in gates {
        if gate.name == failed_gate {
            found = true;
            // Always include the failed gate itself, even if its policy
            // was Skip — remediation must rerun what actually failed.
            rerun.push(gate.name.clone());
            continue;
        }
        if found && gate.policy == GatePolicy::Run {
            rerun.push(gate.name.clone());
        }
    }

    RemediationPacket {
        change_id: change_id.to_string(),
        failed_gate: failed_gate.to_string(),
        error: error.to_string(),
        rerun_gates: rerun,
    }
}

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

    fn gate(name: &str, policy: GatePolicy) -> PlannedGate {
        PlannedGate {
            name: name.to_string(),
            policy,
        }
    }

    #[test]
    fn remediation_includes_failed_gate_and_downstream_run_gates() {
        let gates = vec![
            gate("apply-complete", GatePolicy::Run),
            gate("format", GatePolicy::Run),
            gate("tests", GatePolicy::Run),
            gate("code-review", GatePolicy::Run),
        ];

        let pkt = remediation_packet_for_failure("001-01_demo", &gates, "tests", "boom");
        assert_eq!(pkt.change_id, "001-01_demo");
        assert_eq!(pkt.failed_gate, "tests");
        assert_eq!(pkt.error, "boom");
        assert_eq!(
            pkt.rerun_gates,
            vec!["tests".to_string(), "code-review".to_string()]
        );
    }

    #[test]
    fn remediation_includes_failed_gate_even_when_policy_is_skip() {
        let gates = vec![
            gate("apply-complete", GatePolicy::Run),
            gate("tests", GatePolicy::Skip),
            gate("code-review", GatePolicy::Run),
        ];

        let pkt = remediation_packet_for_failure("001-01_demo", &gates, "tests", "boom");
        assert_eq!(
            pkt.rerun_gates,
            vec!["tests".to_string(), "code-review".to_string()]
        );
    }

    #[test]
    fn remediation_skips_downstream_skip_gates() {
        let gates = vec![
            gate("apply-complete", GatePolicy::Run),
            gate("tests", GatePolicy::Run),
            gate("style", GatePolicy::Skip),
            gate("code-review", GatePolicy::Run),
        ];

        let pkt = remediation_packet_for_failure("001-01_demo", &gates, "tests", "boom");
        assert_eq!(
            pkt.rerun_gates,
            vec!["tests".to_string(), "code-review".to_string()]
        );
    }

    #[test]
    fn remediation_returns_empty_when_failed_gate_not_found() {
        let gates = vec![
            gate("apply-complete", GatePolicy::Run),
            gate("tests", GatePolicy::Run),
        ];

        let pkt = remediation_packet_for_failure("001-01_demo", &gates, "unknown-gate", "boom");
        assert!(pkt.rerun_gates.is_empty());
    }
}