serde-tuple-vec-map 1.0.1

Deserialize a serialized map to a Vec<(K, V)> in 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

#![cfg_attr(not(feature = "std"), no_std)]

#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate serde_json;

#[cfg(not(feature = "std"))]
extern crate alloc;

extern crate serde;
extern crate tuple_vec_map;

use serde::Deserialize;

#[cfg(not(feature = "std"))]
use alloc::borrow::ToOwned;
#[cfg(not(feature = "std"))]
use alloc::string::String;
#[cfg(not(feature = "std"))]
use alloc::vec;
#[cfg(not(feature = "std"))]
use alloc::vec::Vec;

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
struct TestData {
    #[serde(with = "tuple_vec_map")]
    score: Vec<(String, u32)>,
}

#[test]
fn test_deserialization() {
    let data = json!({
        "score": {
            "user1": 50,
            "user2": 30,
            "user3": 0,
            "user4": 100,
        }
    });

    let deserialized = TestData::deserialize(data).expect("expected successful deserialization");

    // Note: This also tests that order is maintained.
    assert_eq!(
        deserialized,
        TestData {
            score: vec![
                ("user1".to_owned(), 50),
                ("user2".to_owned(), 30),
                ("user3".to_owned(), 0),
                ("user4".to_owned(), 100),
            ],
        }
    )
}

#[test]
fn test_serialization() {
    let data = TestData {
        score: vec![
            ("a_guy".to_owned(), 200),
            ("b_guy".to_owned(), 300),
            ("c_guy".to_owned(), 400),
        ],
    };

    let serialized = serde_json::to_value(data).expect("expected data to serialize successfully");

    assert_eq!(
        serialized,
        json!({
            "score": {
                "a_guy": 200,
                "b_guy": 300,
                "c_guy": 400,
            }
        })
    );
}

#[test]
fn serializing_from_slice_works() {
    #[derive(Serialize)]
    struct Data<'a> {
        #[serde(with = "tuple_vec_map")]
        inner: &'a [(&'a str, &'a str)],
    }

    let data = Data { inner: &[("answer", "fourty-two")] };

    let ser = serde_json::to_value(data).unwrap();
    assert_eq!(ser, json!({
        "inner": {
            "answer": "fourty-two",
        }
    }));
}