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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! Tests for `#[mini(rename = "...")]` on struct fields and enum variants.
//!
//! Run: `cargo test -p midiserde --features full rename`

use midiserde::{json, Deserialize, Serialize};

#[derive(Debug, PartialEq, Deserialize, Serialize)]
struct WithRename {
    #[mini(rename = "displayName")]
    display_name: String,
    #[mini(rename = "inner_count")]
    count: u32,
}

#[derive(Debug, PartialEq, Deserialize, Serialize)]
enum Tag {
    A,
    #[mini(rename = "renamedB")]
    B,
}

#[test]
fn struct_rename() {
    let j = r#"{"displayName": "foo", "inner_count": 99}"#;
    let v: WithRename = json::from_str(j).unwrap();
    assert_eq!(v.display_name, "foo");
    assert_eq!(v.count, 99);

    let back = json::to_string(&v);
    assert!(back.contains(r#""displayName":"foo""#));
    assert!(back.contains(r#""inner_count":99"#));
}

#[test]
fn enum_rename() {
    let b: Tag = json::from_str(r#""renamedB""#).unwrap();
    assert!(matches!(b, Tag::B));

    let j = json::to_string(&Tag::B);
    assert_eq!(j, r#""renamedB""#);
}

// ── with + rename ──

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

#[cfg(feature = "base64")]
#[test]
fn with_rename_deserialize() {
    let j = r#"{"name": "test", "data": "SGVsbG8="}"#;
    let v: WithBase64AndRename = json::from_str(j).unwrap();
    assert_eq!(v.name, "test");
    assert_eq!(v.payload, b"Hello");
}

#[cfg(feature = "base64")]
#[test]
fn with_rename_serialize() {
    let v = WithBase64AndRename {
        name: "test".into(),
        payload: b"Hi".to_vec(),
    };
    let j = json::to_string(&v);
    assert!(j.contains(r#""data":"SGk=""#)); // "Hi" in base64
    assert!(j.contains(r#""name":"test""#));
}

/// Unknown enum variant returns Err, does not panic.
#[test]
fn enum_unknown_variant() {
    let result: Result<Tag, _> = json::from_str(r#""unknownVariant""#);
    assert!(result.is_err());
}