Codebase list golang-github-go-playground-validator-v10 / v1.0
Merge branch 'v1-development' into v1 Dean Karn 9 years ago
2 changed file(s) with 179 addition(s) and 14 deletion(s). Raw diff Collapse all Expand all
+8
-8
baked_in.go less more
260260 return st.Float() >= p
261261
262262 default:
263 panic(fmt.Sprintf("Bad field type for Input Param %s for %s\n", param, field))
263 panic(fmt.Sprintf("Bad field type %T", field))
264264 }
265265 }
266266
296296 return st.Float() > p
297297
298298 default:
299 panic(fmt.Sprintf("Bad field type for Input Param %s for %s\n", param, field))
299 panic(fmt.Sprintf("Bad field type %T", field))
300300 }
301301 }
302302
335335 return st.Float() == p
336336
337337 default:
338 panic(fmt.Sprintf("Bad field type for Input Param %s for %s\n", param, field))
338 panic(fmt.Sprintf("Bad field type %T", field))
339339 }
340340 }
341341
380380 return st.Float() <= p
381381
382382 default:
383 panic(fmt.Sprintf("Bad field type for Input Param %s for %s\n", param, field))
383 panic(fmt.Sprintf("Bad field type %T", field))
384384 }
385385 }
386386
416416 return st.Float() < p
417417
418418 default:
419 panic(fmt.Sprintf("Bad field type for Input Param %s for %s\n", param, field))
419 panic(fmt.Sprintf("Bad field type %T", field))
420420 }
421421 }
422422
436436 i, err := strconv.ParseInt(param, 0, 64)
437437
438438 if err != nil {
439 panic(fmt.Sprintf("Bad Input Param %s\n", param))
439 panic(err.Error())
440440 }
441441
442442 return i
449449 i, err := strconv.ParseUint(param, 0, 64)
450450
451451 if err != nil {
452 panic(fmt.Sprintf("Bad Input Param %s\n", param))
452 panic(err.Error())
453453 }
454454
455455 return i
462462 i, err := strconv.ParseFloat(param, 64)
463463
464464 if err != nil {
465 panic(fmt.Sprintf("Bad Input Param %s\n", param))
465 panic(err.Error())
466466 }
467467
468468 return i
+171
-6
validator_test.go less more
2828 }
2929
3030 type TestString struct {
31 BlankTag string `validate:""`
3132 Required string `validate:"required"`
3233 Len string `validate:"len=10"`
3334 Min string `validate:"min=1"`
6970 }
7071
7172 type TestFloat64 struct {
72 Required int64 `validate:"required"`
73 Len int64 `validate:"len=10"`
74 Min int64 `validate:"min=1"`
75 Max int64 `validate:"max=10"`
76 MinMax int64 `validate:"min=1,max=10"`
77 OmitEmpty int64 `validate:"omitempty,min=1,max=10"`
73 Required float64 `validate:"required"`
74 Len float64 `validate:"len=10"`
75 Min float64 `validate:"min=1"`
76 Max float64 `validate:"max=10"`
77 MinMax float64 `validate:"min=1,max=10"`
78 Lte float64 `validate:"lte=10"`
79 OmitEmpty float64 `validate:"omitempty,min=1,max=10"`
7880 }
7981
8082 type TestSlice struct {
118120 c.Assert(val, NotNil)
119121 c.Assert(val.Field, Equals, field)
120122 c.Assert(val.ErrorTag, Equals, expectedTag)
123 }
124
125 func newValidatorFunc(field interface{}, param string) bool {
126
127 return true
128 }
129
130 func (ms *MySuite) TestAddFunctions(c *C) {
131
132 validate := validator.NewValidator("validateme", validator.BakedInValidators)
133
134 err := validate.AddFunction("new", newValidatorFunc)
135 c.Assert(err, IsNil)
136
137 err = validate.AddFunction("", newValidatorFunc)
138 c.Assert(err, NotNil)
139
140 validate.AddFunction("new", nil)
141 c.Assert(err, NotNil)
142
143 err = validator.AddFunction("new", newValidatorFunc)
144 c.Assert(err, IsNil)
145 }
146
147 func (ms *MySuite) TestChangeTag(c *C) {
148
149 validate := validator.NewValidator("validateme", validator.BakedInValidators)
150 validate.SetTag("val")
151
152 type Test struct {
153 Name string `val:"len=4"`
154 }
155 s := &Test{
156 Name: "TEST",
157 }
158
159 err := validator.ValidateStruct(s)
160 c.Assert(err, IsNil)
161
162 validator.SetTag("v")
163 validator.SetTag("validate")
164 }
165
166 func (ms *MySuite) TestUnexposedStruct(c *C) {
167
168 type Test struct {
169 Name string
170 unexposed struct {
171 A string `validate:"required"`
172 }
173 }
174 s := &Test{
175 Name: "TEST",
176 }
177
178 err := validator.ValidateStruct(s)
179 c.Assert(err, IsNil)
180 }
181
182 func (ms *MySuite) TestBadParams(c *C) {
183
184 i := 1
185 err := validator.ValidateFieldByTag(i, "-")
186 c.Assert(err, IsNil)
187
188 c.Assert(func() { validator.ValidateFieldByTag(i, "len=a") }, PanicMatches, "strconv.ParseInt: parsing \"a\": invalid syntax")
189 c.Assert(func() { validator.ValidateFieldByTag(i, "len=a") }, PanicMatches, "strconv.ParseInt: parsing \"a\": invalid syntax")
190
191 var ui uint = 1
192 c.Assert(func() { validator.ValidateFieldByTag(ui, "len=a") }, PanicMatches, "strconv.ParseUint: parsing \"a\": invalid syntax")
193
194 f := 1.23
195 c.Assert(func() { validator.ValidateFieldByTag(f, "len=a") }, PanicMatches, "strconv.ParseFloat: parsing \"a\": invalid syntax")
196 }
197
198 func (ms *MySuite) TestLength(c *C) {
199
200 i := true
201 c.Assert(func() { validator.ValidateFieldByTag(i, "len") }, PanicMatches, "Bad field type bool")
202 }
203
204 func (ms *MySuite) TestIsGt(c *C) {
205
206 myMap := map[string]string{}
207 err := validator.ValidateFieldByTag(myMap, "gt=0")
208 c.Assert(err, NotNil)
209
210 f := 1.23
211 err = validator.ValidateFieldByTag(f, "gt=5")
212 c.Assert(err, NotNil)
213
214 var ui uint = 5
215 err = validator.ValidateFieldByTag(ui, "gt=10")
216 c.Assert(err, NotNil)
217
218 i := true
219 c.Assert(func() { validator.ValidateFieldByTag(i, "gt") }, PanicMatches, "Bad field type bool")
220 }
221
222 func (ms *MySuite) TestIsGte(c *C) {
223
224 i := true
225 c.Assert(func() { validator.ValidateFieldByTag(i, "gte") }, PanicMatches, "Bad field type bool")
226 }
227
228 func (ms *MySuite) TestIsLt(c *C) {
229
230 myMap := map[string]string{}
231 err := validator.ValidateFieldByTag(myMap, "lt=0")
232 c.Assert(err, NotNil)
233
234 f := 1.23
235 err = validator.ValidateFieldByTag(f, "lt=0")
236 c.Assert(err, NotNil)
237
238 var ui uint = 5
239 err = validator.ValidateFieldByTag(ui, "lt=0")
240 c.Assert(err, NotNil)
241
242 i := true
243 c.Assert(func() { validator.ValidateFieldByTag(i, "lt") }, PanicMatches, "Bad field type bool")
244 }
245
246 func (ms *MySuite) TestIsLte(c *C) {
247
248 i := true
249 c.Assert(func() { validator.ValidateFieldByTag(i, "lte") }, PanicMatches, "Bad field type bool")
121250 }
122251
123252 func (ms *MySuite) TestUrl(c *C) {
171300 c.Assert(err.ErrorTag, Equals, "url")
172301 }
173302 }
303
304 i := 1
305 c.Assert(func() { validator.ValidateFieldByTag(i, "url") }, PanicMatches, "Bad field type int")
174306 }
175307
176308 func (ms *MySuite) TestUri(c *C) {
224356 c.Assert(err.ErrorTag, Equals, "uri")
225357 }
226358 }
359
360 i := 1
361 c.Assert(func() { validator.ValidateFieldByTag(i, "uri") }, PanicMatches, "Bad field type int")
227362 }
228363
229364 func (ms *MySuite) TestOrTag(c *C) {
292427 err = validator.ValidateFieldByTag(s, "hsla")
293428 c.Assert(err, NotNil)
294429 c.Assert(err.ErrorTag, Equals, "hsla")
430
431 i := 1
432 c.Assert(func() { validator.ValidateFieldByTag(i, "hsla") }, PanicMatches, "Bad field type int")
295433 }
296434
297435 func (ms *MySuite) TestHsl(c *C) {
323461 err = validator.ValidateFieldByTag(s, "hsl")
324462 c.Assert(err, NotNil)
325463 c.Assert(err.ErrorTag, Equals, "hsl")
464
465 i := 1
466 c.Assert(func() { validator.ValidateFieldByTag(i, "hsl") }, PanicMatches, "Bad field type int")
326467 }
327468
328469 func (ms *MySuite) TestRgba(c *C) {
353494 err = validator.ValidateFieldByTag(s, "rgba")
354495 c.Assert(err, NotNil)
355496 c.Assert(err.ErrorTag, Equals, "rgba")
497
498 i := 1
499 c.Assert(func() { validator.ValidateFieldByTag(i, "rgba") }, PanicMatches, "Bad field type int")
356500 }
357501
358502 func (ms *MySuite) TestRgb(c *C) {
379523 err = validator.ValidateFieldByTag(s, "rgb")
380524 c.Assert(err, NotNil)
381525 c.Assert(err.ErrorTag, Equals, "rgb")
526
527 i := 1
528 c.Assert(func() { validator.ValidateFieldByTag(i, "rgb") }, PanicMatches, "Bad field type int")
382529 }
383530
384531 func (ms *MySuite) TestEmail(c *C) {
406553 err = validator.ValidateFieldByTag(s, "email")
407554 c.Assert(err, NotNil)
408555 c.Assert(err.ErrorTag, Equals, "email")
556
557 i := true
558 c.Assert(func() { validator.ValidateFieldByTag(i, "email") }, PanicMatches, "Bad field type bool")
409559 }
410560
411561 func (ms *MySuite) TestHexColor(c *C) {
427577 err = validator.ValidateFieldByTag(s, "hexcolor")
428578 c.Assert(err, NotNil)
429579 c.Assert(err.ErrorTag, Equals, "hexcolor")
580
581 i := true
582 c.Assert(func() { validator.ValidateFieldByTag(i, "hexcolor") }, PanicMatches, "Bad field type bool")
430583 }
431584
432585 func (ms *MySuite) TestHexadecimal(c *C) {
439592 err = validator.ValidateFieldByTag(s, "hexadecimal")
440593 c.Assert(err, NotNil)
441594 c.Assert(err.ErrorTag, Equals, "hexadecimal")
595
596 i := true
597 c.Assert(func() { validator.ValidateFieldByTag(i, "hexadecimal") }, PanicMatches, "Bad field type bool")
442598 }
443599
444600 func (ms *MySuite) TestNumber(c *C) {
481637 err = validator.ValidateFieldByTag(s, "number")
482638 c.Assert(err, NotNil)
483639 c.Assert(err.ErrorTag, Equals, "number")
640
641 i := 1
642 c.Assert(func() { validator.ValidateFieldByTag(i, "number") }, PanicMatches, "Bad field type int")
484643 }
485644
486645 func (ms *MySuite) TestNumeric(c *C) {
518677 err = validator.ValidateFieldByTag(s, "numeric")
519678 c.Assert(err, NotNil)
520679 c.Assert(err.ErrorTag, Equals, "numeric")
680
681 i := 1
682 c.Assert(func() { validator.ValidateFieldByTag(i, "numeric") }, PanicMatches, "Bad field type int")
521683 }
522684
523685 func (ms *MySuite) TestAlphaNumeric(c *C) {
703865 c.Assert(len(val.StructErrors), Equals, 0)
704866
705867 AssertFieldError(val, "Test", "required", c)
868
869 errors := err.Error()
870 c.Assert(errors, NotNil)
706871 }
707872
708873 func (ms *MySuite) TestStructInt32Validation(c *C) {