comma_serde_urlencoded 0.8.1

serde_urlencoded with support for serialization and deserialization of sequences and tuples in comma separated format
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

use serde_derive::Serialize;

#[derive(Serialize)]
struct NewType<T>(T);

#[test]
fn serialize_newtype_i32() {
    let params = &[("field", Some(NewType(11)))];
    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok("field=11".to_owned())
    );
}

#[test]
fn serialize_newtype_u128() {
    let params = &[("field", Some(NewType(u128::MAX)))];
    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok(format!("field={}", u128::MAX))
    );
}

#[test]
fn serialize_newtype_i128() {
    let params = &[("field", Some(NewType(i128::MIN)))];
    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok(format!("field={}", i128::MIN))
    );
}

#[test]
fn serialize_option_map_int() {
    let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];

    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok("first=23&last=42".to_owned())
    );
}

#[test]
fn serialize_option_map_string() {
    let params = &[
        ("first", Some("hello")),
        ("middle", None),
        ("last", Some("world")),
    ];

    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok("first=hello&last=world".to_owned())
    );
}

#[test]
fn serialize_option_map_bool() {
    let params = &[("one", Some(true)), ("two", Some(false))];

    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok("one=true&two=false".to_owned())
    );
}

#[test]
fn serialize_map_bool() {
    let params = &[("one", true), ("two", false)];

    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok("one=true&two=false".to_owned())
    );
}

#[derive(Serialize)]
enum X {
    A,
    B,
    C,
}

#[test]
fn serialize_unit_enum() {
    let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
    assert_eq!(
        comma_serde_urlencoded::to_string(params),
        Ok("one=A&two=B&three=C".to_owned())
    );
}

#[derive(Serialize)]
struct Unit;

#[test]
fn serialize_unit_struct() {
    assert_eq!(comma_serde_urlencoded::to_string(Unit), Ok("".to_owned()));
}

#[test]
fn serialize_unit_type() {
    assert_eq!(comma_serde_urlencoded::to_string(()), Ok("".to_owned()));
}

#[test]
fn serialize_value_tuple() {
    assert_eq!(
        comma_serde_urlencoded::to_string((
            ("key", ["foo", "baz", "bar"]),
            ("key2", [1,2,3,4,5,6])
        )),
        Ok("key=foo%2Cbaz%2Cbar&key2=1%2C2%2C3%2C4%2C5%2C6".to_owned())
    );
}

#[test]
fn serialize_value_seq() {
    assert_eq!(
        comma_serde_urlencoded::to_string((
            ("key", vec!["foo", "baz", "bar"]),
            ("key2", vec![1,2,3,4,5,6])
        )),
        Ok("key=foo%2Cbaz%2Cbar&key2=1%2C2%2C3%2C4%2C5%2C6".to_owned())
    );
}