fix: accept JSON string defaults for decimal fields in union

Per Avro 1.12.0 Specification, §"Complex Types / Records", the JSON
encoding of a `bytes` field's default value is a string whose codepoints
0-255 map to byte values 0-255 (e.g. `"\u00FF"`). The same section
specifies that a union-typed field's default must correspond to the
first schema that matches in the union.

`decimal` is defined as a logical type over `bytes`, so this rule
transitively applies: a nullable decimal field expressed as
`[{bytes, logicalType: decimal}, null]` with a JSON string default
requires `resolve_decimal` to accept `Value::String` when validating
defaults at schema parse time. Before this change the parser rejected
such schemas with `GetDefaultUnion(Decimal, String)`, even though
Java and Python Avro accept them.

The added arm walks the string's codepoints, rejecting any above
0xFF, and returns a `Value::Decimal`. The precision check is skipped
because the spec does not require a default's byte length to cover
the declared precision — it only requires a valid `bytes` value.
Wire-level decoded records always reach `resolve_decimal` as
`Value::Bytes`, so this arm is exclusively a default-validation path.

Tests cover `\u0000`, a full 0..=255 round-trip, codepoints > 0xFF
being rejected, and end-to-end parsing of a nullable decimal record
schema.

Author: Laurent Valdes

avro/src/types.rs

@@ -846,6 +846,45 @@ impl Value {
                     Ok(Value::Decimal(Decimal::from(bytes)))
                 }
             }
+            // The Avro 1.12.0 Specification, §"Complex Types / Records",
+            // defines the JSON encoding of field default values. The
+            // "field default values" table lists `bytes` and `fixed` with
+            // json-type `string` (example `"\u00FF"`), and the surrounding
+            // prose states:
+            //
+            //   "Default values for bytes and fixed fields are JSON
+            //    strings, where Unicode code points 0-255 are mapped to
+            //    unsigned 8-bit byte values 0-255."
+            //
+            // The same section also states:
+            //
+            //   "Default values for union fields correspond to the first
+            //    schema that matches in the union."
+            //
+            // `decimal` is a logical type whose underlying representation
+            // is `bytes` (or `fixed`) — see §"Logical Types / Decimal" —
+            // so the rule above transitively applies to decimal defaults.
+            // When a nullable decimal field is expressed as a union whose
+            // first branch is `{bytes, logicalType: decimal}`, its JSON
+            // default is therefore a string, which reaches this function
+            // as `Value::String`. Wire-level decoded records always
+            // arrive as `Value::Bytes`, so this arm is exclusively a
+            // default-value validation path. The precision check is
+            // skipped because the spec does not require a default's byte
+            // length to cover the full declared precision — it only
+            // requires the value to be a valid member of the underlying
+            // `bytes` type.
+            Value::String(s) => {
+                let mut bytes = Vec::with_capacity(s.len());
+                for c in s.chars() {
+                    let cp = c as u32;
+                    if cp > 0xFF {
+                        return Err(Details::ResolveDecimal(Value::String(s)).into());
+                    }
+                    bytes.push(cp as u8);
+                }
+                Ok(Value::Decimal(Decimal::from(bytes)))
+            }
             other => Err(Details::ResolveDecimal(other).into()),
         }
     }
@@ -1776,6 +1815,96 @@ Field with name '"b"' is not a member of the map items"#,
         Ok(())
     }
 
+    #[test]
+    fn resolve_decimal_from_string_default() -> TestResult {
+        // Avro 1.12.0 Specification, §"Complex Types / Records":
+        //
+        //   "Default values for bytes and fixed fields are JSON strings,
+        //    where Unicode code points 0-255 are mapped to unsigned 8-bit
+        //    byte values 0-255."
+        //
+        // The `decimal` logical type (§"Logical Types / Decimal") is
+        // defined on top of `bytes`, so the same encoding rule applies to
+        // JSON-default-valued decimal fields, which reach `resolve_decimal`
+        // as `Value::String`.
+        let value = Value::String("\u{0000}".to_string());
+        let resolved = value.resolve(&Schema::Decimal(DecimalSchema {
+            precision: 10,
+            scale: 4,
+            inner: InnerDecimalSchema::Bytes,
+        }))?;
+        assert_eq!(resolved, Value::Decimal(Decimal::from(vec![0u8])));
+
+        // Full 0..=255 round-trip: every byte value is representable.
+        let mut all_bytes_str = String::new();
+        for b in 0u8..=255u8 {
+            all_bytes_str.push(char::from_u32(b as u32).unwrap());
+        }
+        let resolved = Value::String(all_bytes_str).resolve(&Schema::Decimal(DecimalSchema {
+            precision: 10,
+            scale: 0,
+            inner: InnerDecimalSchema::Bytes,
+        }))?;
+        assert_eq!(
+            resolved,
+            Value::Decimal(Decimal::from((0u8..=255u8).collect::<Vec<_>>()))
+        );
+
+        // Code points > 0xFF are not valid bytes defaults.
+        let value = Value::String("\u{0100}".to_string());
+        assert!(
+            value
+                .resolve(&Schema::Decimal(DecimalSchema {
+                    precision: 10,
+                    scale: 4,
+                    inner: InnerDecimalSchema::Bytes,
+                }))
+                .is_err()
+        );
+
+        Ok(())
+    }
+
+    /// A nullable `decimal` field expressed as `[{bytes, logicalType:
+    /// decimal}, null]` with a JSON string default. Per Avro 1.12.0
+    /// Specification, §"Complex Types / Records":
+    ///
+    ///   "Default values for bytes and fixed fields are JSON strings,
+    ///    where Unicode code points 0-255 are mapped to unsigned 8-bit
+    ///    byte values 0-255."
+    ///
+    /// and
+    ///
+    ///   "Default values for union fields correspond to the first schema
+    ///    that matches in the union."
+    ///
+    /// Without the `Value::String` arm in `resolve_decimal`, schema
+    /// parsing fails with `GetDefaultUnion(Decimal, String)`.
+    #[test]
+    fn parse_schema_with_nullable_decimal_string_default() -> TestResult {
+        let schema_json = r#"{
+            "type": "record",
+            "name": "NullableDecimal",
+            "fields": [
+                {
+                    "name": "amount",
+                    "type": [
+                        {
+                            "type": "bytes",
+                            "scale": 4,
+                            "precision": 10,
+                            "logicalType": "decimal"
+                        },
+                        "null"
+                    ],
+                    "default": "\u0000"
+                }
+            ]
+        }"#;
+        Schema::parse_str(schema_json)?;
+        Ok(())
+    }
+
     #[test]
     fn resolve_decimal_invalid_scale() {
         let value = Value::Decimal(Decimal::from(vec![1, 2]));