xidl-parser 0.97.0

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
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use super::*;
use crate::rest_hir::semantics::HttpStreamCodec;

#[test]
fn test_build_http_mapping_covers_bindings_streams_and_codecs() {
    let client_stream = HttpStreamConfig {
        kind: Some(HttpStreamKind::Client),
        codec: HttpStreamCodec::Ndjson,
    };
    let mapping = build_http_mapping(
        HttpMethod::Post,
        &client_stream,
        Some("application/msgpack"),
        Some("application/x-custom"),
        &[
            string_param("id", HttpParamKind::Path),
            string_param("q", HttpParamKind::Query),
            string_param("trace", HttpParamKind::Header),
            string_param("session", HttpParamKind::Cookie),
            string_param("item", HttpParamKind::Body),
        ],
        &[
            string_param("etag", HttpParamKind::Header),
            string_param("token", HttpParamKind::Cookie),
            string_param("ignored", HttpParamKind::Query),
        ],
        &None,
    );

    assert_eq!(mapping.request.path[0].source_param, "id");
    assert_eq!(mapping.request.query[0].source_param, "q");
    assert_eq!(mapping.request.header[0].source_param, "trace");
    assert_eq!(mapping.request.cookie[0].source_param, "session");
    assert_eq!(
        mapping.request.body.content_type.as_deref(),
        Some("application/x-ndjson")
    );
    assert_eq!(mapping.request.body.codec, None);
    assert!(matches!(
        mapping.request.body.shape,
        HttpRequestBodyShape::Stream {
            codec: HttpStreamPayloadCodec::Ndjson,
            ..
        }
    ));
    assert_eq!(mapping.response.header[0].wire_name, "etag");
    assert_eq!(mapping.response.cookie[0].wire_name, "token");
    assert_eq!(mapping.response.body.content_type, None);

    let server_stream = HttpStreamConfig {
        kind: Some(HttpStreamKind::Server),
        codec: HttpStreamCodec::Sse,
    };
    let mapping = build_http_mapping(
        HttpMethod::Get,
        &server_stream,
        Some("application/x-www-form-urlencoded"),
        Some("application/msgpack"),
        &[],
        &[string_param("events", HttpParamKind::Body)],
        &None,
    );
    assert_eq!(
        mapping.response.body.content_type.as_deref(),
        Some("text/event-stream")
    );
    assert!(matches!(
        mapping.response.body.shape,
        HttpResponseBodyShape::Stream {
            item_source: HttpOutputSource::Param { .. },
            codec: HttpStreamPayloadCodec::Sse,
            ..
        }
    ));

    let explicit = build_http_mapping(
        HttpMethod::Head,
        &HttpStreamConfig {
            kind: None,
            codec: HttpStreamCodec::Ndjson,
        },
        Some("application/x-www-form-urlencoded"),
        Some("application/msgpack"),
        &[string_param("form", HttpParamKind::Body)],
        &[string_param("value", HttpParamKind::Body)],
        &None,
    );
    assert_eq!(
        explicit.request.body.codec,
        Some(HttpBodyCodec::FormUrlEncoded)
    );
    assert_eq!(explicit.response.body.codec, Some(HttpBodyCodec::Msgpack));
    assert_eq!(explicit.response.status, "204");
}

#[test]
fn test_build_http_mapping_covers_empty_stream_and_single_output_body() {
    let client_stream_without_body = build_http_mapping(
        HttpMethod::Post,
        &HttpStreamConfig {
            kind: Some(HttpStreamKind::Client),
            codec: HttpStreamCodec::Sse,
        },
        None,
        None,
        &[],
        &[],
        &None,
    );
    assert!(matches!(
        client_stream_without_body.request.body.shape,
        HttpRequestBodyShape::Empty
    ));
    assert_eq!(client_stream_without_body.request.body.content_type, None);

    let server_stream_without_body = build_http_mapping(
        HttpMethod::Get,
        &HttpStreamConfig {
            kind: Some(HttpStreamKind::Server),
            codec: HttpStreamCodec::Ndjson,
        },
        None,
        None,
        &[],
        &[],
        &None,
    );
    assert!(matches!(
        server_stream_without_body.response.body.shape,
        HttpResponseBodyShape::Empty
    ));
    assert_eq!(server_stream_without_body.response.status, "204");

    let single_output = build_http_mapping(
        HttpMethod::Post,
        &HttpStreamConfig {
            kind: None,
            codec: HttpStreamCodec::Ndjson,
        },
        None,
        None,
        &[],
        &[string_param("value", HttpParamKind::Body)],
        &None,
    );
    assert!(matches!(
        single_output.response.body.shape,
        HttpResponseBodyShape::SingleValue {
            source: HttpOutputSource::Param { .. },
            ..
        }
    ));
    assert_eq!(
        single_output.response.body.content_type.as_deref(),
        Some("text/plain")
    );
    assert_eq!(single_output.response.status, "200");
}