golem-schema 1.6.0

Golem schema and value model
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

use super::*;
use crate::schema::graph::SchemaGraph;
use test_r::test;

fn tool(name: &str, version: &str) -> Tool {
    Tool {
        version: version.to_string(),
        requires_filesystem: false,
        commands: CommandTree {
            nodes: vec![CommandNode {
                name: name.to_string(),
                aliases: vec![],
                doc: Doc::default(),
                globals: Globals::default(),
                subcommands: vec![],
                body: None,
            }],
        },
        schema: SchemaGraph::empty(),
    }
}

#[test]
fn tool_wit_roundtrip_preserves_filesystem_requirement() {
    for requires_filesystem in [false, true] {
        let mut tool = tool("filesystem-test", "1");
        tool.requires_filesystem = requires_filesystem;
        let wire = wire::Tool::try_from(&tool).unwrap();
        assert_eq!(Tool::try_from(&wire).unwrap(), tool);
    }
}

#[test]
fn tool_middleware_roundtrip_preserves_independent_versions() {
    let middleware = ToolMiddleware {
        name: "redactor".to_string(),
        version: "middleware-7".to_string(),
        aliases: vec!["scrubber".to_string()],
        doc: Doc::default(),
        scope: ToolMiddlewareScope::Monomorphic(Box::new(MonomorphicToolMiddlewareScope {
            presented: tool("public-tool", "presented-2"),
            expected: Some(tool("private-tool", "expected-9")),
        })),
        parameter_schema: SchemaGraph::anonymous(SchemaType::String {
            metadata: Default::default(),
        }),
    };

    let decoded = tool_middleware_from_wit(tool_middleware_to_wit(&middleware).unwrap()).unwrap();
    assert_eq!(decoded, middleware);
}

#[test]
fn universal_middleware_roundtrip_preserves_its_version() {
    let middleware = ToolMiddleware {
        name: "audit".to_string(),
        version: "middleware-only-version".to_string(),
        aliases: vec![],
        doc: Doc::default(),
        scope: ToolMiddlewareScope::Universal,
        parameter_schema: SchemaGraph::empty(),
    };

    let decoded = tool_middleware_from_wit(tool_middleware_to_wit(&middleware).unwrap()).unwrap();
    assert_eq!(decoded, middleware);
}

#[test]
fn malformed_embedded_tool_is_rejected() {
    let middleware = ToolMiddleware {
        name: "redactor".to_string(),
        version: "1".to_string(),
        aliases: vec![],
        doc: Doc::default(),
        scope: ToolMiddlewareScope::Monomorphic(Box::new(MonomorphicToolMiddlewareScope {
            presented: tool("public-tool", "1"),
            expected: None,
        })),
        parameter_schema: SchemaGraph::empty(),
    };
    let mut wire = tool_middleware_to_wit(&middleware).unwrap();
    let wire::ToolMiddlewareScope::Monomorphic(scope) = &mut wire.scope else {
        unreachable!()
    };
    scope.presented.schema.type_nodes[0].body =
        crate::schema::wit::wire::SchemaTypeBody::RefType(i32::MAX);
    scope
        .presented
        .schema
        .defs
        .push(crate::schema::wit::wire::SchemaTypeDef {
            id: "broken".to_string(),
            name: None,
            body: 0,
        });

    assert!(tool_middleware_from_wit(wire).is_err());
}