Merge pull request #301 from katbyte/kt/validation-make-names-consistent

Validation - Rename some validators to make names more consistant

Author: appilon

helper/validation/int.go

@@ -10,57 +10,57 @@ import (
 // IntBetween returns a SchemaValidateFunc which tests if the provided value
 // is of type int and is between min and max (inclusive)
 func IntBetween(min, max int) schema.SchemaValidateFunc {
-	return func(i interface{}, k string) (s []string, es []error) {
+	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
-			es = append(es, fmt.Errorf("expected type of %s to be int", k))
-			return
+			errors = append(errors, fmt.Errorf("expected type of %s to be integer", k))
+			return warnings, errors
 		}
 
 		if v < min || v > max {
-			es = append(es, fmt.Errorf("expected %s to be in the range (%d - %d), got %d", k, min, max, v))
-			return
+			errors = append(errors, fmt.Errorf("expected %s to be in the range (%d - %d), got %d", k, min, max, v))
+			return warnings, errors
 		}
 
-		return
+		return warnings, errors
 	}
 }
 
 // IntAtLeast returns a SchemaValidateFunc which tests if the provided value
 // is of type int and is at least min (inclusive)
 func IntAtLeast(min int) schema.SchemaValidateFunc {
-	return func(i interface{}, k string) (s []string, es []error) {
+	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
-			es = append(es, fmt.Errorf("expected type of %s to be int", k))
-			return
+			errors = append(errors, fmt.Errorf("expected type of %s to be integer", k))
+			return warnings, errors
 		}
 
 		if v < min {
-			es = append(es, fmt.Errorf("expected %s to be at least (%d), got %d", k, min, v))
-			return
+			errors = append(errors, fmt.Errorf("expected %s to be at least (%d), got %d", k, min, v))
+			return warnings, errors
 		}
 
-		return
+		return warnings, errors
 	}
 }
 
 // IntAtMost returns a SchemaValidateFunc which tests if the provided value
 // is of type int and is at most max (inclusive)
 func IntAtMost(max int) schema.SchemaValidateFunc {
-	return func(i interface{}, k string) (s []string, es []error) {
+	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
-			es = append(es, fmt.Errorf("expected type of %s to be int", k))
-			return
+			errors = append(errors, fmt.Errorf("expected type of %s to be integer", k))
+			return warnings, errors
 		}
 
 		if v > max {
-			es = append(es, fmt.Errorf("expected %s to be at most (%d), got %d", k, max, v))
-			return
+			errors = append(errors, fmt.Errorf("expected %s to be at most (%d), got %d", k, max, v))
+			return warnings, errors
 		}
 
-		return
+		return warnings, errors
 	}
 }
 
@@ -70,13 +70,13 @@ func IntDivisibleBy(divisor int) schema.SchemaValidateFunc {
 	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
-			errors = append(errors, fmt.Errorf("expected type of %s to be int", k))
-			return
+			errors = append(errors, fmt.Errorf("expected type of %s to be integer", k))
+			return warnings, errors
 		}
 
 		if math.Mod(float64(v), float64(divisor)) != 0 {
 			errors = append(errors, fmt.Errorf("expected %s to be divisible by %d, got: %v", k, divisor, i))
-			return
+			return warnings, errors
 		}
 
 		return warnings, errors
@@ -86,32 +86,32 @@ func IntDivisibleBy(divisor int) schema.SchemaValidateFunc {
 // IntInSlice returns a SchemaValidateFunc which tests if the provided value
 // is of type int and matches the value of an element in the valid slice
 func IntInSlice(valid []int) schema.SchemaValidateFunc {
-	return func(i interface{}, k string) (s []string, es []error) {
+	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
-			es = append(es, fmt.Errorf("expected type of %s to be an integer", k))
-			return
+			errors = append(errors, fmt.Errorf("expected type of %s to be integer", k))
+			return warnings, errors
 		}
 
 		for _, validInt := range valid {
 			if v == validInt {
-				return
+				return warnings, errors
 			}
 		}
 
-		es = append(es, fmt.Errorf("expected %s to be one of %v, got %d", k, valid, v))
-		return
+		errors = append(errors, fmt.Errorf("expected %s to be one of %v, got %d", k, valid, v))
+		return warnings, errors
 	}
 }
 
 // IntNotInSlice returns a SchemaValidateFunc which tests if the provided value
 // is of type int and matches the value of an element in the valid slice
 func IntNotInSlice(valid []int) schema.SchemaValidateFunc {
-	return func(i interface{}, k string) (_ []string, errors []error) {
+	return func(i interface{}, k string) (warnings []string, errors []error) {
 		v, ok := i.(int)
 		if !ok {
-			errors = append(errors, fmt.Errorf("expected type of %s to be an integer", k))
-			return
+			errors = append(errors, fmt.Errorf("expected type of %s to be integer", k))
+			return warnings, errors
 		}
 
 		for _, validInt := range valid {
@@ -120,6 +120,6 @@ func IntNotInSlice(valid []int) schema.SchemaValidateFunc {
 			}
 		}
 
-		return
+		return warnings, errors
 	}
 }

helper/validation/int_test.go

@@ -23,7 +23,7 @@ func TestValidationIntBetween(t *testing.T) {
 		{
 			val:         "1",
 			f:           IntBetween(2, 3),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be int"),
+			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
 		},
 	})
 }
