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

apache_avro/serde/
ser.rs
