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    bytes::{BytesType, SER_BYTES_TYPE},
21    types::Value,
22    Error,
23};
24use serde::{ser, Serialize};
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 {
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 {
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<'a> ser::SerializeSeq for SeqVariantSerializer<'a> {
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<'a> ser::SerializeTupleVariant for SeqVariantSerializer<'a> {
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<'a> ser::SerializeStructVariant for StructVariantSerializer<'a> {
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 apache_avro_test_helper::TestResult;
492    use pretty_assertions::assert_eq;
493    use serde::{Deserialize, Serialize};
494    use serial_test::serial;
495    use std::sync::atomic::Ordering;
496
497    #[derive(Debug, Deserialize, Serialize, Clone)]
498    struct Test {
499        a: i64,
500        b: String,
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        };
692        let expected = Value::Record(vec![
693            ("a".to_owned(), Value::Long(27)),
694            ("b".to_owned(), Value::String("foo".to_owned())),
695        ]);
696
697        assert_eq!(to_value(test.clone())?, expected);
698
699        let test_inner = TestInner { a: test, b: 35 };
700
701        let expected_inner = Value::Record(vec![
702            (
703                "a".to_owned(),
704                Value::Record(vec![
705                    ("a".to_owned(), Value::Long(27)),
706                    ("b".to_owned(), Value::String("foo".to_owned())),
707                ]),
708            ),
709            ("b".to_owned(), Value::Int(35)),
710        ]);
711
712        assert_eq!(to_value(test_inner)?, expected_inner);
713
714        Ok(())
715    }
716
717    #[test]
718    fn test_to_value_unit_enum() -> TestResult {
719        let test = TestUnitExternalEnum {
720            a: UnitExternalEnum::Val1,
721        };
722
723        let expected = Value::Record(vec![("a".to_owned(), Value::String("Val1".to_owned()))]);
724
725        assert_eq!(
726            to_value(test)?,
727            expected,
728            "Error serializing unit external enum"
729        );
730
731        let test = TestUnitInternalEnum {
732            a: UnitInternalEnum::Val1,
733        };
734
735        let expected = Value::Record(vec![(
736            "a".to_owned(),
737            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
738        )]);
739
740        assert_eq!(
741            to_value(test)?,
742            expected,
743            "Error serializing unit internal enum"
744        );
745
746        let test = TestUnitAdjacentEnum {
747            a: UnitAdjacentEnum::Val1,
748        };
749
750        let expected = Value::Record(vec![(
751            "a".to_owned(),
752            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
753        )]);
754
755        assert_eq!(
756            to_value(test)?,
757            expected,
758            "Error serializing unit adjacent enum"
759        );
760
761        let test = TestUnitUntaggedEnum {
762            a: UnitUntaggedEnum::Val1,
763        };
764
765        let expected = Value::Record(vec![("a".to_owned(), Value::Null)]);
766
767        assert_eq!(
768            to_value(test)?,
769            expected,
770            "Error serializing unit untagged enum"
771        );
772
773        Ok(())
774    }
775
776    #[test]
777    fn test_to_value_single_value_enum() -> TestResult {
778        let test = TestSingleValueExternalEnum {
779            a: SingleValueExternalEnum::Double(64.0),
780        };
781
782        let expected = Value::Record(vec![(
783            "a".to_owned(),
784            Value::Record(vec![
785                ("type".to_owned(), Value::Enum(0, "Double".to_owned())),
786                (
787                    "value".to_owned(),
788                    Value::Union(0, Box::new(Value::Double(64.0))),
789                ),
790            ]),
791        )]);
792
793        assert_eq!(
794            to_value(test)?,
795            expected,
796            "Error serializing single value external enum"
797        );
798
799        // It is not possible to serialize an internal Single Value enum...
800        let test = TestSingleValueInternalEnum {
801            a: SingleValueInternalEnum::Double(64.0),
802        };
803
804        assert!(to_value(test).is_err(), "{}", true);
805
806        let test = TestSingleValueAdjacentEnum {
807            a: SingleValueAdjacentEnum::Double(64.0),
808        };
809
810        let expected = Value::Record(vec![(
811            "a".to_owned(),
812            Value::Record(vec![
813                ("t".to_owned(), Value::String("Double".to_owned())),
814                ("v".to_owned(), Value::Double(64.0)),
815            ]),
816        )]);
817
818        assert_eq!(
819            to_value(test)?,
820            expected,
821            "Error serializing single value adjacent enum"
822        );
823
824        let test = TestSingleValueUntaggedEnum {
825            a: SingleValueUntaggedEnum::Double(64.0),
826        };
827
828        let expected = Value::Record(vec![("a".to_owned(), Value::Double(64.0))]);
829
830        assert_eq!(
831            to_value(test)?,
832            expected,
833            "Error serializing single value untagged enum"
834        );
835
836        Ok(())
837    }
838
839    #[test]
840    fn test_to_value_struct_enum() -> TestResult {
841        let test = TestStructExternalEnum {
842            a: StructExternalEnum::Val1 { x: 1.0, y: 2.0 },
843        };
844        let expected = Value::Record(vec![(
845            "a".to_owned(),
846            Value::Record(vec![
847                ("type".to_owned(), Value::Enum(0, "Val1".to_owned())),
848                (
849                    "value".to_owned(),
850                    Value::Union(
851                        0,
852                        Box::new(Value::Record(vec![
853                            ("x".to_owned(), Value::Float(1.0)),
854                            ("y".to_owned(), Value::Float(2.0)),
855                        ])),
856                    ),
857                ),
858            ]),
859        )]);
860
861        assert_eq!(
862            to_value(test)?,
863            expected,
864            "error serializing struct external enum"
865        );
866
867        // I don't think that this is feasible in avro
868
869        let test = TestStructInternalEnum {
870            a: StructInternalEnum::Val1 { x: 1.0, y: 2.0 },
871        };
872        let expected = Value::Record(vec![(
873            "a".to_owned(),
874            Value::Record(vec![
875                ("type".to_owned(), Value::String("Val1".to_owned())),
876                ("x".to_owned(), Value::Float(1.0)),
877                ("y".to_owned(), Value::Float(2.0)),
878            ]),
879        )]);
880
881        assert_eq!(
882            to_value(test)?,
883            expected,
884            "error serializing struct internal enum"
885        );
886
887        let test = TestStructAdjacentEnum {
888            a: StructAdjacentEnum::Val1 { x: 1.0, y: 2.0 },
889        };
890        let expected = Value::Record(vec![(
891            "a".to_owned(),
892            Value::Record(vec![
893                ("t".to_owned(), Value::String("Val1".to_owned())),
894                (
895                    "v".to_owned(),
896                    Value::Record(vec![
897                        ("x".to_owned(), Value::Float(1.0)),
898                        ("y".to_owned(), Value::Float(2.0)),
899                    ]),
900                ),
901            ]),
902        )]);
903
904        assert_eq!(
905            to_value(test)?,
906            expected,
907            "error serializing struct adjacent enum"
908        );
909
910        let test = TestStructUntaggedEnum {
911            a: StructUntaggedEnum::Val1 { x: 1.0, y: 2.0 },
912        };
913        let expected = Value::Record(vec![(
914            "a".to_owned(),
915            Value::Record(vec![
916                ("x".to_owned(), Value::Float(1.0)),
917                ("y".to_owned(), Value::Float(2.0)),
918            ]),
919        )]);
920
921        assert_eq!(
922            to_value(test)?,
923            expected,
924            "error serializing struct untagged enum"
925        );
926
927        let test = TestStructUntaggedEnum {
928            a: StructUntaggedEnum::Val2 {
929                x: 1.0,
930                y: 2.0,
931                z: 3.0,
932            },
933        };
934        let expected = Value::Record(vec![(
935            "a".to_owned(),
936            Value::Record(vec![
937                ("x".to_owned(), Value::Float(1.0)),
938                ("y".to_owned(), Value::Float(2.0)),
939                ("z".to_owned(), Value::Float(3.0)),
940            ]),
941        )]);
942
943        assert_eq!(
944            to_value(test)?,
945            expected,
946            "error serializing struct untagged enum variant"
947        );
948
949        Ok(())
950    }
951
952    #[test]
953    fn test_to_value_tuple_enum() -> TestResult {
954        let test = TestTupleExternalEnum {
955            a: TupleExternalEnum::Val2(1.0, 2.0, 3.0),
956        };
957
958        let expected = Value::Record(vec![(
959            "a".to_owned(),
960            Value::Record(vec![
961                ("type".to_owned(), Value::Enum(1, "Val2".to_owned())),
962                (
963                    "value".to_owned(),
964                    Value::Array(vec![
965                        Value::Union(1, Box::new(Value::Float(1.0))),
966                        Value::Union(1, Box::new(Value::Float(2.0))),
967                        Value::Union(1, Box::new(Value::Float(3.0))),
968                    ]),
969                ),
970            ]),
971        )]);
972
973        assert_eq!(
974            to_value(test)?,
975            expected,
976            "error serializing tuple external enum"
977        );
978
979        let test = TestTupleAdjacentEnum {
980            a: TupleAdjacentEnum::Val1(1.0, 2.0),
981        };
982
983        let expected = Value::Record(vec![(
984            "a".to_owned(),
985            Value::Record(vec![
986                ("t".to_owned(), Value::String("Val1".to_owned())),
987                (
988                    "v".to_owned(),
989                    Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
990                ),
991            ]),
992        )]);
993
994        assert_eq!(
995            to_value(test)?,
996            expected,
997            "error serializing tuple adjacent enum"
998        );
999
1000        let test = TestTupleUntaggedEnum {
1001            a: TupleUntaggedEnum::Val1(1.0, 2.0),
1002        };
1003
1004        let expected = Value::Record(vec![(
1005            "a".to_owned(),
1006            Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
1007        )]);
1008
1009        assert_eq!(
1010            to_value(test)?,
1011            expected,
1012            "error serializing tuple untagged enum"
1013        );
1014
1015        Ok(())
1016    }
1017
1018    #[test]
1019    #[serial(avro_3747)]
1020    fn avro_3747_human_readable_false() {
1021        use serde::ser::Serializer as SerdeSerializer;
1022
1023        crate::util::SERDE_HUMAN_READABLE.store(false, Ordering::Release);
1024
1025        let ser = &mut Serializer {};
1026
1027        assert_eq!(ser.is_human_readable(), false);
1028    }
1029
1030    #[test]
1031    #[serial(avro_3747)]
1032    fn avro_3747_human_readable_true() {
1033        use serde::ser::Serializer as SerdeSerializer;
1034
1035        crate::util::SERDE_HUMAN_READABLE.store(true, Ordering::Release);
1036
1037        let ser = &mut Serializer {};
1038
1039        assert!(ser.is_human_readable());
1040    }
1041}
apache_avro/ser.rs

apache_avro/
ser.rs
