blackteay/gin
3
0
Fork 0
mirror of https://github.com/gin-gonic/gin.git synced 2025-10-15 13:02:14 +08:00
Code Issues Projects Releases Wiki Activity

Clean up, removed some redundant code. Used regex call to check email. Improved testing suite.

Browse Source
This commit is contained in:
Michael Schuett 2014-07-17 00:47:24 -05:00
parent de318249e2
commit 797bf049ec
2 changed files with 108 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
binding/validate.go
View File

@ -2,7 +2,6 @@ package binding
import ( import (
"errors" "errors"
"fmt"
"reflect" "reflect"
"regexp" "regexp"
"strconv" "strconv"
@ -55,51 +54,27 @@ func Validate(obj interface{}) error {
return err return err
} }
case "email" == match: case "email" == match:
fmt.Println("email...") if err := regex(`regex:^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$`, fieldValue); err != nil {
if !reflect.DeepEqual(zero, fieldValue) { return err
if err := email(fieldValue); err != nil {
return err
}
} }
case strings.Contains(match, "digit:"): case strings.HasPrefix(match, "min:"):
if !reflect.DeepEqual(zero, fieldValue) { if err := min(match, fieldValue); err != nil {
if err := digit(match, fieldValue); err != nil { return err
return err
}
} }
case strings.Contains(match, "digits_between:"): case strings.HasPrefix(match, "max:"):
if !reflect.DeepEqual(zero, fieldValue) { if err := max(match, fieldValue); err != nil {
if err := digits_between(match, fieldValue); err != nil { return err
return err
}
} }
case strings.Contains(match, "min:"): case strings.HasPrefix(match, "in:"):
if !reflect.DeepEqual(zero, fieldValue) { if err := in(match, fieldValue); err != nil {
if err := min(match, fieldValue); err != nil { return err
return err
}
} }
case strings.Contains(match, "max:"): case strings.HasPrefix(match, "regex:"):
if !reflect.DeepEqual(zero, fieldValue) { if err := regex(match, fieldValue); err != nil {
if err := max(match, fieldValue); err != nil { return err
return err
}
}
case strings.Contains(match, "in:"):
if !reflect.DeepEqual(zero, fieldValue) {
if err := in(match, fieldValue); err != nil {
return err
}
}
case strings.Contains(match, "regex:"):
if !reflect.DeepEqual(zero, fieldValue) {
if err := regex(match, fieldValue); err != nil {
return err
}
} }
default: default:
// Temp logging to check for errors panic("The field " + match + " is not a valid validation check.")
errors.New(array[setting] + " is not a valid validation type.")
} }
} }
} }
@ -123,28 +98,15 @@ func required(field reflect.StructField, value, zero interface{}) error {
return nil return nil
} }
// Check that the passed in field is a valid email
func email(value interface{}) error {
// Email Regex Checker
var emailRegex string = `^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$`
if data, ok := value.(string); ok {
if match, _ := regexp.Match(emailRegex, []byte(data)); match {
return nil
} else {
return errors.New("A valid email address was not entered.")
}
} else {
return errors.New("Email was not able to convert the passed in data to a []byte.")
}
}
// Check that the passed in field is a valid email // Check that the passed in field is a valid email
// Need to improve error logging for this method // Need to improve error logging for this method
// Currently only supports strings, ints // Currently only supports strings, ints
func in(field string, value interface{}) error { func in(field string, value interface{}) error {
if data, ok := value.(string); ok { if data, ok := value.(string); ok {
if len(data) == 0 {
return nil
}
valid := strings.Split(field[3:], ",") valid := strings.Split(field[3:], ",")
@ -154,81 +116,18 @@ func in(field string, value interface{}) error {
} }
} }
return errors.New("In did not match any of the expected values.")
} else if data, ok := value.(int); ok {
// This will run with passed in data is an int
valid := strings.Split(field[3:], ",")
for option := range valid {
// Check for convertion to valid int
if valint, err := strconv.ParseInt(valid[option], 0, 64); err == nil {
if valint == int64(data) {
return nil
}
}
}
return errors.New("In did not match any of the expected values.")
} else { } else {
return errors.New("in, was not able to convert the data passed in to a string.") return errors.New("The value passed in for IN could not be converted to a string.")
} }
} return errors.New("In did not match any of the expected values.")
// Check that the passed in field is exactly X digits
func digit(field string, value interface{}) error {
if data, ok := value.(int); ok {
// Unpack number of digits it should be.
digit := field[6:]
if digits, check := strconv.ParseInt(digit, 0, 64); check == nil {
if int64(len(strconv.FormatInt(int64(data), 10))) == digits {
return nil
} else {
return errors.New("The data you passed in was not the right number of digits.")
}
} else {
return errors.New("Digit must check for a number.")
}
}
return errors.New("The number passed into digit was not an int.")
}
func digits_between(field string, value interface{}) error {
if data, ok := value.(int); ok {
digit := strings.Split(field[15:], ",")
if digitSmall, ok := strconv.ParseInt(digit[0], 0, 64); ok == nil {
if digitLarge, okk := strconv.ParseInt(digit[1], 0, 64); okk == nil {
num := int64(len(strconv.FormatInt(int64(data), 10)))
if num >= digitSmall && num <= digitLarge {
return nil
} else {
return errors.New("The data you passed in was not the right number of digits.")
}
}
}
}
return errors.New("The value passed into digits_between could not be converted to an int.")
} }
func min(field string, value interface{}) error { func min(field string, value interface{}) error {
if data, ok := value.(int); ok { if data, ok := value.(int); ok {
min := field[4:] min := field[strings.Index(field, ":")+1:]
if minNum, ok := strconv.ParseInt(min, 0, 64); ok == nil { if minNum, ok := strconv.ParseInt(min, 0, 64); ok == nil {
@ -241,14 +140,14 @@ func min(field string, value interface{}) error {
} }
} }
return errors.New("The value passed into min could not be converted to an int.") return errors.New("The value passed in for MIN could not be converted to an int.")
} }
func max(field string, value interface{}) error { func max(field string, value interface{}) error {
if data, ok := value.(int); ok { if data, ok := value.(int); ok {
max := field[4:] max := field[strings.Index(field, ":")+1:]
if maxNum, ok := strconv.ParseInt(max, 0, 64); ok == nil { if maxNum, ok := strconv.ParseInt(max, 0, 64); ok == nil {
if int64(data) <= maxNum { if int64(data) <= maxNum {
@ -260,21 +159,38 @@ func max(field string, value interface{}) error {
} }
} }
return errors.New("The value passed into max could not be converted to an int.") return errors.New("The value passed in for MAX could not be converted to an int.")
} }
// Regex handles the general regex call and also handles
// the regex email.
func regex(field string, value interface{}) error { func regex(field string, value interface{}) error {
// Email Regex Checker
reg := field[6:] reg := field[strings.Index(field, ":")+1:]
if data, ok := value.(string); ok { if data, ok := value.(string); ok {
if match, err := regexp.Match(reg, []byte(data)); err == nil && match { if len(data) == 0 {
return nil return nil
} else { } else if err := match_regex(reg, []byte(data)); err != nil {
return errors.New("Your regex did not match or was not valid.") return err
}
} else if data, ok := value.(int); ok {
if err := match_regex(reg, []byte(strconv.Itoa(data))); err != nil {
return err
} }
} else { } else {
return errors.New("Regex was not able to convert the passed in data to a string.") return errors.New("The value passed in for REGEX could not be converted to a string or int.")
}
return nil
}
// Helper function for regex.
func match_regex(reg string, data []byte) error {
if match, err := regexp.Match(reg, []byte(data)); err == nil && match {
return nil
} else {
return errors.New("Your regex did not match or was not valid.")
} }
} }

232
binding/validate_test.go
View File

@ -1,6 +1,7 @@
package binding package binding
import ( import (
"fmt"
"io" "io"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
@ -22,9 +23,7 @@ func TestRequired(t *testing.T) {
Test string `json:"something" validate:"required" ` Test string `json:"something" validate:"required" `
} }
testJSON := jsonFactory(`{"something": "hello"}`) req, _ := http.NewRequest("POST", "/", jsonFactory(`{"something": "hello"}`))
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testString); err != nil { if err := JSON.Bind(req, &testString); err != nil {
t.Error(err) t.Error(err)
@ -34,9 +33,7 @@ func TestRequired(t *testing.T) {
Test string `json:"something" validate:"required" ` Test string `json:"something" validate:"required" `
} }
testJSON = jsonFactory(`{}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testString2); err == nil { if err := JSON.Bind(req, &testString2); err == nil {
t.Error("Required string, empty JSON object should return error but did not.") t.Error("Required string, empty JSON object should return error but did not.")
@ -47,9 +44,7 @@ func TestRequired(t *testing.T) {
Test int `json:"something" validate:"required" ` Test int `json:"something" validate:"required" `
} }
testJSON = jsonFactory(`{"something": 2}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"something": 2}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testInt); err != nil { if err := JSON.Bind(req, &testInt); err != nil {
t.Error(err) t.Error(err)
@ -60,9 +55,7 @@ func TestRequired(t *testing.T) {
Test bool `json:"something" validate:"required" ` Test bool `json:"something" validate:"required" `
} }
testJSON = jsonFactory(`{"something": true}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"something": true}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testBool); err != nil { if err := JSON.Bind(req, &testBool); err != nil {
t.Error(err) t.Error(err)
@ -72,9 +65,7 @@ func TestRequired(t *testing.T) {
Test string `json:"something" validate:"required" ` Test string `json:"something" validate:"required" `
} }
testJSON = jsonFactory(`{}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testBool2); err == nil { if err := JSON.Bind(req, &testBool2); err == nil {
t.Error("Required bool, empty JSON object should return error but did not.") t.Error("Required bool, empty JSON object should return error but did not.")
@ -85,9 +76,7 @@ func TestRequired(t *testing.T) {
Test []string `json:"something" validate:"required" ` Test []string `json:"something" validate:"required" `
} }
testJSON = jsonFactory(`{"something": ["test", "data"]}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"something": ["test", "data"]}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testArray); err != nil { if err := JSON.Bind(req, &testArray); err != nil {
t.Error(err) t.Error(err)
@ -102,17 +91,11 @@ func TestRequired(t *testing.T) {
Test testObjectTP `json:"something" validate:"required" ` Test testObjectTP `json:"something" validate:"required" `
} }
testJSON = jsonFactory(`{"something": {"name": "test"}}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"something": {"name": "test"}}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testObject); err != nil { if err := JSON.Bind(req, &testObject); err != nil {
t.Error(err) t.Error(err)
} }
type testObjectTP2 struct {
Name string `json:"name" validate:"required" `
}
} }
func TestEmail(t *testing.T) { func TestEmail(t *testing.T) {
@ -121,9 +104,7 @@ func TestEmail(t *testing.T) {
Test string `json:"email" validate:"email" ` Test string `json:"email" validate:"email" `
} }
testJSON := jsonFactory(`{"email": "michaeljs@gmail.com"}`) req, _ := http.NewRequest("POST", "/", jsonFactory(`{"email": "michaeljs@gmail.com"}`))
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValEmail); err != nil { if err := JSON.Bind(req, &testValEmail); err != nil {
t.Error(err) t.Error(err)
@ -133,9 +114,7 @@ func TestEmail(t *testing.T) {
Test string `json:"email" validate:"email" ` Test string `json:"email" validate:"email" `
} }
testJSON = jsonFactory(`{"email": "michaeljs@gail.edu"}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"email": "michaeljs@gail.edu"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValEmail2); err != nil { if err := JSON.Bind(req, &testValEmail2); err != nil {
t.Error(err) t.Error(err)
@ -145,9 +124,7 @@ func TestEmail(t *testing.T) {
Test string `json:"email" validate:"email" ` Test string `json:"email" validate:"email" `
} }
testJSON = jsonFactory(`{"email": "michaeljs.edu"}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"email": "michaeljs.edu"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValEmail3); err == nil { if err := JSON.Bind(req, &testValEmail3); err == nil {
t.Error("Email test failed, michaeljs.edu passed as a valid email.") t.Error("Email test failed, michaeljs.edu passed as a valid email.")
@ -158,9 +135,7 @@ func TestEmail(t *testing.T) {
Test string `json:"email" validate:"email" ` Test string `json:"email" validate:"email" `
} }
testJSON = jsonFactory(`{"jeff": "really"}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"jeff": "really"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValEmail4); err != nil { if err := JSON.Bind(req, &testValEmail4); err != nil {
t.Error(err) t.Error(err)
@ -176,21 +151,17 @@ func TestIn(t *testing.T) {
Test string `json:"special" validate:"in:admin,user,other" ` Test string `json:"special" validate:"in:admin,user,other" `
} }
testJSON := jsonFactory(`{"special": "admin"}`) req, _ := http.NewRequest("POST", "/", jsonFactory(`{"special": "admin"}`))
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValIn); err != nil { if err := JSON.Bind(req, &testValIn); err != nil {
t.Error(err) t.Error(err)
} }
var testValIn2 struct { var testValIn2 struct {
Test int `json:"special" validate:"in:1,3,2" ` Test string `json:"special" validate:"in:1,3,2" `
} }
testJSON = jsonFactory(`{"special": 3}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"special": "3"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValIn2); err != nil { if err := JSON.Bind(req, &testValIn2); err != nil {
t.Error(err) t.Error(err)
@ -200,9 +171,7 @@ func TestIn(t *testing.T) {
Test int `json:"special" validate:"in:1,3,2" ` Test int `json:"special" validate:"in:1,3,2" `
} }
testJSON = jsonFactory(`{"special": 6}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"special": 6}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValIn3); err == nil { if err := JSON.Bind(req, &testValIn3); err == nil {
t.Error("6 is not in validate in call, err should not have been nil.") t.Error("6 is not in validate in call, err should not have been nil.")
@ -210,12 +179,10 @@ func TestIn(t *testing.T) {
var testValIn4 struct { var testValIn4 struct {
Test2 string `json:"what" validate:in:this,that` Test2 string `json:"what" validate:in:this,that`
Test int `json:"special" validate:"in:1,3,2" ` Test string `json:"special" validate:"in:1,3,2" `
} }
testJSON = jsonFactory(`{"special": 3,"what": "this"}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"special": "3","what": "this"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValIn4); err != nil { if err := JSON.Bind(req, &testValIn4); err != nil {
t.Error(err) t.Error(err)
@ -223,12 +190,10 @@ func TestIn(t *testing.T) {
var testValIn5 struct { var testValIn5 struct {
Test2 string `json:"what" validate:in:this,that` Test2 string `json:"what" validate:in:this,that`
Test int `json:"special" validate:"in:1,3,2" ` Test string `json:"special" validate:"in:1,3,2" `
} }
testJSON = jsonFactory(`{"special": 3}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"special": "3"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValIn5); err != nil { if err := JSON.Bind(req, &testValIn5); err != nil {
t.Error(err) t.Error(err)
@ -239,100 +204,17 @@ func TestIn(t *testing.T) {
Test3 string `json:"what1" validate:"in:this,then"` Test3 string `json:"what1" validate:"in:this,then"`
Test4 string `json:"what2" validate:"in:this,that"` Test4 string `json:"what2" validate:"in:this,that"`
Test5 string `json:"what3" validate:"in:this,that"` Test5 string `json:"what3" validate:"in:this,that"`
Test int `json:"special" validate:"in:1,3,2"` Test string `json:"special" validate:"in:1,3,2"`
} }
testJSON = jsonFactory(`{"sa": 34, "what":"this", "what1":"then", "what2":"this"}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"sa": 34, "what":"this", "what1":"then", "what2":"this"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
fmt.Println("error here:")
if err := JSON.Bind(req, &testValIn6); err != nil { if err := JSON.Bind(req, &testValIn6); err != nil {
t.Error(err) t.Error(err)
} }
} }
// Check if the entered JSON is a data matching the one in a string.
func TestDigit(t *testing.T) {
var testValDigit struct {
Test int `json:"digit" validate:"digit:5" `
}
testJSON := jsonFactory(`{"digit": 12345}`)
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit); err != nil {
t.Error(err)
}
var testValDigit2 struct {
Test int `json:"digit" validate:"digit:5" `
}
testJSON = jsonFactory(`{"digit": 123456}`)
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit2); err == nil {
t.Error("Error should have been thrown, digits should be 5 but was 6.")
}
var testValDigit3 struct {
Test int `json:"digit" validate:"digit:12" `
}
testJSON = jsonFactory(`{"digit": 111111111111}`)
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit3); err != nil {
t.Error(err)
}
}
// Check if the entered JSON is a data matching the one in a string.
func TestDigitBetween(t *testing.T) {
var testValDigit struct {
Test int `json:"digit" validate:"digits_between:5,7" `
}
testJSON := jsonFactory(`{"digit": 123456}`)
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit); err != nil {
t.Error(err)
}
var testValDigit2 struct {
Test int `json:"digit" validate:"digits_between:0,10" `
}
testJSON = jsonFactory(`{"digit": 1234564}`)
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit2); err != nil {
t.Error("Error should have been thrown, digit was not between 0 and 10.")
}
var testValDigit3 struct {
Test int `json:"digit" validate:"digits_between:0,1" `
}
testJSON = jsonFactory(`{"digit": 1234564}`)
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit3); err == nil {
t.Error(err)
}
}
// Check if the entered JSON is a data matching the one in a string. // Check if the entered JSON is a data matching the one in a string.
func TestMin(t *testing.T) { func TestMin(t *testing.T) {
@ -340,9 +222,7 @@ func TestMin(t *testing.T) {
Test int `json:"digit" validate:"min:23" ` Test int `json:"digit" validate:"min:23" `
} }
testJSON := jsonFactory(`{"digit": 24}`) req, _ := http.NewRequest("POST", "/", jsonFactory(`{"digit": 24}`))
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValMin); err != nil { if err := JSON.Bind(req, &testValMin); err != nil {
t.Error(err) t.Error(err)
@ -352,25 +232,21 @@ func TestMin(t *testing.T) {
Test int `json:"digit" validate:"min:20" ` Test int `json:"digit" validate:"min:20" `
} }
testJSON = jsonFactory(`{"digit": 19}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"digit": 19}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValMin2); err == nil { if err := JSON.Bind(req, &testValMin2); err == nil {
t.Error("Min was 20 digit of 19 should not have validated properly.") t.Error("Min was 20 digit of 19 should not have validated properly.")
} }
var testValMin3 struct { // var testValMin3 struct {
Test int `json:"digit" validate:"min:20" ` // Test int `json:"digit" validate:"min:20" `
} // }
testJSON = jsonFactory(`{"jeff":"greg"}`) // req, _ = http.NewRequest("POST", "/", jsonFactory(`{"jeff":"greg"}`))
req, _ = http.NewRequest("POST", "/", testJSON) // if err := JSON.Bind(req, &testValMin3); err != nil {
// t.Error("Nothing was entered but min was not required. No error should be thrown.")
if err := JSON.Bind(req, &testValMin3); err != nil { // }
t.Error("Nothing was entered but min was not required. No error should be thrown.")
}
} }
func TestMax(t *testing.T) { func TestMax(t *testing.T) {
@ -379,9 +255,7 @@ func TestMax(t *testing.T) {
Test int `json:"digit" validate:"max:23" ` Test int `json:"digit" validate:"max:23" `
} }
testJSON := jsonFactory(`{"digit": 23}`) req, _ := http.NewRequest("POST", "/", jsonFactory(`{"digit": 23}`))
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValMin); err != nil { if err := JSON.Bind(req, &testValMin); err != nil {
t.Error(err) t.Error(err)
@ -391,9 +265,7 @@ func TestMax(t *testing.T) {
Test int `json:"digit" validate:"max:20" ` Test int `json:"digit" validate:"max:20" `
} }
testJSON = jsonFactory(`{"digit": 21}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"digit": 21}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValMin2); err == nil { if err := JSON.Bind(req, &testValMin2); err == nil {
t.Error("Max was 20 digit of 21 should not have validated properly.") t.Error("Max was 20 digit of 21 should not have validated properly.")
@ -403,9 +275,7 @@ func TestMax(t *testing.T) {
Test int `json:"digit" validate:"max:20" ` Test int `json:"digit" validate:"max:20" `
} }
testJSON = jsonFactory(`{"jeff":"greg"}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"jeff":"greg"}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValMin3); err != nil { if err := JSON.Bind(req, &testValMin3); err != nil {
t.Error("Nothing was entered but max was not required. No error should be thrown.") t.Error("Nothing was entered but max was not required. No error should be thrown.")
@ -418,9 +288,7 @@ func TestRegex(t *testing.T) {
Test int `json:"digit" validate:"regex:\d+" ` Test int `json:"digit" validate:"regex:\d+" `
} }
testJSON := jsonFactory(`{"digit": 23}`) req, _ := http.NewRequest("POST", "/", jsonFactory(`{"digit": 23}`))
req, _ := http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit); err != nil { if err := JSON.Bind(req, &testValDigit); err != nil {
t.Error(err) t.Error(err)
@ -430,11 +298,33 @@ func TestRegex(t *testing.T) {
Test int `json:"digit" validate:"regex:\d+" ` Test int `json:"digit" validate:"regex:\d+" `
} }
testJSON = jsonFactory(`{"digit": 2dsa3}`) req, _ = http.NewRequest("POST", "/", jsonFactory(`{"digit": 2dsa3}`))
req, _ = http.NewRequest("POST", "/", testJSON)
if err := JSON.Bind(req, &testValDigit2); err == nil { if err := JSON.Bind(req, &testValDigit2); err == nil {
t.Error("\\d+ regex should not match the string 2dsa3.") t.Error("\\d+ regex should not match the string 2dsa3.")
} }
} }
func TestMultiple(t *testing.T) {
var testValMulti struct {
Test int `json:"digit" validate:"regex:\\d+|required|max:23" `
}
req, _ := http.NewRequest("POST", "/", jsonFactory(`{"digit": 23}`))
if err := JSON.Bind(req, &testValMulti); err != nil {
t.Error(err)
}
var testValMulti2 struct {
Test string `json:"digit" validate:"email|required|regex:\\d+" `
}
req, _ = http.NewRequest("POST", "/", jsonFactory(`{"digit": "m@g.com"}`))
if err := JSON.Bind(req, &testValMulti2); err == nil {
t.Error("Should have returned error but did not.")
}
}