xidl-parser 0.69.2

A IDL codegen.
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

use super::*;
use crate::hir::{
    Annotation, InterfaceBody, InterfaceDcl, InterfaceDclInner, InterfaceDef, InterfaceHeader,
    OpDcl, OpTypeSpec, ParamAttribute, ParamDcl, ParameterDcls, SimpleDeclarator, Specification,
    StringType, TypeSpec,
};

fn string_ty() -> TypeSpec {
    TypeSpec::StringType(StringType { bound: None })
}

fn param(name: &str, attr: Option<&str>) -> ParamDcl {
    ParamDcl {
        annotations: Vec::new(),
        attr: attr.map(|value| ParamAttribute(value.to_string())),
        ty: string_ty(),
        declarator: SimpleDeclarator(name.to_string()),
    }
}

#[test]
fn project_helpers_cover_request_response_and_interface_collection() {
    let op = OpDcl {
        annotations: vec![Annotation::Builtin {
            name: "server_stream".to_string(),
            params: None,
        }],
        ty: OpTypeSpec::TypeSpec(string_ty()),
        ident: "watch".to_string(),
        parameter: Some(ParameterDcls(vec![
            param("id", None),
            param("etag", Some("out")),
            param("both", Some("inout")),
        ])),
        raises: None,
    };
    assert_eq!(
        request_fields(op.parameter.as_ref().unwrap().0.as_slice()).len(),
        2
    );
    assert_eq!(
        response_fields(&op, op.parameter.as_ref().unwrap().0.as_slice()).len(),
        3
    );
    assert_eq!(
        response_kind(&op, op.parameter.as_ref().unwrap().0.as_slice()),
        JsonRpcResponseKind::MultiOutput
    );

    let interface = InterfaceDcl {
        annotations: Vec::new(),
        decl: InterfaceDclInner::InterfaceDef(InterfaceDef {
            header: InterfaceHeader {
                ident: "CityApi".to_string(),
                parent: None,
            },
            interface_body: Some(InterfaceBody(vec![crate::hir::Export::OpDcl(op)])),
        }),
    };
    let spec = Specification(vec![crate::hir::Definition::InterfaceDcl(interface)]);
    let doc = project(&spec).expect("project");
    assert_eq!(doc.interfaces.len(), 1);
    assert_eq!(
        doc.interfaces[0].methods[0].kind,
        JsonRpcMethodKind::ServerStream
    );

    let forward = InterfaceDcl {
        annotations: Vec::new(),
        decl: InterfaceDclInner::InterfaceForwardDcl(crate::hir::InterfaceForwardDcl {
            ident: "ForwardOnly".to_string(),
        }),
    };
    let projected = project_interface(&forward, &["api".to_string()]).expect("forward");
    assert_eq!(projected.ident, "ForwardOnly");
    assert!(projected.methods.is_empty());
}