apcore-cli 0.7.0

Command-line interface for apcore modules
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

// apcore-cli — Integration tests for JSON Schema $ref inliner.
// Protocol spec: FE-08

mod common;

use apcore_cli::ref_resolver::{resolve_refs, RefResolverError};
use serde_json::json;

#[test]
fn test_resolve_refs_no_refs_returns_unchanged() {
    let schema = json!({
        "type": "object",
        "properties": {
            "name": {"type": "string"}
        }
    });
    let resolved = resolve_refs(&schema, 10, "test.module");
    assert!(
        resolved.is_ok(),
        "schema with no $refs must resolve successfully"
    );
    let resolved = resolved.unwrap();
    assert_eq!(
        resolved["properties"]["name"]["type"],
        json!("string"),
        "schema must remain unchanged"
    );
}

#[test]
fn test_resolve_refs_simple_inline() {
    let schema = json!({
        "$defs": {
            "MyString": {"type": "string", "description": "A name"}
        },
        "type": "object",
        "properties": {
            "name": {"$ref": "#/$defs/MyString"}
        }
    });
    let resolved = resolve_refs(&schema, 10, "test.module");
    assert!(resolved.is_ok(), "simple $ref must resolve successfully");
    let resolved = resolved.unwrap();
    assert_eq!(
        resolved["properties"]["name"]["type"],
        json!("string"),
        "inlined $ref must have type=string"
    );
}

#[test]
fn test_resolve_refs_unresolvable_returns_error() {
    let schema = json!({
        "type": "object",
        "properties": {
            "x": {"$ref": "#/$defs/DoesNotExist"}
        }
    });
    let result = resolve_refs(&schema, 10, "test.module");
    assert!(matches!(result, Err(RefResolverError::Unresolvable { .. })));
}

#[test]
fn test_resolve_refs_circular_returns_error() {
    // A → B → A must produce a Circular or MaxDepthExceeded error.
    let schema = json!({
        "$defs": {
            "A": {"$ref": "#/$defs/B"},
            "B": {"$ref": "#/$defs/A"}
        },
        "type": "object",
        "properties": {
            "x": {"$ref": "#/$defs/A"}
        }
    });
    let result = resolve_refs(&schema, 20, "test.module");
    assert!(
        matches!(
            result,
            Err(RefResolverError::Circular { .. }) | Err(RefResolverError::MaxDepthExceeded { .. })
        ),
        "circular $ref must produce Circular or MaxDepthExceeded error, got: {result:?}"
    );
}

#[test]
fn test_resolve_refs_max_depth_exceeded() {
    // max_depth=1 on a 2-level schema must return MaxDepthExceeded.
    let schema = json!({
        "$defs": {
            "Inner": {"type": "string"}
        },
        "type": "object",
        "properties": {
            "x": {"$ref": "#/$defs/Inner"}
        }
    });
    let result = resolve_refs(&schema, 0, "test.module");
    assert!(matches!(
        result,
        Err(RefResolverError::MaxDepthExceeded { .. })
    ));
}

#[test]
fn test_resolve_refs_nested_properties() {
    // $refs inside nested properties must all be resolved.
    let schema = json!({
        "$defs": {
            "Coord": {"type": "number", "description": "A coordinate"}
        },
        "type": "object",
        "properties": {
            "point": {
                "type": "object",
                "properties": {
                    "x": {"$ref": "#/$defs/Coord"},
                    "y": {"$ref": "#/$defs/Coord"}
                }
            }
        }
    });
    let resolved = resolve_refs(&schema, 10, "test.module");
    assert!(resolved.is_ok(), "nested $refs must resolve successfully");
    let resolved = resolved.unwrap();
    assert_eq!(
        resolved["properties"]["point"]["properties"]["x"]["type"],
        json!("number"),
        "nested x $ref must be inlined"
    );
    assert_eq!(
        resolved["properties"]["point"]["properties"]["y"]["type"],
        json!("number"),
        "nested y $ref must be inlined"
    );
}