Merge pull request #40 from bluesuncorp/v5-development

V5 development

Author: Dean Karn

baked_in.go

@@ -17,11 +17,13 @@ var BakedInValidators = map[string]Func{
 	"min":         hasMinOf,
 	"max":         hasMaxOf,
 	"eq":          isEq,
+	"ne":          isNe,
 	"lt":          isLt,
 	"lte":         isLte,
 	"gt":          isGt,
 	"gte":         isGte,
 	"eqfield":     isEqField,
+	"nefield":     isNeField,
 	"gtefield":    isGteField,
 	"gtfield":     isGtField,
 	"ltefield":    isLteField,
@@ -42,6 +44,14 @@ var BakedInValidators = map[string]Func{
 	"base64":      isBase64,
 }
 
+func isNeField(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !isEqField(top, current, field, param)
+}
+
+func isNe(top interface{}, current interface{}, field interface{}, param string) bool {
+	return !isEq(top, current, field, param)
+}
+
 func isEqField(top interface{}, current interface{}, field interface{}, param string) bool {
 
 	if current == nil {

doc.go

@@ -197,6 +197,11 @@ Here is a list of the current built in validators:
 		equal to the parameter given. For slices, arrays, and maps,
 		validates the number of items. (Usage: eq=10)
 
+	ne
+		For strings & numbers, eq will ensure that the value is not
+		equal to the parameter given. For slices, arrays, and maps,
+		validates the number of items. (Usage: eq=10)
+
 	gt
 		For numbers, this will ensure that the value is greater than the
 		parameter given. For strings, it checks that the string length
@@ -233,6 +238,13 @@ Here is a list of the current built in validators:
 		Validation on Password field using validate.Struct Usage(eqfield=ConfirmPassword)
 		Validating by field validate.FieldWithValue(password, confirmpassword, "eqfield")
 
+	nefield
+		This will validate the field value against another fields value either within
+		a struct or passed in field.
+		usage examples are for ensuring two colors are not the same:
+		Validation on Color field using validate.Struct Usage(nefield=Color2)
+		Validating by field validate.FieldWithValue(color1, color2, "nefield")
+
 	gtfield
 		Only valid for Numbers and time.Time types, this will validate the field value
 		against another fields value either within a struct or passed in field.

validator_test.go

@@ -142,6 +142,122 @@ func isEqualFunc(val interface{}, current interface{}, field interface{}, param
 	return current.(string) == field.(string)
 }
 
+func (ms *MySuite) TestIsNeFieldValidation(c *C) {
+
+	var j uint64
+	var k float64
+	s := "abcd"
+	i := 1
+	j = 1
+	k = 1.543
+	arr := []string{"test"}
+	now := time.Now().UTC()
+
+	var j2 uint64
+	var k2 float64
+	s2 := "abcdef"
+	i2 := 3
+	j2 = 2
+	k2 = 1.5434456
+	arr2 := []string{"test", "test2"}
+	arr3 := []string{"test"}
+	now2 := now
+
+	err := validate.FieldWithValue(s, s2, "nefield")
+	c.Assert(err, IsNil)
+
+	err = validate.FieldWithValue(i2, i, "nefield")
+	c.Assert(err, IsNil)
+
+	err = validate.FieldWithValue(j2, j, "nefield")
+	c.Assert(err, IsNil)
+
+	err = validate.FieldWithValue(k2, k, "nefield")
+	c.Assert(err, IsNil)
+
+	err = validate.FieldWithValue(arr2, arr, "nefield")
+	c.Assert(err, IsNil)
+
+	err = validate.FieldWithValue(now2, now, "nefield")
+	c.Assert(err, NotNil)
+
+	err = validate.FieldWithValue(arr3, arr, "nefield")
+	c.Assert(err, NotNil)
+
+	type Test struct {
+		Start *time.Time `validate:"nefield=End"`
+		End   *time.Time
+	}
+
+	sv := &Test{
+		Start: &now,
+		End:   &now,
+	}
+
+	errs := validate.Struct(sv)
+	c.Assert(errs, NotNil)
+
+	now3 := time.Now().UTC()
+
+	sv = &Test{
+		Start: &now,
+		End:   &now3,
+	}
+
+	errs = validate.Struct(sv)
+	c.Assert(errs, IsNil)
+
+	channel := make(chan string)
+
+	c.Assert(func() { validate.FieldWithValue(nil, 1, "nefield") }, PanicMatches, "struct not passed for cross validation")
+	c.Assert(func() { validate.FieldWithValue(5, channel, "nefield") }, PanicMatches, "Bad field type chan string")
+	c.Assert(func() { validate.FieldWithValue(5, now, "nefield") }, PanicMatches, "Bad Top Level field type")
+
+	type Test2 struct {
+		Start *time.Time `validate:"nefield=NonExistantField"`
+		End   *time.Time
+	}
+
+	sv2 := &Test2{
+		Start: &now,
+		End:   &now,
+	}
+
+	c.Assert(func() { validate.Struct(sv2) }, PanicMatches, "Field \"NonExistantField\" not found in struct")
+}
+
+func (ms *MySuite) TestIsNeValidation(c *C) {
+
+	var j uint64
+	var k float64
+	s := "abcdef"
+	i := 3
+	j = 2
+	k = 1.5434
+	arr := []string{"test"}
+	now := time.Now().UTC()
+
+	err := validate.Field(s, "ne=abcd")
+	c.Assert(err, IsNil)
+
+	err = validate.Field(i, "ne=1")
+	c.Assert(err, IsNil)
+
+	err = validate.Field(j, "ne=1")
+	c.Assert(err, IsNil)
+
+	err = validate.Field(k, "ne=1.543")
+	c.Assert(err, IsNil)
+
+	err = validate.Field(arr, "ne=2")
+	c.Assert(err, IsNil)
+
+	err = validate.Field(arr, "ne=1")
+	c.Assert(err, NotNil)
+
+	c.Assert(func() { validate.Field(now, "ne=now") }, PanicMatches, "Bad field type time.Time")
+}
+
 func (ms *MySuite) TestIsEqFieldValidation(c *C) {
 
 	var j uint64