vcon 0.3.0

A library for vCons. It reads and checks a vCon: form, compression, uuid and critical extensions.
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

//! Extensions a vCon declares it cannot be understood without.

use std::collections::BTreeSet;

use serde_json::{Map, Value};

use crate::read::Rejection;

/// The member names that list required extensions: `critical`, and
/// `must_support`, its name before syntax version 0.4.0.
const MEMBERS: [&str; 2] = ["critical", "must_support"];

/// Refuses a vCon that requires an extension not in `supported`.
pub(crate) fn check_critical(
    object: &Map<String, Value>,
    supported: &BTreeSet<String>,
) -> Result<(), Rejection> {
    let mut required: Vec<&str> = Vec::new();
    for member in MEMBERS {
        let Some(value) = object.get(member) else {
            continue;
        };
        let Value::Array(names) = value else {
            return Err(Rejection::BadCritical);
        };
        for name in names {
            let Value::String(name) = name else {
                return Err(Rejection::BadCritical);
            };
            if !required.contains(&name.as_str()) {
                required.push(name);
            }
        }
    }
    let unsupported: Vec<String> = required
        .into_iter()
        .filter(|name| !supported.contains(*name))
        .map(str::to_owned)
        .collect();
    if unsupported.is_empty() {
        Ok(())
    } else {
        Err(Rejection::UnsupportedCritical(unsupported))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn check(body: &str, supported: &[&str]) -> Result<(), Rejection> {
        let Value::Object(map) = serde_json::from_str(body).expect("test JSON") else {
            panic!("test body must be an object")
        };
        let supported = supported.iter().map(|s| s.to_string()).collect();
        check_critical(&map, &supported)
    }

    fn unsupported(names: &[&str]) -> Result<(), Rejection> {
        Err(Rejection::UnsupportedCritical(
            names.iter().map(|s| s.to_string()).collect(),
        ))
    }

    #[test]
    fn passes_when_nothing_unsupported_is_required() {
        let cases: &[(&str, &str, &[&str])] = &[
            ("neither member", "{}", &[]),
            ("empty critical", r#"{"critical": []}"#, &[]),
            ("empty must_support", r#"{"must_support": []}"#, &[]),
            (
                "supported critical",
                r#"{"critical": ["cc"]}"#,
                &["cc", "wtf"],
            ),
            (
                "supported must_support",
                r#"{"must_support": ["wtf"]}"#,
                &["cc", "wtf"],
            ),
            ("other members ignored", r#"{"extensions": ["zzz"]}"#, &[]),
        ];
        for (what, body, supported) in cases {
            assert_eq!(check(body, supported), Ok(()), "{what}");
        }
    }

    #[test]
    fn names_every_unsupported_extension() {
        let cases: &[(&str, &str, &[&str], &[&str])] = &[
            ("one in critical", r#"{"critical": ["x"]}"#, &[], &["x"]),
            (
                "one in must_support",
                r#"{"must_support": ["x"]}"#,
                &[],
                &["x"],
            ),
            (
                "only the unsupported",
                r#"{"critical": ["cc", "x"]}"#,
                &["cc"],
                &["x"],
            ),
            (
                "both members, in order, once each",
                r#"{"critical": ["b", "a", "b"], "must_support": ["c", "a"]}"#,
                &[],
                &["b", "a", "c"],
            ),
            (
                "names are case-sensitive",
                r#"{"critical": ["CC"]}"#,
                &["cc"],
                &["CC"],
            ),
        ];
        for (what, body, supported, names) in cases {
            assert_eq!(check(body, supported), unsupported(names), "{what}");
        }
    }

    #[test]
    fn refuses_a_value_that_is_not_an_array_of_strings() {
        let cases = [
            r#"{"critical": "cc"}"#,
            r#"{"critical": null}"#,
            r#"{"critical": {}}"#,
            r#"{"critical": ["cc", 1]}"#,
            r#"{"must_support": [null]}"#,
            r#"{"critical": [], "must_support": "x"}"#,
            r#"{"critical": ["x"], "must_support": 3}"#,
        ];
        for body in cases {
            assert_eq!(check(body, &[]), Err(Rejection::BadCritical), "{body}");
        }
    }
}