From 13cce390768d00e19c96fb1709ac15e56f36f096 Mon Sep 17 00:00:00 2001 From: Tim Bunce Date: Sun, 31 May 2020 16:12:12 +0100 Subject: [PATCH] Change FormatChecker interface IsFormat() to return error not bool --- format_checkers.go | 122 ++++++++++++++++++++++------------------ format_checkers_test.go | 48 ++++++++-------- validation.go | 2 +- 3 files changed, 92 insertions(+), 80 deletions(-) diff --git a/format_checkers.go b/format_checkers.go index 1e77046..3c3d383 100644 --- a/format_checkers.go +++ b/format_checkers.go @@ -1,6 +1,7 @@ package gojsonschema import ( + "errors" "net" "net/mail" "net/url" @@ -10,11 +11,20 @@ import ( "time" ) +var ErrBadFormat = errors.New("bad format") // TODO better string or other way to indicate a sentinel error + +func badFormatUnless(ok bool) error { + if ok { + return nil + } + return ErrBadFormat +} + type ( // FormatChecker is the interface all formatters added to FormatCheckerChain must implement FormatChecker interface { // IsFormat checks if input has the correct format - IsFormat(input interface{}) bool + IsFormat(input interface{}) error } // FormatCheckerChain holds the formatters @@ -174,59 +184,59 @@ func (c *FormatCheckerChain) Has(name string) bool { // IsFormat will check an input against a FormatChecker with the given name // to see if it is the correct format -func (c *FormatCheckerChain) IsFormat(name string, input interface{}) bool { +func (c *FormatCheckerChain) IsFormat(name string, input interface{}) error { lock.RLock() f, ok := c.formatters[name] lock.RUnlock() // If a format is unrecognized it should always pass validation if !ok { - return true + return nil } return f.IsFormat(input) } // IsFormat checks if input is a correctly formatted e-mail address -func (f EmailFormatChecker) IsFormat(input interface{}) bool { +func (f EmailFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } _, err := mail.ParseAddress(asString) - return err == nil + return badFormatUnless(err == nil) } // IsFormat checks if input is a correctly formatted IPv4-address -func (f IPV4FormatChecker) IsFormat(input interface{}) bool { +func (f IPV4FormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } // Credit: https://github.com/asaskevich/govalidator ip := net.ParseIP(asString) - return ip != nil && strings.Contains(asString, ".") + return badFormatUnless(ip != nil && strings.Contains(asString, ".")) } // IsFormat checks if input is a correctly formatted IPv6=address -func (f IPV6FormatChecker) IsFormat(input interface{}) bool { +func (f IPV6FormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } // Credit: https://github.com/asaskevich/govalidator ip := net.ParseIP(asString) - return ip != nil && strings.Contains(asString, ":") + return badFormatUnless(ip != nil && strings.Contains(asString, ":")) } // IsFormat checks if input is a correctly formatted date/time per RFC3339 5.6 -func (f DateTimeFormatChecker) IsFormat(input interface{}) bool { +func (f DateTimeFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } formats := []string{ @@ -239,130 +249,132 @@ func (f DateTimeFormatChecker) IsFormat(input interface{}) bool { for _, format := range formats { if _, err := time.Parse(format, asString); err == nil { - return true + return nil } } - return false + return ErrBadFormat } // IsFormat checks if input is a correctly formatted date (YYYY-MM-DD) -func (f DateFormatChecker) IsFormat(input interface{}) bool { +func (f DateFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } _, err := time.Parse("2006-01-02", asString) - return err == nil + return badFormatUnless(err == nil) } // IsFormat checks if input correctly formatted time (HH:MM:SS or HH:MM:SSZ-07:00) -func (f TimeFormatChecker) IsFormat(input interface{}) bool { +func (f TimeFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } - if _, err := time.Parse("15:04:05Z07:00", asString); err == nil { - return true + return nil } - - _, err := time.Parse("15:04:05", asString) - return err == nil + if _, err := time.Parse("15:04:05", asString); err == nil { + return nil + } + return ErrBadFormat } -// IsFormat checks if input is correctly formatted URI with a valid Scheme per RFC3986 -func (f URIFormatChecker) IsFormat(input interface{}) bool { +// IsFormat checks if input is correctly formatted URI with a valid Scheme per RFC3986 +func (f URIFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } u, err := url.Parse(asString) if err != nil || u.Scheme == "" { - return false + return ErrBadFormat } - return !strings.Contains(asString, `\`) + if strings.Contains(asString, `\`) { + return ErrBadFormat + } + return nil } // IsFormat checks if input is a correctly formatted URI or relative-reference per RFC3986 -func (f URIReferenceFormatChecker) IsFormat(input interface{}) bool { +func (f URIReferenceFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } _, err := url.Parse(asString) - return err == nil && !strings.Contains(asString, `\`) + return badFormatUnless(err == nil && !strings.Contains(asString, `\`)) } // IsFormat checks if input is a correctly formatted URI template per RFC6570 -func (f URITemplateFormatChecker) IsFormat(input interface{}) bool { +func (f URITemplateFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } u, err := url.Parse(asString) if err != nil || strings.Contains(asString, `\`) { - return false + return ErrBadFormat } - return rxURITemplate.MatchString(u.Path) + return badFormatUnless(rxURITemplate.MatchString(u.Path)) } // IsFormat checks if input is a correctly formatted hostname -func (f HostnameFormatChecker) IsFormat(input interface{}) bool { +func (f HostnameFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } - - return rxHostname.MatchString(asString) && len(asString) < 256 + return badFormatUnless(rxHostname.MatchString(asString) && len(asString) < 256) } // IsFormat checks if input is a correctly formatted UUID -func (f UUIDFormatChecker) IsFormat(input interface{}) bool { +func (f UUIDFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } - return rxUUID.MatchString(asString) + return badFormatUnless(rxUUID.MatchString(asString)) } // IsFormat checks if input is a correctly formatted regular expression -func (f RegexFormatChecker) IsFormat(input interface{}) bool { +func (f RegexFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } if asString == "" { - return true + return nil } _, err := regexp.Compile(asString) - return err == nil + return badFormatUnless(err == nil) } // IsFormat checks if input is a correctly formatted JSON Pointer per RFC6901 -func (f JSONPointerFormatChecker) IsFormat(input interface{}) bool { +func (f JSONPointerFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } - return rxJSONPointer.MatchString(asString) + return badFormatUnless(rxJSONPointer.MatchString(asString)) } // IsFormat checks if input is a correctly formatted relative JSON Pointer -func (f RelativeJSONPointerFormatChecker) IsFormat(input interface{}) bool { +func (f RelativeJSONPointerFormatChecker) IsFormat(input interface{}) error { asString, ok := input.(string) if !ok { - return true + return nil } - return rxRelJSONPointer.MatchString(asString) + return badFormatUnless(rxRelJSONPointer.MatchString(asString)) } diff --git a/format_checkers_test.go b/format_checkers_test.go index 6742178..ddf74f6 100644 --- a/format_checkers_test.go +++ b/format_checkers_test.go @@ -10,20 +10,20 @@ import ( func TestUUIDFormatCheckerIsFormat(t *testing.T) { checker := UUIDFormatChecker{} - assert.True(t, checker.IsFormat("01234567-89ab-cdef-0123-456789abcdef")) - assert.True(t, checker.IsFormat("f1234567-89ab-cdef-0123-456789abcdef")) - assert.True(t, checker.IsFormat("01234567-89AB-CDEF-0123-456789ABCDEF")) - assert.True(t, checker.IsFormat("F1234567-89AB-CDEF-0123-456789ABCDEF")) + assert.Nil(t, checker.IsFormat("01234567-89ab-cdef-0123-456789abcdef")) + assert.Nil(t, checker.IsFormat("f1234567-89ab-cdef-0123-456789abcdef")) + assert.Nil(t, checker.IsFormat("01234567-89AB-CDEF-0123-456789ABCDEF")) + assert.Nil(t, checker.IsFormat("F1234567-89AB-CDEF-0123-456789ABCDEF")) - assert.False(t, checker.IsFormat("not-a-uuid")) - assert.False(t, checker.IsFormat("g1234567-89ab-cdef-0123-456789abcdef")) + assert.NotNil(t, checker.IsFormat("not-a-uuid")) + assert.NotNil(t, checker.IsFormat("g1234567-89ab-cdef-0123-456789abcdef")) } func TestURIReferenceFormatCheckerIsFormat(t *testing.T) { checker := URIReferenceFormatChecker{} - assert.True(t, checker.IsFormat("relative")) - assert.True(t, checker.IsFormat("https://dummyhost.com/dummy-path?dummy-qp-name=dummy-qp-value")) + assert.Nil(t, checker.IsFormat("relative")) + assert.Nil(t, checker.IsFormat("https://dummyhost.com/dummy-path?dummy-qp-name=dummy-qp-value")) } const formatSchema = `{ @@ -41,58 +41,58 @@ const formatSchema = `{ type arrayChecker struct{} -func (c arrayChecker) IsFormat(input interface{}) bool { +func (c arrayChecker) IsFormat(input interface{}) error { arr, ok := input.([]interface{}) if !ok { - return true + return nil } for _, v := range arr { if v == "x" { - return true + return nil } } - return false + return ErrBadFormat } type boolChecker struct{} -func (c boolChecker) IsFormat(input interface{}) bool { +func (c boolChecker) IsFormat(input interface{}) error { b, ok := input.(bool) if !ok { - return true + return nil } - return b + return badFormatUnless(b) } type integerChecker struct{} -func (c integerChecker) IsFormat(input interface{}) bool { +func (c integerChecker) IsFormat(input interface{}) error { number, ok := input.(json.Number) if !ok { - return true + return nil } f, _ := number.Float64() - return int(f)%2 == 0 + return badFormatUnless(int(f)%2 == 0) } type objectChecker struct{} -func (c objectChecker) IsFormat(input interface{}) bool { +func (c objectChecker) IsFormat(input interface{}) error { obj, ok := input.(map[string]interface{}) if !ok { - return true + return nil } - return obj["name"] == "x" + return badFormatUnless(obj["name"] == "x") } type stringChecker struct{} -func (c stringChecker) IsFormat(input interface{}) bool { +func (c stringChecker) IsFormat(input interface{}) error { str, ok := input.(string) if !ok { - return true + return nil } - return str == "o" + return badFormatUnless(str == "o") } func TestCustomFormat(t *testing.T) { diff --git a/validation.go b/validation.go index 9081bd9..e99a162 100644 --- a/validation.go +++ b/validation.go @@ -442,7 +442,7 @@ func (v *subSchema) validateCommon(currentSubSchema *subSchema, value interface{ // format: if currentSubSchema.format != "" { - if !FormatCheckers.IsFormat(currentSubSchema.format, value) { + if err := FormatCheckers.IsFormat(currentSubSchema.format, value); err != nil { result.addInternalError( new(DoesNotMatchFormatError), context,