kynos-openapi 0.1.0

OpenAPI 3.1 and 3.2 document model, serialization and validation.
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

use super::Example;
#[cfg(feature = "openapi32")]
use super::ExampleValue;

#[test]
fn an_embedded_value_excludes_every_other_form() {
    let error = serde_json::from_str::<Example>(r#"{"value":1,"externalValue":"./e.png"}"#)
        .expect_err("`value` is exclusive with `externalValue`");

    assert!(error.to_string().contains("mutually exclusive"));
}

#[test]
fn an_external_example_round_trips() {
    let example = Example::external("./examples/red.png");
    let json = serde_json::to_string(&example).expect("serializable");
    assert_eq!(json, r#"{"externalValue":"./examples/red.png"}"#);

    let parsed: Example = serde_json::from_str(&json).expect("deserializable");
    assert_eq!(parsed, example);
}

#[test]
fn an_example_may_carry_no_value_at_all() {
    let example = Example::default().with_summary("described but not shown");
    assert!(example.value().is_none());
}

#[cfg(feature = "openapi32")]
#[test]
fn data_and_its_serialization_are_one_example() {
    // Exactly the boolean query parameter the specification writes out:
    // `true` is the data and `flag=true` is the wire form, and neither can
    // be derived from the other.
    let example = Example::data_serialized(true, "flag=true");
    let json = serde_json::to_string(&example).expect("serializable");
    assert_eq!(json, r#"{"dataValue":true,"serializedValue":"flag=true"}"#);

    let parsed: Example = serde_json::from_str(&json).expect("deserializable");
    assert_eq!(parsed, example);
    assert!(matches!(
        parsed.value(),
        Some(ExampleValue::Data {
            serialized: Some(_),
            ..
        })
    ));
}

#[cfg(feature = "openapi32")]
#[test]
fn data_may_accompany_an_external_payload() {
    let example = Example::data_external(serde_json::json!({"a": 1}), "./e.bin");
    let parsed: Example =
        serde_json::from_str(&serde_json::to_string(&example).expect("serializable"))
            .expect("deserializable");
    assert_eq!(parsed, example);
}

#[cfg(feature = "openapi32")]
#[test]
fn two_serializations_of_one_example_are_rejected() {
    let error =
        serde_json::from_str::<Example>(r#"{"serializedValue":"a","externalValue":"./e.bin"}"#)
            .expect_err("`serializedValue` is exclusive with `externalValue`");

    assert!(error.to_string().contains("mutually exclusive"));
}