Support lists validation in resources schema definition

builtin/providers/aws/resource_aws_elb.go

@@ -195,6 +195,13 @@ func resourceAwsElb() *schema.Resource {
 					},
 				},
 				Set: resourceAwsElbHealthCheckHash,
+				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
+					vs := v.([]interface{})
+					if len(vs) > 1 {
+						errors = append(errors, fmt.Errorf("ELB doesn't support multiple health checks"))
+					}
+					return
+				},
 			},
 
 			"dns_name": &schema.Schema{

helper/schema/schema.go

@@ -542,13 +542,6 @@ func (m schemaMap) InternalValidate(topSchemaMap schemaMap) error {
 				}
 			}
 		}
-
-		if v.ValidateFunc != nil {
-			switch v.Type {
-			case TypeList, TypeSet:
-				return fmt.Errorf("ValidateFunc is not yet supported on lists or sets.")
-			}
-		}
 	}
 
 	return nil
@@ -1078,6 +1071,23 @@ func (m schemaMap) validateList(
 		}
 	}
 
+	if schema.ValidateFunc != nil {
+		validatableList := make([]interface{}, 0, len(raws))
+		for _, raw := range raws {
+			switch schema.Elem.(type) {
+			case *Resource:
+				validatableMap := make(map[string]interface{})
+				for k, v := range raw.(map[string]interface{}) {
+					validatableMap[k] = v
+				}
+				validatableList = append(validatableList, validatableMap)
+			case *Schema:
+				validatableList = append(validatableList, raw)
+			}
+		}
+		return schema.ValidateFunc(validatableList, k)
+	}
+
 	return ws, es
 }
 

helper/schema/schema_test.go

@@ -2829,6 +2829,9 @@ func TestSchemaMap_InternalValidate(t *testing.T) {
 				"foo": &Schema{
 					Type:     TypeList,
 					Optional: true,
+					ValidateFunc: func(v interface{}, k string) (ws []string, es []error) {
+						return
+					},
 					Elem: &Resource{
 						Schema: map[string]*Schema{
 							"foo": &Schema{
@@ -3550,6 +3553,94 @@ func TestSchemaMap_Validate(t *testing.T) {
 			},
 		},
 
+		"Good set with ValidateFunc": {
+			Schema: map[string]*Schema{
+				"validate_me": &Schema{
+					Type:     TypeSet,
+					Required: true,
+					Elem:     &Schema{Type: TypeInt},
+					Set: func(a interface{}) int {
+						return a.(int)
+					},
+					ValidateFunc: func(v interface{}, k string) (ws []string, es []error) {
+						if _, ok := v.([]interface{}); !ok {
+							t.Fatalf("Expected []interface{}, got: %#v", v)
+						}
+						return
+					},
+				},
+			},
+			Config: map[string]interface{}{
+				"validate_me": []interface{}{1},
+			},
+			Err: false,
+		},
+
+		"Bad set with ValidateFunc": {
+			Schema: map[string]*Schema{
+				"validate_me": &Schema{
+					Type:     TypeSet,
+					Required: true,
+					Elem:     &Schema{Type: TypeInt},
+					Set: func(a interface{}) int {
+						return a.(int)
+					},
+					ValidateFunc: func(v interface{}, k string) (ws []string, es []error) {
+						es = append(es, fmt.Errorf("something is not right here"))
+						return
+					},
+				},
+			},
+			Config: map[string]interface{}{
+				"validate_me": []interface{}{1},
+			},
+			Err: true,
+			Errors: []error{
+				fmt.Errorf(`something is not right here`),
+			},
+		},
+
+		"Good list with ValidateFunc": {
+			Schema: map[string]*Schema{
+				"validate_me": &Schema{
+					Type:     TypeList,
+					Required: true,
+					Elem:     &Schema{Type: TypeInt},
+					ValidateFunc: func(v interface{}, k string) (ws []string, es []error) {
+						if _, ok := v.([]interface{}); !ok {
+							t.Fatalf("Expected []interface{}, got: %#v", v)
+						}
+						return
+					},
+				},
+			},
+			Config: map[string]interface{}{
+				"validate_me": []interface{}{1, 2, 3},
+			},
+			Err: false,
+		},
+
+		"Bad list with ValidateFunc": {
+			Schema: map[string]*Schema{
+				"validate_me": &Schema{
+					Type:     TypeList,
+					Required: true,
+					Elem:     &Schema{Type: TypeInt},
+					ValidateFunc: func(v interface{}, k string) (ws []string, es []error) {
+						es = append(es, fmt.Errorf("something is not right here"))
+						return
+					},
+				},
+			},
+			Config: map[string]interface{}{
+				"validate_me": []interface{}{1, 2, 3},
+			},
+			Err: true,
+			Errors: []error{
+				fmt.Errorf(`something is not right here`),
+			},
+		},
+
 		"ValidateFunc not called when type does not match": {
 			Schema: map[string]*Schema{
 				"number": &Schema{