From afbcf5955372e7683dd50eb3cef1053d9e42e0d6 Mon Sep 17 00:00:00 2001 From: joeybloggs Date: Wed, 6 Jan 2016 08:44:33 -0500 Subject: [PATCH] Add FieldNamespace and NameNamespace * Add FieldNamespace and NameNamespace to FieldError. This allows for having the CustomName i.e. JSON namespace contained within the NameNamespace which would be very useful when using a more restful API approach. --- README.md | 60 ++++++------- validator.go | 215 ++++++++++++++++++++++++++++------------------ validator_test.go | 116 ++++++++++++++++++++++++- 3 files changed, 275 insertions(+), 116 deletions(-) diff --git a/README.md b/README.md index 512696d..e8e1cdd 100644 --- a/README.md +++ b/README.md @@ -308,38 +308,38 @@ func validateStruct() { Benchmarks ------ -###### Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go 1.5.1 +###### Run on MacBook Pro (Retina, 15-inch, Late 2013) 2.6 GHz Intel Core i7 16 GB 1600 MHz DDR3 using Go version go1.5.2 darwin/amd64 ```go -$ go test -cpu=4 -bench=. -benchmem=true +go test -cpu=4 -bench=. -benchmem=true PASS -BenchmarkFieldSuccess-4 10000000 162 ns/op 0 B/op 0 allocs/op -BenchmarkFieldFailure-4 2000000 678 ns/op 400 B/op 4 allocs/op -BenchmarkFieldDiveSuccess-4 500000 3079 ns/op 480 B/op 27 allocs/op -BenchmarkFieldDiveFailure-4 300000 3584 ns/op 880 B/op 31 allocs/op -BenchmarkFieldCustomTypeSuccess-4 5000000 345 ns/op 32 B/op 2 allocs/op -BenchmarkFieldCustomTypeFailure-4 2000000 650 ns/op 400 B/op 4 allocs/op -BenchmarkFieldOrTagSuccess-4 1000000 1188 ns/op 16 B/op 1 allocs/op -BenchmarkFieldOrTagFailure-4 1000000 1088 ns/op 432 B/op 6 allocs/op -BenchmarkStructLevelValidationSuccess-4 2000000 689 ns/op 160 B/op 6 allocs/op -BenchmarkStructLevelValidationFailure-4 1000000 1290 ns/op 592 B/op 11 allocs/op -BenchmarkStructSimpleCustomTypeSuccess-4 2000000 911 ns/op 80 B/op 5 allocs/op -BenchmarkStructSimpleCustomTypeFailure-4 1000000 1446 ns/op 624 B/op 11 allocs/op -BenchmarkStructPartialSuccess-4 1000000 1221 ns/op 384 B/op 10 allocs/op -BenchmarkStructPartialFailure-4 1000000 1764 ns/op 800 B/op 15 allocs/op -BenchmarkStructExceptSuccess-4 2000000 941 ns/op 336 B/op 7 allocs/op -BenchmarkStructExceptFailure-4 1000000 1237 ns/op 384 B/op 10 allocs/op -BenchmarkStructSimpleCrossFieldSuccess-4 2000000 970 ns/op 128 B/op 6 allocs/op -BenchmarkStructSimpleCrossFieldFailure-4 1000000 1560 ns/op 560 B/op 11 allocs/op -BenchmarkStructSimpleCrossStructCrossFieldSuccess-4 1000000 1542 ns/op 176 B/op 9 allocs/op -BenchmarkStructSimpleCrossStructCrossFieldFailure-4 1000000 2147 ns/op 608 B/op 14 allocs/op -BenchmarkStructSimpleSuccess-4 2000000 847 ns/op 48 B/op 3 allocs/op -BenchmarkStructSimpleFailure-4 1000000 1497 ns/op 624 B/op 11 allocs/op -BenchmarkStructSimpleSuccessParallel-4 5000000 257 ns/op 48 B/op 3 allocs/op -BenchmarkStructSimpleFailureParallel-4 2000000 586 ns/op 624 B/op 11 allocs/op -BenchmarkStructComplexSuccess-4 300000 5104 ns/op 496 B/op 29 allocs/op -BenchmarkStructComplexFailure-4 200000 9840 ns/op 3400 B/op 71 allocs/op -BenchmarkStructComplexSuccessParallel-4 1000000 1540 ns/op 496 B/op 29 allocs/op -BenchmarkStructComplexFailureParallel-4 500000 3478 ns/op 3400 B/op 71 allocs/op +BenchmarkFieldSuccess-4 10000000 173 ns/op 0 B/op 0 allocs/op +BenchmarkFieldFailure-4 2000000 730 ns/op 432 B/op 4 allocs/op +BenchmarkFieldDiveSuccess-4 500000 3180 ns/op 480 B/op 27 allocs/op +BenchmarkFieldDiveFailure-4 500000 3844 ns/op 912 B/op 31 allocs/op +BenchmarkFieldCustomTypeSuccess-4 5000000 365 ns/op 32 B/op 2 allocs/op +BenchmarkFieldCustomTypeFailure-4 2000000 705 ns/op 432 B/op 4 allocs/op +BenchmarkFieldOrTagSuccess-4 1000000 1275 ns/op 16 B/op 1 allocs/op +BenchmarkFieldOrTagFailure-4 1000000 1174 ns/op 464 B/op 6 allocs/op +BenchmarkStructLevelValidationSuccess-4 2000000 800 ns/op 192 B/op 7 allocs/op +BenchmarkStructLevelValidationFailure-4 1000000 1495 ns/op 688 B/op 13 allocs/op +BenchmarkStructSimpleCustomTypeSuccess-4 1000000 1048 ns/op 96 B/op 6 allocs/op +BenchmarkStructSimpleCustomTypeFailure-4 1000000 1730 ns/op 736 B/op 14 allocs/op +BenchmarkStructPartialSuccess-4 1000000 1362 ns/op 400 B/op 11 allocs/op +BenchmarkStructPartialFailure-4 1000000 1993 ns/op 864 B/op 17 allocs/op +BenchmarkStructExceptSuccess-4 1000000 1067 ns/op 352 B/op 8 allocs/op +BenchmarkStructExceptFailure-4 1000000 1352 ns/op 400 B/op 11 allocs/op +BenchmarkStructSimpleCrossFieldSuccess-4 1000000 1147 ns/op 144 B/op 7 allocs/op +BenchmarkStructSimpleCrossFieldFailure-4 1000000 1815 ns/op 624 B/op 13 allocs/op +BenchmarkStructSimpleCrossStructCrossFieldSuccess-4 1000000 1779 ns/op 208 B/op 11 allocs/op +BenchmarkStructSimpleCrossStructCrossFieldFailure-4 500000 2465 ns/op 688 B/op 17 allocs/op +BenchmarkStructSimpleSuccess-4 2000000 980 ns/op 64 B/op 4 allocs/op +BenchmarkStructSimpleFailure-4 1000000 1778 ns/op 736 B/op 14 allocs/op +BenchmarkStructSimpleSuccessParallel-4 5000000 313 ns/op 64 B/op 4 allocs/op +BenchmarkStructSimpleFailureParallel-4 2000000 859 ns/op 736 B/op 14 allocs/op +BenchmarkStructComplexSuccess-4 200000 5781 ns/op 592 B/op 33 allocs/op +BenchmarkStructComplexFailure-4 200000 11816 ns/op 4216 B/op 88 allocs/op +BenchmarkStructComplexSuccessParallel-4 1000000 2003 ns/op 592 B/op 33 allocs/op +BenchmarkStructComplexFailureParallel-4 300000 5628 ns/op 4216 B/op 88 allocs/op ``` How to Contribute diff --git a/validator.go b/validator.go index 65a0914..6861337 100644 --- a/validator.go +++ b/validator.go @@ -52,6 +52,7 @@ type StructLevel struct { TopStruct reflect.Value CurrentStruct reflect.Value errPrefix string + nsPrefix string errs ValidationErrors v *Validate } @@ -60,9 +61,29 @@ type StructLevel struct { // Example: had a triple nested struct User, ContactInfo, Country and ran errs := validate.Struct(country) // from within a User struct level validation would call this method like so: // ReportValidationErrors("ContactInfo.", errs) +// NOTE: relativeKey can contain both the Field Relative and Custom name relative paths +// i.e. ReportValidationErrors("ContactInfo.|cInfo", errs) where cInfo represents say the JSON name of +// the relative path; this will be split into 2 variables in the next valiator version. func (sl *StructLevel) ReportValidationErrors(relativeKey string, errs ValidationErrors) { for _, e := range errs { - sl.errs[sl.errPrefix+relativeKey+e.Field] = e + + idx := strings.Index(relativeKey, "|") + var rel string + var cRel string + + if idx != -1 { + rel = relativeKey[:idx] + cRel = relativeKey[idx+1:] + } else { + rel = relativeKey + } + + key := sl.errPrefix + rel + e.Field + + e.FieldNamespace = key + e.NameNamespace = sl.nsPrefix + cRel + e.Name + + sl.errs[key] = e } } @@ -85,26 +106,32 @@ func (sl *StructLevel) ReportError(field reflect.Value, fieldName string, custom panic(tagRequired) } + ns := sl.errPrefix + fieldName + switch kind { case reflect.Invalid: - sl.errs[sl.errPrefix+fieldName] = &FieldError{ - Name: customName, - Field: fieldName, - Tag: tag, - ActualTag: tag, - Param: blank, - Kind: kind, + sl.errs[ns] = &FieldError{ + FieldNamespace: ns, + NameNamespace: sl.nsPrefix + customName, + Name: customName, + Field: fieldName, + Tag: tag, + ActualTag: tag, + Param: blank, + Kind: kind, } default: - sl.errs[sl.errPrefix+fieldName] = &FieldError{ - Name: customName, - Field: fieldName, - Tag: tag, - ActualTag: tag, - Param: blank, - Value: field.Interface(), - Kind: kind, - Type: field.Type(), + sl.errs[ns] = &FieldError{ + FieldNamespace: ns, + NameNamespace: sl.nsPrefix + customName, + Name: customName, + Field: fieldName, + Tag: tag, + ActualTag: tag, + Param: blank, + Value: field.Interface(), + Kind: kind, + Type: field.Type(), } } } @@ -178,14 +205,16 @@ func (ve ValidationErrors) Error() string { // FieldError contains a single field's validation error along // with other properties that may be needed for error message creation type FieldError struct { - Field string - Name string - Tag string - ActualTag string - Kind reflect.Kind - Type reflect.Type - Param string - Value interface{} + FieldNamespace string + NameNamespace string + Field string + Name string + Tag string + ActualTag string + Kind reflect.Kind + Type reflect.Type + Param string + Value interface{} } // New creates a new Validate instance for use. @@ -306,7 +335,7 @@ func (v *Validate) Field(field interface{}, tag string) error { errs := v.errsPool.Get().(ValidationErrors) fieldVal := reflect.ValueOf(field) - v.traverseField(fieldVal, fieldVal, fieldVal, blank, errs, false, tag, blank, blank, false, false, nil, nil) + v.traverseField(fieldVal, fieldVal, fieldVal, blank, blank, errs, false, tag, blank, blank, false, false, nil, nil) if len(errs) == 0 { v.errsPool.Put(errs) @@ -326,7 +355,7 @@ func (v *Validate) FieldWithValue(val interface{}, field interface{}, tag string errs := v.errsPool.Get().(ValidationErrors) topVal := reflect.ValueOf(val) - v.traverseField(topVal, topVal, reflect.ValueOf(field), blank, errs, false, tag, blank, blank, false, false, nil, nil) + v.traverseField(topVal, topVal, reflect.ValueOf(field), blank, blank, errs, false, tag, blank, blank, false, false, nil, nil) if len(errs) == 0 { v.errsPool.Put(errs) @@ -384,7 +413,7 @@ func (v *Validate) StructPartial(current interface{}, fields ...string) error { errs := v.errsPool.Get().(ValidationErrors) - v.tranverseStruct(sv, sv, sv, blank, errs, true, len(m) != 0, false, m, false) + v.tranverseStruct(sv, sv, sv, blank, blank, errs, true, len(m) != 0, false, m, false) if len(errs) == 0 { v.errsPool.Put(errs) @@ -411,7 +440,7 @@ func (v *Validate) StructExcept(current interface{}, fields ...string) error { errs := v.errsPool.Get().(ValidationErrors) - v.tranverseStruct(sv, sv, sv, blank, errs, true, len(m) != 0, true, m, false) + v.tranverseStruct(sv, sv, sv, blank, blank, errs, true, len(m) != 0, true, m, false) if len(errs) == 0 { v.errsPool.Put(errs) @@ -430,7 +459,7 @@ func (v *Validate) Struct(current interface{}) error { errs := v.errsPool.Get().(ValidationErrors) sv := reflect.ValueOf(current) - v.tranverseStruct(sv, sv, sv, blank, errs, true, false, false, nil, false) + v.tranverseStruct(sv, sv, sv, blank, blank, errs, true, false, false, nil, false) if len(errs) == 0 { v.errsPool.Put(errs) @@ -441,7 +470,7 @@ func (v *Validate) Struct(current interface{}) error { } // tranverseStruct traverses a structs fields and then passes them to be validated by traverseField -func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, useStructName bool, partial bool, exclude bool, includeExclude map[string]*struct{}, isStructOnly bool) { +func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, useStructName bool, partial bool, exclude bool, includeExclude map[string]*struct{}, isStructOnly bool) { if current.Kind() == reflect.Ptr && !current.IsNil() { current = current.Elem() @@ -458,6 +487,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec if useStructName { errPrefix += sName + "." + nsPrefix += sName + "." } // structonly tag present don't tranverseFields @@ -493,6 +523,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec } customName = fld.Name + if v.fieldNameTag != "" { name := strings.SplitN(fld.Tag.Get(v.fieldNameTag), ",", 2)[0] @@ -503,7 +534,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec } } - v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, errs, true, fld.Tag.Get(v.tagName), fld.Name, customName, partial, exclude, includeExclude, nil) + v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, nsPrefix, errs, true, fld.Tag.Get(v.tagName), fld.Name, customName, partial, exclude, includeExclude, nil) } } else { s, ok := v.structCache.Get(typ) @@ -523,7 +554,7 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec } fld = typ.Field(i) - v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, errs, true, f.CachedTag.tag, fld.Name, f.AltName, partial, exclude, includeExclude, f.CachedTag) + v.traverseField(topStruct, currentStruct, current.Field(i), errPrefix, nsPrefix, errs, true, f.CachedTag.tag, fld.Name, f.AltName, partial, exclude, includeExclude, f.CachedTag) } } } @@ -531,13 +562,13 @@ func (v *Validate) tranverseStruct(topStruct reflect.Value, currentStruct reflec // check if any struct level validations, after all field validations already checked. if v.hasStructLevelFuncs { if fn, ok := v.structLevelFuncs[current.Type()]; ok { - fn(v, &StructLevel{v: v, TopStruct: topStruct, CurrentStruct: current, errPrefix: errPrefix, errs: errs}) + fn(v, &StructLevel{v: v, TopStruct: topStruct, CurrentStruct: current, errPrefix: errPrefix, nsPrefix: nsPrefix, errs: errs}) } } } // traverseField validates any field, be it a struct or single field, ensures it's validity and passes it along to be validated via it's tag options -func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, isStructField bool, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { +func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, isStructField bool, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { if tag == skipValidationTag { return @@ -563,27 +594,33 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect. if len(tag) > 0 { + ns := errPrefix + name + if kind == reflect.Invalid { - errs[errPrefix+name] = &FieldError{ - Name: customName, - Field: name, - Tag: cTag.tags[0].tag, - ActualTag: cTag.tags[0].tagVals[0][0], - Param: cTag.tags[0].tagVals[0][1], - Kind: kind, + errs[ns] = &FieldError{ + FieldNamespace: ns, + NameNamespace: nsPrefix + customName, + Name: customName, + Field: name, + Tag: cTag.tags[0].tag, + ActualTag: cTag.tags[0].tagVals[0][0], + Param: cTag.tags[0].tagVals[0][1], + Kind: kind, } return } - errs[errPrefix+name] = &FieldError{ - Name: customName, - Field: name, - Tag: cTag.tags[0].tag, - ActualTag: cTag.tags[0].tagVals[0][0], - Param: cTag.tags[0].tagVals[0][1], - Value: current.Interface(), - Kind: kind, - Type: current.Type(), + errs[ns] = &FieldError{ + FieldNamespace: ns, + NameNamespace: nsPrefix + customName, + Name: customName, + Field: name, + Tag: cTag.tags[0].tag, + ActualTag: cTag.tags[0].tagVals[0][0], + Param: cTag.tags[0].tagVals[0][1], + Value: current.Interface(), + Kind: kind, + Type: current.Type(), } return @@ -603,7 +640,7 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect. return } - v.tranverseStruct(topStruct, current, current, errPrefix+name+".", errs, false, partial, exclude, includeExclude, cTag.isStructOnly) + v.tranverseStruct(topStruct, current, current, errPrefix+name+".", nsPrefix+customName+".", errs, false, partial, exclude, includeExclude, cTag.isStructOnly) return } } @@ -637,7 +674,7 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect. continue } - if v.validateField(topStruct, currentStruct, current, typ, kind, errPrefix, errs, valTag, name, customName) { + if v.validateField(topStruct, currentStruct, current, typ, kind, errPrefix, nsPrefix, errs, valTag, name, customName) { return } } @@ -647,9 +684,9 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect. // or panic ;) switch kind { case reflect.Slice, reflect.Array: - v.traverseSlice(topStruct, currentStruct, current, errPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil) + v.traverseSlice(topStruct, currentStruct, current, errPrefix, nsPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil) case reflect.Map: - v.traverseMap(topStruct, currentStruct, current, errPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil) + v.traverseMap(topStruct, currentStruct, current, errPrefix, nsPrefix, errs, diveSubTag, name, customName, partial, exclude, includeExclude, nil) default: // throw error, if not a slice or map then should not have gotten here // bad dive tag @@ -659,23 +696,23 @@ func (v *Validate) traverseField(topStruct reflect.Value, currentStruct reflect. } // traverseSlice traverses a Slice or Array's elements and passes them to traverseField for validation -func (v *Validate) traverseSlice(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { +func (v *Validate) traverseSlice(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { for i := 0; i < current.Len(); i++ { - v.traverseField(topStruct, currentStruct, current.Index(i), errPrefix, errs, false, tag, fmt.Sprintf(arrayIndexFieldName, name, i), fmt.Sprintf(arrayIndexFieldName, customName, i), partial, exclude, includeExclude, cTag) + v.traverseField(topStruct, currentStruct, current.Index(i), errPrefix, nsPrefix, errs, false, tag, fmt.Sprintf(arrayIndexFieldName, name, i), fmt.Sprintf(arrayIndexFieldName, customName, i), partial, exclude, includeExclude, cTag) } } // traverseMap traverses a map's elements and passes them to traverseField for validation -func (v *Validate) traverseMap(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { +func (v *Validate) traverseMap(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, errPrefix string, nsPrefix string, errs ValidationErrors, tag, name, customName string, partial bool, exclude bool, includeExclude map[string]*struct{}, cTag *cachedTag) { for _, key := range current.MapKeys() { - v.traverseField(topStruct, currentStruct, current.MapIndex(key), errPrefix, errs, false, tag, fmt.Sprintf(mapIndexFieldName, name, key.Interface()), fmt.Sprintf(mapIndexFieldName, customName, key.Interface()), partial, exclude, includeExclude, cTag) + v.traverseField(topStruct, currentStruct, current.MapIndex(key), errPrefix, nsPrefix, errs, false, tag, fmt.Sprintf(mapIndexFieldName, name, key.Interface()), fmt.Sprintf(mapIndexFieldName, customName, key.Interface()), partial, exclude, includeExclude, cTag) } } // validateField validates a field based on the provided tag's key and param values and returns true if there is an error or false if all ok -func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, currentType reflect.Type, currentKind reflect.Kind, errPrefix string, errs ValidationErrors, valTag *tagVals, name, customName string) bool { +func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect.Value, current reflect.Value, currentType reflect.Type, currentKind reflect.Kind, errPrefix string, nsPrefix string, errs ValidationErrors, valTag *tagVals, name, customName string) bool { var valFunc Func var ok bool @@ -698,25 +735,31 @@ func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect. errTag += orSeparator + val[0] } + ns := errPrefix + name + if valTag.isAlias { - errs[errPrefix+name] = &FieldError{ - Name: customName, - Field: name, - Tag: valTag.tag, - ActualTag: errTag[1:], - Value: current.Interface(), - Type: currentType, - Kind: currentKind, + errs[ns] = &FieldError{ + FieldNamespace: ns, + NameNamespace: nsPrefix + customName, + Name: customName, + Field: name, + Tag: valTag.tag, + ActualTag: errTag[1:], + Value: current.Interface(), + Type: currentType, + Kind: currentKind, } } else { errs[errPrefix+name] = &FieldError{ - Name: customName, - Field: name, - Tag: errTag[1:], - ActualTag: errTag[1:], - Value: current.Interface(), - Type: currentType, - Kind: currentKind, + FieldNamespace: ns, + NameNamespace: nsPrefix + customName, + Name: customName, + Field: name, + Tag: errTag[1:], + ActualTag: errTag[1:], + Value: current.Interface(), + Type: currentType, + Kind: currentKind, } } @@ -732,15 +775,19 @@ func (v *Validate) validateField(topStruct reflect.Value, currentStruct reflect. return false } - errs[errPrefix+name] = &FieldError{ - Name: customName, - Field: name, - Tag: valTag.tag, - ActualTag: valTag.tagVals[0][0], - Value: current.Interface(), - Param: valTag.tagVals[0][1], - Type: currentType, - Kind: currentKind, + ns := errPrefix + name + + errs[ns] = &FieldError{ + FieldNamespace: ns, + NameNamespace: nsPrefix + customName, + Name: customName, + Field: name, + Tag: valTag.tag, + ActualTag: valTag.tagVals[0][0], + Value: current.Interface(), + Param: valTag.tagVals[0][1], + Type: currentType, + Kind: currentKind, } return true diff --git a/validator_test.go b/validator_test.go index 7f70c61..189e522 100644 --- a/validator_test.go +++ b/validator_test.go @@ -284,8 +284,20 @@ func StructValidationTestStructReturnValidationErrors(v *Validate, structLevel * structLevel.ReportValidationErrors("Inner1.", errs.(ValidationErrors)) } +func StructValidationTestStructReturnValidationErrors2(v *Validate, structLevel *StructLevel) { + + s := structLevel.CurrentStruct.Interface().(TestStructReturnValidationErrors) + + errs := v.Struct(s.Inner1.Inner2) + if errs == nil { + return + } + + structLevel.ReportValidationErrors("Inner1.|Inner1JSON.", errs.(ValidationErrors)) +} + type TestStructReturnValidationErrorsInner2 struct { - String string `validate:"required"` + String string `validate:"required" json:"JSONString"` } type TestStructReturnValidationErrorsInner1 struct { @@ -293,7 +305,52 @@ type TestStructReturnValidationErrorsInner1 struct { } type TestStructReturnValidationErrors struct { - Inner1 *TestStructReturnValidationErrorsInner1 + Inner1 *TestStructReturnValidationErrorsInner1 `json:"Inner1JSON"` +} + +type Inner2Namespace struct { + String []string `validate:"dive,required" json:"JSONString"` +} + +type Inner1Namespace struct { + Inner2 *Inner2Namespace `json:"Inner2JSON"` +} + +type Namespace struct { + Inner1 *Inner1Namespace `json:"Inner1JSON"` +} + +func TestNameNamespace(t *testing.T) { + + config := &Config{ + TagName: "validate", + FieldNameTag: "json", + } + + v1 := New(config) + i2 := &Inner2Namespace{String: []string{"ok", "ok", "ok"}} + i1 := &Inner1Namespace{Inner2: i2} + ns := &Namespace{Inner1: i1} + + errs := v1.Struct(ns) + Equal(t, errs, nil) + + i2.String[1] = "" + + errs = v1.Struct(ns) + NotEqual(t, errs, nil) + + ve := errs.(ValidationErrors) + Equal(t, len(ve), 1) + AssertError(t, errs, "Namespace.Inner1.Inner2.String[1]", "String[1]", "required") + + fe, ok := ve["Namespace.Inner1.Inner2.String[1]"] + Equal(t, ok, true) + + Equal(t, fe.Field, "String[1]") + Equal(t, fe.FieldNamespace, "Namespace.Inner1.Inner2.String[1]") + Equal(t, fe.Name, "JSONString[1]") + Equal(t, fe.NameNamespace, "Namespace.Inner1JSON.Inner2JSON.JSONString[1]") } func TestAnonymous(t *testing.T) { @@ -377,7 +434,62 @@ func TestStructLevelReturnValidationErrors(t *testing.T) { errs = v1.Struct(val) NotEqual(t, errs, nil) + Equal(t, len(errs.(ValidationErrors)), 2) AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required") + // this is an extra error reported from struct validation + AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required") +} + +func TestStructLevelReturnValidationErrorsWithJSON(t *testing.T) { + config := &Config{ + TagName: "validate", + FieldNameTag: "json", + } + + v1 := New(config) + v1.RegisterStructValidation(StructValidationTestStructReturnValidationErrors2, TestStructReturnValidationErrors{}) + + inner2 := &TestStructReturnValidationErrorsInner2{ + String: "I'm HERE", + } + + inner1 := &TestStructReturnValidationErrorsInner1{ + Inner2: inner2, + } + + val := &TestStructReturnValidationErrors{ + Inner1: inner1, + } + + errs := v1.Struct(val) + Equal(t, errs, nil) + + inner2.String = "" + + errs = v1.Struct(val) + NotEqual(t, errs, nil) + Equal(t, len(errs.(ValidationErrors)), 2) + AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.Inner2.String", "String", "required") + // this is an extra error reported from struct validation, it's a badly formatted one, but on purpose + AssertError(t, errs, "TestStructReturnValidationErrors.Inner1.String", "String", "required") + + fe, ok := errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.Inner2.String"] + Equal(t, ok, true) + + // check for proper JSON namespace + Equal(t, fe.Field, "String") + Equal(t, fe.Name, "JSONString") + Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.Inner2.String") + Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.Inner2.JSONString") + + fe, ok = errs.(ValidationErrors)["TestStructReturnValidationErrors.Inner1.String"] + Equal(t, ok, true) + + // check for proper JSON namespace + Equal(t, fe.Field, "String") + Equal(t, fe.Name, "JSONString") + Equal(t, fe.FieldNamespace, "TestStructReturnValidationErrors.Inner1.String") + Equal(t, fe.NameNamespace, "TestStructReturnValidationErrors.Inner1JSON.JSONString") } func TestStructLevelValidations(t *testing.T) {