@@ -46,7 +46,7 @@ func TestValidationIntAtLeast(t *testing.T) {
 		{
 			val:         "1",
 			f:           IntAtLeast(2),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be int"),
+			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
 		},
 	})
 }
@@ -69,7 +69,7 @@ func TestValidationIntAtMost(t *testing.T) {
 		{
 			val:         "1",
 			f:           IntAtMost(0),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be int"),
+			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
 		},
 	})
 }
@@ -124,7 +124,7 @@ func TestValidationIntInSlice(t *testing.T) {
 		{
 			val:         "InvalidValue",
 			f:           IntInSlice([]int{10, 20}),
-			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be an integer"),
+			expectedErr: regexp.MustCompile("expected type of [\\w]+ to be integer"),
 		},
 	})
 }

helper/validation/list.go

@@ -0,0 +1,41 @@
+package validation
+
+import "fmt"
+
+// ValidateListUniqueStrings is a ValidateFunc that ensures a list has no
+// duplicate items in it. It's useful for when a list is needed over a set
+// because order matters, yet the items still need to be unique.
+//
+// Deprecated: use ListOfUniqueStrings
+func ValidateListUniqueStrings(i interface{}, k string) (warnings []string, errors []error) {
+	return ListOfUniqueStrings(i, k)
+}
+
+// ValidateListUniqueStrings is a ValidateFunc that ensures a list has no
+// duplicate items in it. It's useful for when a list is needed over a set
+// because order matters, yet the items still need to be unique.
+func ListOfUniqueStrings(i interface{}, k string) (warnings []string, errors []error) {
+	v, ok := i.([]interface{})
+	if !ok {
+		errors = append(errors, fmt.Errorf("expected type of %q to be List", k))
+		return warnings, errors
+	}
+
+	for _, e := range v {
+		if _, eok := e.(string); !eok {
+			errors = append(errors, fmt.Errorf("expected %q to only contain string elements, found :%v", k, e))
+			return warnings, errors
+		}
+	}
+
+	for n1, i1 := range v {
+		for n2, i2 := range v {
+			if i1.(string) == i2.(string) && n1 != n2 {
+				errors = append(errors, fmt.Errorf("expected %q to not have duplicates: found 2 or more of %v", k, i1))
+				return warnings, errors
+			}
+		}
+	}
+
+	return warnings, errors
+}

helper/validation/list_test.go

@@ -0,0 +1,41 @@
+package validation
+
+import (
+	"testing"
+)
+
+func TestValidationListOfUniqueStrings(t *testing.T) {
+	cases := map[string]struct {
+		Value interface{}
+		Error bool
+	}{
+		"NotList": {
+			Value: "the list is a lie",
+			Error: true,
+		},
+		"NotListOfString": {
+			Value: []interface{}{"seven", 7},
+			Error: true,
+		},
+		"NonUniqueStrings": {
+			Value: []interface{}{"kt", "is", "kt"},
+			Error: true,
+		},
+		"UniqueStrings": {
+			Value: []interface{}{"thanks", "for", "all", "the", "fish"},
+			Error: false,
+		},
+	}
+
+	for tn, tc := range cases {
+		t.Run(tn, func(t *testing.T) {
+			_, errors := ListOfUniqueStrings(tc.Value, tn)
+
+			if len(errors) > 0 && !tc.Error {
+				t.Errorf("ListOfUniqueStrings(%s) produced an unexpected error", tc.Value)
+			} else if len(errors) == 0 && tc.Error {
+				t.Errorf("ListOfUniqueStrings(%s) did not error", tc.Value)
+			}
+		})
+	}
+}