context_deserialize_derive 0.2.1

Procedural macro for deriving the ContextDeserialize trait
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

use context_deserialize::{ContextDeserialize, context_deserialize};
use serde::{Deserialize, Serialize};

#[test]
fn test_context_deserialize_derive() {
    type TestContext = ();

    #[context_deserialize(TestContext)]
    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct Test {
        field: String,
    }

    let test = Test {
        field: "test".to_string(),
    };
    let serialized = serde_json::to_string(&test).unwrap();
    let deserialized =
        Test::context_deserialize(&mut serde_json::Deserializer::from_str(&serialized), ())
            .unwrap();
    assert_eq!(test, deserialized);
}

#[test]
fn test_context_deserialize_derive_multiple_types() {
    #[allow(dead_code)]
    struct TestContext1(u64);
    #[allow(dead_code)]
    struct TestContext2(String);

    // This will derive:
    // - ContextDeserialize<TestContext1> for Test
    // - ContextDeserialize<TestContext2> for Test
    // by just leveraging the Deserialize impl
    #[context_deserialize(TestContext1, TestContext2)]
    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct Test {
        field: String,
    }

    let test = Test {
        field: "test".to_string(),
    };
    let serialized = serde_json::to_string(&test).unwrap();
    let deserialized = Test::context_deserialize(
        &mut serde_json::Deserializer::from_str(&serialized),
        TestContext1(1),
    )
    .unwrap();
    assert_eq!(test, deserialized);

    let deserialized = Test::context_deserialize(
        &mut serde_json::Deserializer::from_str(&serialized),
        TestContext2("2".to_string()),
    )
    .unwrap();

    assert_eq!(test, deserialized);
}

#[test]
fn test_context_deserialize_derive_bound() {
    use std::fmt::Debug;

    struct TestContext;

    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct Inner {
        value: u64,
    }

    #[context_deserialize(
        TestContext,
        bound = "T: Serialize + for<'a> Deserialize<'a> + Debug + PartialEq"
    )]
    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct Wrapper<T> {
        inner: T,
    }

    let val = Wrapper {
        inner: Inner { value: 42 },
    };

    let serialized = serde_json::to_string(&val).unwrap();
    let deserialized = Wrapper::<Inner>::context_deserialize(
        &mut serde_json::Deserializer::from_str(&serialized),
        TestContext,
    )
    .unwrap();

    assert_eq!(val, deserialized);
}