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<'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    use serial_test::serial;
496    use std::sync::atomic::Ordering;
497
498    #[derive(Debug, Deserialize, Serialize, Clone)]
499    struct Test {
500        a: i64,
501        b: String,
502        decimal: Decimal,
503    }
504
505    #[derive(Debug, Deserialize, Serialize)]
506    struct TestInner {
507        a: Test,
508        b: i32,
509    }
510
511    #[derive(Debug, Deserialize, Serialize)]
512    struct TestUnitExternalEnum {
513        a: UnitExternalEnum,
514    }
515
516    #[derive(Debug, Deserialize, Serialize)]
517    enum UnitExternalEnum {
518        Val1,
519        Val2,
520    }
521
522    #[derive(Debug, Deserialize, Serialize)]
523    struct TestUnitInternalEnum {
524        a: UnitInternalEnum,
525    }
526
527    #[derive(Debug, Deserialize, Serialize)]
528    #[serde(tag = "t")]
529    enum UnitInternalEnum {
530        Val1,
531        Val2,
532    }
533
534    #[derive(Debug, Deserialize, Serialize)]
535    struct TestUnitAdjacentEnum {
536        a: UnitAdjacentEnum,
537    }
538
539    #[derive(Debug, Deserialize, Serialize)]
540    #[serde(tag = "t", content = "v")]
541    enum UnitAdjacentEnum {
542        Val1,
543        Val2,
544    }
545
546    #[derive(Debug, Deserialize, Serialize)]
547    struct TestUnitUntaggedEnum {
548        a: UnitUntaggedEnum,
549    }
550
551    #[derive(Debug, Deserialize, Serialize)]
552    #[serde(untagged)]
553    enum UnitUntaggedEnum {
554        Val1,
555        Val2,
556    }
557
558    #[derive(Debug, Serialize, Deserialize)]
559    struct TestSingleValueExternalEnum {
560        a: SingleValueExternalEnum,
561    }
562
563    #[derive(Debug, Serialize, Deserialize)]
564    enum SingleValueExternalEnum {
565        Double(f64),
566        String(String),
567    }
568
569    #[derive(Debug, Serialize, Deserialize)]
570    struct TestSingleValueInternalEnum {
571        a: SingleValueInternalEnum,
572    }
573
574    #[derive(Debug, Serialize, Deserialize)]
575    #[serde(tag = "t")]
576    enum SingleValueInternalEnum {
577        Double(f64),
578        String(String),
579    }
580
581    #[derive(Debug, Serialize, Deserialize)]
582    struct TestSingleValueAdjacentEnum {
583        a: SingleValueAdjacentEnum,
584    }
585    #[derive(Debug, Serialize, Deserialize)]
586    #[serde(tag = "t", content = "v")]
587    enum SingleValueAdjacentEnum {
588        Double(f64),
589        String(String),
590    }
591
592    #[derive(Debug, Serialize, Deserialize)]
593    struct TestSingleValueUntaggedEnum {
594        a: SingleValueUntaggedEnum,
595    }
596
597    #[derive(Debug, Serialize, Deserialize)]
598    #[serde(untagged)]
599    enum SingleValueUntaggedEnum {
600        Double(f64),
601        String(String),
602    }
603
604    #[derive(Debug, Serialize, Deserialize)]
605    struct TestStructExternalEnum {
606        a: StructExternalEnum,
607    }
608
609    #[derive(Debug, Serialize, Deserialize)]
610    enum StructExternalEnum {
611        Val1 { x: f32, y: f32 },
612        Val2 { x: f32, y: f32 },
613    }
614
615    #[derive(Debug, Serialize, Deserialize)]
616    struct TestStructInternalEnum {
617        a: StructInternalEnum,
618    }
619
620    #[derive(Debug, Serialize, Deserialize)]
621    #[serde(tag = "type")]
622    enum StructInternalEnum {
623        Val1 { x: f32, y: f32 },
624        Val2 { x: f32, y: f32 },
625    }
626
627    #[derive(Debug, Serialize, Deserialize)]
628    struct TestStructAdjacentEnum {
629        a: StructAdjacentEnum,
630    }
631
632    #[derive(Debug, Serialize, Deserialize)]
633    #[serde(tag = "t", content = "v")]
634    enum StructAdjacentEnum {
635        Val1 { x: f32, y: f32 },
636        Val2 { x: f32, y: f32 },
637    }
638
639    #[derive(Debug, Serialize, Deserialize)]
640    struct TestStructUntaggedEnum {
641        a: StructUntaggedEnum,
642    }
643
644    #[derive(Debug, Serialize, Deserialize)]
645    #[serde(untagged)]
646    enum StructUntaggedEnum {
647        Val1 { x: f32, y: f32 },
648        Val2 { x: f32, y: f32, z: f32 },
649    }
650
651    #[derive(Debug, Serialize, Deserialize)]
652    struct TestTupleExternalEnum {
653        a: TupleExternalEnum,
654    }
655
656    #[derive(Debug, Serialize, Deserialize)]
657    enum TupleExternalEnum {
658        Val1(f32, f32),
659        Val2(f32, f32, f32),
660    }
661
662    // Tuple Internal Enum cannot be instantiated
663
664    #[derive(Debug, Serialize, Deserialize)]
665    struct TestTupleAdjacentEnum {
666        a: TupleAdjacentEnum,
667    }
668
669    #[derive(Debug, Serialize, Deserialize)]
670    #[serde(tag = "t", content = "v")]
671    enum TupleAdjacentEnum {
672        Val1(f32, f32),
673        Val2(f32, f32, f32),
674    }
675
676    #[derive(Debug, Serialize, Deserialize)]
677    struct TestTupleUntaggedEnum {
678        a: TupleUntaggedEnum,
679    }
680
681    #[derive(Debug, Serialize, Deserialize)]
682    #[serde(untagged)]
683    enum TupleUntaggedEnum {
684        Val1(f32, f32),
685        Val2(f32, f32, f32),
686    }
687
688    #[test]
689    fn test_to_value() -> TestResult {
690        let test = Test {
691            a: 27,
692            b: "foo".to_owned(),
693            decimal: Decimal::from(vec![1, 24]),
694        };
695        let expected = Value::Record(vec![
696            ("a".to_owned(), Value::Long(27)),
697            ("b".to_owned(), Value::String("foo".to_owned())),
698            ("decimal".to_owned(), Value::Bytes(vec![1, 24])),
699        ]);
700
701        assert_eq!(to_value(test.clone())?, expected);
702
703        let test_inner = TestInner { a: test, b: 35 };
704
705        let expected_inner = Value::Record(vec![
706            (
707                "a".to_owned(),
708                Value::Record(vec![
709                    ("a".to_owned(), Value::Long(27)),
710                    ("b".to_owned(), Value::String("foo".to_owned())),
711                    ("decimal".to_owned(), Value::Bytes(vec![1, 24])),
712                ]),
713            ),
714            ("b".to_owned(), Value::Int(35)),
715        ]);
716
717        assert_eq!(to_value(test_inner)?, expected_inner);
718
719        Ok(())
720    }
721
722    #[test]
723    fn test_to_value_unit_enum() -> TestResult {
724        let test = TestUnitExternalEnum {
725            a: UnitExternalEnum::Val1,
726        };
727
728        let expected = Value::Record(vec![("a".to_owned(), Value::String("Val1".to_owned()))]);
729
730        assert_eq!(
731            to_value(test)?,
732            expected,
733            "Error serializing unit external enum"
734        );
735
736        let test = TestUnitInternalEnum {
737            a: UnitInternalEnum::Val1,
738        };
739
740        let expected = Value::Record(vec![(
741            "a".to_owned(),
742            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
743        )]);
744
745        assert_eq!(
746            to_value(test)?,
747            expected,
748            "Error serializing unit internal enum"
749        );
750
751        let test = TestUnitAdjacentEnum {
752            a: UnitAdjacentEnum::Val1,
753        };
754
755        let expected = Value::Record(vec![(
756            "a".to_owned(),
757            Value::Record(vec![("t".to_owned(), Value::String("Val1".to_owned()))]),
758        )]);
759
760        assert_eq!(
761            to_value(test)?,
762            expected,
763            "Error serializing unit adjacent enum"
764        );
765
766        let test = TestUnitUntaggedEnum {
767            a: UnitUntaggedEnum::Val1,
768        };
769
770        let expected = Value::Record(vec![("a".to_owned(), Value::Null)]);
771
772        assert_eq!(
773            to_value(test)?,
774            expected,
775            "Error serializing unit untagged enum"
776        );
777
778        Ok(())
779    }
780
781    #[test]
782    fn test_to_value_single_value_enum() -> TestResult {
783        let test = TestSingleValueExternalEnum {
784            a: SingleValueExternalEnum::Double(64.0),
785        };
786
787        let expected = Value::Record(vec![(
788            "a".to_owned(),
789            Value::Record(vec![
790                ("type".to_owned(), Value::Enum(0, "Double".to_owned())),
791                (
792                    "value".to_owned(),
793                    Value::Union(0, Box::new(Value::Double(64.0))),
794                ),
795            ]),
796        )]);
797
798        assert_eq!(
799            to_value(test)?,
800            expected,
801            "Error serializing single value external enum"
802        );
803
804        // It is not possible to serialize an internal Single Value enum...
805        let test = TestSingleValueInternalEnum {
806            a: SingleValueInternalEnum::Double(64.0),
807        };
808
809        assert!(to_value(test).is_err(), "{}", true);
810
811        let test = TestSingleValueAdjacentEnum {
812            a: SingleValueAdjacentEnum::Double(64.0),
813        };
814
815        let expected = Value::Record(vec![(
816            "a".to_owned(),
817            Value::Record(vec![
818                ("t".to_owned(), Value::String("Double".to_owned())),
819                ("v".to_owned(), Value::Double(64.0)),
820            ]),
821        )]);
822
823        assert_eq!(
824            to_value(test)?,
825            expected,
826            "Error serializing single value adjacent enum"
827        );
828
829        let test = TestSingleValueUntaggedEnum {
830            a: SingleValueUntaggedEnum::Double(64.0),
831        };
832
833        let expected = Value::Record(vec![("a".to_owned(), Value::Double(64.0))]);
834
835        assert_eq!(
836            to_value(test)?,
837            expected,
838            "Error serializing single value untagged enum"
839        );
840
841        Ok(())
842    }
843
844    #[test]
845    fn test_to_value_struct_enum() -> TestResult {
846        let test = TestStructExternalEnum {
847            a: StructExternalEnum::Val1 { x: 1.0, y: 2.0 },
848        };
849        let expected = Value::Record(vec![(
850            "a".to_owned(),
851            Value::Record(vec![
852                ("type".to_owned(), Value::Enum(0, "Val1".to_owned())),
853                (
854                    "value".to_owned(),
855                    Value::Union(
856                        0,
857                        Box::new(Value::Record(vec![
858                            ("x".to_owned(), Value::Float(1.0)),
859                            ("y".to_owned(), Value::Float(2.0)),
860                        ])),
861                    ),
862                ),
863            ]),
864        )]);
865
866        assert_eq!(
867            to_value(test)?,
868            expected,
869            "error serializing struct external enum"
870        );
871
872        // I don't think that this is feasible in avro
873
874        let test = TestStructInternalEnum {
875            a: StructInternalEnum::Val1 { x: 1.0, y: 2.0 },
876        };
877        let expected = Value::Record(vec![(
878            "a".to_owned(),
879            Value::Record(vec![
880                ("type".to_owned(), Value::String("Val1".to_owned())),
881                ("x".to_owned(), Value::Float(1.0)),
882                ("y".to_owned(), Value::Float(2.0)),
883            ]),
884        )]);
885
886        assert_eq!(
887            to_value(test)?,
888            expected,
889            "error serializing struct internal enum"
890        );
891
892        let test = TestStructAdjacentEnum {
893            a: StructAdjacentEnum::Val1 { x: 1.0, y: 2.0 },
894        };
895        let expected = Value::Record(vec![(
896            "a".to_owned(),
897            Value::Record(vec![
898                ("t".to_owned(), Value::String("Val1".to_owned())),
899                (
900                    "v".to_owned(),
901                    Value::Record(vec![
902                        ("x".to_owned(), Value::Float(1.0)),
903                        ("y".to_owned(), Value::Float(2.0)),
904                    ]),
905                ),
906            ]),
907        )]);
908
909        assert_eq!(
910            to_value(test)?,
911            expected,
912            "error serializing struct adjacent enum"
913        );
914
915        let test = TestStructUntaggedEnum {
916            a: StructUntaggedEnum::Val1 { x: 1.0, y: 2.0 },
917        };
918        let expected = Value::Record(vec![(
919            "a".to_owned(),
920            Value::Record(vec![
921                ("x".to_owned(), Value::Float(1.0)),
922                ("y".to_owned(), Value::Float(2.0)),
923            ]),
924        )]);
925
926        assert_eq!(
927            to_value(test)?,
928            expected,
929            "error serializing struct untagged enum"
930        );
931
932        let test = TestStructUntaggedEnum {
933            a: StructUntaggedEnum::Val2 {
934                x: 1.0,
935                y: 2.0,
936                z: 3.0,
937            },
938        };
939        let expected = Value::Record(vec![(
940            "a".to_owned(),
941            Value::Record(vec![
942                ("x".to_owned(), Value::Float(1.0)),
943                ("y".to_owned(), Value::Float(2.0)),
944                ("z".to_owned(), Value::Float(3.0)),
945            ]),
946        )]);
947
948        assert_eq!(
949            to_value(test)?,
950            expected,
951            "error serializing struct untagged enum variant"
952        );
953
954        Ok(())
955    }
956
957    #[test]
958    fn test_to_value_tuple_enum() -> TestResult {
959        let test = TestTupleExternalEnum {
960            a: TupleExternalEnum::Val2(1.0, 2.0, 3.0),
961        };
962
963        let expected = Value::Record(vec![(
964            "a".to_owned(),
965            Value::Record(vec![
966                ("type".to_owned(), Value::Enum(1, "Val2".to_owned())),
967                (
968                    "value".to_owned(),
969                    Value::Array(vec![
970                        Value::Union(1, Box::new(Value::Float(1.0))),
971                        Value::Union(1, Box::new(Value::Float(2.0))),
972                        Value::Union(1, Box::new(Value::Float(3.0))),
973                    ]),
974                ),
975            ]),
976        )]);
977
978        assert_eq!(
979            to_value(test)?,
980            expected,
981            "error serializing tuple external enum"
982        );
983
984        let test = TestTupleAdjacentEnum {
985            a: TupleAdjacentEnum::Val1(1.0, 2.0),
986        };
987
988        let expected = Value::Record(vec![(
989            "a".to_owned(),
990            Value::Record(vec![
991                ("t".to_owned(), Value::String("Val1".to_owned())),
992                (
993                    "v".to_owned(),
994                    Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
995                ),
996            ]),
997        )]);
998
999        assert_eq!(
1000            to_value(test)?,
1001            expected,
1002            "error serializing tuple adjacent enum"
1003        );
1004
1005        let test = TestTupleUntaggedEnum {
1006            a: TupleUntaggedEnum::Val1(1.0, 2.0),
1007        };
1008
1009        let expected = Value::Record(vec![(
1010            "a".to_owned(),
1011            Value::Array(vec![Value::Float(1.0), Value::Float(2.0)]),
1012        )]);
1013
1014        assert_eq!(
1015            to_value(test)?,
1016            expected,
1017            "error serializing tuple untagged enum"
1018        );
1019
1020        Ok(())
1021    }
1022
1023    #[test]
1024    #[serial(serde_is_human_readable)]
1025    fn avro_3747_human_readable_false() {
1026        use serde::ser::Serializer as SerdeSerializer;
1027
1028        crate::util::SERDE_HUMAN_READABLE.store(false, Ordering::Release);
1029
1030        let ser = &mut Serializer {};
1031
1032        assert_eq!(ser.is_human_readable(), false);
1033    }
1034
1035    #[test]
1036    #[serial(serde_is_human_readable)]
1037    fn avro_3747_human_readable_true() {
1038        use serde::ser::Serializer as SerdeSerializer;
1039
1040        crate::util::SERDE_HUMAN_READABLE.store(true, Ordering::Release);
1041
1042        let ser = &mut Serializer {};
1043
1044        assert!(ser.is_human_readable());
1045    }
1046}
apache_avro/ser.rs

apache_avro/
ser.rs
