oatf 0.4.0

Rust SDK for the Open Agent Threat Format (OATF)
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

use super::common::values_structurally_equal;
use oatf::normalize::normalize;
use oatf::parse::parse;
use oatf::serialize::serialize;
use std::path::PathBuf;

fn conformance_dir() -> PathBuf {
    std::env::var("OATF_CONFORMANCE_DIR")
        .map(PathBuf::from)
        .unwrap_or_else(|_| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("spec/conformance"))
}

#[derive(Debug, serde::Deserialize)]
struct TestCase {
    name: String,
    id: String,
    input: String,
    expected: Expected,
}

#[derive(Debug, serde::Deserialize)]
struct Expected {
    identical: bool,
}

#[test]
fn roundtrip_conformance_suite() {
    let suite_path = conformance_dir().join("roundtrip/suite.yaml");
    assert!(
        suite_path.exists(),
        "Conformance fixture not found: {:?}. Is the spec submodule initialized?",
        suite_path
    );

    let content = std::fs::read_to_string(&suite_path).unwrap();
    let cases: Vec<TestCase> = serde_saphyr::from_str(&content).unwrap();

    let mut passed = 0;
    let mut failed = 0;

    for case in &cases {
        if !case.expected.identical {
            // Skip cases that are not expected to be identical
            continue;
        }

        // Step 1: parse -> normalize
        let doc1 = match parse(&case.input) {
            Ok(d) => d,
            Err(e) => {
                eprintln!(
                    "  FAIL [{}] {}: initial parse error: {}",
                    case.id, case.name, e
                );
                failed += 1;
                continue;
            }
        };
        let norm1 = normalize(doc1);

        // Step 2: serialize
        let yaml1 = match serialize(&norm1) {
            Ok(y) => y,
            Err(e) => {
                eprintln!("  FAIL [{}] {}: serialize error: {}", case.id, case.name, e);
                failed += 1;
                continue;
            }
        };

        // Step 3: parse again -> normalize again
        let doc2 = match parse(&yaml1) {
            Ok(d) => d,
            Err(e) => {
                eprintln!("  FAIL [{}] {}: re-parse error: {}", case.id, case.name, e);
                eprintln!("    Serialized YAML:\n{}", yaml1);
                failed += 1;
                continue;
            }
        };
        let norm2 = normalize(doc2);

        // Step 4: compare structurally
        let val1 = serde_json::to_value(&norm1).unwrap();
        let val2 = serde_json::to_value(&norm2).unwrap();

        if values_structurally_equal(&val1, &val2) {
            passed += 1;
        } else {
            eprintln!("  FAIL [{}] {}: round-trip mismatch", case.id, case.name);
            eprintln!(
                "    First normalize:  {}",
                serde_json::to_string_pretty(&val1).unwrap()
            );
            eprintln!(
                "    Second normalize: {}",
                serde_json::to_string_pretty(&val2).unwrap()
            );
            failed += 1;
        }
    }

    eprintln!(
        "\nRound-trip conformance: {} passed, {} failed out of {} total",
        passed,
        failed,
        cases.len()
    );

    assert_eq!(failed, 0, "{} round-trip conformance tests failed", failed);
}