midiserde 0.1.1

When mini isn't enough and serde is too much
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

//! Tests for `#[mini(with = "midiserde::with::base64")]`.
//!
//! Run: `cargo test -p midiserde --features base64 base64`
//! Or: `cargo test -p midiserde base64` (with default includes macros)

#[cfg(not(feature = "base64"))]
#[test]
fn base64_feature_disabled() {
    // Stub when base64 is off — file must compile.
}

#[cfg(feature = "base64")]
mod tests {
    use midiserde::{json, Deserialize, Serialize};

    #[derive(Debug, PartialEq, Deserialize, Serialize)]
    struct WithBase64 {
        name: String,
        #[mini(with = "midiserde::with::base64")]
        payload: Vec<u8>,
    }

    #[test]
    fn deserialize() {
        let j = r#"{"name": "test", "payload": "SGVsbG8="}"#;
        let v: WithBase64 = json::from_str(j).unwrap();
        assert_eq!(v.name, "test");
        assert_eq!(v.payload, b"Hello");
    }

    #[test]
    fn serialize() {
        let v = WithBase64 {
            name: "test".into(),
            payload: b"Hello".to_vec(),
        };
        let j = json::to_string(&v);
        assert!(j.contains(r#""payload":"SGVsbG8=""#));
        assert!(j.contains(r#""name":"test""#));
    }

    #[test]
    fn roundtrip() {
        let original = WithBase64 {
            name: "roundtrip".into(),
            payload: vec![0, 1, 2, 255, 254, 253],
        };
        let j = json::to_string(&original);
        let parsed: WithBase64 = json::from_str(&j).unwrap();
        assert_eq!(original, parsed);
    }

    #[test]
    fn invalid_base64_string() {
        let j = r#"{"name": "test", "payload": "!!!invalid-base64!!!"}"#;
        let result: Result<WithBase64, _> = json::from_str(j);
        assert!(result.is_err());
    }
}