Codebase list golang-github-go-playground-validator-v10 / 1d286c8
Define NotBlank as non standard validator. Andrei Avram 5 years ago
5 changed file(s) with 114 addition(s) and 47 deletion(s). Raw diff Collapse all Expand all
+0
-15
baked_in.go less more
6262 // or even disregard and use your own map if so desired.
6363 bakedInValidators = map[string]Func{
6464 "required": hasValue,
65 "notblank": notBlank,
6665 "isdefault": isDefault,
6766 "len": hasLengthOf,
6867 "min": hasMinOf,
12641263 }
12651264 }
12661265
1267 // NotBlank is the validation function for validating if the current field has a value or length greater than zero.
1268 func notBlank(fl FieldLevel) bool {
1269 field := fl.Field()
1270
1271 switch field.Kind() {
1272 case reflect.String:
1273 return len(strings.TrimSpace(field.String())) > 0
1274 case reflect.Chan, reflect.Map, reflect.Slice, reflect.Array:
1275 return field.Len() > 0
1276 default:
1277 return hasValue(fl)
1278 }
1279 }
1280
12811266 // IsGteField is the validation function for validating if the current field's value is greater than or equal to the field specified by the param's value.
12821267 func isGteField(fl FieldLevel) bool {
12831268
+20
-8
doc.go less more
244244
245245 Usage: required
246246
247 NotBlank
248
249 This validates that the value is not blank or with length zero.
250 For strings ensures they do not contain only spaces. For channels, maps, slices and arrays
251 ensures they don't have zero length. For others, the "required" validation is used.
252
253 Usage: notblank
254
255247 Is Default
256248
257249 This validates that the value is the default value and is almost the
997989 }
998990
999991 validate.Struct(t) // this will panic
992
993 Non standard validators
994
995 type Test struct {
996 TestField string `validate:"yourtag"`
997 }
998
999 t := &Test{
1000 TestField: "Test"
1001 }
1002
1003 validate := validator.New()
1004 validate.RegisterValidation("yourtag", validations.ValidatorName)
1005
1006 NotBlank
1007 This validates that the value is not blank or with length zero.
1008 For strings ensures they do not contain only spaces. For channels, maps, slices and arrays
1009 ensures they don't have zero length. For others, a non empty value is required.
1010
1011 Usage: notblank
10001012 */
10011013 package validator
+24
-0
non-standard/validators/notblank.go less more
0 package validators
1
2 import (
3 "reflect"
4 "strings"
5
6 "github.com/andreiavrammsd/validator"
7 )
8
9 // NotBlank is the validation function for validating if the current field has a value or length greater than zero.
10 func NotBlank(fl validator.FieldLevel) bool {
11 field := fl.Field()
12
13 switch field.Kind() {
14 case reflect.String:
15 return len(strings.TrimSpace(field.String())) > 0
16 case reflect.Chan, reflect.Map, reflect.Slice, reflect.Array:
17 return field.Len() > 0
18 case reflect.Ptr, reflect.Interface, reflect.Func:
19 return !field.IsNil()
20 default:
21 return field.IsValid() && field.Interface() != reflect.Zero(field.Type()).Interface()
22 }
23 }
+65
-0
non-standard/validators/notblank_test.go less more
0 package validators
1
2 import (
3 "testing"
4
5 "github.com/andreiavrammsd/validator"
6 "gopkg.in/go-playground/assert.v1"
7 )
8
9 type test struct {
10 String string `validate:"notblank"`
11 Array []int `validate:"notblank"`
12 Pointer *int `validate:"notblank"`
13 Number int `validate:"notblank"`
14 Interface interface{} `validate:"notblank"`
15 Func func() `validate:"notblank"`
16 }
17
18 func TestNotBlank(t *testing.T) {
19 v := validator.New()
20 err := v.RegisterValidation("notblank", NotBlank)
21 assert.Equal(t, nil, err)
22
23 // Errors
24 var x *int
25 invalid := test{
26 String: " ",
27 Array: []int{},
28 Pointer: x,
29 Number: 0,
30 Interface: nil,
31 Func: nil,
32 }
33 fieldsWithError := []string{
34 "String",
35 "Array",
36 "Pointer",
37 "Number",
38 "Interface",
39 "Func",
40 }
41
42 errors := v.Struct(invalid).(validator.ValidationErrors)
43 var fields []string
44 for _, err := range errors {
45 fields = append(fields, err.Field())
46 }
47
48 assert.Equal(t, fieldsWithError, fields)
49
50 // No errors
51 y := 1
52 x = &y
53 valid := test{
54 String: "str",
55 Array: []int{1},
56 Pointer: x,
57 Number: 1,
58 Interface: "value",
59 Func: func() {},
60 }
61
62 err = v.Struct(valid)
63 assert.Equal(t, nil, err)
64 }
+5
-24
validator_test.go less more
6161 type TestString struct {
6262 BlankTag string `validate:""`
6363 Required string `validate:"required"`
64 NotBlank string `validate:"notblank"`
6564 Len string `validate:"len=10"`
6665 Min string `validate:"min=1"`
6766 Max string `validate:"max=10"`
8180
8281 type TestUint64 struct {
8382 Required uint64 `validate:"required"`
84 NotBlank uint64 `validate:"notblank"`
8583 Len uint64 `validate:"len=10"`
8684 Min uint64 `validate:"min=1"`
8785 Max uint64 `validate:"max=10"`
9189
9290 type TestFloat64 struct {
9391 Required float64 `validate:"required"`
94 NotBlank float64 `validate:"notblank"`
9592 Len float64 `validate:"len=10"`
9693 Min float64 `validate:"min=1"`
9794 Max float64 `validate:"max=10"`
10299
103100 type TestSlice struct {
104101 Required []int `validate:"required"`
105 NotBlank []int `validate:"notblank"`
106102 Len []int `validate:"len=10"`
107103 Min []int `validate:"min=1"`
108104 Max []int `validate:"max=10"`
67286724
67296725 tSuccess := &TestString{
67306726 Required: "Required",
6731 NotBlank: "NotBLank",
67326727 Len: "length==10",
67336728 Min: "min=1",
67346729 Max: "1234567890",
67596754
67606755 tFail := &TestString{
67616756 Required: "",
6762 NotBlank: " ",
67636757 Len: "",
67646758 Min: "",
67656759 Max: "12345678901",
67866780
67876781 // Assert Top Level
67886782 NotEqual(t, errs, nil)
6789 Equal(t, len(errs.(ValidationErrors)), 14)
6783 Equal(t, len(errs.(ValidationErrors)), 13)
67906784
67916785 // Assert Fields
67926786 AssertError(t, errs, "TestString.Required", "TestString.Required", "Required", "Required", "required")
6793 AssertError(t, errs, "TestString.NotBlank", "TestString.NotBlank", "NotBlank", "NotBlank", "notblank")
67946787 AssertError(t, errs, "TestString.Len", "TestString.Len", "Len", "Len", "len")
67956788 AssertError(t, errs, "TestString.Min", "TestString.Min", "Min", "Min", "min")
67966789 AssertError(t, errs, "TestString.Max", "TestString.Max", "Max", "Max", "max")
68116804
68126805 type TestInt32 struct {
68136806 Required int `validate:"required"`
6814 NotBlank int `validate:"notblank"`
68156807 Len int `validate:"len=10"`
68166808 Min int `validate:"min=1"`
68176809 Max int `validate:"max=10"`
68256817
68266818 tSuccess := &TestInt32{
68276819 Required: 1,
6828 NotBlank: 1,
68296820 Len: 10,
68306821 Min: 1,
68316822 Max: 10,
68436834
68446835 tFail := &TestInt32{
68456836 Required: 0,
6846 NotBlank: 0,
68476837 Len: 11,
68486838 Min: -1,
68496839 Max: 11,
68596849
68606850 // Assert Top Level
68616851 NotEqual(t, errs, nil)
6862 Equal(t, len(errs.(ValidationErrors)), 11)
6852 Equal(t, len(errs.(ValidationErrors)), 10)
68636853
68646854 // Assert Fields
68656855 AssertError(t, errs, "TestInt32.Required", "TestInt32.Required", "Required", "Required", "required")
6866 AssertError(t, errs, "TestInt32.NotBlank", "TestInt32.NotBlank", "NotBlank", "NotBlank", "notblank")
68676856 AssertError(t, errs, "TestInt32.Len", "TestInt32.Len", "Len", "Len", "len")
68686857 AssertError(t, errs, "TestInt32.Min", "TestInt32.Min", "Min", "Min", "min")
68696858 AssertError(t, errs, "TestInt32.Max", "TestInt32.Max", "Max", "Max", "max")
68816870
68826871 tSuccess := &TestUint64{
68836872 Required: 1,
6884 NotBlank: 1,
68856873 Len: 10,
68866874 Min: 1,
68876875 Max: 10,
68946882
68956883 tFail := &TestUint64{
68966884 Required: 0,
6897 NotBlank: 0,
68986885 Len: 11,
68996886 Min: 0,
69006887 Max: 11,
69066893
69076894 // Assert Top Level
69086895 NotEqual(t, errs, nil)
6909 Equal(t, len(errs.(ValidationErrors)), 7)
6896 Equal(t, len(errs.(ValidationErrors)), 6)
69106897
69116898 // Assert Fields
69126899 AssertError(t, errs, "TestUint64.Required", "TestUint64.Required", "Required", "Required", "required")
6913 AssertError(t, errs, "TestUint64.NotBlank", "TestUint64.NotBlank", "NotBlank", "NotBlank", "notblank")
69146900 AssertError(t, errs, "TestUint64.Len", "TestUint64.Len", "Len", "Len", "len")
69156901 AssertError(t, errs, "TestUint64.Min", "TestUint64.Min", "Min", "Min", "min")
69166902 AssertError(t, errs, "TestUint64.Max", "TestUint64.Max", "Max", "Max", "max")
69246910
69256911 tSuccess := &TestFloat64{
69266912 Required: 1,
6927 NotBlank: 1,
69286913 Len: 10,
69296914 Min: 1,
69306915 Max: 10,
69376922
69386923 tFail := &TestFloat64{
69396924 Required: 0,
6940 NotBlank: 0,
69416925 Len: 11,
69426926 Min: 0,
69436927 Max: 11,
69496933
69506934 // Assert Top Level
69516935 NotEqual(t, errs, nil)
6952 Equal(t, len(errs.(ValidationErrors)), 7)
6936 Equal(t, len(errs.(ValidationErrors)), 6)
69536937
69546938 // Assert Fields
69556939 AssertError(t, errs, "TestFloat64.Required", "TestFloat64.Required", "Required", "Required", "required")
6956 AssertError(t, errs, "TestFloat64.NotBlank", "TestFloat64.NotBlank", "NotBlank", "NotBlank", "notblank")
69576940 AssertError(t, errs, "TestFloat64.Len", "TestFloat64.Len", "Len", "Len", "len")
69586941 AssertError(t, errs, "TestFloat64.Min", "TestFloat64.Min", "Min", "Min", "min")
69596942 AssertError(t, errs, "TestFloat64.Max", "TestFloat64.Max", "Max", "Max", "max")
69676950
69686951 tSuccess := &TestSlice{
69696952 Required: []int{1},
6970 NotBlank: []int{1},
69716953 Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
69726954 Min: []int{1, 2},
69736955 Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
69806962
69816963 tFail := &TestSlice{
69826964 Required: nil,
6983 NotBlank: []int{},
69846965 Len: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
69856966 Min: []int{},
69866967 Max: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1},
69906971
69916972 errs = validate.Struct(tFail)
69926973 NotEqual(t, errs, nil)
6993 Equal(t, len(errs.(ValidationErrors)), 7)
6974 Equal(t, len(errs.(ValidationErrors)), 6)
69946975
69956976 // Assert Field Errors
69966977 AssertError(t, errs, "TestSlice.Required", "TestSlice.Required", "Required", "Required", "required")