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

apache_avro/serde/
ser.rs
