AVRO-3631: Add more test cases

Signed-off-by: Martin Tzvetanov Grigorov <[email protected]>

Author: martin-g

lang/rust/avro/src/ser.rs

@@ -1059,21 +1059,23 @@ mod tests {
         struct TestStructFixedField<'a> {
             // will be serialized as Value::Array<Vec<Value::Int>>
             array_field: &'a [u8],
+            vec_field: Vec<u8>,
 
             // will be serialized as Value::Fixed
             #[serde(serialize_with = "avro_serialize_fixed")]
             fixed_field: [u8; 6],
             #[serde(serialize_with = "avro_serialize_fixed")]
             fixed_field2: &'a [u8],
+            #[serde(serialize_with = "avro_serialize_fixed")]
+            vec_field2: Vec<u8>,
 
             // will be serialized as Value::Bytes
             #[serde(serialize_with = "avro_serialize_bytes")]
             bytes_field: &'a [u8],
             #[serde(serialize_with = "avro_serialize_bytes")]
             bytes_field2: [u8; 6],
-
-            // will be serialized as Value::Array<Vec<Value::Int>>
-            vec_field: Vec<u8>,
+            #[serde(serialize_with = "avro_serialize_bytes")]
+            vec_field3: Vec<u8>,
         }
 
         let test = TestStructFixedField {
@@ -1083,6 +1085,8 @@ mod tests {
             fixed_field: [1; 6],
             fixed_field2: &[6, 66],
             vec_field: vec![3, 33],
+            vec_field2: vec![4, 44],
+            vec_field3: vec![5, 55],
         };
         let expected = Value::Record(vec![
             (
@@ -1094,6 +1098,15 @@ mod tests {
                         .collect(),
                 ),
             ),
+            (
+                "vec_field".to_owned(),
+                Value::Array(
+                    test.vec_field
+                        .iter()
+                        .map(|i| Value::Int(*i as i32))
+                        .collect(),
+                ),
+            ),
             (
                 "fixed_field".to_owned(),
                 Value::Fixed(6, Vec::from(test.fixed_field)),
@@ -1102,6 +1115,10 @@ mod tests {
                 "fixed_field2".to_owned(),
                 Value::Fixed(2, Vec::from(test.fixed_field2)),
             ),
+            (
+                "vec_field2".to_owned(),
+                Value::Fixed(2, Vec::from(test.vec_field2.clone())),
+            ),
             (
                 "bytes_field".to_owned(),
                 Value::Bytes(Vec::from(test.bytes_field)),
@@ -1111,13 +1128,8 @@ mod tests {
                 Value::Bytes(Vec::from(test.bytes_field2)),
             ),
             (
-                "vec_field".to_owned(),
-                Value::Array(
-                    test.vec_field
-                        .iter()
-                        .map(|i| Value::Int(*i as i32))
-                        .collect(),
-                ),
+                "vec_field3".to_owned(),
+                Value::Bytes(Vec::from(test.vec_field3.clone())),
             ),
         ]);
         assert_eq!(expected, to_value(test).unwrap());

lang/rust/avro/src/types.rs

@@ -535,10 +535,10 @@ impl Value {
                     }
                 })
             }
-            (v, s) => Some(format!(
-                "Unsupported value-schema combination: \nValue: {:?},\nSchema: {:?}",
-                v, s
-            )),
+            (v, s) => {
+                debug!("Unsupported value-schema ({:?}-{:?}) combination:", v, s);
+                Some("Unsupported value-schema combination".to_string())
+            }
         }
     }
 
@@ -2405,11 +2405,10 @@ Field with name '"b"' is not a member of the map items"#,
         struct TestStructFixedField<'a> {
             #[serde(serialize_with = "avro_serialize_bytes")]
             bytes_field: &'a [u8],
+            #[serde(serialize_with = "avro_serialize_bytes")]
             vec_field: Vec<u8>,
             #[serde(serialize_with = "avro_serialize_fixed")]
             fixed_field: [u8; 6],
-            // #[serde(with = "serde_bytes")]
-            // #[serde(with = "serde_bytes")]
         }
 
         let test = TestStructFixedField {