reorganization of code + variables to more appropriate structs

pull/169/head
joeybloggs 9 years ago
parent 9988ba3f45
commit 10cf645b91
  1. 4
      baked_in.go
  2. 21
      benchmarks_test.go
  3. 22
      examples_test.go
  4. 8
      util.go
  5. 90
      validator.go
  6. 124
      validator_test.go

@ -14,14 +14,14 @@ import (
// defines a common or complex set of validation(s) to simplify // defines a common or complex set of validation(s) to simplify
// adding validation to structs. i.e. set key "_ageok" and the tags // adding validation to structs. i.e. set key "_ageok" and the tags
// are "gt=0,lte=130" or key "_preferredname" and tags "omitempty,gt=0,lte=60" // are "gt=0,lte=130" or key "_preferredname" and tags "omitempty,gt=0,lte=60"
var BakedInAliasValidators = map[string]string{ var bakedInAliasValidators = map[string]string{
"iscolor": "hexcolor|rgb|rgba|hsl|hsla", "iscolor": "hexcolor|rgb|rgba|hsl|hsla",
} }
// BakedInValidators is the default map of ValidationFunc // BakedInValidators is the default map of ValidationFunc
// you can add, remove or even replace items to suite your needs, // you can add, remove or even replace items to suite your needs,
// or even disregard and use your own map if so desired. // or even disregard and use your own map if so desired.
var BakedInValidators = map[string]Func{ var bakedInValidators = map[string]Func{
"required": hasValue, "required": hasValue,
"len": hasLengthOf, "len": hasLengthOf,
"min": hasMinOf, "min": hasMinOf,

@ -32,11 +32,6 @@ func BenchmarkFieldDiveFailure(b *testing.B) {
func BenchmarkFieldCustomTypeSuccess(b *testing.B) { func BenchmarkFieldCustomTypeSuccess(b *testing.B) {
// customTypes := map[reflect.Type]CustomTypeFunc{}
// customTypes[reflect.TypeOf((*sql.Valuer)(nil))] = ValidateValuerType
// customTypes[reflect.TypeOf(valuer{})] = ValidateValuerType
validate := New(Config{TagName: "validate"})
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{ val := valuer{
@ -50,11 +45,7 @@ func BenchmarkFieldCustomTypeSuccess(b *testing.B) {
func BenchmarkFieldCustomTypeFailure(b *testing.B) { func BenchmarkFieldCustomTypeFailure(b *testing.B) {
// customTypes := map[reflect.Type]CustomTypeFunc{} // validate := New(Config{TagName: "validate"})
// customTypes[reflect.TypeOf((*sql.Valuer)(nil))] = ValidateValuerType
// customTypes[reflect.TypeOf(valuer{})] = ValidateValuerType
validate := New(Config{TagName: "validate"})
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{} val := valuer{}
@ -78,11 +69,6 @@ func BenchmarkFieldOrTagFailure(b *testing.B) {
func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) { func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) {
// customTypes := map[reflect.Type]CustomTypeFunc{}
// customTypes[reflect.TypeOf((*sql.Valuer)(nil))] = ValidateValuerType
// customTypes[reflect.TypeOf(valuer{})] = ValidateValuerType
validate := New(Config{TagName: "validate"})
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{ val := valuer{
@ -103,11 +89,6 @@ func BenchmarkStructSimpleCustomTypeSuccess(b *testing.B) {
func BenchmarkStructSimpleCustomTypeFailure(b *testing.B) { func BenchmarkStructSimpleCustomTypeFailure(b *testing.B) {
// customTypes := map[reflect.Type]CustomTypeFunc{}
// customTypes[reflect.TypeOf((*sql.Valuer)(nil))] = ValidateValuerType
// customTypes[reflect.TypeOf(valuer{})] = ValidateValuerType
validate := New(Config{TagName: "validate"})
validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{}) validate.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
val := valuer{} val := valuer{}

@ -3,14 +3,12 @@ package validator_test
import ( import (
"fmt" "fmt"
"gopkg.in/bluesuncorp/validator.v7" // "gopkg.in/bluesuncorp/validator.v7"
"../validator"
) )
func ExampleValidate_new() { func ExampleValidate_new() {
config := validator.Config{ config := validator.Config{TagName: "validate"}
TagName: "validate",
ValidationFuncs: validator.BakedInValidators,
}
validator.New(config) validator.New(config)
} }
@ -19,16 +17,13 @@ func ExampleValidate_field() {
// This should be stored somewhere globally // This should be stored somewhere globally
var validate *validator.Validate var validate *validator.Validate
config := validator.Config{ config := validator.Config{TagName: "validate"}
TagName: "validate",
ValidationFuncs: validator.BakedInValidators,
}
validate = validator.New(config) validate = validator.New(config)
i := 0 i := 0
errs := validate.Field(i, "gt=1,lte=10") errs := validate.Field(i, "gt=1,lte=10")
err := errs[""] err := errs.(validator.ValidationErrors)[""]
fmt.Println(err.Field) fmt.Println(err.Field)
fmt.Println(err.Tag) fmt.Println(err.Tag)
fmt.Println(err.Kind) // NOTE: Kind and Type can be different i.e. time Kind=struct and Type=time.Time fmt.Println(err.Kind) // NOTE: Kind and Type can be different i.e. time Kind=struct and Type=time.Time
@ -48,10 +43,7 @@ func ExampleValidate_struct() {
// This should be stored somewhere globally // This should be stored somewhere globally
var validate *validator.Validate var validate *validator.Validate
config := validator.Config{ config := validator.Config{TagName: "validate"}
TagName: "validate",
ValidationFuncs: validator.BakedInValidators,
}
validate = validator.New(config) validate = validator.New(config)
@ -81,7 +73,7 @@ func ExampleValidate_struct() {
} }
errs := validate.Struct(user) errs := validate.Struct(user)
for _, v := range errs { for _, v := range errs.(validator.ValidationErrors) {
fmt.Println(v.Field) // Phone fmt.Println(v.Field) // Phone
fmt.Println(v.Tag) // required fmt.Println(v.Tag) // required
//... and so forth //... and so forth

@ -53,8 +53,8 @@ func (v *Validate) extractType(current reflect.Value) (reflect.Value, reflect.Ki
default: default:
if v.config.hasCustomFuncs { if v.hasCustomFuncs {
if fn, ok := v.config.customTypeFuncs[current.Type()]; ok { if fn, ok := v.customTypeFuncs[current.Type()]; ok {
return v.extractType(reflect.ValueOf(fn(current))) return v.extractType(reflect.ValueOf(fn(current)))
} }
} }
@ -248,9 +248,9 @@ func (v *Validate) parseTagsRecursive(cTag *cachedTag, tag, fieldName, alias str
for _, t := range strings.Split(tag, tagSeparator) { for _, t := range strings.Split(tag, tagSeparator) {
if v.config.hasAliasValidators { if v.hasAliasValidators {
// check map for alias and process new tags, otherwise process as usual // check map for alias and process new tags, otherwise process as usual
if tagsVal, ok := v.config.aliasValidators[t]; ok { if tagsVal, ok := v.aliasValidators[t]; ok {
leave := v.parseTagsRecursive(cTag, tagsVal, fieldName, t, true) leave := v.parseTagsRecursive(cTag, tagsVal, fieldName, t, true)

@ -40,9 +40,8 @@ const (
var ( var (
timeType = reflect.TypeOf(time.Time{}) timeType = reflect.TypeOf(time.Time{})
timePtrType = reflect.TypeOf(&time.Time{}) timePtrType = reflect.TypeOf(&time.Time{})
errsPool = &sync.Pool{New: newValidationErrors}
tagsCache = &tagCacheMap{m: map[string]*cachedTag{}}
emptyStructPtr = new(struct{}) emptyStructPtr = new(struct{})
errsPool = &sync.Pool{New: newValidationErrors}
) )
// returns new ValidationErrors to the pool // returns new ValidationErrors to the pool
@ -84,17 +83,18 @@ func (s *tagCacheMap) Set(key string, value *cachedTag) {
// Validate contains the validator settings passed in using the Config struct // Validate contains the validator settings passed in using the Config struct
type Validate struct { type Validate struct {
config Config config Config
validationFuncs map[string]Func
customTypeFuncs map[reflect.Type]CustomTypeFunc
aliasValidators map[string]string
hasCustomFuncs bool
hasAliasValidators bool
tagsCache *tagCacheMap
} }
// Config contains the options that a Validator instance will use. // Config contains the options that a Validator instance will use.
// It is passed to the New() function // It is passed to the New() function
type Config struct { type Config struct {
TagName string TagName string
validationFuncs map[string]Func
customTypeFuncs map[reflect.Type]CustomTypeFunc
aliasValidators map[string]string
hasCustomFuncs bool
hasAliasValidators bool
} }
// CustomTypeFunc allows for overriding or adding custom field type handler functions // CustomTypeFunc allows for overriding or adding custom field type handler functions
@ -149,20 +149,20 @@ func New(config Config) *Validate {
// if config.CustomTypeFuncs != nil && len(config.CustomTypeFuncs) > 0 { // if config.CustomTypeFuncs != nil && len(config.CustomTypeFuncs) > 0 {
// config.hasCustomFuncs = true // config.hasCustomFuncs = true
// } // }
v := &Validate{config: config} v := &Validate{config: config, tagsCache: &tagCacheMap{m: map[string]*cachedTag{}}}
if len(v.config.aliasValidators) == 0 { if len(v.aliasValidators) == 0 {
// must copy validators for separate validations to be used in each // must copy validators for separate validations to be used in each validator instance
v.config.aliasValidators = map[string]string{} v.aliasValidators = map[string]string{}
for k, val := range BakedInAliasValidators { for k, val := range bakedInAliasValidators {
v.RegisterAliasValidation(k, val) v.RegisterAliasValidation(k, val)
} }
} }
if len(v.config.validationFuncs) == 0 { if len(v.validationFuncs) == 0 {
// must copy validators for separate validations to be used in each // must copy validators for separate validations to be used in each instance
v.config.validationFuncs = map[string]Func{} v.validationFuncs = map[string]Func{}
for k, val := range BakedInValidators { for k, val := range bakedInValidators {
v.RegisterValidation(k, val) v.RegisterValidation(k, val)
} }
} }
@ -189,7 +189,7 @@ func (v *Validate) RegisterValidation(key string, f Func) error {
panic(fmt.Sprintf(restrictedTagErr, key)) panic(fmt.Sprintf(restrictedTagErr, key))
} }
v.config.validationFuncs[key] = f v.validationFuncs[key] = f
return nil return nil
} }
@ -197,15 +197,15 @@ func (v *Validate) RegisterValidation(key string, f Func) error {
// RegisterCustomTypeFunc registers a CustomTypeFunc against a number of types // RegisterCustomTypeFunc registers a CustomTypeFunc against a number of types
func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{}) { func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{}) {
if v.config.customTypeFuncs == nil { if v.customTypeFuncs == nil {
v.config.customTypeFuncs = map[reflect.Type]CustomTypeFunc{} v.customTypeFuncs = map[reflect.Type]CustomTypeFunc{}
} }
for _, t := range types { for _, t := range types {
v.config.customTypeFuncs[reflect.TypeOf(t)] = fn v.customTypeFuncs[reflect.TypeOf(t)] = fn
} }
v.config.hasCustomFuncs = true v.hasCustomFuncs = true
} }
// RegisterAliasValidation registers a mapping of a single validationstag that // RegisterAliasValidation registers a mapping of a single validationstag that
@ -216,28 +216,21 @@ func (v *Validate) RegisterCustomTypeFunc(fn CustomTypeFunc, types ...interface{
// will be the actual tag within the alias that failed. // will be the actual tag within the alias that failed.
func (v *Validate) RegisterAliasValidation(alias, tags string) { func (v *Validate) RegisterAliasValidation(alias, tags string) {
// if len(v.config.aliasValidators) == 0 {
// // must copy validators for separate validations to be used in each
// v.config.aliasValidators = map[string]string{}
// for k, val := range BakedInAliasValidators {
// v.config.aliasValidators[k] = val
// }
// }
_, ok := restrictedTags[alias] _, ok := restrictedTags[alias]
if ok || strings.ContainsAny(alias, restrictedTagChars) { if ok || strings.ContainsAny(alias, restrictedTagChars) {
panic(fmt.Sprintf(restrictedAliasErr, alias)) panic(fmt.Sprintf(restrictedAliasErr, alias))
} }
v.config.aliasValidators[alias] = tags v.aliasValidators[alias] = tags
v.config.hasAliasValidators = true v.hasAliasValidators = true
} }
// Field validates a single field using tag style validation and returns ValidationErrors // Field validates a single field using tag style validation and returns nil or ValidationErrors as type error.
// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
// NOTE: it returns ValidationErrors instead of a single FieldError because this can also // NOTE: it returns ValidationErrors instead of a single FieldError because this can also
// validate Array, Slice and maps fields which may contain more than one error // validate Array, Slice and maps fields which may contain more than one error
func (v *Validate) Field(field interface{}, tag string) ValidationErrors { func (v *Validate) Field(field interface{}, tag string) error {
errs := errsPool.Get().(ValidationErrors) errs := errsPool.Get().(ValidationErrors)
fieldVal := reflect.ValueOf(field) fieldVal := reflect.ValueOf(field)
@ -252,10 +245,11 @@ func (v *Validate) Field(field interface{}, tag string) ValidationErrors {
return errs return errs
} }
// FieldWithValue validates a single field, against another fields value using tag style validation and returns ValidationErrors // FieldWithValue validates a single field, against another fields value using tag style validation and returns nil or ValidationErrors.
// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
// NOTE: it returns ValidationErrors instead of a single FieldError because this can also // NOTE: it returns ValidationErrors instead of a single FieldError because this can also
// validate Array, Slice and maps fields which may contain more than one error // validate Array, Slice and maps fields which may contain more than one error
func (v *Validate) FieldWithValue(val interface{}, field interface{}, tag string) ValidationErrors { func (v *Validate) FieldWithValue(val interface{}, field interface{}, tag string) error {
errs := errsPool.Get().(ValidationErrors) errs := errsPool.Get().(ValidationErrors)
topVal := reflect.ValueOf(val) topVal := reflect.ValueOf(val)
@ -272,10 +266,9 @@ func (v *Validate) FieldWithValue(val interface{}, field interface{}, tag string
// StructPartial validates the fields passed in only, ignoring all others. // StructPartial validates the fields passed in only, ignoring all others.
// Fields may be provided in a namespaced fashion relative to the struct provided // Fields may be provided in a namespaced fashion relative to the struct provided
// i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name // i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name and returns nil or ValidationErrors as error
// NOTE: This is normally not needed, however in some specific cases such as: tied to a // You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
// legacy data structure, it will be useful func (v *Validate) StructPartial(current interface{}, fields ...string) error {
func (v *Validate) StructPartial(current interface{}, fields ...string) ValidationErrors {
sv, _ := v.extractType(reflect.ValueOf(current)) sv, _ := v.extractType(reflect.ValueOf(current))
name := sv.Type().Name() name := sv.Type().Name()
@ -330,10 +323,9 @@ func (v *Validate) StructPartial(current interface{}, fields ...string) Validati
// StructExcept validates all fields except the ones passed in. // StructExcept validates all fields except the ones passed in.
// Fields may be provided in a namespaced fashion relative to the struct provided // Fields may be provided in a namespaced fashion relative to the struct provided
// i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name // i.e. NestedStruct.Field or NestedArrayField[0].Struct.Name and returns nil or ValidationErrors as error
// NOTE: This is normally not needed, however in some specific cases such as: tied to a // You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
// legacy data structure, it will be useful func (v *Validate) StructExcept(current interface{}, fields ...string) error {
func (v *Validate) StructExcept(current interface{}, fields ...string) ValidationErrors {
sv, _ := v.extractType(reflect.ValueOf(current)) sv, _ := v.extractType(reflect.ValueOf(current))
name := sv.Type().Name() name := sv.Type().Name()
@ -356,7 +348,9 @@ func (v *Validate) StructExcept(current interface{}, fields ...string) Validatio
} }
// Struct validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified. // Struct validates a structs exposed fields, and automatically validates nested structs, unless otherwise specified.
func (v *Validate) Struct(current interface{}) ValidationErrors { // it returns nil or ValidationErrors as error.
// You will need to assert the error if it's not nil i.e. err.(validator.ValidationErrors) to access the map of errors.
func (v *Validate) Struct(current interface{}) error {
errs := errsPool.Get().(ValidationErrors) errs := errsPool.Get().(ValidationErrors)
sv := reflect.ValueOf(current) sv := reflect.ValueOf(current)
@ -420,11 +414,11 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.
return return
} }
cTag, isCached := tagsCache.Get(tag) cTag, isCached := v.tagsCache.Get(tag)
if !isCached { if !isCached {
cTag = v.parseTags(tag, name) cTag = v.parseTags(tag, name)
tagsCache.Set(tag, cTag) v.tagsCache.Set(tag, cTag)
} }
current, kind := v.extractType(current) current, kind := v.extractType(current)
@ -561,7 +555,7 @@ func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.
for _, val := range valTag.tagVals { for _, val := range valTag.tagVals {
valFunc, ok = v.config.validationFuncs[val[0]] valFunc, ok = v.validationFuncs[val[0]]
if !ok { if !ok {
panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, name))) panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, name)))
} }
@ -596,7 +590,7 @@ func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.
return true return true
} }
valFunc, ok = v.config.validationFuncs[valTag.tagVals[0][0]] valFunc, ok = v.validationFuncs[valTag.tagVals[0][0]]
if !ok { if !ok {
panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, name))) panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, name)))
} }

@ -113,7 +113,9 @@ type TestSlice struct {
var validate = New(Config{TagName: "validate"}) var validate = New(Config{TagName: "validate"})
func AssertError(t *testing.T, errs ValidationErrors, key, field, expectedTag string) { func AssertError(t *testing.T, err error, key, field, expectedTag string) {
errs := err.(ValidationErrors)
val, ok := errs[key] val, ok := errs[key]
EqualSkip(t, 2, ok, true) EqualSkip(t, 2, ok, true)
@ -242,7 +244,7 @@ func TestAliasTags(t *testing.T) {
errs = validate.Struct(tst) errs = validate.Struct(tst)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
AssertError(t, errs, "Test.Color", "Color", "iscolor") AssertError(t, errs, "Test.Color", "Color", "iscolor")
Equal(t, errs["Test.Color"].ActualTag, "hexcolor|rgb|rgba|hsl|hsla") Equal(t, errs.(ValidationErrors)["Test.Color"].ActualTag, "hexcolor|rgb|rgba|hsl|hsla")
validate.RegisterAliasValidation("req", "required,dive,iscolor") validate.RegisterAliasValidation("req", "required,dive,iscolor")
arr := []string{"val1", "#fff", "#000"} arr := []string{"val1", "#fff", "#000"}
@ -397,12 +399,12 @@ func TestStructPartial(t *testing.T) {
// these will fail as unset item IS tested // these will fail as unset item IS tested
errs = validate.StructExcept(tPartial, p1...) errs = validate.StructExcept(tPartial, p1...)
AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
errs = validate.StructPartial(tPartial, p2...) errs = validate.StructPartial(tPartial, p2...)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
// Unset second slice member concurrently to test dive behavior: // Unset second slice member concurrently to test dive behavior:
tPartial.SubSlice[1].Test = "" tPartial.SubSlice[1].Test = ""
@ -417,13 +419,13 @@ func TestStructPartial(t *testing.T) {
AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
errs = validate.StructExcept(tPartial, p1...) errs = validate.StructExcept(tPartial, p1...)
Equal(t, len(errs), 2) Equal(t, len(errs.(ValidationErrors)), 2)
AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
errs = validate.StructPartial(tPartial, p2...) errs = validate.StructPartial(tPartial, p2...)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[0].Test", "Test", "required")
// reset struct in slice, and unset struct in slice in unset posistion // reset struct in slice, and unset struct in slice in unset posistion
@ -439,7 +441,7 @@ func TestStructPartial(t *testing.T) {
// testing for missing item by exception, yes it dives and fails // testing for missing item by exception, yes it dives and fails
errs = validate.StructExcept(tPartial, p1...) errs = validate.StructExcept(tPartial, p1...)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required") AssertError(t, errs, "TestPartial.SubSlice[1].Test", "Test", "required")
errs = validate.StructExcept(tPartial, p2...) errs = validate.StructExcept(tPartial, p2...)
@ -1303,7 +1305,7 @@ func TestSQLValue2Validation(t *testing.T) {
errs = validate.Struct(c) errs = validate.Struct(c)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 2) Equal(t, len(errs.(ValidationErrors)), 2)
AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required") AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required")
AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt") AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt")
} }
@ -1362,7 +1364,7 @@ func TestSQLValueValidation(t *testing.T) {
errs = validate.Struct(c) errs = validate.Struct(c)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 2) Equal(t, len(errs.(ValidationErrors)), 2)
AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required") AssertError(t, errs, "CustomMadeUpStruct.MadeUp", "MadeUp", "required")
AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt") AssertError(t, errs, "CustomMadeUpStruct.OverriddenInt", "OverriddenInt", "gt")
} }
@ -1393,7 +1395,7 @@ func TestMACValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d mac failed Error: %s", i, errs) t.Fatalf("Index: %d mac failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "mac" { if val.Tag != "mac" {
t.Fatalf("Index: %d mac failed Error: %s", i, errs) t.Fatalf("Index: %d mac failed Error: %s", i, errs)
} }
@ -1431,7 +1433,7 @@ func TestIPValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ip failed Error: %s", i, errs) t.Fatalf("Index: %d ip failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "ip" { if val.Tag != "ip" {
t.Fatalf("Index: %d ip failed Error: %s", i, errs) t.Fatalf("Index: %d ip failed Error: %s", i, errs)
} }
@ -1469,7 +1471,7 @@ func TestIPv6Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs) t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "ipv6" { if val.Tag != "ipv6" {
t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs) t.Fatalf("Index: %d ipv6 failed Error: %s", i, errs)
} }
@ -1507,7 +1509,7 @@ func TestIPv4Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs) t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "ipv4" { if val.Tag != "ipv4" {
t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs) t.Fatalf("Index: %d ipv4 failed Error: %s", i, errs)
} }
@ -1664,7 +1666,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(s) errs = validate.Struct(s)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "ExternalCMD.Data", "Data", "required") AssertError(t, errs, "ExternalCMD.Data", "Data", "required")
type ExternalCMD2 struct { type ExternalCMD2 struct {
@ -1681,7 +1683,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(s2) errs = validate.Struct(s2)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "ExternalCMD2.Data", "Data", "len") AssertError(t, errs, "ExternalCMD2.Data", "Data", "len")
s3 := &ExternalCMD2{ s3 := &ExternalCMD2{
@ -1692,7 +1694,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(s3) errs = validate.Struct(s3)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "ExternalCMD2.Data", "Data", "len") AssertError(t, errs, "ExternalCMD2.Data", "Data", "len")
type Inner struct { type Inner struct {
@ -1711,7 +1713,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(s4) errs = validate.Struct(s4)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "ExternalCMD.Data.Name", "Name", "required") AssertError(t, errs, "ExternalCMD.Data.Name", "Name", "required")
type TestMapStructPtr struct { type TestMapStructPtr struct {
@ -1726,7 +1728,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(msp) errs = validate.Struct(msp)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "len") AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "len")
type TestMultiDimensionalStructs struct { type TestMultiDimensionalStructs struct {
@ -1744,7 +1746,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(tms) errs = validate.Struct(tms)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 4) Equal(t, len(errs.(ValidationErrors)), 4)
AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required")
@ -1766,7 +1768,7 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Struct(tmsp2) errs = validate.Struct(tmsp2)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 6) Equal(t, len(errs.(ValidationErrors)), 6)
AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required")
@ -1778,24 +1780,24 @@ func TestInterfaceErrValidation(t *testing.T) {
errs = validate.Field(m, "len=3,dive,len=2") errs = validate.Field(m, "len=3,dive,len=2")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "[3]", "[3]", "len") AssertError(t, errs, "[3]", "[3]", "len")
errs = validate.Field(m, "len=2,dive,required") errs = validate.Field(m, "len=2,dive,required")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "", "", "len") AssertError(t, errs, "", "", "len")
arr := []interface{}{"ok", "", "ok"} arr := []interface{}{"ok", "", "ok"}
errs = validate.Field(arr, "len=3,dive,len=2") errs = validate.Field(arr, "len=3,dive,len=2")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "[1]", "[1]", "len") AssertError(t, errs, "[1]", "[1]", "len")
errs = validate.Field(arr, "len=2,dive,required") errs = validate.Field(arr, "len=2,dive,required")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "", "", "len") AssertError(t, errs, "", "", "len")
type MyStruct struct { type MyStruct struct {
@ -1822,12 +1824,12 @@ func TestMapDiveValidation(t *testing.T) {
errs = validate.Field(m, "len=3,dive,required") errs = validate.Field(m, "len=3,dive,required")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "[3]", "[3]", "required") AssertError(t, errs, "[3]", "[3]", "required")
errs = validate.Field(m, "len=2,dive,required") errs = validate.Field(m, "len=2,dive,required")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "", "", "len") AssertError(t, errs, "", "", "len")
type Inner struct { type Inner struct {
@ -1846,7 +1848,7 @@ func TestMapDiveValidation(t *testing.T) {
errs = validate.Struct(ms) errs = validate.Struct(ms)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "TestMapStruct.Errs[3].Name", "Name", "required") AssertError(t, errs, "TestMapStruct.Errs[3].Name", "Name", "required")
// for full test coverage // for full test coverage
@ -1867,7 +1869,7 @@ func TestMapDiveValidation(t *testing.T) {
errs = validate.Struct(mt) errs = validate.Struct(mt)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 2) Equal(t, len(errs.(ValidationErrors)), 2)
AssertError(t, errs, "TestMapTimeStruct.Errs[3]", "Errs[3]", "required") AssertError(t, errs, "TestMapTimeStruct.Errs[3]", "Errs[3]", "required")
AssertError(t, errs, "TestMapTimeStruct.Errs[4]", "Errs[4]", "required") AssertError(t, errs, "TestMapTimeStruct.Errs[4]", "Errs[4]", "required")
@ -1883,7 +1885,7 @@ func TestMapDiveValidation(t *testing.T) {
errs = validate.Struct(msp) errs = validate.Struct(msp)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "required") AssertError(t, errs, "TestMapStructPtr.Errs[3]", "Errs[3]", "required")
type TestMapStructPtr2 struct { type TestMapStructPtr2 struct {
@ -1906,12 +1908,12 @@ func TestArrayDiveValidation(t *testing.T) {
errs := validate.Field(arr, "len=3,dive,required") errs := validate.Field(arr, "len=3,dive,required")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "[1]", "[1]", "required") AssertError(t, errs, "[1]", "[1]", "required")
errs = validate.Field(arr, "len=2,dive,required") errs = validate.Field(arr, "len=2,dive,required")
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "", "", "len") AssertError(t, errs, "", "", "len")
type BadDive struct { type BadDive struct {
@ -1934,7 +1936,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(test) errs = validate.Struct(test)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "Test.Errs[1]", "Errs[1]", "required") AssertError(t, errs, "Test.Errs[1]", "Errs[1]", "required")
test = &Test{ test = &Test{
@ -1943,7 +1945,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(test) errs = validate.Struct(test)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 1) Equal(t, len(errs.(ValidationErrors)), 1)
AssertError(t, errs, "Test.Errs[2]", "Errs[2]", "required") AssertError(t, errs, "Test.Errs[2]", "Errs[2]", "required")
type TestMultiDimensional struct { type TestMultiDimensional struct {
@ -1961,7 +1963,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tm) errs = validate.Struct(tm)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 4) Equal(t, len(errs.(ValidationErrors)), 4)
AssertError(t, errs, "TestMultiDimensional.Errs[0][1]", "Errs[0][1]", "required") AssertError(t, errs, "TestMultiDimensional.Errs[0][1]", "Errs[0][1]", "required")
AssertError(t, errs, "TestMultiDimensional.Errs[0][2]", "Errs[0][2]", "required") AssertError(t, errs, "TestMultiDimensional.Errs[0][2]", "Errs[0][2]", "required")
AssertError(t, errs, "TestMultiDimensional.Errs[1][1]", "Errs[1][1]", "required") AssertError(t, errs, "TestMultiDimensional.Errs[1][1]", "Errs[1][1]", "required")
@ -1986,7 +1988,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tms) errs = validate.Struct(tms)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 4) Equal(t, len(errs.(ValidationErrors)), 4)
AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][1].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructs.Errs[0][2].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructs.Errs[1][1].Name", "Name", "required")
@ -2008,7 +2010,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tmsp) errs = validate.Struct(tmsp)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 5) Equal(t, len(errs.(ValidationErrors)), 5)
AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][1].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][2].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[0][2].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[1][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr.Errs[1][1].Name", "Name", "required")
@ -2035,7 +2037,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tmsp2) errs = validate.Struct(tmsp2)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 6) Equal(t, len(errs.(ValidationErrors)), 6)
AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][1].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[0][2].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr2.Errs[1][1].Name", "Name", "required")
@ -2059,7 +2061,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tmsp3) errs = validate.Struct(tmsp3)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 5) Equal(t, len(errs.(ValidationErrors)), 5)
AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][1].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][2].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[0][2].Name", "Name", "required")
AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[1][1].Name", "Name", "required") AssertError(t, errs, "TestMultiDimensionalStructsPtr3.Errs[1][1].Name", "Name", "required")
@ -2086,7 +2088,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tmtp3) errs = validate.Struct(tmtp3)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 3) Equal(t, len(errs.(ValidationErrors)), 3)
AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[1][2]", "Errs[1][2]", "required") AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[1][2]", "Errs[1][2]", "required")
AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][1]", "Errs[2][1]", "required") AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][1]", "Errs[2][1]", "required")
AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][2]", "Errs[2][2]", "required") AssertError(t, errs, "TestMultiDimensionalTimeTime.Errs[2][2]", "Errs[2][2]", "required")
@ -2111,7 +2113,7 @@ func TestArrayDiveValidation(t *testing.T) {
errs = validate.Struct(tmtp) errs = validate.Struct(tmtp)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 3) Equal(t, len(errs.(ValidationErrors)), 3)
AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[1][2]", "Errs[1][2]", "required") AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[1][2]", "Errs[1][2]", "required")
AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][1]", "Errs[2][1]", "required") AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][1]", "Errs[2][1]", "required")
AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][2]", "Errs[2][2]", "required") AssertError(t, errs, "TestMultiDimensionalTimeTime2.Errs[2][2]", "Errs[2][2]", "required")
@ -2234,7 +2236,7 @@ func TestSSNValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d SSN failed Error: %s", i, errs) t.Fatalf("Index: %d SSN failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "ssn" { if val.Tag != "ssn" {
t.Fatalf("Index: %d Latitude failed Error: %s", i, errs) t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
} }
@ -2268,7 +2270,7 @@ func TestLongitudeValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d Longitude failed Error: %s", i, errs) t.Fatalf("Index: %d Longitude failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "longitude" { if val.Tag != "longitude" {
t.Fatalf("Index: %d Latitude failed Error: %s", i, errs) t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
} }
@ -2302,7 +2304,7 @@ func TestLatitudeValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d Latitude failed Error: %s", i, errs) t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "latitude" { if val.Tag != "latitude" {
t.Fatalf("Index: %d Latitude failed Error: %s", i, errs) t.Fatalf("Index: %d Latitude failed Error: %s", i, errs)
} }
@ -2342,7 +2344,7 @@ func TestDataURIValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d DataURI failed Error: %s", i, errs) t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "datauri" { if val.Tag != "datauri" {
t.Fatalf("Index: %d DataURI failed Error: %s", i, errs) t.Fatalf("Index: %d DataURI failed Error: %s", i, errs)
} }
@ -2380,7 +2382,7 @@ func TestMultibyteValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs) t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "multibyte" { if val.Tag != "multibyte" {
t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs) t.Fatalf("Index: %d Multibyte failed Error: %s", i, errs)
} }
@ -2419,7 +2421,7 @@ func TestPrintableASCIIValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs) t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "printascii" { if val.Tag != "printascii" {
t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs) t.Fatalf("Index: %d Printable ASCII failed Error: %s", i, errs)
} }
@ -2457,7 +2459,7 @@ func TestASCIIValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ASCII failed Error: %s", i, errs) t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "ascii" { if val.Tag != "ascii" {
t.Fatalf("Index: %d ASCII failed Error: %s", i, errs) t.Fatalf("Index: %d ASCII failed Error: %s", i, errs)
} }
@ -2492,7 +2494,7 @@ func TestUUID5Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs) t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "uuid5" { if val.Tag != "uuid5" {
t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs) t.Fatalf("Index: %d UUID5 failed Error: %s", i, errs)
} }
@ -2526,7 +2528,7 @@ func TestUUID4Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs) t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "uuid4" { if val.Tag != "uuid4" {
t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs) t.Fatalf("Index: %d UUID4 failed Error: %s", i, errs)
} }
@ -2559,7 +2561,7 @@ func TestUUID3Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs) t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "uuid3" { if val.Tag != "uuid3" {
t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs) t.Fatalf("Index: %d UUID3 failed Error: %s", i, errs)
} }
@ -2595,7 +2597,7 @@ func TestUUIDValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d UUID failed Error: %s", i, errs) t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "uuid" { if val.Tag != "uuid" {
t.Fatalf("Index: %d UUID failed Error: %s", i, errs) t.Fatalf("Index: %d UUID failed Error: %s", i, errs)
} }
@ -2633,7 +2635,7 @@ func TestISBNValidation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ISBN failed Error: %s", i, errs) t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "isbn" { if val.Tag != "isbn" {
t.Fatalf("Index: %d ISBN failed Error: %s", i, errs) t.Fatalf("Index: %d ISBN failed Error: %s", i, errs)
} }
@ -2670,7 +2672,7 @@ func TestISBN13Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs) t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "isbn13" { if val.Tag != "isbn13" {
t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs) t.Fatalf("Index: %d ISBN13 failed Error: %s", i, errs)
} }
@ -2708,7 +2710,7 @@ func TestISBN10Validation(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs) t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "isbn10" { if val.Tag != "isbn10" {
t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs) t.Fatalf("Index: %d ISBN10 failed Error: %s", i, errs)
} }
@ -4177,7 +4179,7 @@ func TestUrl(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d URL failed Error: %s", i, errs) t.Fatalf("Index: %d URL failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "url" { if val.Tag != "url" {
t.Fatalf("Index: %d URL failed Error: %s", i, errs) t.Fatalf("Index: %d URL failed Error: %s", i, errs)
} }
@ -4241,7 +4243,7 @@ func TestUri(t *testing.T) {
if IsEqual(errs, nil) { if IsEqual(errs, nil) {
t.Fatalf("Index: %d URI failed Error: %s", i, errs) t.Fatalf("Index: %d URI failed Error: %s", i, errs)
} else { } else {
val := errs[""] val := errs.(ValidationErrors)[""]
if val.Tag != "uri" { if val.Tag != "uri" {
t.Fatalf("Index: %d URI failed Error: %s", i, errs) t.Fatalf("Index: %d URI failed Error: %s", i, errs)
} }
@ -4707,7 +4709,7 @@ func TestStructStringValidation(t *testing.T) {
// Assert Top Level // Assert Top Level
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 13) Equal(t, len(errs.(ValidationErrors)), 13)
// Assert Fields // Assert Fields
AssertError(t, errs, "TestString.Required", "Required", "required") AssertError(t, errs, "TestString.Required", "Required", "required")
@ -4762,7 +4764,7 @@ func TestStructInt32Validation(t *testing.T) {
// Assert Top Level // Assert Top Level
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 10) Equal(t, len(errs.(ValidationErrors)), 10)
// Assert Fields // Assert Fields
AssertError(t, errs, "TestInt32.Required", "Required", "required") AssertError(t, errs, "TestInt32.Required", "Required", "required")
@ -4804,7 +4806,7 @@ func TestStructUint64Validation(t *testing.T) {
// Assert Top Level // Assert Top Level
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 6) Equal(t, len(errs.(ValidationErrors)), 6)
// Assert Fields // Assert Fields
AssertError(t, errs, "TestUint64.Required", "Required", "required") AssertError(t, errs, "TestUint64.Required", "Required", "required")
@ -4842,7 +4844,7 @@ func TestStructFloat64Validation(t *testing.T) {
// Assert Top Level // Assert Top Level
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 6) Equal(t, len(errs.(ValidationErrors)), 6)
// Assert Fields // Assert Fields
AssertError(t, errs, "TestFloat64.Required", "Required", "required") AssertError(t, errs, "TestFloat64.Required", "Required", "required")
@ -4878,7 +4880,7 @@ func TestStructSliceValidation(t *testing.T) {
errs = validate.Struct(tFail) errs = validate.Struct(tFail)
NotEqual(t, errs, nil) NotEqual(t, errs, nil)
Equal(t, len(errs), 6) Equal(t, len(errs.(ValidationErrors)), 6)
// Assert Field Errors // Assert Field Errors
AssertError(t, errs, "TestSlice.Required", "Required", "required") AssertError(t, errs, "TestSlice.Required", "Required", "required")

Loading…
Cancel
Save