pax_global_header00006660000000000000000000000064127171365730014526gustar00rootroot0000000000000052 comment=7664702784775e51966f0885f5cd27435916517b govalidator-4/000077500000000000000000000000001271713657300135465ustar00rootroot00000000000000govalidator-4/.travis.yml000066400000000000000000000001721271713657300156570ustar00rootroot00000000000000language: go go: - 1.1 - 1.2 - 1.3 - 1.4 - 1.5 - 1.6 - tip notifications: email: - bwatas@gmail.com govalidator-4/LICENSE000066400000000000000000000020701271713657300145520ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014 Alex Saskevich Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.govalidator-4/README.md000066400000000000000000000334071271713657300150340ustar00rootroot00000000000000govalidator =========== [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/asaskevich/govalidator?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) [![GoDoc](https://godoc.org/github.com/asaskevich/govalidator?status.png)](https://godoc.org/github.com/asaskevich/govalidator) [![Coverage Status](https://img.shields.io/coveralls/asaskevich/govalidator.svg)](https://coveralls.io/r/asaskevich/govalidator?branch=master) [![views](https://sourcegraph.com/api/repos/github.com/asaskevich/govalidator/.counters/views.png)](https://sourcegraph.com/github.com/asaskevich/govalidator) [![wercker status](https://app.wercker.com/status/1ec990b09ea86c910d5f08b0e02c6043/s "wercker status")](https://app.wercker.com/project/bykey/1ec990b09ea86c910d5f08b0e02c6043) [![Build Status](https://travis-ci.org/asaskevich/govalidator.svg?branch=master)](https://travis-ci.org/asaskevich/govalidator) A package of validators and sanitizers for strings, structs and collections. Based on [validator.js](https://github.com/chriso/validator.js). #### Installation Make sure that Go is installed on your computer. Type the following command in your terminal: go get github.com/asaskevich/govalidator After it the package is ready to use. #### Import package in your project Add following line in your `*.go` file: ```go import "github.com/asaskevich/govalidator" ``` If you are unhappy to use long `govalidator`, you can do something like this: ```go import ( valid "github.com/asaskevich/govalidator" ) ``` #### Activate behavior to require all fields have a validation tag by default `SetFieldsRequiredByDefault` causes validation to fail when struct fields do not include validations or are not explicitly marked as exempt (using `valid:"-"` or `valid:"email,optional"`). A good place to activate this is a package init function or the main() function. ```go import "github.com/asaskevich/govalidator" func init() { govalidator.SetFieldsRequiredByDefault(true) } ``` Here's some code to explain it: ```go // this struct definition will fail govalidator.ValidateStruct() (and the field values do not matter): type exampleStruct struct { Name string `` Email string `valid:"email"` // this, however, will only fail when Email is empty or an invalid email address: type exampleStruct2 struct { Name string `valid:"-"` Email string `valid:"email"` // lastly, this will only fail when Email is an invalid email address but not when it's empty: type exampleStruct2 struct { Name string `valid:"-"` Email string `valid:"email,optional"` ``` #### Recent breaking changes (see [#123](https://github.com/asaskevich/govalidator/pull/123)) ##### Custom validator function signature A context was added as the second parameter, for structs this is the object being validated – this makes dependent validation possible. ```go import "github.com/asaskevich/govalidator" // old signature func(i interface{}) bool // new signature func(i interface{}, o interface{}) bool ``` ##### Adding a custom validator This was changed to prevent data races when accessing custom validators. ```go import "github.com/asaskevich/govalidator" // before govalidator.CustomTypeTagMap["customByteArrayValidator"] = CustomTypeValidator(func(i interface{}, o interface{}) bool { // ... }) // after govalidator.CustomTypeTagMap.Set("customByteArrayValidator", CustomTypeValidator(func(i interface{}, o interface{}) bool { // ... })) ``` #### List of functions: ```go func Abs(value float64) float64 func BlackList(str, chars string) string func ByteLength(str string, params ...string) bool func StringLength(str string, params ...string) bool func StringMatches(s string, params ...string) bool func CamelCaseToUnderscore(str string) string func Contains(str, substring string) bool func Count(array []interface{}, iterator ConditionIterator) int func Each(array []interface{}, iterator Iterator) func ErrorByField(e error, field string) string func Filter(array []interface{}, iterator ConditionIterator) []interface{} func Find(array []interface{}, iterator ConditionIterator) interface{} func GetLine(s string, index int) (string, error) func GetLines(s string) []string func IsHost(s string) bool func InRange(value, left, right float64) bool func IsASCII(str string) bool func IsAlpha(str string) bool func IsAlphanumeric(str string) bool func IsBase64(str string) bool func IsByteLength(str string, min, max int) bool func IsCreditCard(str string) bool func IsDataURI(str string) bool func IsDialString(str string) bool func IsDNSName(str string) bool func IsDivisibleBy(str, num string) bool func IsEmail(str string) bool func IsFilePath(str string) (bool, int) func IsFloat(str string) bool func IsFullWidth(str string) bool func IsHalfWidth(str string) bool func IsHexadecimal(str string) bool func IsHexcolor(str string) bool func IsIP(str string) bool func IsIPv4(str string) bool func IsIPv6(str string) bool func IsISBN(str string, version int) bool func IsISBN10(str string) bool func IsISBN13(str string) bool func IsISO3166Alpha2(str string) bool func IsISO3166Alpha3(str string) bool func IsInt(str string) bool func IsJSON(str string) bool func IsLatitude(str string) bool func IsLongitude(str string) bool func IsLowerCase(str string) bool func IsMAC(str string) bool func IsMongoID(str string) bool func IsMultibyte(str string) bool func IsNatural(value float64) bool func IsNegative(value float64) bool func IsNonNegative(value float64) bool func IsNonPositive(value float64) bool func IsNull(str string) bool func IsNumeric(str string) bool func IsPort(str string) bool func IsPositive(value float64) bool func IsPrintableASCII(str string) bool func IsRGBcolor(str string) bool func IsRequestURI(rawurl string) bool func IsRequestURL(rawurl string) bool func IsSSN(str string) bool func IsSemver(str string) bool func IsURL(str string) bool func IsUTFDigit(str string) bool func IsUTFLetter(str string) bool func IsUTFLetterNumeric(str string) bool func IsUTFNumeric(str string) bool func IsUUID(str string) bool func IsUUIDv3(str string) bool func IsUUIDv4(str string) bool func IsUUIDv5(str string) bool func IsUpperCase(str string) bool func IsVariableWidth(str string) bool func IsWhole(value float64) bool func LeftTrim(str, chars string) string func Map(array []interface{}, iterator ResultIterator) []interface{} func Matches(str, pattern string) bool func NormalizeEmail(str string) (string, error) func RemoveTags(s string) string func ReplacePattern(str, pattern, replace string) string func Reverse(s string) string func RightTrim(str, chars string) string func SafeFileName(str string) string func Sign(value float64) float64 func StripLow(str string, keepNewLines bool) string func ToBoolean(str string) (bool, error) func ToFloat(str string) (float64, error) func ToInt(str string) (int64, error) func ToJSON(obj interface{}) (string, error) func ToString(obj interface{}) string func Trim(str, chars string) string func Truncate(str string, length int, ending string) string func UnderscoreToCamelCase(s string) string func ValidateStruct(s interface{}) (bool, error) func WhiteList(str, chars string) string type ConditionIterator type Error func (e Error) Error() string type Errors func (es Errors) Error() string type ISO3166Entry type Iterator type ParamValidator type ResultIterator type UnsupportedTypeError func (e *UnsupportedTypeError) Error() string type Validator ``` #### Examples ###### IsURL ```go println(govalidator.IsURL(`http://user@pass:domain.com/path/page`)) ``` ###### ToString ```go type User struct { FirstName string LastName string } str := govalidator.ToString(&User{"John", "Juan"}) println(str) ``` ###### Each, Map, Filter, Count for slices Each iterates over the slice/array and calls Iterator for every item ```go data := []interface{}{1, 2, 3, 4, 5} var fn govalidator.Iterator = func(value interface{}, index int) { println(value.(int)) } govalidator.Each(data, fn) ``` ```go data := []interface{}{1, 2, 3, 4, 5} var fn govalidator.ResultIterator = func(value interface{}, index int) interface{} { return value.(int) * 3 } _ = govalidator.Map(data, fn) // result = []interface{}{1, 6, 9, 12, 15} ``` ```go data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} var fn govalidator.ConditionIterator = func(value interface{}, index int) bool { return value.(int)%2 == 0 } _ = govalidator.Filter(data, fn) // result = []interface{}{2, 4, 6, 8, 10} _ = govalidator.Count(data, fn) // result = 5 ``` ###### ValidateStruct [#2](https://github.com/asaskevich/govalidator/pull/2) If you want to validate structs, you can use tag `valid` for any field in your structure. All validators used with this field in one tag are separated by comma. If you want to skip validation, place `-` in your tag. If you need a validator that is not on the list below, you can add it like this: ```go govalidator.TagMap["duck"] = govalidator.Validator(func(str string) bool { return str == "duck" }) ``` For completely custom validators (interface-based), see below. Here is a list of available validators for struct fields (validator - used function): ```go "alpha": IsAlpha, "alphanum": IsAlphanumeric, "ascii": IsASCII, "base64": IsBase64, "creditcard": IsCreditCard, "datauri": IsDataURI, "dialstring": IsDialString, "dns": IsDNSName, "email": IsEmail, "float": IsFloat, "fullwidth": IsFullWidth, "halfwidth": IsHalfWidth, "hexadecimal": IsHexadecimal, "hexcolor": IsHexcolor, "host": IsHost, "int": IsInt, "ip": IsIP, "ipv4": IsIPv4, "ipv6": IsIPv6, "isbn10": IsISBN10, "isbn13": IsISBN13, "json": IsJSON, "latitude": IsLatitude, "longitude": IsLongitude, "lowercase": IsLowerCase, "mac": IsMAC, "multibyte": IsMultibyte, "null": IsNull, "numeric": IsNumeric, "port": IsPort, "printableascii": IsPrintableASCII, "requri": IsRequestURI, "requrl": IsRequestURL, "rgbcolor": IsRGBcolor, "ssn": IsSSN, "semver": IsSemver, "uppercase": IsUpperCase, "url": IsURL, "utfdigit": IsUTFDigit, "utfletter": IsUTFLetter, "utfletternum": IsUTFLetterNumeric, "utfnumeric": IsUTFNumeric, "uuid": IsUUID, "uuidv3": IsUUIDv3, "uuidv4": IsUUIDv4, "uuidv5": IsUUIDv5, "variablewidth": IsVariableWidth, ``` Validators with parameters ```go "length(min|max)": ByteLength, "matches(pattern)": StringMatches, ``` And here is small example of usage: ```go type Post struct { Title string `valid:"alphanum,required"` Message string `valid:"duck,ascii"` AuthorIP string `valid:"ipv4"` Date string `valid:"-"` } post := &Post{ Title: "My Example Post", Message: "duck", AuthorIP: "123.234.54.3", } // Add your own struct validation tags govalidator.TagMap["duck"] = govalidator.Validator(func(str string) bool { return str == "duck" }) result, err := govalidator.ValidateStruct(post) if err != nil { println("error: " + err.Error()) } println(result) ``` ###### WhiteList ```go // Remove all characters from string ignoring characters between "a" and "z" println(govalidator.WhiteList("a3a43a5a4a3a2a23a4a5a4a3a4", "a-z") == "aaaaaaaaaaaa") ``` ###### Custom validation functions Custom validation using your own domain specific validators is also available - here's an example of how to use it: ```go import "github.com/asaskevich/govalidator" type CustomByteArray [6]byte // custom types are supported and can be validated type StructWithCustomByteArray struct { ID CustomByteArray `valid:"customByteArrayValidator,customMinLengthValidator"` // multiple custom validators are possible as well and will be evaluated in sequence Email string `valid:"email"` CustomMinLength int `valid:"-"` } govalidator.CustomTypeTagMap.Set("customByteArrayValidator", CustomTypeValidator(func(i interface{}, context interface{}) bool { switch v := context.(type) { // you can type switch on the context interface being validated case StructWithCustomByteArray: // you can check and validate against some other field in the context, // return early or not validate against the context at all – your choice case SomeOtherType: // ... default: // expecting some other type? Throw/panic here or continue } switch v := i.(type) { // type switch on the struct field being validated case CustomByteArray: for _, e := range v { // this validator checks that the byte array is not empty, i.e. not all zeroes if e != 0 { return true } } } return false })) govalidator.CustomTypeTagMap.Set("customMinLengthValidator", CustomTypeValidator(func(i interface{}, context interface{}) bool { switch v := context.(type) { // this validates a field against the value in another field, i.e. dependent validation case StructWithCustomByteArray: return len(v.ID) >= v.CustomMinLength } return false })) ``` #### Notes Documentation is available here: [godoc.org](https://godoc.org/github.com/asaskevich/govalidator). Full information about code coverage is also available here: [govalidator on gocover.io](http://gocover.io/github.com/asaskevich/govalidator). #### Support If you do have a contribution for the package feel free to put up a Pull Request or open Issue. #### Special thanks to [contributors](https://github.com/asaskevich/govalidator/graphs/contributors) * [Attila Oláh](https://github.com/attilaolah) * [Daniel Korner](https://github.com/Dadie) * [Steven Wilkin](https://github.com/stevenwilkin) * [Deiwin Sarjas](https://github.com/deiwin) * [Noah Shibley](https://github.com/slugmobile) * [Nathan Davies](https://github.com/nathj07) * [Matt Sanford](https://github.com/mzsanford) * [Simon ccl1115](https://github.com/ccl1115) [![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/asaskevich/govalidator/trend.png)](https://bitdeli.com/free "Bitdeli Badge") govalidator-4/arrays.go000066400000000000000000000035701271713657300154030ustar00rootroot00000000000000package govalidator // Iterator is the function that accepts element of slice/array and its index type Iterator func(interface{}, int) // ResultIterator is the function that accepts element of slice/array and its index and returns any result type ResultIterator func(interface{}, int) interface{} // ConditionIterator is the function that accepts element of slice/array and its index and returns boolean type ConditionIterator func(interface{}, int) bool // Each iterates over the slice and apply Iterator to every item func Each(array []interface{}, iterator Iterator) { for index, data := range array { iterator(data, index) } } // Map iterates over the slice and apply ResultIterator to every item. Returns new slice as a result. func Map(array []interface{}, iterator ResultIterator) []interface{} { var result = make([]interface{}, len(array)) for index, data := range array { result[index] = iterator(data, index) } return result } // Find iterates over the slice and apply ConditionIterator to every item. Returns first item that meet ConditionIterator or nil otherwise. func Find(array []interface{}, iterator ConditionIterator) interface{} { for index, data := range array { if iterator(data, index) { return data } } return nil } // Filter iterates over the slice and apply ConditionIterator to every item. Returns new slice. func Filter(array []interface{}, iterator ConditionIterator) []interface{} { var result = make([]interface{}, 0) for index, data := range array { if iterator(data, index) { result = append(result, data) } } return result } // Count iterates over the slice and apply ConditionIterator to every item. Returns count of items that meets ConditionIterator. func Count(array []interface{}, iterator ConditionIterator) int { count := 0 for index, data := range array { if iterator(data, index) { count = count + 1 } } return count } govalidator-4/arrays_test.go000066400000000000000000000056101271713657300164370ustar00rootroot00000000000000package govalidator import "testing" func TestEach(t *testing.T) { // TODO Maybe refactor? t.Parallel() acc := 0 data := []interface{}{1, 2, 3, 4, 5} var fn Iterator = func(value interface{}, index int) { acc = acc + value.(int) } Each(data, fn) if acc != 15 { t.Errorf("Expected Each(..) to be %v, got %v", 15, acc) } } func ExampleEach() { data := []interface{}{1, 2, 3, 4, 5} var fn Iterator = func(value interface{}, index int) { println(value.(int)) } Each(data, fn) } func TestMap(t *testing.T) { // TODO Maybe refactor? t.Parallel() data := []interface{}{1, 2, 3, 4, 5} var fn ResultIterator = func(value interface{}, index int) interface{} { return value.(int) * 3 } result := Map(data, fn) for i, d := range result { if d != fn(data[i], i) { t.Errorf("Expected Map(..) to be %v, got %v", fn(data[i], i), d) } } } func ExampleMap() { data := []interface{}{1, 2, 3, 4, 5} var fn ResultIterator = func(value interface{}, index int) interface{} { return value.(int) * 3 } _ = Map(data, fn) // result = []interface{}{1, 6, 9, 12, 15} } func TestFind(t *testing.T) { // TODO Maybe refactor? t.Parallel() findElement := 96 data := []interface{}{1, 2, 3, 4, findElement, 5} var fn1 ConditionIterator = func(value interface{}, index int) bool { return value.(int) == findElement } var fn2 ConditionIterator = func(value interface{}, index int) bool { value, _ = value.(string) return value == "govalidator" } val1 := Find(data, fn1) val2 := Find(data, fn2) if val1 != findElement { t.Errorf("Expected Find(..) to be %v, got %v", findElement, val1) } if val2 != nil { t.Errorf("Expected Find(..) to be %v, got %v", nil, val2) } } func TestFilter(t *testing.T) { // TODO Maybe refactor? t.Parallel() data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} answer := []interface{}{2, 4, 6, 8, 10} var fn ConditionIterator = func(value interface{}, index int) bool { return value.(int)%2 == 0 } result := Filter(data, fn) for i := range result { if result[i] != answer[i] { t.Errorf("Expected Filter(..) to be %v, got %v", answer[i], result[i]) } } } func ExampleFilter() { data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} var fn ConditionIterator = func(value interface{}, index int) bool { return value.(int)%2 == 0 } _ = Filter(data, fn) // result = []interface{}{2, 4, 6, 8, 10} } func TestCount(t *testing.T) { // TODO Maybe refactor? t.Parallel() data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} count := 5 var fn ConditionIterator = func(value interface{}, index int) bool { return value.(int)%2 == 0 } result := Count(data, fn) if result != count { t.Errorf("Expected Count(..) to be %v, got %v", count, result) } } func ExampleCount() { data := []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} var fn ConditionIterator = func(value interface{}, index int) bool { return value.(int)%2 == 0 } _ = Count(data, fn) // result = 5 } govalidator-4/converter.go000066400000000000000000000020001271713657300160740ustar00rootroot00000000000000package govalidator import ( "encoding/json" "fmt" "strconv" ) // ToString convert the input to a string. func ToString(obj interface{}) string { res := fmt.Sprintf("%v", obj) return string(res) } // ToJSON convert the input to a valid JSON string func ToJSON(obj interface{}) (string, error) { res, err := json.Marshal(obj) if err != nil { res = []byte("") } return string(res), err } // ToFloat convert the input string to a float, or 0.0 if the input is not a float. func ToFloat(str string) (float64, error) { res, err := strconv.ParseFloat(str, 64) if err != nil { res = 0.0 } return res, err } // ToInt convert the input string to an integer, or 0 if the input is not an integer. func ToInt(str string) (int64, error) { res, err := strconv.ParseInt(str, 0, 64) if err != nil { res = 0 } return res, err } // ToBoolean convert the input string to a boolean. func ToBoolean(str string) (bool, error) { res, err := strconv.ParseBool(str) if err != nil { res = false } return res, err } govalidator-4/converter_test.go000066400000000000000000000045271271713657300171530ustar00rootroot00000000000000package govalidator import ( "fmt" "testing" ) func TestToInt(t *testing.T) { tests := []string{"1000", "-123", "abcdef", "100000000000000000000000000000000000000000000"} expected := []int64{1000, -123, 0, 0} for i := 0; i < len(tests); i++ { result, _ := ToInt(tests[i]) if result != expected[i] { t.Log("Case ", i, ": expected ", expected[i], " when result is ", result) t.FailNow() } } } func TestToBoolean(t *testing.T) { tests := []string{"true", "1", "True", "false", "0", "abcdef"} expected := []bool{true, true, true, false, false, false} for i := 0; i < len(tests); i++ { res, _ := ToBoolean(tests[i]) if res != expected[i] { t.Log("Case ", i, ": expected ", expected[i], " when result is ", res) t.FailNow() } } } func toString(t *testing.T, test interface{}, expected string) { res := ToString(test) if res != expected { t.Log("Case ToString: expected ", expected, " when result is ", res) t.FailNow() } } func TestToString(t *testing.T) { toString(t, "str123", "str123") toString(t, 123, "123") toString(t, 12.3, "12.3") toString(t, true, "true") toString(t, 1.5+10i, "(1.5+10i)") // Sprintf function not guarantee that maps with equal keys always will be equal in string representation //toString(t, struct{ Keys map[int]int }{Keys: map[int]int{1: 2, 3: 4}}, "{map[1:2 3:4]}") } func TestToFloat(t *testing.T) { tests := []string{"", "123", "-.01", "10.", "string", "1.23e3", ".23e10"} expected := []float64{0, 123, -0.01, 10.0, 0, 1230, 0.23e10} for i := 0; i < len(tests); i++ { res, _ := ToFloat(tests[i]) if res != expected[i] { t.Log("Case ", i, ": expected ", expected[i], " when result is ", res) t.FailNow() } } } func TestToJSON(t *testing.T) { tests := []interface{}{"test", map[string]string{"a": "b", "b": "c"}, func() error { return fmt.Errorf("Error") }} expected := [][]string{ []string{"\"test\"", ""}, []string{"{\"a\":\"b\",\"b\":\"c\"}", ""}, []string{"", "json: unsupported type: func() error"}, } for i, test := range tests { actual, err := ToJSON(test) if actual != expected[i][0] { t.Errorf("Expected toJSON(%v) to return '%v', got '%v'", test, expected[i][0], actual) } if fmt.Sprintf("%v", err) != expected[i][1] { t.Errorf("Expected error returned from toJSON(%v) to return '%v', got '%v'", test, expected[i][1], fmt.Sprintf("%v", err)) } } } govalidator-4/error.go000066400000000000000000000012151271713657300152250ustar00rootroot00000000000000package govalidator // Errors is an array of multiple errors and conforms to the error interface. type Errors []error // Errors returns itself. func (es Errors) Errors() []error { return es } func (es Errors) Error() string { var err string for _, e := range es { err += e.Error() + ";" } return err } // Error encapsulates a name, an error and whether there's a custom error message or not. type Error struct { Name string Err error CustomErrorMessageExists bool } func (e Error) Error() string { if e.CustomErrorMessageExists { return e.Err.Error() } return e.Name + ": " + e.Err.Error() } govalidator-4/error_test.go000066400000000000000000000016231271713657300162670ustar00rootroot00000000000000package govalidator import ( "fmt" "testing" ) func TestErrorsToString(t *testing.T) { t.Parallel() customErr := &Error{Name: "Custom Error Name", Err: fmt.Errorf("stdlib error")} customErrWithCustomErrorMessage := &Error{Name: "Custom Error Name 2", Err: fmt.Errorf("Bad stuff happened"), CustomErrorMessageExists: true} var tests = []struct { param1 Errors expected string }{ {Errors{}, ""}, {Errors{fmt.Errorf("Error 1")}, "Error 1;"}, {Errors{fmt.Errorf("Error 1"), fmt.Errorf("Error 2")}, "Error 1;Error 2;"}, {Errors{customErr, fmt.Errorf("Error 2")}, "Custom Error Name: stdlib error;Error 2;"}, {Errors{fmt.Errorf("Error 123"), customErrWithCustomErrorMessage}, "Error 123;Bad stuff happened;"}, } for _, test := range tests { actual := test.param1.Error() if actual != test.expected { t.Errorf("Expected Error() to return '%v', got '%v'", test.expected, actual) } } } govalidator-4/numerics.go000066400000000000000000000023641271713657300157270ustar00rootroot00000000000000package govalidator import "math" // Abs returns absolute value of number func Abs(value float64) float64 { return value * Sign(value) } // Sign returns signum of number: 1 in case of value > 0, -1 in case of value < 0, 0 otherwise func Sign(value float64) float64 { if value > 0 { return 1 } else if value < 0 { return -1 } else { return 0 } } // IsNegative returns true if value < 0 func IsNegative(value float64) bool { return value < 0 } // IsPositive returns true if value > 0 func IsPositive(value float64) bool { return value > 0 } // IsNonNegative returns true if value >= 0 func IsNonNegative(value float64) bool { return value >= 0 } // IsNonPositive returns true if value <= 0 func IsNonPositive(value float64) bool { return value <= 0 } // InRange returns true if value lies between left and right border func InRange(value, left, right float64) bool { if left > right { left, right = right, left } return value >= left && value <= right } // IsWhole returns true if value is whole number func IsWhole(value float64) bool { return Abs(math.Remainder(value, 1)) == 0 } // IsNatural returns true if value is natural number (positive and whole) func IsNatural(value float64) bool { return IsWhole(value) && IsPositive(value) } govalidator-4/numerics_test.go000066400000000000000000000073311271713657300167650ustar00rootroot00000000000000package govalidator import "testing" func TestAbs(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected float64 }{ {0, 0}, {-1, 1}, {10, 10}, {3.14, 3.14}, {-96, 96}, {-10e-12, 10e-12}, } for _, test := range tests { actual := Abs(test.param) if actual != test.expected { t.Errorf("Expected Abs(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestSign(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected float64 }{ {0, 0}, {-1, -1}, {10, 1}, {3.14, 1}, {-96, -1}, {-10e-12, -1}, } for _, test := range tests { actual := Sign(test.param) if actual != test.expected { t.Errorf("Expected Sign(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsNegative(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected bool }{ {0, false}, {-1, true}, {10, false}, {3.14, false}, {-96, true}, {-10e-12, true}, } for _, test := range tests { actual := IsNegative(test.param) if actual != test.expected { t.Errorf("Expected IsNegative(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsNonNegative(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected bool }{ {0, true}, {-1, false}, {10, true}, {3.14, true}, {-96, false}, {-10e-12, false}, } for _, test := range tests { actual := IsNonNegative(test.param) if actual != test.expected { t.Errorf("Expected IsNonNegative(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsPositive(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected bool }{ {0, false}, {-1, false}, {10, true}, {3.14, true}, {-96, false}, {-10e-12, false}, } for _, test := range tests { actual := IsPositive(test.param) if actual != test.expected { t.Errorf("Expected IsPositive(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsNonPositive(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected bool }{ {0, true}, {-1, true}, {10, false}, {3.14, false}, {-96, true}, {-10e-12, true}, } for _, test := range tests { actual := IsNonPositive(test.param) if actual != test.expected { t.Errorf("Expected IsNonPositive(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsWhole(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected bool }{ {0, true}, {-1, true}, {10, true}, {3.14, false}, {-96, true}, {-10e-12, false}, } for _, test := range tests { actual := IsWhole(test.param) if actual != test.expected { t.Errorf("Expected IsWhole(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsNatural(t *testing.T) { t.Parallel() var tests = []struct { param float64 expected bool }{ {0, false}, {-1, false}, {10, true}, {3.14, false}, {96, true}, {-10e-12, false}, } for _, test := range tests { actual := IsNatural(test.param) if actual != test.expected { t.Errorf("Expected IsNatural(%v) to be %v, got %v", test.param, test.expected, actual) } } } func TestInRange(t *testing.T) { t.Parallel() var tests = []struct { param float64 left float64 right float64 expected bool }{ {0, 0, 0, true}, {1, 0, 0, false}, {-1, 0, 0, false}, {0, -1, 1, true}, {0, 0, 1, true}, {0, -1, 0, true}, {0, 0, -1, true}, {0, 10, 5, false}, } for _, test := range tests { actual := InRange(test.param, test.left, test.right) if actual != test.expected { t.Errorf("Expected InRange(%v, %v, %v) to be %v, got %v", test.param, test.left, test.right, test.expected, actual) } } } govalidator-4/patterns.go000066400000000000000000000132121271713657300157340ustar00rootroot00000000000000package govalidator import "regexp" // Basic regular expressions for validating strings const ( Email string = "^(((([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+(\\.([a-zA-Z]|\\d|[!#\\$%&'\\*\\+\\-\\/=\\?\\^_`{\\|}~]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])+)*)|((\\x22)((((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(([\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x7f]|\\x21|[\\x23-\\x5b]|[\\x5d-\\x7e]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(\\([\\x01-\\x09\\x0b\\x0c\\x0d-\\x7f]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}]))))*(((\\x20|\\x09)*(\\x0d\\x0a))?(\\x20|\\x09)+)?(\\x22)))@((([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|\\d|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.)+(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])|(([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])([a-zA-Z]|\\d|-|\\.|_|~|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])*([a-zA-Z]|[\\x{00A0}-\\x{D7FF}\\x{F900}-\\x{FDCF}\\x{FDF0}-\\x{FFEF}])))\\.?$" CreditCard string = "^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})$" ISBN10 string = "^(?:[0-9]{9}X|[0-9]{10})$" ISBN13 string = "^(?:[0-9]{13})$" UUID3 string = "^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$" UUID4 string = "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" UUID5 string = "^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" UUID string = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$" Alpha string = "^[a-zA-Z]+$" Alphanumeric string = "^[a-zA-Z0-9]+$" Numeric string = "^[-+]?[0-9]+$" Int string = "^(?:[-+]?(?:0|[1-9][0-9]*))$" Float string = "^(?:[-+]?(?:[0-9]+))?(?:\\.[0-9]*)?(?:[eE][\\+\\-]?(?:[0-9]+))?$" Hexadecimal string = "^[0-9a-fA-F]+$" Hexcolor string = "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$" RGBcolor string = "^rgb\\(\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*,\\s*(0|[1-9]\\d?|1\\d\\d?|2[0-4]\\d|25[0-5])\\s*\\)$" ASCII string = "^[\x00-\x7F]+$" Multibyte string = "[^\x00-\x7F]" FullWidth string = "[^\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]" HalfWidth string = "[\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]" Base64 string = "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=|[A-Za-z0-9+\\/]{4})$" PrintableASCII string = "^[\x20-\x7E]+$" DataURI string = "^data:.+\\/(.+);base64$" Latitude string = "^[-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?)$" Longitude string = "^[-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?)$" DNSName string = `^([a-zA-Z0-9]{1}[a-zA-Z0-9_-]{1,62}){1}(\.[a-zA-Z0-9]{1}[a-zA-Z0-9_-]{1,62})*$` URL string = `^((ftp|https?):\/\/)?(\S+(:\S*)?@)?((([1-9]\d?|1\d\d|2[01]\d|22[0-3])(\.(1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.([0-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(([a-zA-Z0-9]+([-\.][a-zA-Z0-9]+)*)|((www\.)?))?(([a-zA-Z\x{00a1}-\x{ffff}0-9]+-?-?)*[a-zA-Z\x{00a1}-\x{ffff}0-9]+)(?:\.([a-zA-Z\x{00a1}-\x{ffff}]{1,}))?))(:(\d{1,5}))?((\/|\?|#)[^\s]*)?$` SSN string = `^\d{3}[- ]?\d{2}[- ]?\d{4}$` WinPath string = `^[a-zA-Z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*[^\\/:*?"<>|\r\n]*$` UnixPath string = `^((?:\/[a-zA-Z0-9\.\:]+(?:_[a-zA-Z0-9\:\.]+)*(?:\-[\:a-zA-Z0-9\.]+)*)+\/?)$` Semver string = "^v?(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(-(0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(\\.(0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\\+[0-9a-zA-Z-]+(\\.[0-9a-zA-Z-]+)*)?$" tagName string = "valid" ) // Used by IsFilePath func const ( // Unknown is unresolved OS type Unknown = iota // Win is Windows type Win // Unix is *nix OS types Unix ) var ( rxEmail = regexp.MustCompile(Email) rxCreditCard = regexp.MustCompile(CreditCard) rxISBN10 = regexp.MustCompile(ISBN10) rxISBN13 = regexp.MustCompile(ISBN13) rxUUID3 = regexp.MustCompile(UUID3) rxUUID4 = regexp.MustCompile(UUID4) rxUUID5 = regexp.MustCompile(UUID5) rxUUID = regexp.MustCompile(UUID) rxAlpha = regexp.MustCompile(Alpha) rxAlphanumeric = regexp.MustCompile(Alphanumeric) rxNumeric = regexp.MustCompile(Numeric) rxInt = regexp.MustCompile(Int) rxFloat = regexp.MustCompile(Float) rxHexadecimal = regexp.MustCompile(Hexadecimal) rxHexcolor = regexp.MustCompile(Hexcolor) rxRGBcolor = regexp.MustCompile(RGBcolor) rxASCII = regexp.MustCompile(ASCII) rxPrintableASCII = regexp.MustCompile(PrintableASCII) rxMultibyte = regexp.MustCompile(Multibyte) rxFullWidth = regexp.MustCompile(FullWidth) rxHalfWidth = regexp.MustCompile(HalfWidth) rxBase64 = regexp.MustCompile(Base64) rxDataURI = regexp.MustCompile(DataURI) rxLatitude = regexp.MustCompile(Latitude) rxLongitude = regexp.MustCompile(Longitude) rxDNSName = regexp.MustCompile(DNSName) rxURL = regexp.MustCompile(URL) rxSSN = regexp.MustCompile(SSN) rxWinPath = regexp.MustCompile(WinPath) rxUnixPath = regexp.MustCompile(UnixPath) rxSemver = regexp.MustCompile(Semver) ) govalidator-4/types.go000066400000000000000000000446751271713657300152610ustar00rootroot00000000000000package govalidator import ( "reflect" "regexp" "sync" ) // Validator is a wrapper for a validator function that returns bool and accepts string. type Validator func(str string) bool // CustomTypeValidator is a wrapper for validator functions that returns bool and accepts any type. // The second parameter should be the context (in the case of validating a struct: the whole object being validated). type CustomTypeValidator func(i interface{}, o interface{}) bool // ParamValidator is a wrapper for validator functions that accepts additional parameters. type ParamValidator func(str string, params ...string) bool type tagOptions []string // UnsupportedTypeError is a wrapper for reflect.Type type UnsupportedTypeError struct { Type reflect.Type } // stringValues is a slice of reflect.Value holding *reflect.StringValue. // It implements the methods to sort by string. type stringValues []reflect.Value // ParamTagMap is a map of functions accept variants parameters var ParamTagMap = map[string]ParamValidator{ "length": ByteLength, "stringlength": StringLength, "matches": StringMatches, } // ParamTagRegexMap maps param tags to their respective regexes. var ParamTagRegexMap = map[string]*regexp.Regexp{ "length": regexp.MustCompile("^length\\((\\d+)\\|(\\d+)\\)$"), "stringlength": regexp.MustCompile("^stringlength\\((\\d+)\\|(\\d+)\\)$"), "matches": regexp.MustCompile(`matches\(([^)]+)\)`), } type customTypeTagMap struct { validators map[string]CustomTypeValidator sync.RWMutex } func (tm *customTypeTagMap) Get(name string) (CustomTypeValidator, bool) { tm.RLock() defer tm.RUnlock() v, ok := tm.validators[name] return v, ok } func (tm *customTypeTagMap) Set(name string, ctv CustomTypeValidator) { tm.Lock() defer tm.Unlock() tm.validators[name] = ctv } // CustomTypeTagMap is a map of functions that can be used as tags for ValidateStruct function. // Use this to validate compound or custom types that need to be handled as a whole, e.g. // `type UUID [16]byte` (this would be handled as an array of bytes). var CustomTypeTagMap = &customTypeTagMap{validators: make(map[string]CustomTypeValidator)} // TagMap is a map of functions, that can be used as tags for ValidateStruct function. var TagMap = map[string]Validator{ "email": IsEmail, "url": IsURL, "dialstring": IsDialString, "requrl": IsRequestURL, "requri": IsRequestURI, "alpha": IsAlpha, "utfletter": IsUTFLetter, "alphanum": IsAlphanumeric, "utfletternum": IsUTFLetterNumeric, "numeric": IsNumeric, "utfnumeric": IsUTFNumeric, "utfdigit": IsUTFDigit, "hexadecimal": IsHexadecimal, "hexcolor": IsHexcolor, "rgbcolor": IsRGBcolor, "lowercase": IsLowerCase, "uppercase": IsUpperCase, "int": IsInt, "float": IsFloat, "null": IsNull, "uuid": IsUUID, "uuidv3": IsUUIDv3, "uuidv4": IsUUIDv4, "uuidv5": IsUUIDv5, "creditcard": IsCreditCard, "isbn10": IsISBN10, "isbn13": IsISBN13, "json": IsJSON, "multibyte": IsMultibyte, "ascii": IsASCII, "printableascii": IsPrintableASCII, "fullwidth": IsFullWidth, "halfwidth": IsHalfWidth, "variablewidth": IsVariableWidth, "base64": IsBase64, "datauri": IsDataURI, "ip": IsIP, "port": IsPort, "ipv4": IsIPv4, "ipv6": IsIPv6, "dns": IsDNSName, "host": IsHost, "mac": IsMAC, "latitude": IsLatitude, "longitude": IsLongitude, "ssn": IsSSN, "semver": IsSemver, } // ISO3166Entry stores country codes type ISO3166Entry struct { EnglishShortName string FrenchShortName string Alpha2Code string Alpha3Code string Numeric string } //ISO3166List based on https://www.iso.org/obp/ui/#search/code/ Code Type "Officially Assigned Codes" var ISO3166List = []ISO3166Entry{ {"Afghanistan", "Afghanistan (l')", "AF", "AFG", "004"}, {"Albania", "Albanie (l')", "AL", "ALB", "008"}, {"Antarctica", "Antarctique (l')", "AQ", "ATA", "010"}, {"Algeria", "Algérie (l')", "DZ", "DZA", "012"}, {"American Samoa", "Samoa américaines (les)", "AS", "ASM", "016"}, {"Andorra", "Andorre (l')", "AD", "AND", "020"}, {"Angola", "Angola (l')", "AO", "AGO", "024"}, {"Antigua and Barbuda", "Antigua-et-Barbuda", "AG", "ATG", "028"}, {"Azerbaijan", "Azerbaïdjan (l')", "AZ", "AZE", "031"}, {"Argentina", "Argentine (l')", "AR", "ARG", "032"}, {"Australia", "Australie (l')", "AU", "AUS", "036"}, {"Austria", "Autriche (l')", "AT", "AUT", "040"}, {"Bahamas (the)", "Bahamas (les)", "BS", "BHS", "044"}, {"Bahrain", "Bahreïn", "BH", "BHR", "048"}, {"Bangladesh", "Bangladesh (le)", "BD", "BGD", "050"}, {"Armenia", "Arménie (l')", "AM", "ARM", "051"}, {"Barbados", "Barbade (la)", "BB", "BRB", "052"}, {"Belgium", "Belgique (la)", "BE", "BEL", "056"}, {"Bermuda", "Bermudes (les)", "BM", "BMU", "060"}, {"Bhutan", "Bhoutan (le)", "BT", "BTN", "064"}, {"Bolivia (Plurinational State of)", "Bolivie (État plurinational de)", "BO", "BOL", "068"}, {"Bosnia and Herzegovina", "Bosnie-Herzégovine (la)", "BA", "BIH", "070"}, {"Botswana", "Botswana (le)", "BW", "BWA", "072"}, {"Bouvet Island", "Bouvet (l'Île)", "BV", "BVT", "074"}, {"Brazil", "Brésil (le)", "BR", "BRA", "076"}, {"Belize", "Belize (le)", "BZ", "BLZ", "084"}, {"British Indian Ocean Territory (the)", "Indien (le Territoire britannique de l'océan)", "IO", "IOT", "086"}, {"Solomon Islands", "Salomon (Îles)", "SB", "SLB", "090"}, {"Virgin Islands (British)", "Vierges britanniques (les Îles)", "VG", "VGB", "092"}, {"Brunei Darussalam", "Brunéi Darussalam (le)", "BN", "BRN", "096"}, {"Bulgaria", "Bulgarie (la)", "BG", "BGR", "100"}, {"Myanmar", "Myanmar (le)", "MM", "MMR", "104"}, {"Burundi", "Burundi (le)", "BI", "BDI", "108"}, {"Belarus", "Bélarus (le)", "BY", "BLR", "112"}, {"Cambodia", "Cambodge (le)", "KH", "KHM", "116"}, {"Cameroon", "Cameroun (le)", "CM", "CMR", "120"}, {"Canada", "Canada (le)", "CA", "CAN", "124"}, {"Cabo Verde", "Cabo Verde", "CV", "CPV", "132"}, {"Cayman Islands (the)", "Caïmans (les Îles)", "KY", "CYM", "136"}, {"Central African Republic (the)", "République centrafricaine (la)", "CF", "CAF", "140"}, {"Sri Lanka", "Sri Lanka", "LK", "LKA", "144"}, {"Chad", "Tchad (le)", "TD", "TCD", "148"}, {"Chile", "Chili (le)", "CL", "CHL", "152"}, {"China", "Chine (la)", "CN", "CHN", "156"}, {"Taiwan (Province of China)", "Taïwan (Province de Chine)", "TW", "TWN", "158"}, {"Christmas Island", "Christmas (l'Île)", "CX", "CXR", "162"}, {"Cocos (Keeling) Islands (the)", "Cocos (les Îles)/ Keeling (les Îles)", "CC", "CCK", "166"}, {"Colombia", "Colombie (la)", "CO", "COL", "170"}, {"Comoros (the)", "Comores (les)", "KM", "COM", "174"}, {"Mayotte", "Mayotte", "YT", "MYT", "175"}, {"Congo (the)", "Congo (le)", "CG", "COG", "178"}, {"Congo (the Democratic Republic of the)", "Congo (la République démocratique du)", "CD", "COD", "180"}, {"Cook Islands (the)", "Cook (les Îles)", "CK", "COK", "184"}, {"Costa Rica", "Costa Rica (le)", "CR", "CRI", "188"}, {"Croatia", "Croatie (la)", "HR", "HRV", "191"}, {"Cuba", "Cuba", "CU", "CUB", "192"}, {"Cyprus", "Chypre", "CY", "CYP", "196"}, {"Czech Republic (the)", "tchèque (la République)", "CZ", "CZE", "203"}, {"Benin", "Bénin (le)", "BJ", "BEN", "204"}, {"Denmark", "Danemark (le)", "DK", "DNK", "208"}, {"Dominica", "Dominique (la)", "DM", "DMA", "212"}, {"Dominican Republic (the)", "dominicaine (la République)", "DO", "DOM", "214"}, {"Ecuador", "Équateur (l')", "EC", "ECU", "218"}, {"El Salvador", "El Salvador", "SV", "SLV", "222"}, {"Equatorial Guinea", "Guinée équatoriale (la)", "GQ", "GNQ", "226"}, {"Ethiopia", "Éthiopie (l')", "ET", "ETH", "231"}, {"Eritrea", "Érythrée (l')", "ER", "ERI", "232"}, {"Estonia", "Estonie (l')", "EE", "EST", "233"}, {"Faroe Islands (the)", "Féroé (les Îles)", "FO", "FRO", "234"}, {"Falkland Islands (the) [Malvinas]", "Falkland (les Îles)/Malouines (les Îles)", "FK", "FLK", "238"}, {"South Georgia and the South Sandwich Islands", "Géorgie du Sud-et-les Îles Sandwich du Sud (la)", "GS", "SGS", "239"}, {"Fiji", "Fidji (les)", "FJ", "FJI", "242"}, {"Finland", "Finlande (la)", "FI", "FIN", "246"}, {"Åland Islands", "Åland(les Îles)", "AX", "ALA", "248"}, {"France", "France (la)", "FR", "FRA", "250"}, {"French Guiana", "Guyane française (la )", "GF", "GUF", "254"}, {"French Polynesia", "Polynésie française (la)", "PF", "PYF", "258"}, {"French Southern Territories (the)", "Terres australes françaises (les)", "TF", "ATF", "260"}, {"Djibouti", "Djibouti", "DJ", "DJI", "262"}, {"Gabon", "Gabon (le)", "GA", "GAB", "266"}, {"Georgia", "Géorgie (la)", "GE", "GEO", "268"}, {"Gambia (the)", "Gambie (la)", "GM", "GMB", "270"}, {"Palestine, State of", "Palestine, État de", "PS", "PSE", "275"}, {"Germany", "Allemagne (l')", "DE", "DEU", "276"}, {"Ghana", "Ghana (le)", "GH", "GHA", "288"}, {"Gibraltar", "Gibraltar", "GI", "GIB", "292"}, {"Kiribati", "Kiribati", "KI", "KIR", "296"}, {"Greece", "Grèce (la)", "GR", "GRC", "300"}, {"Greenland", "Groenland (le)", "GL", "GRL", "304"}, {"Grenada", "Grenade (la)", "GD", "GRD", "308"}, {"Guadeloupe", "Guadeloupe (la)", "GP", "GLP", "312"}, {"Guam", "Guam", "GU", "GUM", "316"}, {"Guatemala", "Guatemala (le)", "GT", "GTM", "320"}, {"Guinea", "Guinée (la)", "GN", "GIN", "324"}, {"Guyana", "Guyana (le)", "GY", "GUY", "328"}, {"Haiti", "Haïti", "HT", "HTI", "332"}, {"Heard Island and McDonald Islands", "Heard-et-Îles MacDonald (l'Île)", "HM", "HMD", "334"}, {"Holy See (the)", "Saint-Siège (le)", "VA", "VAT", "336"}, {"Honduras", "Honduras (le)", "HN", "HND", "340"}, {"Hong Kong", "Hong Kong", "HK", "HKG", "344"}, {"Hungary", "Hongrie (la)", "HU", "HUN", "348"}, {"Iceland", "Islande (l')", "IS", "ISL", "352"}, {"India", "Inde (l')", "IN", "IND", "356"}, {"Indonesia", "Indonésie (l')", "ID", "IDN", "360"}, {"Iran (Islamic Republic of)", "Iran (République Islamique d')", "IR", "IRN", "364"}, {"Iraq", "Iraq (l')", "IQ", "IRQ", "368"}, {"Ireland", "Irlande (l')", "IE", "IRL", "372"}, {"Israel", "Israël", "IL", "ISR", "376"}, {"Italy", "Italie (l')", "IT", "ITA", "380"}, {"Côte d'Ivoire", "Côte d'Ivoire (la)", "CI", "CIV", "384"}, {"Jamaica", "Jamaïque (la)", "JM", "JAM", "388"}, {"Japan", "Japon (le)", "JP", "JPN", "392"}, {"Kazakhstan", "Kazakhstan (le)", "KZ", "KAZ", "398"}, {"Jordan", "Jordanie (la)", "JO", "JOR", "400"}, {"Kenya", "Kenya (le)", "KE", "KEN", "404"}, {"Korea (the Democratic People's Republic of)", "Corée (la République populaire démocratique de)", "KP", "PRK", "408"}, {"Korea (the Republic of)", "Corée (la République de)", "KR", "KOR", "410"}, {"Kuwait", "Koweït (le)", "KW", "KWT", "414"}, {"Kyrgyzstan", "Kirghizistan (le)", "KG", "KGZ", "417"}, {"Lao People's Democratic Republic (the)", "Lao, République démocratique populaire", "LA", "LAO", "418"}, {"Lebanon", "Liban (le)", "LB", "LBN", "422"}, {"Lesotho", "Lesotho (le)", "LS", "LSO", "426"}, {"Latvia", "Lettonie (la)", "LV", "LVA", "428"}, {"Liberia", "Libéria (le)", "LR", "LBR", "430"}, {"Libya", "Libye (la)", "LY", "LBY", "434"}, {"Liechtenstein", "Liechtenstein (le)", "LI", "LIE", "438"}, {"Lithuania", "Lituanie (la)", "LT", "LTU", "440"}, {"Luxembourg", "Luxembourg (le)", "LU", "LUX", "442"}, {"Macao", "Macao", "MO", "MAC", "446"}, {"Madagascar", "Madagascar", "MG", "MDG", "450"}, {"Malawi", "Malawi (le)", "MW", "MWI", "454"}, {"Malaysia", "Malaisie (la)", "MY", "MYS", "458"}, {"Maldives", "Maldives (les)", "MV", "MDV", "462"}, {"Mali", "Mali (le)", "ML", "MLI", "466"}, {"Malta", "Malte", "MT", "MLT", "470"}, {"Martinique", "Martinique (la)", "MQ", "MTQ", "474"}, {"Mauritania", "Mauritanie (la)", "MR", "MRT", "478"}, {"Mauritius", "Maurice", "MU", "MUS", "480"}, {"Mexico", "Mexique (le)", "MX", "MEX", "484"}, {"Monaco", "Monaco", "MC", "MCO", "492"}, {"Mongolia", "Mongolie (la)", "MN", "MNG", "496"}, {"Moldova (the Republic of)", "Moldova , République de", "MD", "MDA", "498"}, {"Montenegro", "Monténégro (le)", "ME", "MNE", "499"}, {"Montserrat", "Montserrat", "MS", "MSR", "500"}, {"Morocco", "Maroc (le)", "MA", "MAR", "504"}, {"Mozambique", "Mozambique (le)", "MZ", "MOZ", "508"}, {"Oman", "Oman", "OM", "OMN", "512"}, {"Namibia", "Namibie (la)", "NA", "NAM", "516"}, {"Nauru", "Nauru", "NR", "NRU", "520"}, {"Nepal", "Népal (le)", "NP", "NPL", "524"}, {"Netherlands (the)", "Pays-Bas (les)", "NL", "NLD", "528"}, {"Curaçao", "Curaçao", "CW", "CUW", "531"}, {"Aruba", "Aruba", "AW", "ABW", "533"}, {"Sint Maarten (Dutch part)", "Saint-Martin (partie néerlandaise)", "SX", "SXM", "534"}, {"Bonaire, Sint Eustatius and Saba", "Bonaire, Saint-Eustache et Saba", "BQ", "BES", "535"}, {"New Caledonia", "Nouvelle-Calédonie (la)", "NC", "NCL", "540"}, {"Vanuatu", "Vanuatu (le)", "VU", "VUT", "548"}, {"New Zealand", "Nouvelle-Zélande (la)", "NZ", "NZL", "554"}, {"Nicaragua", "Nicaragua (le)", "NI", "NIC", "558"}, {"Niger (the)", "Niger (le)", "NE", "NER", "562"}, {"Nigeria", "Nigéria (le)", "NG", "NGA", "566"}, {"Niue", "Niue", "NU", "NIU", "570"}, {"Norfolk Island", "Norfolk (l'Île)", "NF", "NFK", "574"}, {"Norway", "Norvège (la)", "NO", "NOR", "578"}, {"Northern Mariana Islands (the)", "Mariannes du Nord (les Îles)", "MP", "MNP", "580"}, {"United States Minor Outlying Islands (the)", "Îles mineures éloignées des États-Unis (les)", "UM", "UMI", "581"}, {"Micronesia (Federated States of)", "Micronésie (États fédérés de)", "FM", "FSM", "583"}, {"Marshall Islands (the)", "Marshall (Îles)", "MH", "MHL", "584"}, {"Palau", "Palaos (les)", "PW", "PLW", "585"}, {"Pakistan", "Pakistan (le)", "PK", "PAK", "586"}, {"Panama", "Panama (le)", "PA", "PAN", "591"}, {"Papua New Guinea", "Papouasie-Nouvelle-Guinée (la)", "PG", "PNG", "598"}, {"Paraguay", "Paraguay (le)", "PY", "PRY", "600"}, {"Peru", "Pérou (le)", "PE", "PER", "604"}, {"Philippines (the)", "Philippines (les)", "PH", "PHL", "608"}, {"Pitcairn", "Pitcairn", "PN", "PCN", "612"}, {"Poland", "Pologne (la)", "PL", "POL", "616"}, {"Portugal", "Portugal (le)", "PT", "PRT", "620"}, {"Guinea-Bissau", "Guinée-Bissau (la)", "GW", "GNB", "624"}, {"Timor-Leste", "Timor-Leste (le)", "TL", "TLS", "626"}, {"Puerto Rico", "Porto Rico", "PR", "PRI", "630"}, {"Qatar", "Qatar (le)", "QA", "QAT", "634"}, {"Réunion", "Réunion (La)", "RE", "REU", "638"}, {"Romania", "Roumanie (la)", "RO", "ROU", "642"}, {"Russian Federation (the)", "Russie (la Fédération de)", "RU", "RUS", "643"}, {"Rwanda", "Rwanda (le)", "RW", "RWA", "646"}, {"Saint Barthélemy", "Saint-Barthélemy", "BL", "BLM", "652"}, {"Saint Helena, Ascension and Tristan da Cunha", "Sainte-Hélène, Ascension et Tristan da Cunha", "SH", "SHN", "654"}, {"Saint Kitts and Nevis", "Saint-Kitts-et-Nevis", "KN", "KNA", "659"}, {"Anguilla", "Anguilla", "AI", "AIA", "660"}, {"Saint Lucia", "Sainte-Lucie", "LC", "LCA", "662"}, {"Saint Martin (French part)", "Saint-Martin (partie française)", "MF", "MAF", "663"}, {"Saint Pierre and Miquelon", "Saint-Pierre-et-Miquelon", "PM", "SPM", "666"}, {"Saint Vincent and the Grenadines", "Saint-Vincent-et-les Grenadines", "VC", "VCT", "670"}, {"San Marino", "Saint-Marin", "SM", "SMR", "674"}, {"Sao Tome and Principe", "Sao Tomé-et-Principe", "ST", "STP", "678"}, {"Saudi Arabia", "Arabie saoudite (l')", "SA", "SAU", "682"}, {"Senegal", "Sénégal (le)", "SN", "SEN", "686"}, {"Serbia", "Serbie (la)", "RS", "SRB", "688"}, {"Seychelles", "Seychelles (les)", "SC", "SYC", "690"}, {"Sierra Leone", "Sierra Leone (la)", "SL", "SLE", "694"}, {"Singapore", "Singapour", "SG", "SGP", "702"}, {"Slovakia", "Slovaquie (la)", "SK", "SVK", "703"}, {"Viet Nam", "Viet Nam (le)", "VN", "VNM", "704"}, {"Slovenia", "Slovénie (la)", "SI", "SVN", "705"}, {"Somalia", "Somalie (la)", "SO", "SOM", "706"}, {"South Africa", "Afrique du Sud (l')", "ZA", "ZAF", "710"}, {"Zimbabwe", "Zimbabwe (le)", "ZW", "ZWE", "716"}, {"Spain", "Espagne (l')", "ES", "ESP", "724"}, {"South Sudan", "Soudan du Sud (le)", "SS", "SSD", "728"}, {"Sudan (the)", "Soudan (le)", "SD", "SDN", "729"}, {"Western Sahara*", "Sahara occidental (le)*", "EH", "ESH", "732"}, {"Suriname", "Suriname (le)", "SR", "SUR", "740"}, {"Svalbard and Jan Mayen", "Svalbard et l'Île Jan Mayen (le)", "SJ", "SJM", "744"}, {"Swaziland", "Swaziland (le)", "SZ", "SWZ", "748"}, {"Sweden", "Suède (la)", "SE", "SWE", "752"}, {"Switzerland", "Suisse (la)", "CH", "CHE", "756"}, {"Syrian Arab Republic", "République arabe syrienne (la)", "SY", "SYR", "760"}, {"Tajikistan", "Tadjikistan (le)", "TJ", "TJK", "762"}, {"Thailand", "Thaïlande (la)", "TH", "THA", "764"}, {"Togo", "Togo (le)", "TG", "TGO", "768"}, {"Tokelau", "Tokelau (les)", "TK", "TKL", "772"}, {"Tonga", "Tonga (les)", "TO", "TON", "776"}, {"Trinidad and Tobago", "Trinité-et-Tobago (la)", "TT", "TTO", "780"}, {"United Arab Emirates (the)", "Émirats arabes unis (les)", "AE", "ARE", "784"}, {"Tunisia", "Tunisie (la)", "TN", "TUN", "788"}, {"Turkey", "Turquie (la)", "TR", "TUR", "792"}, {"Turkmenistan", "Turkménistan (le)", "TM", "TKM", "795"}, {"Turks and Caicos Islands (the)", "Turks-et-Caïcos (les Îles)", "TC", "TCA", "796"}, {"Tuvalu", "Tuvalu (les)", "TV", "TUV", "798"}, {"Uganda", "Ouganda (l')", "UG", "UGA", "800"}, {"Ukraine", "Ukraine (l')", "UA", "UKR", "804"}, {"Macedonia (the former Yugoslav Republic of)", "Macédoine (l'ex‑République yougoslave de)", "MK", "MKD", "807"}, {"Egypt", "Égypte (l')", "EG", "EGY", "818"}, {"United Kingdom of Great Britain and Northern Ireland (the)", "Royaume-Uni de Grande-Bretagne et d'Irlande du Nord (le)", "GB", "GBR", "826"}, {"Guernsey", "Guernesey", "GG", "GGY", "831"}, {"Jersey", "Jersey", "JE", "JEY", "832"}, {"Isle of Man", "Île de Man", "IM", "IMN", "833"}, {"Tanzania, United Republic of", "Tanzanie, République-Unie de", "TZ", "TZA", "834"}, {"United States of America (the)", "États-Unis d'Amérique (les)", "US", "USA", "840"}, {"Virgin Islands (U.S.)", "Vierges des États-Unis (les Îles)", "VI", "VIR", "850"}, {"Burkina Faso", "Burkina Faso (le)", "BF", "BFA", "854"}, {"Uruguay", "Uruguay (l')", "UY", "URY", "858"}, {"Uzbekistan", "Ouzbékistan (l')", "UZ", "UZB", "860"}, {"Venezuela (Bolivarian Republic of)", "Venezuela (République bolivarienne du)", "VE", "VEN", "862"}, {"Wallis and Futuna", "Wallis-et-Futuna", "WF", "WLF", "876"}, {"Samoa", "Samoa (le)", "WS", "WSM", "882"}, {"Yemen", "Yémen (le)", "YE", "YEM", "887"}, {"Zambia", "Zambie (la)", "ZM", "ZMB", "894"}, } govalidator-4/utils.go000066400000000000000000000141051271713657300152360ustar00rootroot00000000000000package govalidator import ( "errors" "fmt" "html" "path" "regexp" "strings" "unicode" ) // Contains check if the string contains the substring. func Contains(str, substring string) bool { return strings.Contains(str, substring) } // Matches check if string matches the pattern (pattern is regular expression) // In case of error return false func Matches(str, pattern string) bool { match, _ := regexp.MatchString(pattern, str) return match } // LeftTrim trim characters from the left-side of the input. // If second argument is empty, it's will be remove leading spaces. func LeftTrim(str, chars string) string { pattern := "" if chars == "" { pattern = "^\\s+" } else { pattern = "^[" + chars + "]+" } r, _ := regexp.Compile(pattern) return string(r.ReplaceAll([]byte(str), []byte(""))) } // RightTrim trim characters from the right-side of the input. // If second argument is empty, it's will be remove spaces. func RightTrim(str, chars string) string { pattern := "" if chars == "" { pattern = "\\s+$" } else { pattern = "[" + chars + "]+$" } r, _ := regexp.Compile(pattern) return string(r.ReplaceAll([]byte(str), []byte(""))) } // Trim trim characters from both sides of the input. // If second argument is empty, it's will be remove spaces. func Trim(str, chars string) string { return LeftTrim(RightTrim(str, chars), chars) } // WhiteList remove characters that do not appear in the whitelist. func WhiteList(str, chars string) string { pattern := "[^" + chars + "]+" r, _ := regexp.Compile(pattern) return string(r.ReplaceAll([]byte(str), []byte(""))) } // BlackList remove characters that appear in the blacklist. func BlackList(str, chars string) string { pattern := "[" + chars + "]+" r, _ := regexp.Compile(pattern) return string(r.ReplaceAll([]byte(str), []byte(""))) } // StripLow remove characters with a numerical value < 32 and 127, mostly control characters. // If keep_new_lines is true, newline characters are preserved (\n and \r, hex 0xA and 0xD). func StripLow(str string, keepNewLines bool) string { chars := "" if keepNewLines { chars = "\x00-\x09\x0B\x0C\x0E-\x1F\x7F" } else { chars = "\x00-\x1F\x7F" } return BlackList(str, chars) } // ReplacePattern replace regular expression pattern in string func ReplacePattern(str, pattern, replace string) string { r, _ := regexp.Compile(pattern) return string(r.ReplaceAll([]byte(str), []byte(replace))) } // Escape replace <, >, & and " with HTML entities. var Escape = html.EscapeString func addSegment(inrune, segment []rune) []rune { if len(segment) == 0 { return inrune } if len(inrune) != 0 { inrune = append(inrune, '_') } inrune = append(inrune, segment...) return inrune } // UnderscoreToCamelCase converts from underscore separated form to camel case form. // Ex.: my_func => MyFunc func UnderscoreToCamelCase(s string) string { return strings.Replace(strings.Title(strings.Replace(strings.ToLower(s), "_", " ", -1)), " ", "", -1) } // CamelCaseToUnderscore converts from camel case form to underscore separated form. // Ex.: MyFunc => my_func func CamelCaseToUnderscore(str string) string { var output []rune var segment []rune for _, r := range str { if !unicode.IsLower(r) { output = addSegment(output, segment) segment = nil } segment = append(segment, unicode.ToLower(r)) } output = addSegment(output, segment) return string(output) } // Reverse return reversed string func Reverse(s string) string { r := []rune(s) for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 { r[i], r[j] = r[j], r[i] } return string(r) } // GetLines split string by "\n" and return array of lines func GetLines(s string) []string { return strings.Split(s, "\n") } // GetLine return specified line of multiline string func GetLine(s string, index int) (string, error) { lines := GetLines(s) if index < 0 || index >= len(lines) { return "", errors.New("line index out of bounds") } return lines[index], nil } // RemoveTags remove all tags from HTML string func RemoveTags(s string) string { return ReplacePattern(s, "<[^>]*>", "") } // SafeFileName return safe string that can be used in file names func SafeFileName(str string) string { name := strings.ToLower(str) name = path.Clean(path.Base(name)) name = strings.Trim(name, " ") separators, err := regexp.Compile(`[ &_=+:]`) if err == nil { name = separators.ReplaceAllString(name, "-") } legal, err := regexp.Compile(`[^[:alnum:]-.]`) if err == nil { name = legal.ReplaceAllString(name, "") } for strings.Contains(name, "--") { name = strings.Replace(name, "--", "-", -1) } return name } // NormalizeEmail canonicalize an email address. // The local part of the email address is lowercased for all domains; the hostname is always lowercased and // the local part of the email address is always lowercased for hosts that are known to be case-insensitive (currently only GMail). // Normalization follows special rules for known providers: currently, GMail addresses have dots removed in the local part and // are stripped of tags (e.g. some.one+tag@gmail.com becomes someone@gmail.com) and all @googlemail.com addresses are // normalized to @gmail.com. func NormalizeEmail(str string) (string, error) { if !IsEmail(str) { return "", fmt.Errorf("%s is not an email", str) } parts := strings.Split(str, "@") parts[0] = strings.ToLower(parts[0]) parts[1] = strings.ToLower(parts[1]) if parts[1] == "gmail.com" || parts[1] == "googlemail.com" { parts[1] = "gmail.com" parts[0] = strings.Split(ReplacePattern(parts[0], `\.`, ""), "+")[0] } return strings.Join(parts, "@"), nil } // Truncate a string to the closest length without breaking words. func Truncate(str string, length int, ending string) string { var aftstr, befstr string if len(str) > length { words := strings.Fields(str) before, present := 0, 0 for i := range words { befstr = aftstr before = present aftstr = aftstr + words[i] + " " present = len(aftstr) if present > length && i != 0 { if (length - before) < (present - length) { return Trim(befstr, " /\\.,\"'#!?&@+-") + ending } return Trim(aftstr, " /\\.,\"'#!?&@+-") + ending } } } return str } govalidator-4/utils_test.go000066400000000000000000000256521271713657300163060ustar00rootroot00000000000000package govalidator import ( "reflect" "testing" ) func TestContains(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected bool }{ {"abacada", "", true}, {"abacada", "ritir", false}, {"abacada", "a", true}, {"abacada", "aca", true}, } for _, test := range tests { actual := Contains(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected Contains(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestMatches(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected bool }{ {"123456789", "[0-9]+", true}, {"abacada", "cab$", false}, {"111222333", "((111|222|333)+)+", true}, {"abacaba", "((123+]", false}, } for _, test := range tests { actual := Matches(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected Matches(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestLeftTrim(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected string }{ {" \r\n\tfoo \r\n\t ", "", "foo \r\n\t "}, {"010100201000", "01", "201000"}, } for _, test := range tests { actual := LeftTrim(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected LeftTrim(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestRightTrim(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected string }{ {" \r\n\tfoo \r\n\t ", "", " \r\n\tfoo"}, {"010100201000", "01", "0101002"}, } for _, test := range tests { actual := RightTrim(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected RightTrim(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestTrim(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected string }{ {" \r\n\tfoo \r\n\t ", "", "foo"}, {"010100201000", "01", "2"}, {"1234567890987654321", "1-8", "909"}, } for _, test := range tests { actual := Trim(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected Trim(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } // This small example illustrate how to work with Trim function. func ExampleTrim() { // Remove from left and right spaces and "\r", "\n", "\t" characters println(Trim(" \r\r\ntext\r \t\n", "") == "text") // Remove from left and right characters that are between "1" and "8". // "1-8" is like full list "12345678". println(Trim("1234567890987654321", "1-8") == "909") } func TestWhiteList(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected string }{ {"abcdef", "abc", "abc"}, {"aaaaaaaaaabbbbbbbbbb", "abc", "aaaaaaaaaabbbbbbbbbb"}, {"a1b2c3", "abc", "abc"}, {" ", "abc", ""}, {"a3a43a5a4a3a2a23a4a5a4a3a4", "a-z", "aaaaaaaaaaaa"}, } for _, test := range tests { actual := WhiteList(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected WhiteList(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } // This small example illustrate how to work with WhiteList function. func ExampleWhiteList() { // Remove all characters from string ignoring characters between "a" and "z" println(WhiteList("a3a43a5a4a3a2a23a4a5a4a3a4", "a-z") == "aaaaaaaaaaaa") } func TestBlackList(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected string }{ {"abcdef", "abc", "def"}, {"aaaaaaaaaabbbbbbbbbb", "abc", ""}, {"a1b2c3", "abc", "123"}, {" ", "abc", " "}, {"a3a43a5a4a3a2a23a4a5a4a3a4", "a-z", "34354322345434"}, } for _, test := range tests { actual := BlackList(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected BlackList(%q,%q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestStripLow(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 bool expected string }{ {"foo\x00", false, "foo"}, {"\x7Ffoo\x02", false, "foo"}, {"\x01\x09", false, ""}, {"foo\x0A\x0D", false, "foo"}, {"perch\u00e9", false, "perch\u00e9"}, {"\u20ac", false, "\u20ac"}, {"\u2206\x0A", false, "\u2206"}, {"foo\x0A\x0D", true, "foo\x0A\x0D"}, {"\x03foo\x0A\x0D", true, "foo\x0A\x0D"}, } for _, test := range tests { actual := StripLow(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected StripLow(%q,%t) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestReplacePattern(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string param3 string expected string }{ {"ab123ba", "[0-9]+", "aca", "abacaba"}, {"abacaba", "[0-9]+", "aca", "abacaba"}, {"httpftp://github.comio", "(ftp|io)", "", "http://github.com"}, {"aaaaaaaaaa", "a", "", ""}, {"http123123ftp://git534543hub.comio", "(ftp|io|[0-9]+)", "", "http://github.com"}, } for _, test := range tests { actual := ReplacePattern(test.param1, test.param2, test.param3) if actual != test.expected { t.Errorf("Expected ReplacePattern(%q,%q,%q) to be %v, got %v", test.param1, test.param2, test.param3, test.expected, actual) } } } // This small example illustrate how to work with ReplacePattern function. func ExampleReplacePattern() { // Replace in "http123123ftp://git534543hub.comio" following (pattern "(ftp|io|[0-9]+)"): // - Sequence "ftp". // - Sequence "io". // - Sequence of digits. // with empty string. println(ReplacePattern("http123123ftp://git534543hub.comio", "(ftp|io|[0-9]+)", "") == "http://github.com") } func TestEscape(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {`foo&bar`, "<img alt="foo&bar">"}, } for _, test := range tests { actual := Escape(test.param) if actual != test.expected { t.Errorf("Expected Escape(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestUnderscoreToCamelCase(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"a_b_c", "ABC"}, {"my_func", "MyFunc"}, {"1ab_cd", "1abCd"}, } for _, test := range tests { actual := UnderscoreToCamelCase(test.param) if actual != test.expected { t.Errorf("Expected UnderscoreToCamelCase(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestCamelCaseToUnderscore(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"MyFunc", "my_func"}, {"ABC", "a_b_c"}, {"1B", "1_b"}, } for _, test := range tests { actual := CamelCaseToUnderscore(test.param) if actual != test.expected { t.Errorf("Expected CamelCaseToUnderscore(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestReverse(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"abc", "cba"}, {"ｶﾀｶﾅ", "ﾅｶﾀｶ"}, } for _, test := range tests { actual := Reverse(test.param) if actual != test.expected { t.Errorf("Expected Reverse(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestGetLines(t *testing.T) { t.Parallel() var tests = []struct { param string expected []string }{ {"abc", []string{"abc"}}, {"a\nb\nc", []string{"a", "b", "c"}}, } for _, test := range tests { actual := GetLines(test.param) if !reflect.DeepEqual(actual, test.expected) { t.Errorf("Expected GetLines(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestGetLine(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 int expected string }{ {"abc", 0, "abc"}, {"a\nb\nc", 0, "a"}, {"abc", -1, ""}, {"abacaba\n", 1, ""}, {"abc", 3, ""}, } for _, test := range tests { actual, _ := GetLine(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected GetLine(%q, %d) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } func TestRemoveTags(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"abc", "abc"}, {"", ""}, {"

Text

", "Text"}, {`Link`, "Link"}, } for _, test := range tests { actual := RemoveTags(test.param) if actual != test.expected { t.Errorf("Expected RemoveTags(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestSafeFileName(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"abc", "abc"}, {"123456789 '_-?ASDF@£$%£%^é.html", "123456789-asdf.html"}, {"ReadMe.md", "readme.md"}, {"file:///c:/test.go", "test.go"}, {"../../../Hello World!.txt", "hello-world.txt"}, } for _, test := range tests { actual := SafeFileName(test.param) if actual != test.expected { t.Errorf("Expected SafeFileName(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestNormalizeEmail(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {`test@me.com`, `test@me.com`}, {`some.name@gmail.com`, `somename@gmail.com`}, {`some.name@googlemail.com`, `somename@gmail.com`}, {`some.name+extension@gmail.com`, `somename@gmail.com`}, {`some.name+extension@googlemail.com`, `somename@gmail.com`}, {`some.name.middlename+extension@gmail.com`, `somenamemiddlename@gmail.com`}, {`some.name.middlename+extension@googlemail.com`, `somenamemiddlename@gmail.com`}, {`some.name.midd.lena.me.+extension@gmail.com`, `somenamemiddlename@gmail.com`}, {`some.name.midd.lena.me.+extension@googlemail.com`, `somenamemiddlename@gmail.com`}, {`some.name+extension@unknown.com`, `some.name+extension@unknown.com`}, {`hans@m端ller.com`, `hans@m端ller.com`}, {`hans`, ``}, } for _, test := range tests { actual, err := NormalizeEmail(test.param) if actual != test.expected { t.Errorf("Expected NormalizeEmail(%q) to be %v, got %v, err %v", test.param, test.expected, actual, err) } } } func TestTruncate(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 int param3 string expected string }{ {`Lorem ipsum dolor sit amet, consectetur adipiscing elit.`, 25, `...`, `Lorem ipsum dolor sit amet...`}, {`Measuring programming progress by lines of code is like measuring aircraft building progress by weight.`, 35, ` new born babies!`, `Measuring programming progress by new born babies!`}, {`Testestestestestestestestestest testestestestestestestestest`, 7, `...`, `Testestestestestestestestestest...`}, {`Testing`, 7, `...`, `Testing`}, } for _, test := range tests { actual := Truncate(test.param1, test.param2, test.param3) if actual != test.expected { t.Errorf("Expected Truncate(%q, %d, %q) to be %v, got %v", test.param1, test.param2, test.param3, test.expected, actual) } } } govalidator-4/validator.go000066400000000000000000000616461271713657300160770ustar00rootroot00000000000000// Package govalidator is package of validators and sanitizers for strings, structs and collections. package govalidator import ( "encoding/json" "fmt" "net" "net/url" "reflect" "regexp" "sort" "strconv" "strings" "unicode" "unicode/utf8" ) var fieldsRequiredByDefault bool // SetFieldsRequiredByDefault causes validation to fail when struct fields // do not include validations or are not explicitly marked as exempt (using `valid:"-"` or `valid:"email,optional"`). // This struct definition will fail govalidator.ValidateStruct() (and the field values do not matter): // type exampleStruct struct { // Name string `` // Email string `valid:"email"` // This, however, will only fail when Email is empty or an invalid email address: // type exampleStruct2 struct { // Name string `valid:"-"` // Email string `valid:"email"` // Lastly, this will only fail when Email is an invalid email address but not when it's empty: // type exampleStruct2 struct { // Name string `valid:"-"` // Email string `valid:"email,optional"` func SetFieldsRequiredByDefault(value bool) { fieldsRequiredByDefault = value } // IsEmail check if the string is an email. func IsEmail(str string) bool { // TODO uppercase letters are not supported return rxEmail.MatchString(str) } // IsURL check if the string is an URL. func IsURL(str string) bool { if str == "" || len(str) >= 2083 || len(str) <= 3 || strings.HasPrefix(str, ".") { return false } u, err := url.Parse(str) if err != nil { return false } if strings.HasPrefix(u.Host, ".") { return false } if u.Host == "" && (u.Path != "" && !strings.Contains(u.Path, ".")) { return false } return rxURL.MatchString(str) } // IsRequestURL check if the string rawurl, assuming // it was recieved in an HTTP request, is a valid // URL confirm to RFC 3986 func IsRequestURL(rawurl string) bool { url, err := url.ParseRequestURI(rawurl) if err != nil { return false //Couldn't even parse the rawurl } if len(url.Scheme) == 0 { return false //No Scheme found } return true } // IsRequestURI check if the string rawurl, assuming // it was recieved in an HTTP request, is an // absolute URI or an absolute path. func IsRequestURI(rawurl string) bool { _, err := url.ParseRequestURI(rawurl) return err == nil } // IsAlpha check if the string contains only letters (a-zA-Z). Empty string is valid. func IsAlpha(str string) bool { if IsNull(str) { return true } return rxAlpha.MatchString(str) } //IsUTFLetter check if the string contains only unicode letter characters. //Similar to IsAlpha but for all languages. Empty string is valid. func IsUTFLetter(str string) bool { if IsNull(str) { return true } for _, c := range str { if !unicode.IsLetter(c) { return false } } return true } // IsAlphanumeric check if the string contains only letters and numbers. Empty string is valid. func IsAlphanumeric(str string) bool { if IsNull(str) { return true } return rxAlphanumeric.MatchString(str) } // IsUTFLetterNumeric check if the string contains only unicode letters and numbers. Empty string is valid. func IsUTFLetterNumeric(str string) bool { if IsNull(str) { return true } for _, c := range str { if !unicode.IsLetter(c) && !unicode.IsNumber(c) { //letters && numbers are ok return false } } return true } // IsNumeric check if the string contains only numbers. Empty string is valid. func IsNumeric(str string) bool { if IsNull(str) { return true } return rxNumeric.MatchString(str) } // IsUTFNumeric check if the string contains only unicode numbers of any kind. // Numbers can be 0-9 but also Fractions ¾,Roman Ⅸ and Hangzhou 〩. Empty string is valid. func IsUTFNumeric(str string) bool { if IsNull(str) { return true } if strings.IndexAny(str, "+-") > 0 { return false } if len(str) > 1 { str = strings.TrimPrefix(str, "-") str = strings.TrimPrefix(str, "+") } for _, c := range str { if unicode.IsNumber(c) == false { //numbers && minus sign are ok return false } } return true } // IsUTFDigit check if the string contains only unicode radix-10 decimal digits. Empty string is valid. func IsUTFDigit(str string) bool { if IsNull(str) { return true } if strings.IndexAny(str, "+-") > 0 { return false } if len(str) > 1 { str = strings.TrimPrefix(str, "-") str = strings.TrimPrefix(str, "+") } for _, c := range str { if !unicode.IsDigit(c) { //digits && minus sign are ok return false } } return true } // IsHexadecimal check if the string is a hexadecimal number. func IsHexadecimal(str string) bool { return rxHexadecimal.MatchString(str) } // IsHexcolor check if the string is a hexadecimal color. func IsHexcolor(str string) bool { return rxHexcolor.MatchString(str) } // IsRGBcolor check if the string is a valid RGB color in form rgb(RRR, GGG, BBB). func IsRGBcolor(str string) bool { return rxRGBcolor.MatchString(str) } // IsLowerCase check if the string is lowercase. Empty string is valid. func IsLowerCase(str string) bool { if IsNull(str) { return true } return str == strings.ToLower(str) } // IsUpperCase check if the string is uppercase. Empty string is valid. func IsUpperCase(str string) bool { if IsNull(str) { return true } return str == strings.ToUpper(str) } // IsInt check if the string is an integer. Empty string is valid. func IsInt(str string) bool { if IsNull(str) { return true } return rxInt.MatchString(str) } // IsFloat check if the string is a float. func IsFloat(str string) bool { return str != "" && rxFloat.MatchString(str) } // IsDivisibleBy check if the string is a number that's divisible by another. // If second argument is not valid integer or zero, it's return false. // Otherwise, if first argument is not valid integer or zero, it's return true (Invalid string converts to zero). func IsDivisibleBy(str, num string) bool { f, _ := ToFloat(str) p := int64(f) q, _ := ToInt(num) if q == 0 { return false } return (p == 0) || (p%q == 0) } // IsNull check if the string is null. func IsNull(str string) bool { return len(str) == 0 } // IsByteLength check if the string's length (in bytes) falls in a range. func IsByteLength(str string, min, max int) bool { return len(str) >= min && len(str) <= max } // IsUUIDv3 check if the string is a UUID version 3. func IsUUIDv3(str string) bool { return rxUUID3.MatchString(str) } // IsUUIDv4 check if the string is a UUID version 4. func IsUUIDv4(str string) bool { return rxUUID4.MatchString(str) } // IsUUIDv5 check if the string is a UUID version 5. func IsUUIDv5(str string) bool { return rxUUID5.MatchString(str) } // IsUUID check if the string is a UUID (version 3, 4 or 5). func IsUUID(str string) bool { return rxUUID.MatchString(str) } // IsCreditCard check if the string is a credit card. func IsCreditCard(str string) bool { r, _ := regexp.Compile("[^0-9]+") sanitized := r.ReplaceAll([]byte(str), []byte("")) if !rxCreditCard.MatchString(string(sanitized)) { return false } var sum int64 var digit string var tmpNum int64 var shouldDouble bool for i := len(sanitized) - 1; i >= 0; i-- { digit = string(sanitized[i:(i + 1)]) tmpNum, _ = ToInt(digit) if shouldDouble { tmpNum *= 2 if tmpNum >= 10 { sum += ((tmpNum % 10) + 1) } else { sum += tmpNum } } else { sum += tmpNum } shouldDouble = !shouldDouble } if sum%10 == 0 { return true } return false } // IsISBN10 check if the string is an ISBN version 10. func IsISBN10(str string) bool { return IsISBN(str, 10) } // IsISBN13 check if the string is an ISBN version 13. func IsISBN13(str string) bool { return IsISBN(str, 13) } // IsISBN check if the string is an ISBN (version 10 or 13). // If version value is not equal to 10 or 13, it will be check both variants. func IsISBN(str string, version int) bool { r, _ := regexp.Compile("[\\s-]+") sanitized := r.ReplaceAll([]byte(str), []byte("")) var checksum int32 var i int32 if version == 10 { if !rxISBN10.MatchString(string(sanitized)) { return false } for i = 0; i < 9; i++ { checksum += (i + 1) * int32(sanitized[i]-'0') } if sanitized[9] == 'X' { checksum += 10 * 10 } else { checksum += 10 * int32(sanitized[9]-'0') } if checksum%11 == 0 { return true } return false } else if version == 13 { if !rxISBN13.MatchString(string(sanitized)) { return false } factor := []int32{1, 3} for i = 0; i < 12; i++ { checksum += factor[i%2] * int32(sanitized[i]-'0') } if (int32(sanitized[12]-'0'))-((10-(checksum%10))%10) == 0 { return true } return false } return IsISBN(str, 10) || IsISBN(str, 13) } // IsJSON check if the string is valid JSON (note: uses json.Unmarshal). func IsJSON(str string) bool { var js json.RawMessage return json.Unmarshal([]byte(str), &js) == nil } // IsMultibyte check if the string contains one or more multibyte chars. Empty string is valid. func IsMultibyte(str string) bool { if IsNull(str) { return true } return rxMultibyte.MatchString(str) } // IsASCII check if the string contains ASCII chars only. Empty string is valid. func IsASCII(str string) bool { if IsNull(str) { return true } return rxASCII.MatchString(str) } // IsPrintableASCII check if the string contains printable ASCII chars only. Empty string is valid. func IsPrintableASCII(str string) bool { if IsNull(str) { return true } return rxPrintableASCII.MatchString(str) } // IsFullWidth check if the string contains any full-width chars. Empty string is valid. func IsFullWidth(str string) bool { if IsNull(str) { return true } return rxFullWidth.MatchString(str) } // IsHalfWidth check if the string contains any half-width chars. Empty string is valid. func IsHalfWidth(str string) bool { if IsNull(str) { return true } return rxHalfWidth.MatchString(str) } // IsVariableWidth check if the string contains a mixture of full and half-width chars. Empty string is valid. func IsVariableWidth(str string) bool { if IsNull(str) { return true } return rxHalfWidth.MatchString(str) && rxFullWidth.MatchString(str) } // IsBase64 check if a string is base64 encoded. func IsBase64(str string) bool { return rxBase64.MatchString(str) } // IsFilePath check is a string is Win or Unix file path and returns it's type. func IsFilePath(str string) (bool, int) { if rxWinPath.MatchString(str) { //check windows path limit see: // http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath if len(str[3:]) > 32767 { return false, Win } return true, Win } else if rxUnixPath.MatchString(str) { return true, Unix } return false, Unknown } // IsDataURI checks if a string is base64 encoded data URI such as an image func IsDataURI(str string) bool { dataURI := strings.Split(str, ",") if !rxDataURI.MatchString(dataURI[0]) { return false } return IsBase64(dataURI[1]) } // IsISO3166Alpha2 checks if a string is valid two-letter country code func IsISO3166Alpha2(str string) bool { for _, entry := range ISO3166List { if str == entry.Alpha2Code { return true } } return false } // IsISO3166Alpha3 checks if a string is valid three-letter country code func IsISO3166Alpha3(str string) bool { for _, entry := range ISO3166List { if str == entry.Alpha3Code { return true } } return false } // IsDNSName will validate the given string as a DNS name func IsDNSName(str string) bool { if str == "" || len(strings.Replace(str, ".", "", -1)) > 255 { // constraints already violated return false } return rxDNSName.MatchString(str) } // IsDialString validates the given string for usage with the various Dial() functions func IsDialString(str string) bool { if h, p, err := net.SplitHostPort(str); err == nil && h != "" && p != "" && (IsDNSName(h) || IsIP(h)) && IsPort(p) { return true } return false } // IsIP checks if a string is either IP version 4 or 6. func IsIP(str string) bool { return net.ParseIP(str) != nil } // IsPort checks if a string represents a valid port func IsPort(str string) bool { if i, err := strconv.Atoi(str); err == nil && i > 0 && i < 65536 { return true } return false } // IsIPv4 check if the string is an IP version 4. func IsIPv4(str string) bool { ip := net.ParseIP(str) return ip != nil && strings.Contains(str, ".") } // IsIPv6 check if the string is an IP version 6. func IsIPv6(str string) bool { ip := net.ParseIP(str) return ip != nil && strings.Contains(str, ":") } // IsMAC check if a string is valid MAC address. // Possible MAC formats: // 01:23:45:67:89:ab // 01:23:45:67:89:ab:cd:ef // 01-23-45-67-89-ab // 01-23-45-67-89-ab-cd-ef // 0123.4567.89ab // 0123.4567.89ab.cdef func IsMAC(str string) bool { _, err := net.ParseMAC(str) return err == nil } // IsHost checks if the string is a valid IP (both v4 and v6) or a valid DNS name func IsHost(str string) bool { return IsIP(str) || IsDNSName(str) } // IsMongoID check if the string is a valid hex-encoded representation of a MongoDB ObjectId. func IsMongoID(str string) bool { return rxHexadecimal.MatchString(str) && (len(str) == 24) } // IsLatitude check if a string is valid latitude. func IsLatitude(str string) bool { return rxLatitude.MatchString(str) } // IsLongitude check if a string is valid longitude. func IsLongitude(str string) bool { return rxLongitude.MatchString(str) } // ValidateStruct use tags for fields. // result will be equal to `false` if there are any errors. func ValidateStruct(s interface{}) (bool, error) { if s == nil { return true, nil } result := true var err error val := reflect.ValueOf(s) if val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr { val = val.Elem() } // we only accept structs if val.Kind() != reflect.Struct { return false, fmt.Errorf("function only accepts structs; got %s", val.Kind()) } var errs Errors for i := 0; i < val.NumField(); i++ { valueField := val.Field(i) typeField := val.Type().Field(i) if typeField.PkgPath != "" { continue // Private field } resultField, err2 := typeCheck(valueField, typeField, val) if err2 != nil { errs = append(errs, err2) } result = result && resultField } if len(errs) > 0 { err = errs } return result, err } // parseTag splits a struct field's tag into its // comma-separated options. func parseTag(tag string) tagOptions { split := strings.SplitN(tag, ",", -1) return tagOptions(split) } func isValidTag(s string) bool { if s == "" { return false } for _, c := range s { switch { case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c): // Backslash and quote chars are reserved, but // otherwise any punctuation chars are allowed // in a tag name. default: if !unicode.IsLetter(c) && !unicode.IsDigit(c) { return false } } } return true } // IsSSN will validate the given string as a U.S. Social Security Number func IsSSN(str string) bool { if str == "" || len(str) != 11 { return false } return rxSSN.MatchString(str) } // IsSemver check if string is valid semantic version func IsSemver(str string) bool { return rxSemver.MatchString(str) } // ByteLength check string's length func ByteLength(str string, params ...string) bool { if len(params) == 2 { min, _ := ToInt(params[0]) max, _ := ToInt(params[1]) return len(str) >= int(min) && len(str) <= int(max) } return false } // StringMatches checks if a string matches a given pattern. func StringMatches(s string, params ...string) bool { if len(params) == 1 { pattern := params[0] return Matches(s, pattern) } return false } // StringLength check string's length (including multi byte strings) func StringLength(str string, params ...string) bool { if len(params) == 2 { strLength := utf8.RuneCountInString(str) min, _ := ToInt(params[0]) max, _ := ToInt(params[1]) return strLength >= int(min) && strLength <= int(max) } return false } // Contains returns whether checks that a comma-separated list of options // contains a particular substr flag. substr must be surrounded by a // string boundary or commas. func (opts tagOptions) contains(optionName string) bool { for i := range opts { tagOpt := opts[i] if tagOpt == optionName { return true } } return false } func searchOption(limit int, predicate func(counter int) bool) int { for counter := 0; counter < limit; counter++ { if predicate(counter) { return counter } } return -1 } func checkRequired(v reflect.Value, t reflect.StructField, options tagOptions) (bool, error) { var err error var customErrorMessageExists bool requiredIndex := searchOption(len(options), func(index int) bool { return strings.HasPrefix(options[index], "required") }) optionalIndex := searchOption(len(options), func(index int) bool { return strings.HasPrefix(options[index], "optional") }) if requiredIndex > -1 { validationOptions := strings.Split(options[requiredIndex], "~") if len(validationOptions) == 2 { err = fmt.Errorf(strings.Split(options[requiredIndex], "~")[1]) customErrorMessageExists = true } else { err = fmt.Errorf("non zero value required") } return false, Error{t.Name, err, customErrorMessageExists} } else if fieldsRequiredByDefault && optionalIndex == -1 { err := fmt.Errorf("All fields are required to at least have one validation defined") return false, Error{t.Name, err, customErrorMessageExists} } // not required and empty is valid return true, nil } func typeCheck(v reflect.Value, t reflect.StructField, o reflect.Value) (bool, error) { var customErrorMessageExists bool if !v.IsValid() { return false, nil } tag := t.Tag.Get(tagName) // Check if the field should be ignored switch tag { case "": if !fieldsRequiredByDefault { return true, nil } err := fmt.Errorf("All fields are required to at least have one validation defined") return false, Error{t.Name, err, customErrorMessageExists} case "-": return true, nil } options := parseTag(tag) var customTypeErrors Errors var customTypeValidatorsExist bool for _, tagOpt := range options { tagOpts := strings.Split(tagOpt, "~") if ok := isValidTag(tagOpts[0]); !ok { continue } if validatefunc, ok := CustomTypeTagMap.Get(tagOpts[0]); ok { customTypeValidatorsExist = true if result := validatefunc(v.Interface(), o.Interface()); !result { if len(tagOpts) == 2 { customTypeErrors = append(customTypeErrors, Error{Name: t.Name, Err: fmt.Errorf(tagOpts[1]), CustomErrorMessageExists: true}) continue } customTypeErrors = append(customTypeErrors, Error{Name: t.Name, Err: fmt.Errorf("%s does not validate as %s", fmt.Sprint(v), tagOpts[0]), CustomErrorMessageExists: false}) } } } if customTypeValidatorsExist { if len(customTypeErrors.Errors()) > 0 { return false, customTypeErrors } return true, nil } if isEmptyValue(v) { // an empty value is not validated, check only required return checkRequired(v, t, options) } switch v.Kind() { case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64, reflect.String: // for each tag option check the map of validator functions for i := range options { tagOpt := options[i] tagOptions := strings.Split(tagOpt, "~") negate := false customMsgExists := (len(tagOptions) == 2) // Check wether the tag looks like '!something' or 'something' if len(tagOptions[0]) > 0 && tagOptions[0][0] == '!' { tagOpt = string(tagOptions[0][1:]) tagOptions[0] = tagOpt negate = true } if ok := isValidTag(tagOptions[0]); !ok { err := fmt.Errorf("Unknown Validator %s", tagOptions[0]) return false, Error{t.Name, err, false} } // Check for param validators for key, value := range ParamTagRegexMap { ps := value.FindStringSubmatch(tagOptions[0]) if len(ps) > 0 { if validatefunc, ok := ParamTagMap[key]; ok { switch v.Kind() { case reflect.String: field := fmt.Sprint(v) // make value into string, then validate with regex if result := validatefunc(field, ps[1:]...); (!result && !negate) || (result && negate) { var err error if !negate { if customMsgExists { err = fmt.Errorf(tagOptions[1]) } else { err = fmt.Errorf("%s does not validate as %s", field, tagOpt) } } else { if customMsgExists { err = fmt.Errorf(tagOptions[1]) } else { err = fmt.Errorf("%s does validate as %s", field, tagOpt) } } return false, Error{t.Name, err, customMsgExists} } default: //Not Yet Supported Types (Fail here!) err := fmt.Errorf("Validator %s doesn't support kind %s", tagOptions[0], v.Kind()) return false, Error{t.Name, err, false} } } } } if validatefunc, ok := TagMap[tagOptions[0]]; ok { switch v.Kind() { case reflect.String: field := fmt.Sprint(v) // make value into string, then validate with regex if result := validatefunc(field); !result && !negate || result && negate { var err error if !negate { if customMsgExists { err = fmt.Errorf(tagOptions[1]) } else { err = fmt.Errorf("%s does not validate as %s", field, tagOpt) } } else { if customMsgExists { err = fmt.Errorf(tagOptions[1]) } else { err = fmt.Errorf("%s does validate as %s", field, tagOpt) } } return false, Error{t.Name, err, customMsgExists} } default: //Not Yet Supported Types (Fail here!) err := fmt.Errorf("Validator %s doesn't support kind %s for value %v", tagOptions[0], v.Kind(), v) return false, Error{t.Name, err, false} } } } return true, nil case reflect.Map: if v.Type().Key().Kind() != reflect.String { return false, &UnsupportedTypeError{v.Type()} } var sv stringValues sv = v.MapKeys() sort.Sort(sv) result := true for _, k := range sv { resultItem, err := ValidateStruct(v.MapIndex(k).Interface()) if err != nil { return false, err } result = result && resultItem } return result, nil case reflect.Slice: result := true for i := 0; i < v.Len(); i++ { var resultItem bool var err error if v.Index(i).Kind() != reflect.Struct { resultItem, err = typeCheck(v.Index(i), t, o) if err != nil { return false, err } } else { resultItem, err = ValidateStruct(v.Index(i).Interface()) if err != nil { return false, err } } result = result && resultItem } return result, nil case reflect.Array: result := true for i := 0; i < v.Len(); i++ { var resultItem bool var err error if v.Index(i).Kind() != reflect.Struct { resultItem, err = typeCheck(v.Index(i), t, o) if err != nil { return false, err } } else { resultItem, err = ValidateStruct(v.Index(i).Interface()) if err != nil { return false, err } } result = result && resultItem } return result, nil case reflect.Interface: // If the value is an interface then encode its element if v.IsNil() { return true, nil } return ValidateStruct(v.Interface()) case reflect.Ptr: // If the value is a pointer then check its element if v.IsNil() { return true, nil } return typeCheck(v.Elem(), t, o) case reflect.Struct: return ValidateStruct(v.Interface()) default: return false, &UnsupportedTypeError{v.Type()} } } func isEmptyValue(v reflect.Value) bool { switch v.Kind() { case reflect.String, reflect.Array: return v.Len() == 0 case reflect.Map, reflect.Slice: return v.Len() == 0 || v.IsNil() case reflect.Bool: return !v.Bool() case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return v.Int() == 0 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return v.Uint() == 0 case reflect.Float32, reflect.Float64: return v.Float() == 0 case reflect.Interface, reflect.Ptr: return v.IsNil() } return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) } // ErrorByField returns error for specified field of the struct // validated by ValidateStruct or empty string if there are no errors // or this field doesn't exists or doesn't have any errors. func ErrorByField(e error, field string) string { if e == nil { return "" } return ErrorsByField(e)[field] } // ErrorsByField returns map of errors of the struct validated // by ValidateStruct or empty map if there are no errors. func ErrorsByField(e error) map[string]string { m := make(map[string]string) if e == nil { return m } // prototype for ValidateStruct switch e.(type) { case Error: m[e.(Error).Name] = e.(Error).Err.Error() case Errors: for _, item := range e.(Errors).Errors() { m[item.(Error).Name] = item.(Error).Err.Error() } } return m } // Error returns string equivalent for reflect.Type func (e *UnsupportedTypeError) Error() string { return "validator: unsupported type: " + e.Type.String() } func (sv stringValues) Len() int { return len(sv) } func (sv stringValues) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] } func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) } func (sv stringValues) get(i int) string { return sv[i].String() } govalidator-4/validator_test.go000066400000000000000000001622261271713657300171320ustar00rootroot00000000000000package govalidator import ( "fmt" "strings" "testing" ) func TestIsAlpha(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", false}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc1", false}, {"abc〩", false}, {"abc", true}, {"소주", false}, {"ABC", true}, {"FoObAr", true}, {"소aBC", false}, {"소", false}, {"달기&Co.", false}, {"〩Hours", false}, {"\ufff0", false}, {"\u0070", true}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", false}, //UTF-8(ASCII): 0 {"123", false}, {"0123", false}, {"-00123", false}, {"0", false}, {"-0", false}, {"123.123", false}, {" ", false}, {".", false}, {"-1¾", false}, {"1¾", false}, {"〥〩", false}, {"모자", false}, {"ix", true}, {"۳۵۶۰", false}, {"1--", false}, {"1-1", false}, {"-", false}, {"--", false}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", false}, } for _, test := range tests { actual := IsAlpha(test.param) if actual != test.expected { t.Errorf("Expected IsAlpha(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsUTFLetter(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", false}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc1", false}, {"abc〩", false}, {"", true}, {"abc", true}, {"소주", true}, {"ABC", true}, {"FoObAr", true}, {"소aBC", true}, {"소", true}, {"달기&Co.", false}, {"〩Hours", false}, {"\ufff0", false}, {"\u0070", true}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", false}, //UTF-8(ASCII): 0 {"123", false}, {"0123", false}, {"-00123", false}, {"0", false}, {"-0", false}, {"123.123", false}, {" ", false}, {".", false}, {"-1¾", false}, {"1¾", false}, {"〥〩", false}, {"모자", true}, {"ix", true}, {"۳۵۶۰", false}, {"1--", false}, {"1-1", false}, {"-", false}, {"--", false}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", false}, } for _, test := range tests { actual := IsUTFLetter(test.param) if actual != test.expected { t.Errorf("Expected IsUTFLetter(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsAlphanumeric(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", false}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc123", true}, {"ABC111", true}, {"abc1", true}, {"abc〩", false}, {"abc", true}, {"소주", false}, {"ABC", true}, {"FoObAr", true}, {"소aBC", false}, {"소", false}, {"달기&Co.", false}, {"〩Hours", false}, {"\ufff0", false}, {"\u0070", true}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", true}, //UTF-8(ASCII): 0 {"123", true}, {"0123", true}, {"-00123", false}, {"0", true}, {"-0", false}, {"123.123", false}, {" ", false}, {".", false}, {"-1¾", false}, {"1¾", false}, {"〥〩", false}, {"모자", false}, {"ix", true}, {"۳۵۶۰", false}, {"1--", false}, {"1-1", false}, {"-", false}, {"--", false}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", false}, } for _, test := range tests { actual := IsAlphanumeric(test.param) if actual != test.expected { t.Errorf("Expected IsAlphanumeric(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsUTFLetterNumeric(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", true}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc1", true}, {"abc〩", true}, {"abc", true}, {"소주", true}, {"ABC", true}, {"FoObAr", true}, {"소aBC", true}, {"소", true}, {"달기&Co.", false}, {"〩Hours", true}, {"\ufff0", false}, {"\u0070", true}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", true}, //UTF-8(ASCII): 0 {"123", true}, {"0123", true}, {"-00123", false}, {"0", true}, {"-0", false}, {"123.123", false}, {" ", false}, {".", false}, {"-1¾", false}, {"1¾", true}, {"〥〩", true}, {"모자", true}, {"ix", true}, {"۳۵۶۰", true}, {"1--", false}, {"1-1", false}, {"-", false}, {"--", false}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", false}, } for _, test := range tests { actual := IsUTFLetterNumeric(test.param) if actual != test.expected { t.Errorf("Expected IsUTFLetterNumeric(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsNumeric(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", false}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc1", false}, {"abc〩", false}, {"abc", false}, {"소주", false}, {"ABC", false}, {"FoObAr", false}, {"소aBC", false}, {"소", false}, {"달기&Co.", false}, {"〩Hours", false}, {"\ufff0", false}, {"\u0070", false}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", true}, //UTF-8(ASCII): 0 {"123", true}, {"0123", true}, {"-00123", true}, {"+00123", true}, {"0", true}, {"-0", true}, {"123.123", false}, {" ", false}, {".", false}, {"12𐅪3", false}, {"-1¾", false}, {"1¾", false}, {"〥〩", false}, {"모자", false}, {"ix", false}, {"۳۵۶۰", false}, {"1--", false}, {"1-1", false}, {"-", false}, {"--", false}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", true}, } for _, test := range tests { actual := IsNumeric(test.param) if actual != test.expected { t.Errorf("Expected IsNumeric(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsUTFNumeric(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", true}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc1", false}, {"abc〩", false}, {"abc", false}, {"소주", false}, {"ABC", false}, {"FoObAr", false}, {"소aBC", false}, {"소", false}, {"달기&Co.", false}, {"〩Hours", false}, {"\ufff0", false}, {"\u0070", false}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", true}, //UTF-8(ASCII): 0 {"123", true}, {"0123", true}, {"-00123", true}, {"0", true}, {"-0", true}, {"--0", false}, {"-0-", false}, {"123.123", false}, {" ", false}, {".", false}, {"12𐅪3", true}, {"-1¾", true}, {"1¾", true}, {"〥〩", true}, {"모자", false}, {"ix", false}, {"۳۵۶۰", true}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", true}, } for _, test := range tests { actual := IsUTFNumeric(test.param) if actual != test.expected { t.Errorf("Expected IsUTFNumeric(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsUTFDigit(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"\n", false}, {"\r", false}, {"Ⅸ", false}, {"", true}, {" fooo ", false}, {"abc!!!", false}, {"abc1", false}, {"abc〩", false}, {"abc", false}, {"소주", false}, {"ABC", false}, {"FoObAr", false}, {"소aBC", false}, {"소", false}, {"달기&Co.", false}, {"〩Hours", false}, {"\ufff0", false}, {"\u0070", false}, //UTF-8(ASCII): p {"\u0026", false}, //UTF-8(ASCII): & {"\u0030", true}, //UTF-8(ASCII): 0 {"123", true}, {"0123", true}, {"-00123", true}, {"0", true}, {"-0", true}, {"--0", false}, {"-0-", false}, {"123.123", false}, {" ", false}, {".", false}, {"12𐅪3", false}, {"1483920", true}, {"", true}, {"۳۵۶۰", true}, {"-29", true}, {"-1¾", false}, {"1¾", false}, {"〥〩", false}, {"모자", false}, {"ix", false}, {"۳۵۶۰", true}, {"1++", false}, {"1+1", false}, {"+", false}, {"++", false}, {"+1", true}, } for _, test := range tests { actual := IsUTFDigit(test.param) if actual != test.expected { t.Errorf("Expected IsUTFDigit(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsLowerCase(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"abc123", true}, {"abc", true}, {"a b c", true}, {"abcß", true}, {"abcẞ", false}, {"ABCẞ", false}, {"tr竪s 端ber", true}, {"fooBar", false}, {"123ABC", false}, {"ABC123", false}, {"ABC", false}, {"S T R", false}, {"fooBar", false}, {"abacaba123", true}, } for _, test := range tests { actual := IsLowerCase(test.param) if actual != test.expected { t.Errorf("Expected IsLowerCase(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsUpperCase(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"abc123", false}, {"abc", false}, {"a b c", false}, {"abcß", false}, {"abcẞ", false}, {"ABCẞ", true}, {"tr竪s 端ber", false}, {"fooBar", false}, {"123ABC", true}, {"ABC123", true}, {"ABC", true}, {"S T R", true}, {"fooBar", false}, {"abacaba123", false}, } for _, test := range tests { actual := IsUpperCase(test.param) if actual != test.expected { t.Errorf("Expected IsUpperCase(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsInt(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"-2147483648", true}, //Signed 32 Bit Min Int {"2147483647", true}, //Signed 32 Bit Max Int {"-2147483649", true}, //Signed 32 Bit Min Int - 1 {"2147483648", true}, //Signed 32 Bit Max Int + 1 {"4294967295", true}, //Unsigned 32 Bit Max Int {"4294967296", true}, //Unsigned 32 Bit Max Int + 1 {"-9223372036854775808", true}, //Signed 64 Bit Min Int {"9223372036854775807", true}, //Signed 64 Bit Max Int {"-9223372036854775809", true}, //Signed 64 Bit Min Int - 1 {"9223372036854775808", true}, //Signed 64 Bit Max Int + 1 {"18446744073709551615", true}, //Unsigned 64 Bit Max Int {"18446744073709551616", true}, //Unsigned 64 Bit Max Int + 1 {"", true}, {"123", true}, {"0", true}, {"-0", true}, {"+0", true}, {"01", false}, {"123.123", false}, {" ", false}, {"000", false}, } for _, test := range tests { actual := IsInt(test.param) if actual != test.expected { t.Errorf("Expected IsInt(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsEmail(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"foo@bar.com", true}, {"x@x.x", true}, {"foo@bar.com.au", true}, {"foo+bar@bar.com", true}, {"foo@bar.coffee", true}, {"foo@bar.中文网", true}, {"invalidemail@", false}, {"invalid.com", false}, {"@invalid.com", false}, {"test|123@m端ller.com", true}, {"hans@m端ller.com", true}, {"hans.m端ller@test.com", true}, {"NathAn.daVIeS@DomaIn.cOM", true}, {"NATHAN.DAVIES@DOMAIN.CO.UK", true}, } for _, test := range tests { actual := IsEmail(test.param) if actual != test.expected { t.Errorf("Expected IsEmail(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsURL(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"http://foo.bar#com", true}, {"http://foobar.com", true}, {"https://foobar.com", true}, {"foobar.com", true}, {"http://foobar.coffee/", true}, {"http://foobar.中文网/", true}, {"http://foobar.org/", true}, {"http://foobar.ORG", true}, {"http://foobar.org:8080/", true}, {"ftp://foobar.ru/", true}, {"ftp.foo.bar", true}, {"http://user:pass@www.foobar.com/", true}, {"http://user:pass@www.foobar.com/path/file", true}, {"http://127.0.0.1/", true}, {"http://duckduckgo.com/?q=%2F", true}, {"http://localhost:3000/", true}, {"http://foobar.com/?foo=bar#baz=qux", true}, {"http://foobar.com?foo=bar", true}, {"http://www.xn--froschgrn-x9a.net/", true}, {"http://foobar.com/a-", true}, {"http://foobar.پاکستان/", true}, {"http://foobar.c_o_m", false}, {"", false}, {"xyz://foobar.com", false}, {"invalid.", false}, {".com", false}, {"rtmp://foobar.com", false}, {"http://www.foo_bar.com/", false}, {"http://localhost:3000/", true}, {"http://foobar.com#baz=qux", true}, {"http://foobar.com/t$-_.+!*\\'(),", true}, {"http://www.foobar.com/~foobar", true}, {"http://www.-foobar.com/", false}, {"http://www.foo---bar.com/", false}, {"mailto:someone@example.com", true}, {"irc://irc.server.org/channel", false}, {"irc://#channel@network", true}, {"/abs/test/dir", false}, {"./rel/test/dir", false}, {"http://foo^bar.org", false}, {"http://foo&*bar.org", false}, {"http://foo&bar.org", false}, {"http://foo bar.org", false}, {"http://foo.bar.org", true}, {"http://www.foo.bar.org", true}, {"http://www.foo.co.uk", true}, {"foo", false}, {"http://.foo.com", false}, {"http://,foo.com", false}, {",foo.com", false}, // according to issues #62 #66 {"https://pbs.twimg.com/profile_images/560826135676588032/j8fWrmYY_normal.jpeg", true}, // according to #125 {"http://prometheus-alertmanager.service.q:9093", true}, {"https://www.logn-123-123.url.with.sigle.letter.d:12345/url/path/foo?bar=zzz#user", true}, {"http://me.example.com", true}, {"http://www.me.example.com", true}, {"https://farm6.static.flickr.com", true}, {"https://zh.wikipedia.org/wiki/Wikipedia:%E9%A6%96%E9%A1%B5", true}, {"google", false}, // According to #87 {"http://hyphenated-host-name.example.co.in", true}, {"http://cant-end-with-hyphen-.example.com", false}, {"http://-cant-start-with-hyphen.example.com", false}, {"http://www.domain-can-have-dashes.com", true}, } for _, test := range tests { actual := IsURL(test.param) if actual != test.expected { t.Errorf("Expected IsURL(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsRequestURL(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"http://foo.bar/#com", true}, {"http://foobar.com", true}, {"https://foobar.com", true}, {"foobar.com", false}, {"http://foobar.coffee/", true}, {"http://foobar.中文网/", true}, {"http://foobar.org/", true}, {"http://foobar.org:8080/", true}, {"ftp://foobar.ru/", true}, {"http://user:pass@www.foobar.com/", true}, {"http://127.0.0.1/", true}, {"http://duckduckgo.com/?q=%2F", true}, {"http://localhost:3000/", true}, {"http://foobar.com/?foo=bar#baz=qux", true}, {"http://foobar.com?foo=bar", true}, {"http://www.xn--froschgrn-x9a.net/", true}, {"", false}, {"xyz://foobar.com", true}, {"invalid.", false}, {".com", false}, {"rtmp://foobar.com", true}, {"http://www.foo_bar.com/", true}, {"http://localhost:3000/", true}, {"http://foobar.com/#baz=qux", true}, {"http://foobar.com/t$-_.+!*\\'(),", true}, {"http://www.foobar.com/~foobar", true}, {"http://www.-foobar.com/", true}, {"http://www.foo---bar.com/", true}, {"mailto:someone@example.com", true}, {"irc://irc.server.org/channel", true}, {"irc://#channel@network", true}, {"/abs/test/dir", false}, {"./rel/test/dir", false}, } for _, test := range tests { actual := IsRequestURL(test.param) if actual != test.expected { t.Errorf("Expected IsRequestURL(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsRequestURI(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"http://foo.bar/#com", true}, {"http://foobar.com", true}, {"https://foobar.com", true}, {"foobar.com", false}, {"http://foobar.coffee/", true}, {"http://foobar.中文网/", true}, {"http://foobar.org/", true}, {"http://foobar.org:8080/", true}, {"ftp://foobar.ru/", true}, {"http://user:pass@www.foobar.com/", true}, {"http://127.0.0.1/", true}, {"http://duckduckgo.com/?q=%2F", true}, {"http://localhost:3000/", true}, {"http://foobar.com/?foo=bar#baz=qux", true}, {"http://foobar.com?foo=bar", true}, {"http://www.xn--froschgrn-x9a.net/", true}, {"xyz://foobar.com", true}, {"invalid.", false}, {".com", false}, {"rtmp://foobar.com", true}, {"http://www.foo_bar.com/", true}, {"http://localhost:3000/", true}, {"http://foobar.com/#baz=qux", true}, {"http://foobar.com/t$-_.+!*\\'(),", true}, {"http://www.foobar.com/~foobar", true}, {"http://www.-foobar.com/", true}, {"http://www.foo---bar.com/", true}, {"mailto:someone@example.com", true}, {"irc://irc.server.org/channel", true}, {"irc://#channel@network", true}, {"/abs/test/dir", true}, {"./rel/test/dir", false}, } for _, test := range tests { actual := IsRequestURI(test.param) if actual != test.expected { t.Errorf("Expected IsRequestURI(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsFloat(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {" ", false}, {"-.123", false}, {"abacaba", false}, {"1f", false}, {"-1f", false}, {"+1f", false}, {"123", true}, {"123.", true}, {"123.123", true}, {"-123.123", true}, {"+123.123", true}, {"0.123", true}, {"-0.123", true}, {"+0.123", true}, {".0", true}, {"01.123", true}, {"-0.22250738585072011e-307", true}, {"+0.22250738585072011e-307", true}, } for _, test := range tests { actual := IsFloat(test.param) if actual != test.expected { t.Errorf("Expected IsFloat(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsHexadecimal(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"abcdefg", false}, {"", false}, {"..", false}, {"deadBEEF", true}, {"ff0044", true}, } for _, test := range tests { actual := IsHexadecimal(test.param) if actual != test.expected { t.Errorf("Expected IsHexadecimal(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsHexcolor(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"#ff", false}, {"fff0", false}, {"#ff12FG", false}, {"CCccCC", true}, {"fff", true}, {"#f00", true}, } for _, test := range tests { actual := IsHexcolor(test.param) if actual != test.expected { t.Errorf("Expected IsHexcolor(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsRGBcolor(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"rgb(0,31,255)", true}, {"rgb(1,349,275)", false}, {"rgb(01,31,255)", false}, {"rgb(0.6,31,255)", false}, {"rgba(0,31,255)", false}, {"rgb(0, 31, 255)", true}, } for _, test := range tests { actual := IsRGBcolor(test.param) if actual != test.expected { t.Errorf("Expected IsRGBcolor(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsNull(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"abacaba", false}, {"", true}, } for _, test := range tests { actual := IsNull(test.param) if actual != test.expected { t.Errorf("Expected IsNull(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsDivisibleBy(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 string expected bool }{ {"4", "2", true}, {"100", "10", true}, {"", "1", true}, {"123", "foo", false}, {"123", "0", false}, } for _, test := range tests { actual := IsDivisibleBy(test.param1, test.param2) if actual != test.expected { t.Errorf("Expected IsDivisibleBy(%q, %q) to be %v, got %v", test.param1, test.param2, test.expected, actual) } } } // This small example illustrate how to work with IsDivisibleBy function. func ExampleIsDivisibleBy() { println("1024 is divisible by 64: ", IsDivisibleBy("1024", "64")) } func TestIsByteLength(t *testing.T) { t.Parallel() var tests = []struct { param1 string param2 int param3 int expected bool }{ {"abacaba", 100, -1, false}, {"abacaba", 1, 3, false}, {"abacaba", 1, 7, true}, {"abacaba", 0, 8, true}, {"\ufff0", 1, 1, false}, } for _, test := range tests { actual := IsByteLength(test.param1, test.param2, test.param3) if actual != test.expected { t.Errorf("Expected IsByteLength(%q, %q, %q) to be %v, got %v", test.param1, test.param2, test.param3, test.expected, actual) } } } func TestIsJSON(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"145", true}, {"asdf", false}, {"123:f00", false}, {"{\"Name\":\"Alice\",\"Body\":\"Hello\",\"Time\":1294706395881547000}", true}, {"{}", true}, {"{\"Key\":{\"Key\":{\"Key\":123}}}", true}, {"[]", true}, {"null", true}, } for _, test := range tests { actual := IsJSON(test.param) if actual != test.expected { t.Errorf("Expected IsJSON(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsMultibyte(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"abc", false}, {"123", false}, {"<>@;.-=", false}, {"ひらがな・カタカナ、．漢字", true}, {"あいうえお foobar", true}, {"test＠example.com", true}, {"test＠example.com", true}, {"1234abcDEｘｙｚ", true}, {"ｶﾀｶﾅ", true}, } for _, test := range tests { actual := IsMultibyte(test.param) if actual != test.expected { t.Errorf("Expected IsMultibyte(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsASCII(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"ｆｏｏbar", false}, {"ｘｙｚ０９８", false}, {"１２３456", false}, {"ｶﾀｶﾅ", false}, {"foobar", true}, {"0987654321", true}, {"test@example.com", true}, {"1234abcDEF", true}, {"", true}, } for _, test := range tests { actual := IsASCII(test.param) if actual != test.expected { t.Errorf("Expected IsASCII(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsPrintableASCII(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"ｆｏｏbar", false}, {"ｘｙｚ０９８", false}, {"１２３456", false}, {"ｶﾀｶﾅ", false}, {"foobar", true}, {"0987654321", true}, {"test@example.com", true}, {"1234abcDEF", true}, {"newline\n", false}, {"\x19test\x7F", false}, } for _, test := range tests { actual := IsPrintableASCII(test.param) if actual != test.expected { t.Errorf("Expected IsPrintableASCII(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsFullWidth(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"abc", false}, {"abc123", false}, {"!\"#$%&()<>/+=-_? ~^|.,@`{}[]", false}, {"ひらがな・カタカナ、．漢字", true}, {"３ー０　ａ＠ｃｏｍ", true}, {"Ｆｶﾀｶﾅﾞﾬ", true}, {"Good＝Parts", true}, {"", true}, } for _, test := range tests { actual := IsFullWidth(test.param) if actual != test.expected { t.Errorf("Expected IsFullWidth(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsHalfWidth(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"あいうえお", false}, {"００１１", false}, {"!\"#$%&()<>/+=-_? ~^|.,@`{}[]", true}, {"l-btn_02--active", true}, {"abc123い", true}, {"ｶﾀｶﾅﾞﾬ￩", true}, {"", true}, } for _, test := range tests { actual := IsHalfWidth(test.param) if actual != test.expected { t.Errorf("Expected IsHalfWidth(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsVariableWidth(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", true}, {"ひらがなカタカナ漢字ABCDE", true}, {"３ー０123", true}, {"Ｆｶﾀｶﾅﾞﾬ", true}, {"", true}, {"Good＝Parts", true}, {"abc", false}, {"abc123", false}, {"!\"#$%&()<>/+=-_? ~^|.,@`{}[]", false}, {"ひらがな・カタカナ、．漢字", false}, {"１２３４５６", false}, {"ｶﾀｶﾅﾞﾬ", false}, } for _, test := range tests { actual := IsVariableWidth(test.param) if actual != test.expected { t.Errorf("Expected IsVariableWidth(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsUUID(t *testing.T) { t.Parallel() // Tests without version var tests = []struct { param string expected bool }{ {"", false}, {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false}, {"a987fbc9-4bed-3078-cf07-9141ba07c9f3xxx", false}, {"a987fbc94bed3078cf079141ba07c9f3", false}, {"934859", false}, {"987fbc9-4bed-3078-cf07a-9141ba07c9f3", false}, {"aaaaaaaa-1111-1111-aaag-111111111111", false}, {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", true}, } for _, test := range tests { actual := IsUUID(test.param) if actual != test.expected { t.Errorf("Expected IsUUID(%q) to be %v, got %v", test.param, test.expected, actual) } } // UUID ver. 3 tests = []struct { param string expected bool }{ {"", false}, {"412452646", false}, {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false}, {"a987fbc9-4bed-4078-8f07-9141ba07c9f3", false}, {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", true}, } for _, test := range tests { actual := IsUUIDv3(test.param) if actual != test.expected { t.Errorf("Expected IsUUIDv3(%q) to be %v, got %v", test.param, test.expected, actual) } } // UUID ver. 4 tests = []struct { param string expected bool }{ {"", false}, {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false}, {"a987fbc9-4bed-5078-af07-9141ba07c9f3", false}, {"934859", false}, {"57b73598-8764-4ad0-a76a-679bb6640eb1", true}, {"625e63f3-58f5-40b7-83a1-a72ad31acffb", true}, } for _, test := range tests { actual := IsUUIDv4(test.param) if actual != test.expected { t.Errorf("Expected IsUUIDv4(%q) to be %v, got %v", test.param, test.expected, actual) } } // UUID ver. 5 tests = []struct { param string expected bool }{ {"", false}, {"xxxa987fbc9-4bed-3078-cf07-9141ba07c9f3", false}, {"9c858901-8a57-4791-81fe-4c455b099bc9", false}, {"a987fbc9-4bed-3078-cf07-9141ba07c9f3", false}, {"987fbc97-4bed-5078-af07-9141ba07c9f3", true}, {"987fbc97-4bed-5078-9f07-9141ba07c9f3", true}, } for _, test := range tests { actual := IsUUIDv5(test.param) if actual != test.expected { t.Errorf("Expected IsUUIDv5(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsCreditCard(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"foo", false}, {"5398228707871528", false}, {"375556917985515", true}, {"36050234196908", true}, {"4716461583322103", true}, {"4716-2210-5188-5662", true}, {"4929 7226 5379 7141", true}, {"5398228707871527", true}, } for _, test := range tests { actual := IsCreditCard(test.param) if actual != test.expected { t.Errorf("Expected IsCreditCard(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsISBN(t *testing.T) { t.Parallel() // Without version var tests = []struct { param string expected bool }{ {"", false}, {"foo", false}, {"3836221195", true}, {"1-61729-085-8", true}, {"3 423 21412 0", true}, {"3 401 01319 X", true}, {"9784873113685", true}, {"978-4-87311-368-5", true}, {"978 3401013190", true}, {"978-3-8362-2119-1", true}, } for _, test := range tests { actual := IsISBN(test.param, -1) if actual != test.expected { t.Errorf("Expected IsISBN(%q, -1) to be %v, got %v", test.param, test.expected, actual) } } // ISBN 10 tests = []struct { param string expected bool }{ {"", false}, {"foo", false}, {"3423214121", false}, {"978-3836221191", false}, {"3-423-21412-1", false}, {"3 423 21412 1", false}, {"3836221195", true}, {"1-61729-085-8", true}, {"3 423 21412 0", true}, {"3 401 01319 X", true}, } for _, test := range tests { actual := IsISBN10(test.param) if actual != test.expected { t.Errorf("Expected IsISBN10(%q) to be %v, got %v", test.param, test.expected, actual) } } // ISBN 13 tests = []struct { param string expected bool }{ {"", false}, {"foo", false}, {"3-8362-2119-5", false}, {"01234567890ab", false}, {"978 3 8362 2119 0", false}, {"9784873113685", true}, {"978-4-87311-368-5", true}, {"978 3401013190", true}, {"978-3-8362-2119-1", true}, } for _, test := range tests { actual := IsISBN13(test.param) if actual != test.expected { t.Errorf("Expected IsISBN13(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsDataURI(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"data:image/png;base64,TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4=", true}, {"data:text/plain;base64,Vml2YW11cyBmZXJtZW50dW0gc2VtcGVyIHBvcnRhLg==", true}, {"image/gif;base64,U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", false}, {"data:image/gif;base64,MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuMPNS1Ufof9EW/M98FNw" + "UAKrwflsqVxaxQjBQnHQmiI7Vac40t8x7pIb8gLGV6wL7sBTJiPovJ0V7y7oc0Ye" + "rhKh0Rm4skP2z/jHwwZICgGzBvA0rH8xlhUiTvcwDCJ0kc+fh35hNt8srZQM4619" + "FTgB66Xmp4EtVyhpQV+t02g6NzK72oZI0vnAvqhpkxLeLiMCyrI416wHm5Tkukhx" + "QmcL2a6hNOyu0ixX/x2kSFXApEnVrJ+/IxGyfyw8kf4N2IZpW5nEP847lpfj0SZZ" + "Fwrd1mnfnDbYohX2zRptLy2ZUn06Qo9pkG5ntvFEPo9bfZeULtjYzIl6K8gJ2uGZ" + "HQIDAQAB", true}, {"data:image/png;base64,12345", false}, {"", false}, {"data:text,:;base85,U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", false}, } for _, test := range tests { actual := IsDataURI(test.param) if actual != test.expected { t.Errorf("Expected IsDataURI(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsBase64(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdC4=", true}, {"Vml2YW11cyBmZXJtZW50dW0gc2VtcGVyIHBvcnRhLg==", true}, {"U3VzcGVuZGlzc2UgbGVjdHVzIGxlbw==", true}, {"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuMPNS1Ufof9EW/M98FNw" + "UAKrwflsqVxaxQjBQnHQmiI7Vac40t8x7pIb8gLGV6wL7sBTJiPovJ0V7y7oc0Ye" + "rhKh0Rm4skP2z/jHwwZICgGzBvA0rH8xlhUiTvcwDCJ0kc+fh35hNt8srZQM4619" + "FTgB66Xmp4EtVyhpQV+t02g6NzK72oZI0vnAvqhpkxLeLiMCyrI416wHm5Tkukhx" + "QmcL2a6hNOyu0ixX/x2kSFXApEnVrJ+/IxGyfyw8kf4N2IZpW5nEP847lpfj0SZZ" + "Fwrd1mnfnDbYohX2zRptLy2ZUn06Qo9pkG5ntvFEPo9bfZeULtjYzIl6K8gJ2uGZ" + "HQIDAQAB", true}, {"12345", false}, {"", false}, {"Vml2YW11cyBmZXJtZtesting123", false}, } for _, test := range tests { actual := IsBase64(test.param) if actual != test.expected { t.Errorf("Expected IsBase64(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsISO3166Alpha2(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"ABCD", false}, {"A", false}, {"AC", false}, {"AP", false}, {"GER", false}, {"NU", true}, {"DE", true}, {"JP", true}, {"JPN", false}, {"ZWE", false}, {"GER", false}, {"DEU", false}, } for _, test := range tests { actual := IsISO3166Alpha2(test.param) if actual != test.expected { t.Errorf("Expected IsISO3166Alpha2(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsISO3166Alpha3(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"ABCD", false}, {"A", false}, {"AC", false}, {"AP", false}, {"NU", false}, {"DE", false}, {"JP", false}, {"ZWE", true}, {"JPN", true}, {"GER", false}, {"DEU", true}, } for _, test := range tests { actual := IsISO3166Alpha3(test.param) if actual != test.expected { t.Errorf("Expected IsISO3166Alpha3(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsIP(t *testing.T) { t.Parallel() // Without version var tests = []struct { param string expected bool }{ {"", false}, {"127.0.0.1", true}, {"0.0.0.0", true}, {"255.255.255.255", true}, {"1.2.3.4", true}, {"::1", true}, {"2001:db8:0000:1:1:1:1:1", true}, {"300.0.0.0", false}, } for _, test := range tests { actual := IsIP(test.param) if actual != test.expected { t.Errorf("Expected IsIP(%q) to be %v, got %v", test.param, test.expected, actual) } } // IPv4 tests = []struct { param string expected bool }{ {"", false}, {"127.0.0.1", true}, {"0.0.0.0", true}, {"255.255.255.255", true}, {"1.2.3.4", true}, {"::1", false}, {"2001:db8:0000:1:1:1:1:1", false}, {"300.0.0.0", false}, } for _, test := range tests { actual := IsIPv4(test.param) if actual != test.expected { t.Errorf("Expected IsIPv4(%q) to be %v, got %v", test.param, test.expected, actual) } } // IPv6 tests = []struct { param string expected bool }{ {"", false}, {"127.0.0.1", false}, {"0.0.0.0", false}, {"255.255.255.255", false}, {"1.2.3.4", false}, {"::1", true}, {"2001:db8:0000:1:1:1:1:1", true}, {"300.0.0.0", false}, } for _, test := range tests { actual := IsIPv6(test.param) if actual != test.expected { t.Errorf("Expected IsIPv6(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsPort(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"1", true}, {"65535", true}, {"0", false}, {"65536", false}, {"65538", false}, } for _, test := range tests { actual := IsPort(test.param) if actual != test.expected { t.Errorf("Expected IsPort(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsDNSName(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"localhost", true}, {"localhost.local", true}, {"localhost.localdomain.intern", true}, {"-localhost", false}, {"localhost.-localdomain", false}, {"localhost.localdomain.-int", false}, {"_localhost", false}, {"localhost._localdomain", false}, {"localhost.localdomain._int", false}, {"lÖcalhost", false}, {"localhost.lÖcaldomain", false}, {"localhost.localdomain.üntern", false}, {"127.0.0.1", false}, {"[::1]", false}, {"localhost.localdomain.intern:65535", false}, {"漢字汉字", false}, {"www.jubfvq1v3p38i51622y0dvmdk1mymowjyeu26gbtw9andgynj1gg8z3msb1kl5z6906k846pj3sulm4kiyk82ln5teqj9nsht59opr0cs5ssltx78lfyvml19lfq1wp4usbl0o36cmiykch1vywbttcus1p9yu0669h8fj4ll7a6bmop505908s1m83q2ec2qr9nbvql2589adma3xsq2o38os2z3dmfh2tth4is4ixyfasasasefqwe4t2ub2fz1rme.de", false}, } for _, test := range tests { actual := IsDNSName(test.param) if actual != test.expected { t.Errorf("Expected IsDNS(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsHost(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"localhost", true}, {"localhost.localdomain", true}, {"2001:db8:0000:1:1:1:1:1", true}, {"::1", true}, {"play.golang.org", true}, {"localhost.localdomain.intern:65535", false}, {"-[::1]", false}, {"-localhost", false}, {".localhost", false}, } for _, test := range tests { actual := IsHost(test.param) if actual != test.expected { t.Errorf("Expected IsHost(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsDialString(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"localhost.local:1", true}, {"localhost.localdomain:9090", true}, {"localhost.localdomain.intern:65535", true}, {"127.0.0.1:30000", true}, {"[::1]:80", true}, {"[1200::AB00:1234::2552:7777:1313]:22", false}, {"-localhost:1", false}, {"localhost.-localdomain:9090", false}, {"localhost.localdomain.-int:65535", false}, {"localhost.loc:100000", false}, {"漢字汉字:2", false}, {"www.jubfvq1v3p38i51622y0dvmdk1mymowjyeu26gbtw9andgynj1gg8z3msb1kl5z6906k846pj3sulm4kiyk82ln5teqj9nsht59opr0cs5ssltx78lfyvml19lfq1wp4usbl0o36cmiykch1vywbttcus1p9yu0669h8fj4ll7a6bmop505908s1m83q2ec2qr9nbvql2589adma3xsq2o38os2z3dmfh2tth4is4ixyfasasasefqwe4t2ub2fz1rme.de:20000", false}, } for _, test := range tests { actual := IsDialString(test.param) if actual != test.expected { t.Errorf("Expected IsDialString(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsMAC(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"3D:F2:C9:A6:B3:4F", true}, {"3D-F2-C9-A6-B3:4F", false}, {"123", false}, {"", false}, {"abacaba", false}, } for _, test := range tests { actual := IsMAC(test.param) if actual != test.expected { t.Errorf("Expected IsMAC(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestFilePath(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool osType int }{ {"c:\\" + strings.Repeat("a", 32767), true, Win}, //See http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx#maxpath {"c:\\" + strings.Repeat("a", 32768), false, Win}, {"c:\\path\\file (x86)\bar", true, Win}, {"c:\\path\\file", true, Win}, {"c:\\path\\file:exe", false, Unknown}, {"C:\\", true, Win}, {"c:\\path\\file\\", true, Win}, {"c:/path/file/", false, Unknown}, {"/path/file/", true, Unix}, {"/path/file:SAMPLE/", true, Unix}, {"/path/file:/.txt", true, Unix}, {"/path", true, Unix}, } for _, test := range tests { actual, osType := IsFilePath(test.param) if actual != test.expected || osType != test.osType { t.Errorf("Expected IsFilePath(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsLatitude(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"-90.000", true}, {"+90", true}, {"47.1231231", true}, {"+99.9", false}, {"108", false}, } for _, test := range tests { actual := IsLatitude(test.param) if actual != test.expected { t.Errorf("Expected IsLatitude(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsLongitude(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"-180.000", true}, {"180.1", false}, {"+73.234", true}, {"+382.3811", false}, {"23.11111111", true}, } for _, test := range tests { actual := IsLongitude(test.param) if actual != test.expected { t.Errorf("Expected IsLongitude(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsSSN(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"", false}, {"00-90-8787", false}, {"66690-76", false}, {"191 60 2869", true}, {"191-60-2869", true}, } for _, test := range tests { actual := IsSSN(test.param) if actual != test.expected { t.Errorf("Expected IsSSN(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsMongoID(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"507f1f77bcf86cd799439011", true}, {"507f1f77bcf86cd7994390", false}, {"507f1f77bcf86cd79943901z", false}, {"507f1f77bcf86cd799439011 ", false}, {"", false}, } for _, test := range tests { actual := IsMongoID(test.param) if actual != test.expected { t.Errorf("Expected IsMongoID(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestIsSemver(t *testing.T) { t.Parallel() var tests = []struct { param string expected bool }{ {"v1.0.0", true}, {"1.0.0", true}, {"1.1.01", false}, {"1.01.0", false}, {"01.1.0", false}, {"v1.1.01", false}, {"v1.01.0", false}, {"v01.1.0", false}, {"1.0.0-alpha", true}, {"1.0.0-alpha.1", true}, {"1.0.0-0.3.7", true}, {"1.0.0-0.03.7", false}, {"1.0.0-00.3.7", false}, {"1.0.0-x.7.z.92", true}, {"1.0.0-alpha+001", true}, {"1.0.0+20130313144700", true}, {"1.0.0-beta+exp.sha.5114f85", true}, {"1.0.0-beta+exp.sha.05114f85", true}, {"1.0.0-+beta", false}, {"1.0.0-b+-9+eta", false}, {"v+1.8.0-b+-9+eta", false}, } for _, test := range tests { actual := IsSemver(test.param) if actual != test.expected { t.Errorf("Expected IsSemver(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestByteLength(t *testing.T) { t.Parallel() var tests = []struct { value string min string max string expected bool }{ {"123456", "0", "100", true}, {"1239999", "0", "0", false}, {"1239asdfasf99", "100", "200", false}, {"1239999asdff29", "10", "30", true}, } for _, test := range tests { actual := ByteLength(test.value, test.min, test.max) if actual != test.expected { t.Errorf("Expected ByteLength(%s, %s, %s) to be %v, got %v", test.value, test.min, test.max, test.expected, actual) } } } func TestStringLength(t *testing.T) { t.Parallel() var tests = []struct { value string min string max string expected bool }{ {"123456", "0", "100", true}, {"1239999", "0", "0", false}, {"1239asdfasf99", "100", "200", false}, {"1239999asdff29", "10", "30", true}, {"あいうえお", "0", "5", true}, {"あいうえおか", "0", "5", false}, {"あいうえお", "0", "0", false}, {"あいうえ", "5", "10", false}, } for _, test := range tests { actual := StringLength(test.value, test.min, test.max) if actual != test.expected { t.Errorf("Expected StringLength(%s, %s, %s) to be %v, got %v", test.value, test.min, test.max, test.expected, actual) } } } type Address struct { Street string `valid:"-"` Zip string `json:"zip" valid:"numeric,required"` } type User struct { Name string `valid:"required"` Email string `valid:"required,email"` Password string `valid:"required"` Age int `valid:"required,numeric,@#\u0000"` Home *Address Work []Address } type UserValid struct { Name string `valid:"required"` Email string `valid:"required,email"` Password string `valid:"required"` Age int `valid:"required"` Home *Address Work []Address } type PrivateStruct struct { privateField string `valid:"required,alpha,d_k"` NonZero int ListInt []int ListString []string `valid:"alpha"` Work [2]Address Home Address Map map[string]Address } type NegationStruct struct { NotInt string `valid:"!int"` Int string `valid:"int"` } type LengthStruct struct { Length string `valid:"length(10|20)"` } type StringLengthStruct struct { Length string `valid:"stringlength(10|20)"` } type StringMatchesStruct struct { StringMatches string `valid:"matches(^[0-9]{3}$)"` } type Post struct { Title string `valid:"alpha,required"` Message string `valid:"ascii"` AuthorIP string `valid:"ipv4"` } type MissingValidationDeclationStruct struct { Name string `` Email string `valid:"required,email"` } type FieldsRequiredByDefaultButExemptStruct struct { Name string `valid:"-"` Email string `valid:"email"` } type FieldsRequiredByDefaultButExemptOrOptionalStruct struct { Name string `valid:"-"` Email string `valid:"optional,email"` } type MessageWithSeveralFieldsStruct struct { Title string `valid:"length(1|10)"` Body string `valid:"length(1|10)"` } func TestValidateMissingValidationDeclationStruct(t *testing.T) { var tests = []struct { param MissingValidationDeclationStruct expected bool }{ {MissingValidationDeclationStruct{}, false}, {MissingValidationDeclationStruct{Name: "TEST", Email: "test@example.com"}, false}, } SetFieldsRequiredByDefault(true) for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } SetFieldsRequiredByDefault(false) } func TestFieldsRequiredByDefaultButExemptStruct(t *testing.T) { var tests = []struct { param FieldsRequiredByDefaultButExemptStruct expected bool }{ {FieldsRequiredByDefaultButExemptStruct{}, false}, {FieldsRequiredByDefaultButExemptStruct{Name: "TEST"}, false}, {FieldsRequiredByDefaultButExemptStruct{Email: ""}, false}, {FieldsRequiredByDefaultButExemptStruct{Email: "test@example.com"}, true}, } SetFieldsRequiredByDefault(true) for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } SetFieldsRequiredByDefault(false) } func TestFieldsRequiredByDefaultButExemptOrOptionalStruct(t *testing.T) { var tests = []struct { param FieldsRequiredByDefaultButExemptOrOptionalStruct expected bool }{ {FieldsRequiredByDefaultButExemptOrOptionalStruct{}, true}, {FieldsRequiredByDefaultButExemptOrOptionalStruct{Name: "TEST"}, true}, {FieldsRequiredByDefaultButExemptOrOptionalStruct{Email: ""}, true}, {FieldsRequiredByDefaultButExemptOrOptionalStruct{Email: "test@example.com"}, true}, {FieldsRequiredByDefaultButExemptOrOptionalStruct{Email: "test@example"}, false}, } SetFieldsRequiredByDefault(true) for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } SetFieldsRequiredByDefault(false) } type CustomByteArray [6]byte type StructWithCustomByteArray struct { ID CustomByteArray `valid:"customByteArrayValidator,customMinLengthValidator"` Email string `valid:"email"` CustomMinLength int `valid:"-"` } func TestStructWithCustomByteArray(t *testing.T) { t.Parallel() // add our custom byte array validator that fails when the byte array is pristine (all zeroes) CustomTypeTagMap.Set("customByteArrayValidator", CustomTypeValidator(func(i interface{}, o interface{}) bool { switch v := o.(type) { case StructWithCustomByteArray: if len(v.Email) > 0 { if v.Email != "test@example.com" { t.Errorf("v.Email should have been 'test@example.com' but was '%s'", v.Email) } } default: t.Errorf("Context object passed to custom validator should have been a StructWithCustomByteArray but was %T (%+v)", o, o) } switch v := i.(type) { case CustomByteArray: for _, e := range v { // check if v is empty, i.e. all zeroes if e != 0 { return true } } } return false })) CustomTypeTagMap.Set("customMinLengthValidator", CustomTypeValidator(func(i interface{}, o interface{}) bool { switch v := o.(type) { case StructWithCustomByteArray: return len(v.ID) >= v.CustomMinLength } return false })) testCustomByteArray := CustomByteArray{'1', '2', '3', '4', '5', '6'} var tests = []struct { param StructWithCustomByteArray expected bool }{ {StructWithCustomByteArray{}, false}, {StructWithCustomByteArray{Email: "test@example.com"}, false}, {StructWithCustomByteArray{ID: testCustomByteArray, Email: "test@example.com"}, true}, {StructWithCustomByteArray{ID: testCustomByteArray, Email: "test@example.com", CustomMinLength: 7}, false}, } SetFieldsRequiredByDefault(true) for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } SetFieldsRequiredByDefault(false) } func TestValidateNegationStruct(t *testing.T) { var tests = []struct { param NegationStruct expected bool }{ {NegationStruct{"a1", "11"}, true}, {NegationStruct{"email@email.email", "11"}, true}, {NegationStruct{"123456----", "11"}, true}, {NegationStruct{"::1", "11"}, true}, {NegationStruct{"123.123", "11"}, true}, {NegationStruct{"a1", "a1"}, false}, {NegationStruct{"11", "a1"}, false}, {NegationStruct{"11", "11"}, false}, } for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } } func TestLengthStruct(t *testing.T) { var tests = []struct { param interface{} expected bool }{ {LengthStruct{"11111"}, false}, {LengthStruct{"11111111111111111110000000000000000"}, false}, {LengthStruct{"11dfffdf0099"}, true}, } for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } } func TestStringLengthStruct(t *testing.T) { var tests = []struct { param interface{} expected bool }{ {StringLengthStruct{"11111"}, false}, {StringLengthStruct{"11111111111111111110000000000000000"}, false}, {StringLengthStruct{"11dfffdf0099"}, true}, {StringLengthStruct{"あいうえお"}, false}, {StringLengthStruct{"あいうえおかきくけこ"}, true}, {StringLengthStruct{"あいうえおかきくけこさしすせそたちつてと"}, true}, {StringLengthStruct{"あいうえおかきくけこさしすせそたちつてとな"}, false}, } for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } } func TestStringMatchesStruct(t *testing.T) { var tests = []struct { param interface{} expected bool }{ {StringMatchesStruct{"123"}, true}, {StringMatchesStruct{"123456"}, false}, {StringMatchesStruct{"123abcd"}, false}, } for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } } func TestValidateStruct(t *testing.T) { var tests = []struct { param interface{} expected bool }{ {User{"John", "john@yahoo.com", "123G#678", 20, &Address{"Street", "123456"}, []Address{Address{"Street", "123456"}, Address{"Street", "123456"}}}, false}, {User{"John", "john!yahoo.com", "12345678", 20, &Address{"Street", "ABC456D89"}, []Address{Address{"Street", "ABC456D89"}, Address{"Street", "123456"}}}, false}, {User{"John", "", "12345", 0, &Address{"Street", "123456789"}, []Address{Address{"Street", "ABC456D89"}, Address{"Street", "123456"}}}, false}, {UserValid{"John", "john@yahoo.com", "123G#678", 20, &Address{"Street", "123456"}, []Address{Address{"Street", "123456"}, Address{"Street", "123456"}}}, true}, {UserValid{"John", "john!yahoo.com", "12345678", 20, &Address{"Street", "ABC456D89"}, []Address{Address{"Street", "ABC456D89"}, Address{"Street", "123456"}}}, false}, {UserValid{"John", "", "12345", 0, &Address{"Street", "123456789"}, []Address{Address{"Street", "ABC456D89"}, Address{"Street", "123456"}}}, false}, {nil, true}, {User{"John", "john@yahoo.com", "123G#678", 0, &Address{"Street", "123456"}, []Address{}}, false}, {"im not a struct", false}, } for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } TagMap["d_k"] = Validator(func(str string) bool { return str == "d_k" }) result, err := ValidateStruct(PrivateStruct{"d_k", 0, []int{1, 2}, []string{"hi", "super"}, [2]Address{Address{"Street", "123456"}, Address{"Street", "123456"}}, Address{"Street", "123456"}, map[string]Address{"address": Address{"Street", "123456"}}}) if result != true { t.Log("Case ", 6, ": expected ", true, " when result is ", result) t.Error(err) t.FailNow() } } type testByteArray [8]byte type testByteMap map[byte]byte type testByteSlice []byte func TestRequired(t *testing.T) { testString := "foobar" var tests = []struct { param interface{} expected bool }{ { struct { Pointer *string `valid:"required"` }{}, false, }, { struct { Pointer *string `valid:"required"` }{ Pointer: &testString, }, true, }, { struct { Addr Address `valid:"required"` }{}, false, }, { struct { Addr Address `valid:"required"` }{ Addr: Address{"", "123"}, }, true, }, { struct { Pointer *Address `valid:"required"` }{}, false, }, { struct { Pointer *Address `valid:"required"` }{ Pointer: &Address{"", "123"}, }, true, }, { struct { TestByteArray testByteArray `valid:"required"` }{}, false, }, { struct { TestByteArray testByteArray `valid:"required"` }{ testByteArray{}, }, false, }, { struct { TestByteArray testByteArray `valid:"required"` }{ testByteArray{'1', '2', '3', '4', '5', '6', '7', 'A'}, }, true, }, { struct { TestByteMap testByteMap `valid:"required"` }{}, false, }, { struct { TestByteSlice testByteSlice `valid:"required"` }{}, false, }, } for _, test := range tests { actual, err := ValidateStruct(test.param) if actual != test.expected { t.Errorf("Expected ValidateStruct(%q) to be %v, got %v", test.param, test.expected, actual) if err != nil { t.Errorf("Got Error on ValidateStruct(%q): %s", test.param, err) } } } } func TestErrorByField(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"message", ""}, {"Message", ""}, {"title", ""}, {"Title", "My123 does not validate as alpha"}, {"AuthorIP", "123 does not validate as ipv4"}, } post := &Post{"My123", "duck13126", "123"} _, err := ValidateStruct(post) for _, test := range tests { actual := ErrorByField(err, test.param) if actual != test.expected { t.Errorf("Expected ErrorByField(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestErrorsByField(t *testing.T) { t.Parallel() var tests = []struct { param string expected string }{ {"Title", "My123 does not validate as alpha"}, {"AuthorIP", "123 does not validate as ipv4"}, } post := &Post{Title: "My123", Message: "duck13126", AuthorIP: "123"} _, err := ValidateStruct(post) errs := ErrorsByField(err) if len(errs) != 2 { t.Errorf("There should only be 2 errors but got %v", len(errs)) } for _, test := range tests { if actual, ok := errs[test.param]; !ok || actual != test.expected { t.Errorf("Expected ErrorsByField(%q) to be %v, got %v", test.param, test.expected, actual) } } tests = []struct { param string expected string }{ {"Title", ";:;message;:; does not validate as length(1|10)"}, {"Body", ";:;message;:; does not validate as length(1|10)"}, } message := &MessageWithSeveralFieldsStruct{Title: ";:;message;:;", Body: ";:;message;:;"} _, err = ValidateStruct(message) errs = ErrorsByField(err) if len(errs) != 2 { t.Errorf("There should only be 2 errors but got %v", len(errs)) } for _, test := range tests { if actual, ok := errs[test.param]; !ok || actual != test.expected { t.Errorf("Expected ErrorsByField(%q) to be %v, got %v", test.param, test.expected, actual) } } tests = []struct { param string expected string }{ {"CustomField", "An error occured"}, } err = Error{"CustomField", fmt.Errorf("An error occured"), false} errs = ErrorsByField(err) if len(errs) != 1 { t.Errorf("There should only be 1 errors but got %v", len(errs)) } for _, test := range tests { if actual, ok := errs[test.param]; !ok || actual != test.expected { t.Errorf("Expected ErrorsByField(%q) to be %v, got %v", test.param, test.expected, actual) } } } func TestValidateStructPointers(t *testing.T) { // Struct which uses pointers for values type UserWithPointers struct { Name *string `valid:"-"` Email *string `valid:"email"` FavoriteFood *string `valid:"length(0|32)"` Nerd *bool `valid:"-"` } var tests = []struct { param string expected string }{ {"Name", ""}, {"Email", "invalid does not validate as email"}, {"FavoriteFood", ""}, {"Nerd", ""}, } name := "Herman" email := "invalid" food := "Pizza" nerd := true user := &UserWithPointers{&name, &email, &food, &nerd} _, err := ValidateStruct(user) for _, test := range tests { actual := ErrorByField(err, test.param) if actual != test.expected { t.Errorf("Expected ErrorByField(%q) to be %v, got %v", test.param, test.expected, actual) } } } func ExampleValidateStruct() { type Post struct { Title string `valid:"alphanum,required"` Message string `valid:"duck,ascii"` AuthorIP string `valid:"ipv4"` } post := &Post{"My Example Post", "duck", "123.234.54.3"} //Add your own struct validation tags TagMap["duck"] = Validator(func(str string) bool { return str == "duck" }) result, err := ValidateStruct(post) if err != nil { println("error: " + err.Error()) } println(result) } govalidator-4/wercker.yml000066400000000000000000000003631271713657300157350ustar00rootroot00000000000000box: wercker/golang build: steps: - setup-go-workspace - script: name: go get code: | go version go get -t ./... - script: name: go test code: | go test -race ./...