(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 344eb87a8778b9fddca63b257598f029473dd865
Author: Kriskras99 <git...@kriskras99.nl>
AuthorDate: Thu Dec 4 15:01:24 2025 +0100

    test: Different field order between Serde and the Schema
---
 avro_derive/tests/derive.rs | 66 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 63 insertions(+), 3 deletions(-)

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)
+    }
 }