Function test_can_validate_array_fields

validator_derive_tests/tests/nested.rs:402–468

()

#[test]
fn test_can_validate_array_fields() {
    #[derive(Validate)]
    struct ParentWithArrayOfChildren {
        #[validate(length(min = 1))]
        #[validate(nested)]
        child: [Child; 4],
    }

    #[derive(Validate, Serialize)]
    struct Child {
        #[validate(length(min = 1))]
        value: String,
    }

    let instance = ParentWithArrayOfChildren {
        child: [
            Child { value: "valid".to_string() },
            Child { value: String::new() },
            Child { value: "valid".to_string() },
            Child { value: String::new() },
        ],
    };

    let res = instance.validate();
    assert!(res.is_err());
    let err = res.unwrap_err();
    let errs = err.errors();
    assert_eq!(errs.len(), 1);
    assert!(errs.contains_key("child"));
    if let ValidationErrorsKind::List(ref errs) = errs["child"] {
        assert!(errs.contains_key(&1));
        unwrap_map(&errs[&1], |errs| {
            assert_eq!(errs.len(), 1);
            assert!(errs.contains_key("value"));
            if let ValidationErrorsKind::Field(ref errs) = errs["value"] {
                assert_eq!(errs.len(), 1);
                assert_eq!(errs[0].code, "length");
            } else {
                panic!("Expected field validation errors");
            }
        });
        assert!(errs.contains_key(&3));
        unwrap_map(&errs[&3], |errs| {
            assert_eq!(errs.len(), 1);
            assert!(errs.contains_key("value"));
            if let ValidationErrorsKind::Field(ref errs) = errs["value"] {
                assert_eq!(errs.len(), 1);
                assert_eq!(errs[0].code, "length");
            } else {
                panic!("Expected field validation errors");
            }
        });
    } else {
        panic!("Expected list validation errors");
    }

    // A valid struct should not fail
    let instance = ParentWithArrayOfChildren {