(avro-rs) 01/01: test: Different field order between Serde and the Schema

[kriskras99]

This is an automated email from the ASF dual-hosted git repository.

kriskras99 pushed a commit to branch serde_ub
in repository https://gitbox.apache.org/repos/asf/avro-rs.git

commit 9c6b0fec3cc2e0366f24cfdec18d35e5ed44b9b4
Author: Kriskras99 <git...@kriskras99.nl>
AuthorDate: Thu Dec 4 15:12:50 2025 +0100

    test: Different field order between Serde and the Schema
---
 avro/src/ser_schema.rs      | 51 ++++++++++++++++++++++++++++++++---
 avro_derive/tests/derive.rs | 66 ++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 110 insertions(+), 7 deletions(-)

diff --git a/avro/src/ser_schema.rs b/avro/src/ser_schema.rs
index 5a91eb6..93fef0b 100644
--- a/avro/src/ser_schema.rs
+++ b/avro/src/ser_schema.rs
@@ -1740,13 +1740,11 @@ impl<'a, 's, W: Write> ser::Serializer for &'a mut 
SchemaAwareWriteSerializer<'s
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        Days, Duration, Millis, Months, decimal::Decimal, error::Details, 
schema::ResolvedSchema,
-    };
+    use crate::{Days, Duration, Millis, Months, decimal::Decimal, 
error::Details, schema::ResolvedSchema, Writer, Reader, from_value};
     use apache_avro_test_helper::TestResult;
     use bigdecimal::BigDecimal;
     use num_bigint::{BigInt, Sign};
-    use serde::Serialize;
+    use serde::{Deserialize, Serialize};
     use serde_bytes::{ByteArray, Bytes};
     use std::{
         collections::{BTreeMap, HashMap},
@@ -2900,4 +2898,49 @@ mod tests {
         string_record.serialize(&mut serializer)?;
         Ok(())
     }
+
+
+    #[test]
+    fn different_field_order_serde_vs_schema() -> TestResult {
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        struct Foo {
+            a: String,
+            b: String,
+        }
+        let schema = Schema::parse_str(
+            r#"
+        {
+            "type":"record",
+            "name":"Foo",
+            "fields": [
+                {
+                    "name":"b",
+                    "type":"string"
+                },
+                {
+                    "name":"a",
+                    "type":"string"
+                }
+            ]
+        }
+        "#,
+        )?;
+
+
+        let mut writer = Writer::new(&schema, Vec::new())?;
+        if let Err(e) = writer.append_ser(Foo {
+            a: "Hello".into(),
+            b: "World".into(),
+        }) {
+            panic!("{e:?}");
+        }
+        let encoded = writer.into_inner()?;
+        let mut reader = Reader::with_schema(&schema, &encoded[..])?;
+        let decoded = from_value::<Foo>(&reader.next().unwrap()?)?;
+        assert_eq!(decoded, Foo {
+            a: "Hello".into(),
+            b: "World".into(),
+        });
+        Ok(())
+    }
 }
diff --git a/avro_derive/tests/derive.rs b/avro_derive/tests/derive.rs
index 8d92c57..409e2d0 100644
--- a/avro_derive/tests/derive.rs
+++ b/avro_derive/tests/derive.rs
@@ -40,6 +40,13 @@ mod test_derive {
         assert_eq!(obj, serde(obj.clone()));
     }
 
+    fn serde_with_schema_assert<T>(obj: T, schema: &Schema)
+    where
+        T: std::fmt::Debug + Serialize + DeserializeOwned + Clone + PartialEq,
+    {
+        assert_eq!(obj, serde_with_schema(obj.clone(), schema));
+    }
+
     fn serde<T>(obj: T) -> T
     where
         T: Serialize + DeserializeOwned + AvroSchema,
@@ -47,12 +54,26 @@ mod test_derive {
         de(ser(obj))
     }
 
+    fn serde_with_schema<T>(obj: T, schema: &Schema) -> T
+    where
+        T: Serialize + DeserializeOwned,
+    {
+        de_with_schema(ser_with_schema(obj, schema), schema)
+    }
+
     fn ser<T>(obj: T) -> Vec<u8>
     where
         T: Serialize + AvroSchema,
     {
         let schema = T::get_schema();
-        let mut writer = Writer::new(&schema, Vec::new()).unwrap();
+        ser_with_schema(obj, &schema)
+    }
+
+    fn ser_with_schema<T>(obj: T, schema: &Schema) -> Vec<u8>
+    where
+        T: Serialize,
+    {
+        let mut writer = Writer::new(schema, Vec::new()).unwrap();
         if let Err(e) = writer.append_ser(obj) {
             panic!("{e:?}");
         }
@@ -63,9 +84,16 @@ mod test_derive {
     where
         T: DeserializeOwned + AvroSchema,
     {
-        assert!(!encoded.is_empty());
         let schema = T::get_schema();
-        let mut reader = Reader::with_schema(&schema, &encoded[..]).unwrap();
+        de_with_schema(encoded, &schema)
+    }
+
+    fn de_with_schema<T>(encoded: Vec<u8>, schema: &Schema) -> T
+    where
+        T: DeserializeOwned,
+    {
+        assert!(!encoded.is_empty());
+        let mut reader = Reader::with_schema(schema, &encoded[..]).unwrap();
         if let Some(res) = reader.next() {
             match res {
                 Ok(value) => {
@@ -1686,4 +1714,36 @@ mod test_derive {
             panic!("Unexpected schema type for Foo")
         }
     }
+
+    #[test]
+    fn different_field_order_serde_vs_schema() {
+        #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+        struct Foo {
+            a: String,
+            b: String,
+        }
+
+        let schema_str = r#"
+        {
+            "type":"record",
+            "name":"Foo",
+            "fields": [
+                {
+                    "name":"b",
+                    "type":"string"
+                },
+                {
+                    "name":"a",
+                    "type":"string"
+                }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str).unwrap();
+
+        serde_with_schema_assert(Foo {
+            a: "Hello".into(),
+            b: "World".into(),
+        }, &schema)
+    }
 }