fn avro_3631_validate_schema_for_struct_with_byte_types()

in avro/src/bytes.rs [295:359]

• 62 lines of code
• 1 McCabe index (conditional complexity)

    fn avro_3631_validate_schema_for_struct_with_byte_types() {
        #[derive(Debug, Serialize)]
        struct TestStructWithBytes<'a> {
            #[serde(with = "serde_avro_bytes")]
            vec_field: Vec<u8>,
            #[serde(with = "serde_avro_bytes_opt")]
            vec_field_opt: Option<Vec<u8>>,

            #[serde(with = "serde_avro_fixed")]
            fixed_field: [u8; 6],
            #[serde(with = "serde_avro_fixed_opt")]
            fixed_field_opt: Option<[u8; 7]>,

            #[serde(with = "serde_avro_slice")]
            slice_field: &'a [u8],
            #[serde(with = "serde_avro_slice_opt")]
            slice_field_opt: Option<&'a [u8]>,
        }

        let test = TestStructWithBytes {
            vec_field: vec![2, 3, 4],
            vec_field_opt: Some(vec![2, 3, 4]),
            fixed_field: [1; 6],
            fixed_field_opt: Some([1; 7]),
            slice_field: &[1, 2, 3],
            slice_field_opt: Some(&[1, 2, 3]),
        };
        let value: Value = to_value(test).unwrap();
        let schema = Schema::parse_str(
            r#"
            {
              "type": "record",
              "name": "TestStructWithBytes",
              "fields": [ {
                "name": "vec_field",
                "type": "bytes"
              }, {
                "name": "vec_field_opt",
                "type": ["null", "bytes"]
              }, {
                "name": "fixed_field",
                "type": {
                  "name": "ByteData",
                  "type": "fixed",
                  "size": 6
                }
              }, {
                "name": "fixed_field_opt",
                "type": ["null", {
                  "name": "ByteData2",
                  "type": "fixed",
                  "size": 7
                } ]
              }, {
                "name": "slice_field",
                "type": "bytes"
              }, {
                "name": "slice_field_opt",
                "type": ["null", "bytes"]
              } ]
            }"#,
        )
        .unwrap();
        assert!(value.validate(&schema));
    }