avro_rs/
de.rs

1//! Logic for serde-compatible deserialization.
2use crate::{types::Value, Error};
3use serde::{
4    de::{self, DeserializeSeed, Visitor},
5    forward_to_deserialize_any, Deserialize,
6};
7use std::{
8    collections::{
9        hash_map::{Keys, Values},
10        HashMap,
11    },
12    slice::Iter,
13};
14
15pub struct Deserializer<'de> {
16    input: &'de Value,
17}
18
19struct SeqDeserializer<'de> {
20    input: Iter<'de, Value>,
21}
22
23struct MapDeserializer<'de> {
24    input_keys: Keys<'de, String, Value>,
25    input_values: Values<'de, String, Value>,
26}
27
28struct StructDeserializer<'de> {
29    input: Iter<'de, (String, Value)>,
30    value: Option<&'de Value>,
31}
32
33pub struct EnumUnitDeserializer<'a> {
34    input: &'a str,
35}
36
37pub struct EnumDeserializer<'de> {
38    input: &'de [(String, Value)],
39}
40
41impl<'de> Deserializer<'de> {
42    pub fn new(input: &'de Value) -> Self {
43        Deserializer { input }
44    }
45}
46
47impl<'de> SeqDeserializer<'de> {
48    pub fn new(input: &'de [Value]) -> Self {
49        SeqDeserializer {
50            input: input.iter(),
51        }
52    }
53}
54
55impl<'de> MapDeserializer<'de> {
56    pub fn new(input: &'de HashMap<String, Value>) -> Self {
57        MapDeserializer {
58            input_keys: input.keys(), // input.keys().map(|k| Value::String(k.clone())).collect::<Vec<_>>().iter(),
59            input_values: input.values(),
60            // keys: input.keys().map(|s| Value::String(s.to_owned())).collect::<Vec<Value>>(),
61            // values: input.values().map(|s| s.to_owned()).collect::<Vec<Value>>(),
62        }
63    }
64}
65
66impl<'de> StructDeserializer<'de> {
67    pub fn new(input: &'de [(String, Value)]) -> Self {
68        StructDeserializer {
69            input: input.iter(),
70            value: None,
71        }
72    }
73}
74
75impl<'a> EnumUnitDeserializer<'a> {
76    pub fn new(input: &'a str) -> Self {
77        EnumUnitDeserializer { input }
78    }
79}
80
81impl<'de> EnumDeserializer<'de> {
82    pub fn new(input: &'de [(String, Value)]) -> Self {
83        EnumDeserializer { input }
84    }
85}
86
87impl<'de> de::EnumAccess<'de> for EnumUnitDeserializer<'de> {
88    type Error = Error;
89    type Variant = Self;
90
91    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
92    where
93        V: DeserializeSeed<'de>,
94    {
95        Ok((
96            seed.deserialize(StringDeserializer {
97                input: self.input.to_owned(),
98            })?,
99            self,
100        ))
101    }
102}
103
104impl<'de> de::VariantAccess<'de> for EnumUnitDeserializer<'de> {
105    type Error = Error;
106
107    fn unit_variant(self) -> Result<(), Error> {
108        Ok(())
109    }
110
111    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
112    where
113        T: DeserializeSeed<'de>,
114    {
115        Err(de::Error::custom("Unexpected Newtype variant"))
116    }
117
118    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
119    where
120        V: Visitor<'de>,
121    {
122        Err(de::Error::custom("Unexpected tuple variant"))
123    }
124
125    fn struct_variant<V>(
126        self,
127        _fields: &'static [&'static str],
128        _visitor: V,
129    ) -> Result<V::Value, Error>
130    where
131        V: Visitor<'de>,
132    {
133        Err(de::Error::custom("Unexpected struct variant"))
134    }
135}
136
137impl<'de> de::EnumAccess<'de> for EnumDeserializer<'de> {
138    type Error = Error;
139    type Variant = Self;
140
141    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
142    where
143        V: DeserializeSeed<'de>,
144    {
145        self.input.first().map_or(
146            Err(de::Error::custom("A record must have a least one field")),
147            |item| match (item.0.as_ref(), &item.1) {
148                ("type", Value::String(x)) => Ok((
149                    seed.deserialize(StringDeserializer {
150                        input: x.to_owned(),
151                    })?,
152                    self,
153                )),
154                (field, Value::String(_)) => Err(de::Error::custom(format!(
155                    "Expected first field named 'type': got '{}' instead",
156                    field
157                ))),
158                (_, _) => Err(de::Error::custom(
159                    "Expected first field of type String for the type name".to_string(),
160                )),
161            },
162        )
163    }
164}
165
166impl<'de> de::VariantAccess<'de> for EnumDeserializer<'de> {
167    type Error = Error;
168
169    fn unit_variant(self) -> Result<(), Error> {
170        Ok(())
171    }
172
173    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
174    where
175        T: DeserializeSeed<'de>,
176    {
177        self.input.get(1).map_or(
178            Err(de::Error::custom(
179                "Expected a newtype variant, got nothing instead.",
180            )),
181            |item| seed.deserialize(&Deserializer::new(&item.1)),
182        )
183    }
184
185    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
186    where
187        V: Visitor<'de>,
188    {
189        self.input.get(1).map_or(
190            Err(de::Error::custom(
191                "Expected a tuple variant, got nothing instead.",
192            )),
193            |item| de::Deserializer::deserialize_seq(&Deserializer::new(&item.1), visitor),
194        )
195    }
196
197    fn struct_variant<V>(
198        self,
199        fields: &'static [&'static str],
200        visitor: V,
201    ) -> Result<V::Value, Error>
202    where
203        V: Visitor<'de>,
204    {
205        self.input.get(1).map_or(
206            Err(de::Error::custom("Expected a struct variant, got nothing")),
207            |item| {
208                de::Deserializer::deserialize_struct(
209                    &Deserializer::new(&item.1),
210                    "",
211                    fields,
212                    visitor,
213                )
214            },
215        )
216    }
217}
218
219impl<'a, 'de> de::Deserializer<'de> for &'a Deserializer<'de> {
220    type Error = Error;
221
222    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
223    where
224        V: Visitor<'de>,
225    {
226        match self.input {
227            Value::Null => visitor.visit_unit(),
228            &Value::Boolean(b) => visitor.visit_bool(b),
229            Value::Int(i) | Value::Date(i) | Value::TimeMillis(i) => visitor.visit_i32(*i),
230            Value::Long(i)
231            | Value::TimeMicros(i)
232            | Value::TimestampMillis(i)
233            | Value::TimestampMicros(i) => visitor.visit_i64(*i),
234            &Value::Float(f) => visitor.visit_f32(f),
235            &Value::Double(d) => visitor.visit_f64(d),
236            Value::Union(u) => match **u {
237                Value::Null => visitor.visit_unit(),
238                Value::Boolean(b) => visitor.visit_bool(b),
239                Value::Int(i) => visitor.visit_i32(i),
240                Value::Long(i) => visitor.visit_i64(i),
241                Value::Float(f) => visitor.visit_f32(f),
242                Value::Double(d) => visitor.visit_f64(d),
243                _ => Err(de::Error::custom("Unsupported union")),
244            },
245            Value::Record(ref fields) => visitor.visit_map(StructDeserializer::new(fields)),
246            Value::Array(ref fields) => visitor.visit_seq(SeqDeserializer::new(fields)),
247            value => Err(de::Error::custom(format!(
248                "incorrect value of type: {:?}",
249                crate::schema::SchemaKind::from(value)
250            ))),
251        }
252    }
253
254    forward_to_deserialize_any! {
255        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64
256    }
257
258    fn deserialize_char<V>(self, _: V) -> Result<V::Value, Self::Error>
259    where
260        V: Visitor<'de>,
261    {
262        Err(de::Error::custom("avro does not support char"))
263    }
264
265    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
266    where
267        V: Visitor<'de>,
268    {
269        match *self.input {
270            Value::String(ref s) => visitor.visit_str(s),
271            Value::Bytes(ref bytes) | Value::Fixed(_, ref bytes) => ::std::str::from_utf8(bytes)
272                .map_err(|e| de::Error::custom(e.to_string()))
273                .and_then(|s| visitor.visit_str(s)),
274            Value::Uuid(ref u) => visitor.visit_str(&u.to_string()),
275            _ => Err(de::Error::custom("not a string|bytes|fixed")),
276        }
277    }
278
279    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
280    where
281        V: Visitor<'de>,
282    {
283        match *self.input {
284            Value::String(ref s) => visitor.visit_string(s.to_owned()),
285            Value::Bytes(ref bytes) | Value::Fixed(_, ref bytes) => {
286                String::from_utf8(bytes.to_owned())
287                    .map_err(|e| de::Error::custom(e.to_string()))
288                    .and_then(|s| visitor.visit_string(s))
289            }
290            Value::Union(ref x) => match **x {
291                Value::String(ref s) => visitor.visit_string(s.to_owned()),
292                _ => Err(de::Error::custom("not a string|bytes|fixed")),
293            },
294            _ => Err(de::Error::custom("not a string|bytes|fixed")),
295        }
296    }
297
298    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
299    where
300        V: Visitor<'de>,
301    {
302        match *self.input {
303            Value::String(ref s) => visitor.visit_bytes(s.as_bytes()),
304            Value::Bytes(ref bytes) | Value::Fixed(_, ref bytes) => visitor.visit_bytes(bytes),
305            Value::Uuid(ref u) => visitor.visit_bytes(u.as_bytes()),
306            _ => Err(de::Error::custom("not a string|bytes|fixed")),
307        }
308    }
309
310    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
311    where
312        V: Visitor<'de>,
313    {
314        match *self.input {
315            Value::String(ref s) => visitor.visit_byte_buf(s.clone().into_bytes()),
316            Value::Bytes(ref bytes) | Value::Fixed(_, ref bytes) => {
317                visitor.visit_byte_buf(bytes.to_owned())
318            }
319            _ => Err(de::Error::custom("not a string|bytes|fixed")),
320        }
321    }
322
323    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
324    where
325        V: Visitor<'de>,
326    {
327        match *self.input {
328            Value::Union(ref inner) if inner.as_ref() == &Value::Null => visitor.visit_none(),
329            Value::Union(ref inner) => visitor.visit_some(&Deserializer::new(inner)),
330            _ => Err(de::Error::custom("not a union")),
331        }
332    }
333
334    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
335    where
336        V: Visitor<'de>,
337    {
338        match *self.input {
339            Value::Null => visitor.visit_unit(),
340            _ => Err(de::Error::custom("not a null")),
341        }
342    }
343
344    fn deserialize_unit_struct<V>(
345        self,
346        _: &'static str,
347        visitor: V,
348    ) -> Result<V::Value, Self::Error>
349    where
350        V: Visitor<'de>,
351    {
352        self.deserialize_unit(visitor)
353    }
354
355    fn deserialize_newtype_struct<V>(
356        self,
357        _: &'static str,
358        visitor: V,
359    ) -> Result<V::Value, Self::Error>
360    where
361        V: Visitor<'de>,
362    {
363        visitor.visit_newtype_struct(self)
364    }
365
366    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
367    where
368        V: Visitor<'de>,
369    {
370        match *self.input {
371            Value::Array(ref items) => visitor.visit_seq(SeqDeserializer::new(items)),
372            Value::Union(ref inner) => match **inner {
373                Value::Array(ref items) => visitor.visit_seq(SeqDeserializer::new(items)),
374                _ => Err(de::Error::custom("not an array")),
375            },
376            _ => Err(de::Error::custom("not an array")),
377        }
378    }
379
380    fn deserialize_tuple<V>(self, _: usize, visitor: V) -> Result<V::Value, Self::Error>
381    where
382        V: Visitor<'de>,
383    {
384        self.deserialize_seq(visitor)
385    }
386
387    fn deserialize_tuple_struct<V>(
388        self,
389        _: &'static str,
390        _: usize,
391        visitor: V,
392    ) -> Result<V::Value, Self::Error>
393    where
394        V: Visitor<'de>,
395    {
396        self.deserialize_seq(visitor)
397    }
398
399    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
400    where
401        V: Visitor<'de>,
402    {
403        match *self.input {
404            Value::Map(ref items) => visitor.visit_map(MapDeserializer::new(items)),
405            _ => Err(de::Error::custom("not a map")),
406        }
407    }
408
409    fn deserialize_struct<V>(
410        self,
411        _: &'static str,
412        _: &'static [&'static str],
413        visitor: V,
414    ) -> Result<V::Value, Self::Error>
415    where
416        V: Visitor<'de>,
417    {
418        match *self.input {
419            Value::Record(ref fields) => visitor.visit_map(StructDeserializer::new(fields)),
420            Value::Union(ref inner) => match **inner {
421                Value::Record(ref fields) => visitor.visit_map(StructDeserializer::new(fields)),
422                _ => Err(de::Error::custom("not a record")),
423            },
424            _ => Err(de::Error::custom("not a record")),
425        }
426    }
427
428    fn deserialize_enum<V>(
429        self,
430        _: &'static str,
431        _variants: &'static [&'static str],
432        visitor: V,
433    ) -> Result<V::Value, Self::Error>
434    where
435        V: Visitor<'de>,
436    {
437        match *self.input {
438            // This branch can be anything...
439            Value::Record(ref fields) => visitor.visit_enum(EnumDeserializer::new(&fields)),
440            // This has to be a unit Enum
441            Value::Enum(_index, ref field) => visitor.visit_enum(EnumUnitDeserializer::new(&field)),
442            _ => Err(de::Error::custom("not an enum")),
443        }
444    }
445
446    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
447    where
448        V: Visitor<'de>,
449    {
450        self.deserialize_str(visitor)
451    }
452
453    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
454    where
455        V: Visitor<'de>,
456    {
457        self.deserialize_any(visitor)
458    }
459}
460
461impl<'de> de::SeqAccess<'de> for SeqDeserializer<'de> {
462    type Error = Error;
463
464    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
465    where
466        T: DeserializeSeed<'de>,
467    {
468        match self.input.next() {
469            Some(item) => seed.deserialize(&Deserializer::new(&item)).map(Some),
470            None => Ok(None),
471        }
472    }
473}
474
475impl<'de> de::MapAccess<'de> for MapDeserializer<'de> {
476    type Error = Error;
477
478    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
479    where
480        K: DeserializeSeed<'de>,
481    {
482        match self.input_keys.next() {
483            Some(ref key) => seed
484                .deserialize(StringDeserializer {
485                    input: (*key).clone(),
486                })
487                .map(Some),
488            None => Ok(None),
489        }
490    }
491
492    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
493    where
494        V: DeserializeSeed<'de>,
495    {
496        match self.input_values.next() {
497            Some(ref value) => seed.deserialize(&Deserializer::new(value)),
498            None => Err(de::Error::custom("should not happen - too many values")),
499        }
500    }
501}
502
503impl<'de> de::MapAccess<'de> for StructDeserializer<'de> {
504    type Error = Error;
505
506    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
507    where
508        K: DeserializeSeed<'de>,
509    {
510        match self.input.next() {
511            Some(item) => {
512                let (ref field, ref value) = *item;
513                self.value = Some(value);
514                seed.deserialize(StringDeserializer {
515                    input: field.clone(),
516                })
517                .map(Some)
518            }
519            None => Ok(None),
520        }
521    }
522
523    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
524    where
525        V: DeserializeSeed<'de>,
526    {
527        match self.value.take() {
528            Some(value) => seed.deserialize(&Deserializer::new(value)),
529            None => Err(de::Error::custom("should not happen - too many values")),
530        }
531    }
532}
533
534#[derive(Clone)]
535struct StringDeserializer {
536    input: String,
537}
538
539impl<'de> de::Deserializer<'de> for StringDeserializer {
540    type Error = Error;
541
542    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
543    where
544        V: Visitor<'de>,
545    {
546        visitor.visit_string(self.input)
547    }
548
549    forward_to_deserialize_any! {
550        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
551        seq bytes byte_buf map unit_struct newtype_struct
552        tuple_struct struct tuple enum identifier ignored_any
553    }
554}
555
556/// Interpret a `Value` as an instance of type `D`.
557///
558/// This conversion can fail if the structure of the `Value` does not match the
559/// structure expected by `D`.
560pub fn from_value<'de, D: Deserialize<'de>>(value: &'de Value) -> Result<D, Error> {
561    let de = Deserializer::new(value);
562    D::deserialize(&de)
563}
564
565#[cfg(test)]
566mod tests {
567    use serde::Serialize;
568    use uuid::Uuid;
569
570    use super::*;
571
572    #[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
573    struct Test {
574        a: i64,
575        b: String,
576    }
577
578    #[derive(Debug, Deserialize, Serialize, PartialEq)]
579    struct TestInner {
580        a: Test,
581        b: i32,
582    }
583
584    #[derive(Debug, Deserialize, Serialize, PartialEq)]
585    struct TestUnitExternalEnum {
586        a: UnitExternalEnum,
587    }
588
589    #[derive(Debug, Deserialize, Serialize, PartialEq)]
590    enum UnitExternalEnum {
591        Val1,
592        Val2,
593    }
594
595    #[derive(Debug, Deserialize, Serialize, PartialEq)]
596    struct TestUnitInternalEnum {
597        a: UnitInternalEnum,
598    }
599
600    #[derive(Debug, Deserialize, Serialize, PartialEq)]
601    #[serde(tag = "t")]
602    enum UnitInternalEnum {
603        Val1,
604        Val2,
605    }
606
607    #[derive(Debug, Deserialize, Serialize, PartialEq)]
608    struct TestUnitAdjacentEnum {
609        a: UnitAdjacentEnum,
610    }
611
612    #[derive(Debug, Deserialize, Serialize, PartialEq)]
613    #[serde(tag = "t", content = "v")]
614    enum UnitAdjacentEnum {
615        Val1,
616        Val2,
617    }
618
619    #[derive(Debug, Deserialize, Serialize, PartialEq)]
620    struct TestUnitUntaggedEnum {
621        a: UnitUntaggedEnum,
622    }
623
624    #[derive(Debug, Deserialize, Serialize, PartialEq)]
625    #[serde(untagged)]
626    enum UnitUntaggedEnum {
627        Val1,
628        Val2,
629    }
630
631    #[derive(Debug, Serialize, Deserialize, PartialEq)]
632    struct TestSingleValueExternalEnum {
633        a: SingleValueExternalEnum,
634    }
635
636    #[derive(Debug, Serialize, Deserialize, PartialEq)]
637    enum SingleValueExternalEnum {
638        Double(f64),
639        String(String),
640    }
641
642    #[derive(Debug, Serialize, Deserialize, PartialEq)]
643    struct TestStructExternalEnum {
644        a: StructExternalEnum,
645    }
646
647    #[derive(Debug, Serialize, Deserialize, PartialEq)]
648    enum StructExternalEnum {
649        Val1 { x: f32, y: f32 },
650        Val2 { x: f32, y: f32 },
651    }
652
653    #[derive(Debug, Serialize, Deserialize, PartialEq)]
654    struct TestTupleExternalEnum {
655        a: TupleExternalEnum,
656    }
657
658    #[derive(Debug, Serialize, Deserialize, PartialEq)]
659    enum TupleExternalEnum {
660        Val1(f32, f32),
661        Val2(f32, f32, f32),
662    }
663
664    #[test]
665    fn test_from_value() {
666        let test = Value::Record(vec![
667            ("a".to_owned(), Value::Long(27)),
668            ("b".to_owned(), Value::String("foo".to_owned())),
669        ]);
670        let expected = Test {
671            a: 27,
672            b: "foo".to_owned(),
673        };
674        let final_value: Test = from_value(&test).unwrap();
675        assert_eq!(final_value, expected);
676
677        let test_inner = Value::Record(vec![
678            (
679                "a".to_owned(),
680                Value::Record(vec![
681                    ("a".to_owned(), Value::Long(27)),
682                    ("b".to_owned(), Value::String("foo".to_owned())),
683                ]),
684            ),
685            ("b".to_owned(), Value::Int(35)),
686        ]);
687
688        let expected_inner = TestInner { a: expected, b: 35 };
689        let final_value: TestInner = from_value(&test_inner).unwrap();
690        assert_eq!(final_value, expected_inner)
691    }
692    #[test]
693    fn test_from_value_unit_enum() {
694        let expected = TestUnitExternalEnum {
695            a: UnitExternalEnum::Val1,
696        };
697
698        let test = Value::Record(vec![("a".to_owned(), Value::Enum(0, "Val1".to_owned()))]);
699        let final_value: TestUnitExternalEnum = from_value(&test).unwrap();
700        assert_eq!(
701            final_value, expected,
702            "Error deserializing unit external enum"
703        );
704
705        let expected = TestUnitInternalEnum {
706            a: UnitInternalEnum::Val1,
707        };
708
709        let test = Value::Record(vec![(
710            "a".to_owned(),
711            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
712        )]);
713        let final_value: TestUnitInternalEnum = from_value(&test).unwrap();
714        assert_eq!(
715            final_value, expected,
716            "Error deserializing unit internal enum"
717        );
718        let expected = TestUnitAdjacentEnum {
719            a: UnitAdjacentEnum::Val1,
720        };
721
722        let test = Value::Record(vec![(
723            "a".to_owned(),
724            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
725        )]);
726        let final_value: TestUnitAdjacentEnum = from_value(&test).unwrap();
727        assert_eq!(
728            final_value, expected,
729            "Error deserializing unit adjacent enum"
730        );
731        let expected = TestUnitUntaggedEnum {
732            a: UnitUntaggedEnum::Val1,
733        };
734
735        let test = Value::Record(vec![("a".to_owned(), Value::Null)]);
736        let final_value: TestUnitUntaggedEnum = from_value(&test).unwrap();
737        assert_eq!(
738            final_value, expected,
739            "Error deserializing unit untagged enum"
740        );
741    }
742
743    #[test]
744    fn test_from_value_single_value_enum() {
745        let expected = TestSingleValueExternalEnum {
746            a: SingleValueExternalEnum::Double(64.0),
747        };
748
749        let test = Value::Record(vec![(
750            "a".to_owned(),
751            Value::Record(vec![
752                ("type".to_owned(), Value::String("Double".to_owned())),
753                (
754                    "value".to_owned(),
755                    Value::Union(Box::new(Value::Double(64.0))),
756                ),
757            ]),
758        )]);
759        let final_value: TestSingleValueExternalEnum = from_value(&test).unwrap();
760        assert_eq!(
761            final_value, expected,
762            "Error deserializing single value external enum(union)"
763        );
764    }
765
766    #[test]
767    fn test_from_value_struct_enum() {
768        let expected = TestStructExternalEnum {
769            a: StructExternalEnum::Val1 { x: 1.0, y: 2.0 },
770        };
771
772        let test = Value::Record(vec![(
773            "a".to_owned(),
774            Value::Record(vec![
775                ("type".to_owned(), Value::String("Val1".to_owned())),
776                (
777                    "value".to_owned(),
778                    Value::Union(Box::new(Value::Record(vec![
779                        ("x".to_owned(), Value::Float(1.0)),
780                        ("y".to_owned(), Value::Float(2.0)),
781                    ]))),
782                ),
783            ]),
784        )]);
785        let final_value: TestStructExternalEnum = from_value(&test).unwrap();
786        assert_eq!(
787            final_value, expected,
788            "error deserializing struct external enum(union)"
789        );
790    }
791
792    #[test]
793    fn test_from_value_tuple_enum() {
794        let expected = TestTupleExternalEnum {
795            a: TupleExternalEnum::Val1(1.0, 2.0),
796        };
797
798        let test = Value::Record(vec![(
799            "a".to_owned(),
800            Value::Record(vec![
801                ("type".to_owned(), Value::String("Val1".to_owned())),
802                (
803                    "value".to_owned(),
804                    Value::Union(Box::new(Value::Array(vec![
805                        Value::Float(1.0),
806                        Value::Float(2.0),
807                    ]))),
808                ),
809            ]),
810        )]);
811        let final_value: TestTupleExternalEnum = from_value(&test).unwrap();
812        assert_eq!(
813            final_value, expected,
814            "error serializing tuple external enum(union)"
815        );
816    }
817
818    type TestResult<T> = Result<T, Box<dyn std::error::Error>>;
819
820    #[test]
821    fn test_date() -> TestResult<()> {
822        let raw_value = 1;
823        let value = Value::Date(raw_value);
824        let result = crate::from_value::<i32>(&value)?;
825        assert_eq!(result, raw_value);
826        Ok(())
827    }
828
829    #[test]
830    fn test_time_millis() -> TestResult<()> {
831        let raw_value = 1;
832        let value = Value::TimeMillis(raw_value);
833        let result = crate::from_value::<i32>(&value)?;
834        assert_eq!(result, raw_value);
835        Ok(())
836    }
837
838    #[test]
839    fn test_time_micros() -> TestResult<()> {
840        let raw_value = 1;
841        let value = Value::TimeMicros(raw_value);
842        let result = crate::from_value::<i64>(&value)?;
843        assert_eq!(result, raw_value);
844        Ok(())
845    }
846
847    #[test]
848    fn test_timestamp_millis() -> TestResult<()> {
849        let raw_value = 1;
850        let value = Value::TimestampMillis(raw_value);
851        let result = crate::from_value::<i64>(&value)?;
852        assert_eq!(result, raw_value);
853        Ok(())
854    }
855
856    #[test]
857    fn test_timestamp_micros() -> TestResult<()> {
858        let raw_value = 1;
859        let value = Value::TimestampMicros(raw_value);
860        let result = crate::from_value::<i64>(&value)?;
861        assert_eq!(result, raw_value);
862        Ok(())
863    }
864
865    #[test]
866    fn test_from_value_uuid_str() -> TestResult<()> {
867        let raw_value = "9ec535ff-3e2a-45bd-91d3-0a01321b5a49";
868        let value = Value::Uuid(Uuid::parse_str(raw_value).unwrap());
869        let result = crate::from_value::<Uuid>(&value)?;
870        assert_eq!(result.to_string(), raw_value);
871        Ok(())
872    }
873
874    #[test]
875    fn test_from_value_uuid_slice() -> TestResult<()> {
876        let raw_value = &[4, 54, 67, 12, 43, 2, 2, 76, 32, 50, 87, 5, 1, 33, 43, 87];
877        let value = Value::Uuid(Uuid::from_slice(raw_value)?);
878        let result = crate::from_value::<Uuid>(&value)?;
879        assert_eq!(result.as_bytes(), raw_value);
880        Ok(())
881    }
882}
avro_rs/de.rs

avro_rs/
de.rs
