apache_avro/
ser.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18//! Logic for serde-compatible serialization.
19use crate::{
20    Error,
21    bytes::{BytesType, SER_BYTES_TYPE},
22    types::Value,
23};
24use serde::{Serialize, ser};
25use std::{collections::HashMap, iter::once};
26
27#[derive(Clone, Default)]
28pub struct Serializer {}
29
30pub struct SeqSerializer {
31    items: Vec<Value>,
32}
33
34pub struct SeqVariantSerializer<'a> {
35    index: u32,
36    variant: &'a str,
37    items: Vec<Value>,
38}
39
40pub struct MapSerializer {
41    indices: HashMap<String, usize>,
42    values: Vec<Value>,
43}
44
45pub struct StructSerializer {
46    fields: Vec<(String, Value)>,
47}
48
49pub struct StructVariantSerializer<'a> {
50    index: u32,
51    variant: &'a str,
52    fields: Vec<(String, Value)>,
53}
54
55impl SeqSerializer {
56    pub fn new(len: Option<usize>) -> SeqSerializer {
57        let items = match len {
58            Some(len) => Vec::with_capacity(len),
59            None => Vec::new(),
60        };
61
62        SeqSerializer { items }
63    }
64}
65
66impl<'a> SeqVariantSerializer<'a> {
67    pub fn new(index: u32, variant: &'a str, len: Option<usize>) -> SeqVariantSerializer<'a> {
68        let items = match len {
69            Some(len) => Vec::with_capacity(len),
70            None => Vec::new(),
71        };
72        SeqVariantSerializer {
73            index,
74            variant,
75            items,
76        }
77    }
78}
79
80impl MapSerializer {
81    pub fn new(len: Option<usize>) -> MapSerializer {
82        let (indices, values) = match len {
83            Some(len) => (HashMap::with_capacity(len), Vec::with_capacity(len)),
84            None => (HashMap::new(), Vec::new()),
85        };
86
87        MapSerializer { indices, values }
88    }
89}
90
91impl StructSerializer {
92    pub fn new(len: usize) -> StructSerializer {
93        StructSerializer {
94            fields: Vec::with_capacity(len),
95        }
96    }
97}
98
99impl<'a> StructVariantSerializer<'a> {
100    pub fn new(index: u32, variant: &'a str, len: usize) -> StructVariantSerializer<'a> {
101        StructVariantSerializer {
102            index,
103            variant,
104            fields: Vec::with_capacity(len),
105        }
106    }
107}
108
109impl<'b> ser::Serializer for &'b mut Serializer {
110    type Ok = Value;
111    type Error = Error;
112    type SerializeSeq = SeqSerializer;
113    type SerializeTuple = SeqSerializer;
114    type SerializeTupleStruct = SeqSerializer;
115    type SerializeTupleVariant = SeqVariantSerializer<'b>;
116    type SerializeMap = MapSerializer;
117    type SerializeStruct = StructSerializer;
118    type SerializeStructVariant = StructVariantSerializer<'b>;
119
120    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
121        Ok(Value::Boolean(v))
122    }
123
124    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
125        self.serialize_i32(i32::from(v))
126    }
127
128    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
129        self.serialize_i32(i32::from(v))
130    }
131
132    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
133        Ok(Value::Int(v))
134    }
135
136    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
137        Ok(Value::Long(v))
138    }
139
140    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
141        self.serialize_i32(i32::from(v))
142    }
143
144    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
145        self.serialize_i32(i32::from(v))
146    }
147
148    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
149        if v <= i32::MAX as u32 {
150            self.serialize_i32(v as i32)
151        } else {
152            self.serialize_i64(i64::from(v))
153        }
154    }
155
156    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
157        if v <= i64::MAX as u64 {
158            self.serialize_i64(v as i64)
159        } else {
160            Err(ser::Error::custom("u64 is too large"))
161        }
162    }
163
164    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
165        Ok(Value::Float(v))
166    }
167
168    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
169        Ok(Value::Double(v))
170    }
171
172    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
173        self.serialize_str(&once(v).collect::<String>())
174    }
175
176    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
177        Ok(Value::String(v.to_owned()))
178    }
179
180    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
181        match SER_BYTES_TYPE.get() {
182            BytesType::Bytes => Ok(Value::Bytes(v.to_owned())),
183            BytesType::Fixed => Ok(Value::Fixed(v.len(), v.to_owned())),
184        }
185    }
186
187    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
188        Ok(Value::from(None::<Self::Ok>))
189    }
190
191    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
192    where
193        T: Serialize + ?Sized,
194    {
195        let v = value.serialize(&mut Serializer::default())?;
196        Ok(Value::from(Some(v)))
197    }
198
199    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
200        Ok(Value::Null)
201    }
202
203    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
204        self.serialize_unit()
205    }
206
207    fn serialize_unit_variant(
208        self,
209        _: &'static str,
210        _variant_index: u32,
211        variant: &'static str,
212    ) -> Result<Self::Ok, Self::Error> {
213        Ok(Value::String(variant.to_string()))
214    }
215
216    fn serialize_newtype_struct<T>(
217        self,
218        _: &'static str,
219        value: &T,
220    ) -> Result<Self::Ok, Self::Error>
221    where
222        T: Serialize + ?Sized,
223    {
224        value.serialize(self)
225    }
226
227    fn serialize_newtype_variant<T>(
228        self,
229        _: &'static str,
230        index: u32,
231        variant: &'static str,
232        value: &T,
233    ) -> Result<Self::Ok, Self::Error>
234    where
235        T: Serialize + ?Sized,
236    {
237        Ok(Value::Record(vec![
238            ("type".to_owned(), Value::Enum(index, variant.to_owned())),
239            (
240                "value".to_owned(),
241                Value::Union(index, Box::new(value.serialize(self)?)),
242            ),
243        ]))
244    }
245
246    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
247        Ok(SeqSerializer::new(len))
248    }
249
250    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
251        self.serialize_seq(Some(len))
252    }
253
254    fn serialize_tuple_struct(
255        self,
256        _: &'static str,
257        len: usize,
258    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
259        self.serialize_seq(Some(len))
260    }
261
262    fn serialize_tuple_variant(
263        self,
264        _: &'static str,
265        index: u32,
266        variant: &'static str,
267        len: usize,
268    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
269        Ok(SeqVariantSerializer::new(index, variant, Some(len)))
270    }
271
272    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
273        Ok(MapSerializer::new(len))
274    }
275
276    fn serialize_struct(
277        self,
278        _: &'static str,
279        len: usize,
280    ) -> Result<Self::SerializeStruct, Self::Error> {
281        Ok(StructSerializer::new(len))
282    }
283
284    fn serialize_struct_variant(
285        self,
286        _: &'static str,
287        index: u32,
288        variant: &'static str,
289        len: usize,
290    ) -> Result<Self::SerializeStructVariant, Self::Error> {
291        Ok(StructVariantSerializer::new(index, variant, len))
292    }
293
294    fn is_human_readable(&self) -> bool {
295        crate::util::is_human_readable()
296    }
297}
298
299impl ser::SerializeSeq for SeqSerializer {
300    type Ok = Value;
301    type Error = Error;
302
303    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
304    where
305        T: Serialize + ?Sized,
306    {
307        self.items
308            .push(value.serialize(&mut Serializer::default())?);
309        Ok(())
310    }
311
312    fn end(self) -> Result<Self::Ok, Self::Error> {
313        Ok(Value::Array(self.items))
314    }
315}
316
317impl ser::SerializeTuple for SeqSerializer {
318    type Ok = Value;
319    type Error = Error;
320
321    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
322    where
323        T: Serialize + ?Sized,
324    {
325        ser::SerializeSeq::serialize_element(self, value)
326    }
327
328    fn end(self) -> Result<Self::Ok, Self::Error> {
329        ser::SerializeSeq::end(self)
330    }
331}
332
333impl ser::SerializeTupleStruct for SeqSerializer {
334    type Ok = Value;
335    type Error = Error;
336
337    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
338    where
339        T: Serialize + ?Sized,
340    {
341        ser::SerializeSeq::serialize_element(self, value)
342    }
343
344    fn end(self) -> Result<Self::Ok, Self::Error> {
345        ser::SerializeSeq::end(self)
346    }
347}
348
349impl ser::SerializeSeq for SeqVariantSerializer<'_> {
350    type Ok = Value;
351    type Error = Error;
352
353    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
354    where
355        T: Serialize + ?Sized,
356    {
357        self.items.push(Value::Union(
358            self.index,
359            Box::new(value.serialize(&mut Serializer::default())?),
360        ));
361        Ok(())
362    }
363
364    fn end(self) -> Result<Self::Ok, Self::Error> {
365        Ok(Value::Record(vec![
366            (
367                "type".to_owned(),
368                Value::Enum(self.index, self.variant.to_owned()),
369            ),
370            ("value".to_owned(), Value::Array(self.items)),
371        ]))
372    }
373}
374
375impl ser::SerializeTupleVariant for SeqVariantSerializer<'_> {
376    type Ok = Value;
377    type Error = Error;
378
379    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
380    where
381        T: Serialize + ?Sized,
382    {
383        ser::SerializeSeq::serialize_element(self, value)
384    }
385
386    fn end(self) -> Result<Self::Ok, Self::Error> {
387        ser::SerializeSeq::end(self)
388    }
389}
390
391impl ser::SerializeMap for MapSerializer {
392    type Ok = Value;
393    type Error = Error;
394
395    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
396    where
397        T: Serialize + ?Sized,
398    {
399        let key = key.serialize(&mut Serializer::default())?;
400
401        if let Value::String(key) = key {
402            self.indices.insert(key, self.values.len());
403            Ok(())
404        } else {
405            Err(ser::Error::custom("map key is not a string"))
406        }
407    }
408
409    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
410    where
411        T: Serialize + ?Sized,
412    {
413        self.values
414            .push(value.serialize(&mut Serializer::default())?);
415        Ok(())
416    }
417
418    fn end(self) -> Result<Self::Ok, Self::Error> {
419        let mut items = HashMap::new();
420        for (key, index) in self.indices {
421            if let Some(value) = self.values.get(index) {
422                items.insert(key, value.clone());
423            }
424        }
425
426        Ok(Value::Map(items))
427    }
428}
429
430impl ser::SerializeStruct for StructSerializer {
431    type Ok = Value;
432    type Error = Error;
433
434    fn serialize_field<T>(&mut self, name: &'static str, value: &T) -> Result<(), Self::Error>
435    where
436        T: Serialize + ?Sized,
437    {
438        self.fields.push((
439            name.to_owned(),
440            value.serialize(&mut Serializer::default())?,
441        ));
442        Ok(())
443    }
444
445    fn end(self) -> Result<Self::Ok, Self::Error> {
446        Ok(Value::Record(self.fields))
447    }
448}
449
450impl ser::SerializeStructVariant for StructVariantSerializer<'_> {
451    type Ok = Value;
452    type Error = Error;
453
454    fn serialize_field<T>(&mut self, name: &'static str, value: &T) -> Result<(), Self::Error>
455    where
456        T: Serialize + ?Sized,
457    {
458        self.fields.push((
459            name.to_owned(),
460            value.serialize(&mut Serializer::default())?,
461        ));
462        Ok(())
463    }
464
465    fn end(self) -> Result<Self::Ok, Self::Error> {
466        Ok(Value::Record(vec![
467            (
468                "type".to_owned(),
469                Value::Enum(self.index, self.variant.to_owned()),
470            ),
471            (
472                "value".to_owned(),
473                Value::Union(self.index, Box::new(Value::Record(self.fields))),
474            ),
475        ]))
476    }
477}
478
479/// Interpret a serializeable instance as a `Value`.
480///
481/// This conversion can fail if the value is not valid as per the Avro specification.
482/// e.g: HashMap with non-string keys
483pub fn to_value<S: Serialize>(value: S) -> Result<Value, Error> {
484    let mut serializer = Serializer::default();
485    value.serialize(&mut serializer)
486}
487
488#[cfg(test)]
489mod tests {
490    use super::*;
491    use crate::Decimal;
492    use apache_avro_test_helper::TestResult;
493    use pretty_assertions::assert_eq;
494    use serde::{Deserialize, Serialize};
495
496    #[derive(Debug, Deserialize, Serialize, Clone)]
497    struct Test {
498        a: i64,
499        b: String,
500        decimal: Decimal,
501    }
502
503    #[derive(Debug, Deserialize, Serialize)]
504    struct TestInner {
505        a: Test,
506        b: i32,
507    }
508
509    #[derive(Debug, Deserialize, Serialize)]
510    struct TestUnitExternalEnum {
511        a: UnitExternalEnum,
512    }
513
514    #[derive(Debug, Deserialize, Serialize)]
515    enum UnitExternalEnum {
516        Val1,
517        Val2,
518    }
519
520    #[derive(Debug, Deserialize, Serialize)]
521    struct TestUnitInternalEnum {
522        a: UnitInternalEnum,
523    }
524
525    #[derive(Debug, Deserialize, Serialize)]
526    #[serde(tag = "t")]
527    enum UnitInternalEnum {
528        Val1,
529        Val2,
530    }
531
532    #[derive(Debug, Deserialize, Serialize)]
533    struct TestUnitAdjacentEnum {
534        a: UnitAdjacentEnum,
535    }
536
537    #[derive(Debug, Deserialize, Serialize)]
538    #[serde(tag = "t", content = "v")]
539    enum UnitAdjacentEnum {
540        Val1,
541        Val2,
542    }
543
544    #[derive(Debug, Deserialize, Serialize)]
545    struct TestUnitUntaggedEnum {
546        a: UnitUntaggedEnum,
547    }
548
549    #[derive(Debug, Deserialize, Serialize)]
550    #[serde(untagged)]
551    enum UnitUntaggedEnum {
552        Val1,
553        Val2,
554    }
555
556    #[derive(Debug, Serialize, Deserialize)]
557    struct TestSingleValueExternalEnum {
558        a: SingleValueExternalEnum,
559    }
560
561    #[derive(Debug, Serialize, Deserialize)]
562    enum SingleValueExternalEnum {
563        Double(f64),
564        String(String),
565    }
566
567    #[derive(Debug, Serialize, Deserialize)]
568    struct TestSingleValueInternalEnum {
569        a: SingleValueInternalEnum,
570    }
571
572    #[derive(Debug, Serialize, Deserialize)]
573    #[serde(tag = "t")]
574    enum SingleValueInternalEnum {
575        Double(f64),
576        String(String),
577    }
578
579    #[derive(Debug, Serialize, Deserialize)]
580    struct TestSingleValueAdjacentEnum {
581        a: SingleValueAdjacentEnum,
582    }
583    #[derive(Debug, Serialize, Deserialize)]
584    #[serde(tag = "t", content = "v")]
585    enum SingleValueAdjacentEnum {
586        Double(f64),
587        String(String),
588    }
589
590    #[derive(Debug, Serialize, Deserialize)]
591    struct TestSingleValueUntaggedEnum {
592        a: SingleValueUntaggedEnum,
593    }
594
595    #[derive(Debug, Serialize, Deserialize)]
596    #[serde(untagged)]
597    enum SingleValueUntaggedEnum {
598        Double(f64),
599        String(String),
600    }
601
602    #[derive(Debug, Serialize, Deserialize)]
603    struct TestStructExternalEnum {
604        a: StructExternalEnum,
605    }
606
607    #[derive(Debug, Serialize, Deserialize)]
608    enum StructExternalEnum {
609        Val1 { x: f32, y: f32 },
610        Val2 { x: f32, y: f32 },
611    }
612
613    #[derive(Debug, Serialize, Deserialize)]
614    struct TestStructInternalEnum {
615        a: StructInternalEnum,
616    }
617
618    #[derive(Debug, Serialize, Deserialize)]
619    #[serde(tag = "type")]
620    enum StructInternalEnum {
621        Val1 { x: f32, y: f32 },
622        Val2 { x: f32, y: f32 },
623    }
624
625    #[derive(Debug, Serialize, Deserialize)]
626    struct TestStructAdjacentEnum {
627        a: StructAdjacentEnum,
628    }
629
630    #[derive(Debug, Serialize, Deserialize)]
631    #[serde(tag = "t", content = "v")]
632    enum StructAdjacentEnum {
633        Val1 { x: f32, y: f32 },
634        Val2 { x: f32, y: f32 },
635    }
636
637    #[derive(Debug, Serialize, Deserialize)]
638    struct TestStructUntaggedEnum {
639        a: StructUntaggedEnum,
640    }
641
642    #[derive(Debug, Serialize, Deserialize)]
643    #[serde(untagged)]
644    enum StructUntaggedEnum {
645        Val1 { x: f32, y: f32 },
646        Val2 { x: f32, y: f32, z: f32 },
647    }
648
649    #[derive(Debug, Serialize, Deserialize)]
650    struct TestTupleExternalEnum {
651        a: TupleExternalEnum,
652    }
653
654    #[derive(Debug, Serialize, Deserialize)]
655    enum TupleExternalEnum {
656        Val1(f32, f32),
657        Val2(f32, f32, f32),
658    }
659
660    // Tuple Internal Enum cannot be instantiated
661
662    #[derive(Debug, Serialize, Deserialize)]
663    struct TestTupleAdjacentEnum {
664        a: TupleAdjacentEnum,
665    }
666
667    #[derive(Debug, Serialize, Deserialize)]
668    #[serde(tag = "t", content = "v")]
669    enum TupleAdjacentEnum {
670        Val1(f32, f32),
671        Val2(f32, f32, f32),
672    }
673
674    #[derive(Debug, Serialize, Deserialize)]
675    struct TestTupleUntaggedEnum {
676        a: TupleUntaggedEnum,
677    }
678
679    #[derive(Debug, Serialize, Deserialize)]
680    #[serde(untagged)]
681    enum TupleUntaggedEnum {
682        Val1(f32, f32),
683        Val2(f32, f32, f32),
684    }
685
686    #[test]
687    fn test_to_value() -> TestResult {
688        let test = Test {
689            a: 27,
690            b: "foo".to_owned(),
691            decimal: Decimal::from(vec![1, 24]),
692        };
693        let expected = Value::Record(vec![
694            ("a".to_owned(), Value::Long(27)),
695            ("b".to_owned(), Value::String("foo".to_owned())),
696            ("decimal".to_owned(), Value::Bytes(vec![1, 24])),
697        ]);
698
699        assert_eq!(to_value(test.clone())?, expected);
700
701        let test_inner = TestInner { a: test, b: 35 };
702
703        let expected_inner = Value::Record(vec![
704            (
705                "a".to_owned(),
706                Value::Record(vec![
707                    ("a".to_owned(), Value::Long(27)),
708                    ("b".to_owned(), Value::String("foo".to_owned())),
709                    ("decimal".to_owned(), Value::Bytes(vec![1, 24])),
710                ]),
711            ),
712            ("b".to_owned(), Value::Int(35)),
713        ]);
714
715        assert_eq!(to_value(test_inner)?, expected_inner);
716
717        Ok(())
718    }
719
720    #[test]
721    fn test_to_value_unit_enum() -> TestResult {
722        let test = TestUnitExternalEnum {
723            a: UnitExternalEnum::Val1,
724        };
725
726        let expected = Value::Record(vec![("a".to_owned(), Value::String("Val1".to_owned()))]);
727
728        assert_eq!(
729            to_value(test)?,
730            expected,
731            "Error serializing unit external enum"
732        );
733
734        let test = TestUnitInternalEnum {
735            a: UnitInternalEnum::Val1,
736        };
737
738        let expected = Value::Record(vec![(
739            "a".to_owned(),
740            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
741        )]);
742
743        assert_eq!(
744            to_value(test)?,
745            expected,
746            "Error serializing unit internal enum"
747        );
748
749        let test = TestUnitAdjacentEnum {
750            a: UnitAdjacentEnum::Val1,
751        };
752
753        let expected = Value::Record(vec![(
754            "a".to_owned(),
755            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
756        )]);
757
758        assert_eq!(
759            to_value(test)?,
760            expected,
761            "Error serializing unit adjacent enum"
762        );
763
764        let test = TestUnitUntaggedEnum {
765            a: UnitUntaggedEnum::Val1,
766        };
767
768        let expected = Value::Record(vec![("a".to_owned(), Value::Null)]);
769
770        assert_eq!(
771            to_value(test)?,
772            expected,
773            "Error serializing unit untagged enum"
774        );
775
776        Ok(())
777    }
778
779    #[test]
780    fn test_to_value_single_value_enum() -> TestResult {
781        let test = TestSingleValueExternalEnum {
782            a: SingleValueExternalEnum::Double(64.0),
783        };
784
785        let expected = Value::Record(vec![(
786            "a".to_owned(),
787            Value::Record(vec![
788                ("type".to_owned(), Value::Enum(0, "Double".to_owned())),
789                (
790                    "value".to_owned(),
791                    Value::Union(0, Box::new(Value::Double(64.0))),
792                ),
793            ]),
794        )]);
795
796        assert_eq!(
797            to_value(test)?,
798            expected,
799            "Error serializing single value external enum"
800        );
801
802        // It is not possible to serialize an internal Single Value enum...
803        let test = TestSingleValueInternalEnum {
804            a: SingleValueInternalEnum::Double(64.0),
805        };
806
807        assert!(to_value(test).is_err(), "{}", true);
808
809        let test = TestSingleValueAdjacentEnum {
810            a: SingleValueAdjacentEnum::Double(64.0),
811        };
812
813        let expected = Value::Record(vec![(
814            "a".to_owned(),
815            Value::Record(vec![
816                ("t".to_owned(), Value::String("Double".to_owned())),
817                ("v".to_owned(), Value::Double(64.0)),
818            ]),
819        )]);
820
821        assert_eq!(
822            to_value(test)?,
823            expected,
824            "Error serializing single value adjacent enum"
825        );
826
827        let test = TestSingleValueUntaggedEnum {
828            a: SingleValueUntaggedEnum::Double(64.0),
829        };
830
831        let expected = Value::Record(vec![("a".to_owned(), Value::Double(64.0))]);
832
833        assert_eq!(
834            to_value(test)?,
835            expected,
836            "Error serializing single value untagged enum"
837        );
838
839        Ok(())
840    }
841
842    #[test]
843    fn test_to_value_struct_enum() -> TestResult {
844        let test = TestStructExternalEnum {
845            a: StructExternalEnum::Val1 { x: 1.0, y: 2.0 },
846        };
847        let expected = Value::Record(vec![(
848            "a".to_owned(),
849            Value::Record(vec![
850                ("type".to_owned(), Value::Enum(0, "Val1".to_owned())),
851                (
852                    "value".to_owned(),
853                    Value::Union(
854                        0,
855                        Box::new(Value::Record(vec![
856                            ("x".to_owned(), Value::Float(1.0)),
857                            ("y".to_owned(), Value::Float(2.0)),
858                        ])),
859                    ),
860                ),
861            ]),
862        )]);
863
864        assert_eq!(
865            to_value(test)?,
866            expected,
867            "error serializing struct external enum"
868        );
869
870        // I don't think that this is feasible in avro
871
872        let test = TestStructInternalEnum {
873            a: StructInternalEnum::Val1 { x: 1.0, y: 2.0 },
874        };
875        let expected = Value::Record(vec![(
876            "a".to_owned(),
877            Value::Record(vec![
878                ("type".to_owned(), Value::String("Val1".to_owned())),
879                ("x".to_owned(), Value::Float(1.0)),
880                ("y".to_owned(), Value::Float(2.0)),
881            ]),
882        )]);
883
884        assert_eq!(
885            to_value(test)?,
886            expected,
887            "error serializing struct internal enum"
888        );
889
890        let test = TestStructAdjacentEnum {
891            a: StructAdjacentEnum::Val1 { x: 1.0, y: 2.0 },
892        };
893        let expected = Value::Record(vec![(
894            "a".to_owned(),
895            Value::Record(vec![
896                ("t".to_owned(), Value::String("Val1".to_owned())),
897                (
898                    "v".to_owned(),
899                    Value::Record(vec![
900                        ("x".to_owned(), Value::Float(1.0)),
901                        ("y".to_owned(), Value::Float(2.0)),
902                    ]),
903                ),
904            ]),
905        )]);
906
907        assert_eq!(
908            to_value(test)?,
909            expected,
910            "error serializing struct adjacent enum"
911        );
912
913        let test = TestStructUntaggedEnum {
914            a: StructUntaggedEnum::Val1 { x: 1.0, y: 2.0 },
915        };
916        let expected = Value::Record(vec![(
917            "a".to_owned(),
918            Value::Record(vec![
919                ("x".to_owned(), Value::Float(1.0)),
920                ("y".to_owned(), Value::Float(2.0)),
921            ]),
922        )]);
923
924        assert_eq!(
925            to_value(test)?,
926            expected,
927            "error serializing struct untagged enum"
928        );
929
930        let test = TestStructUntaggedEnum {
931            a: StructUntaggedEnum::Val2 {
932                x: 1.0,
933                y: 2.0,
934                z: 3.0,
935            },
936        };
937        let expected = Value::Record(vec![(
938            "a".to_owned(),
939            Value::Record(vec![
940                ("x".to_owned(), Value::Float(1.0)),
941                ("y".to_owned(), Value::Float(2.0)),
942                ("z".to_owned(), Value::Float(3.0)),
943            ]),
944        )]);
945
946        assert_eq!(
947            to_value(test)?,
948            expected,
949            "error serializing struct untagged enum variant"
950        );
951
952        Ok(())
953    }
954
955    #[test]
956    fn test_to_value_tuple_enum() -> TestResult {
957        let test = TestTupleExternalEnum {
958            a: TupleExternalEnum::Val2(1.0, 2.0, 3.0),
959        };
960
961        let expected = Value::Record(vec![(
962            "a".to_owned(),
963            Value::Record(vec![
964                ("type".to_owned(), Value::Enum(1, "Val2".to_owned())),
965                (
966                    "value".to_owned(),
967                    Value::Array(vec![
968                        Value::Union(1, Box::new(Value::Float(1.0))),
969                        Value::Union(1, Box::new(Value::Float(2.0))),
970                        Value::Union(1, Box::new(Value::Float(3.0))),
971                    ]),
972                ),
973            ]),
974        )]);
975
976        assert_eq!(
977            to_value(test)?,
978            expected,
979            "error serializing tuple external enum"
980        );
981
982        let test = TestTupleAdjacentEnum {
983            a: TupleAdjacentEnum::Val1(1.0, 2.0),
984        };
985
986        let expected = Value::Record(vec![(
987            "a".to_owned(),
988            Value::Record(vec![
989                ("t".to_owned(), Value::String("Val1".to_owned())),
990                (
991                    "v".to_owned(),
992                    Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
993                ),
994            ]),
995        )]);
996
997        assert_eq!(
998            to_value(test)?,
999            expected,
1000            "error serializing tuple adjacent enum"
1001        );
1002
1003        let test = TestTupleUntaggedEnum {
1004            a: TupleUntaggedEnum::Val1(1.0, 2.0),
1005        };
1006
1007        let expected = Value::Record(vec![(
1008            "a".to_owned(),
1009            Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
1010        )]);
1011
1012        assert_eq!(
1013            to_value(test)?,
1014            expected,
1015            "error serializing tuple untagged enum"
1016        );
1017
1018        Ok(())
1019    }
1020
1021    #[test]
1022    fn avro_3747_human_readable_false() {
1023        use serde::ser::Serializer as SerdeSerializer;
1024
1025        assert!(!crate::util::is_human_readable());
1026
1027        let ser = &mut Serializer {};
1028
1029        assert!(!ser.is_human_readable());
1030    }
1031}
apache_avro/ser.rs

apache_avro/
ser.rs
