operonx 0.7.1

High-performance Rust execution backend for Operon workflows
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

//! Runtime graph validation.
//!
//! Mirrors Python [`operonx/core/ops/graph/validation.py`](../../../../../operonx/core/ops/graph/validation.py).
//! Checks: unresolvable refs, cycles in compiled adjacency, unreachable
//! entries/exits, unknown edge endpoints, branch targets.
//!
//! # Phase 4 scope
//! Minimal: only the checks the scheduler relies on at startup. Full
//! parity with the Python validator (cycle detection, ref-scope walks, etc.)
//! is deferred to Phase 9 alongside the spec fixture suite.

use std::collections::HashSet;

use crate::core::configs::op_config::{OpConfig, OpType};
use crate::core::exceptions::OperonError;

/// Run the minimum set of structural checks on a graph config.
///
/// Returns `Ok(())` if the graph is dispatchable — unknown adjacency targets,
/// missing entry/exit declarations, and duplicate op names are all rejected.
pub fn validate_graph(graph: &OpConfig) -> Result<(), OperonError> {
    if !matches!(graph.kind, OpType::Graph) {
        return Err(OperonError::Config(format!(
            "validate_graph: expected type=\"graph\", got {:?}",
            graph.kind
        )));
    }
    if graph.entries.is_empty() {
        return Err(OperonError::Config(format!(
            "graph '{}': no entry ops declared",
            graph.name
        )));
    }
    let op_names: HashSet<&str> = graph.ops.keys().map(String::as_str).collect();
    for entry in &graph.entries {
        if !op_names.contains(entry.as_str()) {
            return Err(OperonError::Config(format!(
                "graph '{}': entry '{}' not in ops",
                graph.name, entry
            )));
        }
    }
    for exit in &graph.exits {
        if !op_names.contains(exit.as_str()) {
            return Err(OperonError::Config(format!(
                "graph '{}': exit '{}' not in ops",
                graph.name, exit
            )));
        }
    }
    for (src, links) in &graph.compiled_adj {
        if !op_names.contains(src.as_str()) {
            return Err(OperonError::Config(format!(
                "graph '{}': compiled_adj source '{}' not in ops",
                graph.name, src
            )));
        }
        for link in links {
            if !op_names.contains(link.dst.as_str()) {
                return Err(OperonError::Config(format!(
                    "graph '{}': edge {}→{} — destination not in ops",
                    graph.name, src, link.dst
                )));
            }
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::configs::op_config::{CompiledLink, OpConfig, OpType};
    use std::collections::BTreeMap;

    fn graph_with_ops(entries: Vec<&str>, exits: Vec<&str>, ops: &[&str]) -> OpConfig {
        let mut g = OpConfig {
            kind: OpType::Graph,
            name: "main".into(),
            full_name: "main".into(),
            entries: entries.iter().map(|s| s.to_string()).collect(),
            exits: exits.iter().map(|s| s.to_string()).collect(),
            ..Default::default()
        };
        for op in ops {
            g.ops.insert(
                op.to_string(),
                OpConfig {
                    kind: OpType::Code,
                    name: op.to_string(),
                    full_name: format!("main.{}", op),
                    ..Default::default()
                },
            );
        }
        g
    }

    #[test]
    fn rejects_non_graph_root() {
        let mut cfg = OpConfig::default();
        cfg.kind = OpType::Code;
        assert!(validate_graph(&cfg).is_err());
    }

    #[test]
    fn rejects_missing_entry() {
        let g = graph_with_ops(vec![], vec![], &[]);
        assert!(validate_graph(&g).is_err());
    }

    #[test]
    fn rejects_unknown_entry() {
        let g = graph_with_ops(vec!["ghost"], vec!["a"], &["a"]);
        assert!(validate_graph(&g).is_err());
    }

    #[test]
    fn rejects_unknown_edge_target() {
        let mut g = graph_with_ops(vec!["a"], vec!["a"], &["a"]);
        let mut adj = BTreeMap::new();
        adj.insert(
            "a".into(),
            vec![CompiledLink {
                dst: "b".into(),
                soft: false,
            }],
        );
        g.compiled_adj = adj;
        assert!(validate_graph(&g).is_err());
    }

    #[test]
    fn accepts_valid_graph() {
        let g = graph_with_ops(vec!["a"], vec!["a"], &["a"]);
        validate_graph(&g).unwrap();
    }
}