base64-serde 0.8.0

Integration between rust-base64 and serde
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

#![allow(clippy::box_collection)]

use base64::{engine::general_purpose::STANDARD, Engine};
use base64_serde::base64_serde_type;
use std::cell::RefCell;

base64_serde_type!(Base64Standard, STANDARD);

mod some_other_mod {
    use base64::engine::general_purpose::STANDARD;
    use base64_serde::base64_serde_type;

    base64_serde_type!(pub Base64StandardInModule, STANDARD);
}

#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
struct ByteHolder {
    #[serde(with = "Base64Standard")]
    bytes: Vec<u8>,
}

#[derive(Debug, PartialEq, serde::Deserialize)]
struct BoxVecHolder {
    #[serde(with = "Base64Standard")]
    bytes: Box<Vec<u8>>,
}

#[derive(Debug, PartialEq, serde::Deserialize)]
struct RefCellVecHolder {
    #[serde(with = "Base64Standard")]
    bytes: RefCell<Vec<u8>>,
}

#[derive(Debug, PartialEq, serde::Serialize)]
struct SliceHolder<'a> {
    #[serde(with = "Base64Standard")]
    bytes: &'a [u8],
}

#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
struct ByteHolderHelperInMod {
    #[serde(with = "some_other_mod::Base64StandardInModule")]
    bytes: Vec<u8>,
}

#[test]
fn serde_with_type() {
    let b = ByteHolder {
        bytes: vec![0x00, 0x77, 0xFF],
    };

    let s = serde_json::to_string(&b).unwrap();
    let expected = format!("{{\"bytes\":\"{}\"}}", STANDARD.encode(&b.bytes));
    assert_eq!(expected, s);

    let b2 = serde_json::from_str(&s).unwrap();
    assert_eq!(b, b2);
}

#[test]
fn deserialize_with_box_vec() {
    let b = BoxVecHolder {
        bytes: Box::new(vec![0x00, 0x77, 0xFF]),
    };

    let json = format!("{{\"bytes\":\"{}\"}}", STANDARD.encode(b.bytes.as_slice()));

    let b2 = serde_json::from_str(&json).unwrap();
    assert_eq!(b, b2);
}

#[test]
fn deserialize_with_refcell() {
    let b = RefCellVecHolder {
        bytes: RefCell::new(vec![0x00, 0x77, 0xFF]),
    };

    let expected = format!(
        "{{\"bytes\":\"{}\"}}",
        STANDARD.encode(b.bytes.borrow().as_slice())
    );

    let b2 = serde_json::from_str(&expected).unwrap();
    assert_eq!(b, b2);
}

#[test]
fn serialize_with_u8_slice() {
    let bytes = vec![0x00, 0x77, 0xFF];
    let b = SliceHolder { bytes: &bytes };

    let s = serde_json::to_string(&b).unwrap();
    let expected = format!("{{\"bytes\":\"{}\"}}", STANDARD.encode(b.bytes));
    assert_eq!(expected, s);
}

#[test]
fn serde_with_type_using_public_helper() {
    let b = ByteHolderHelperInMod {
        bytes: vec![0x00, 0x77, 0xFF],
    };

    let s = serde_json::to_string(&b).unwrap();
    let expected = format!("{{\"bytes\":\"{}\"}}", STANDARD.encode(&b.bytes));
    assert_eq!(expected, s);

    let b2 = serde_json::from_str(&s).unwrap();
    assert_eq!(b, b2);
}

#[test]
fn fails_nicely_on_inappropriate_input() {
    assert_eq!(
        "invalid type: integer `1234`, expected base64 ASCII text at line 1 column 13",
        format!(
            "{}",
            serde_json::from_str::<ByteHolder>("{\"bytes\":1234}").unwrap_err()
        )
    );
}