pax_global_header00006660000000000000000000000064142677465140014532gustar00rootroot0000000000000052 comment=f74aeabb853b293136cf648e780b456b3f774978 golang-github-flowstack-go-jsonschema-0.1.2/000077500000000000000000000000001426774651400210075ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/.github/000077500000000000000000000000001426774651400223475ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/.github/workflows/000077500000000000000000000000001426774651400244045ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/.github/workflows/go.yml000066400000000000000000000005451426774651400255400ustar00rootroot00000000000000name: Go on: push: branches: [ main ] pull_request: branches: [ main ] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Go uses: actions/setup-go@v2 with: go-version: 1.17 - name: Build run: go build -v ./... - name: Test run: go test -v ./... golang-github-flowstack-go-jsonschema-0.1.2/LICENSE000066400000000000000000000020521426774651400220130ustar00rootroot00000000000000MIT License Copyright (c) 2021 FlowStack 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. golang-github-flowstack-go-jsonschema-0.1.2/README.md000066400000000000000000000063571426774651400223010ustar00rootroot00000000000000[![Go Reference](https://pkg.go.dev/badge/github.com/flowstack/go-jsonschema.svg)](https://pkg.go.dev/github.com/flowstack/go-jsonschema) # go-jsonschema Go JSON Schema parser and validator Although go-jsonschema hasn't reached version 1.0, it already passes all mandatory tests and most optional tests in the test suites for Draft 4, Draft 6 and Draft 7. A lot of work has already been done to parse a lot of draft2019-09 and draft2020-12 tests. Errors are not very informative. E.g. line number, keys, values, etc. aren't reported back. The main focus has been on speed and correctness of validation, but error reporting should get better over time. Until the release of version 1.0, breaking changes can happen, but will be avoided if possible. ## Usage It is now possible to marshal and unmarshal schemas directly with [encoding/json](https://pkg.go.dev/encoding/json). ### Validate JSON Schema ```go import "github.com/flowstack/go-jsonschema" func main() { schema := `{"properties": {"id": {"type": "string"}}}` // Validate a JSON Schema _, err := jsonschema.Validate(schema) if err != nil { log.Fatal(err) } } ``` ### Validate JSON against a JSON Schema ```go import "github.com/flowstack/go-jsonschema" func main() { schema := `{"properties": {"id": {"type": "string"}}}` // Create a validator validator, err := jsonschema.NewFromString(schema) // Alternative: validator, err := jsonschema.New([]byte(schema)) if err != nil { log.Fatal(err) } // Validate a JSON document against the schema json := `{"id": "123abc"}` _, err = validator.Validate([]byte(json)) if err != nil { log.Fatal(err) } } ``` ### Marshal / Unmarshal ```go import "github.com/flowstack/go-jsonschema" func main() { schemaStr := `{"properties": {"id": {"type": "string"}}}` // Unmarshal from string to Schema struct schema := &jsonschema.Schema{} err := json.Unmarshal([]byte(schemaStr), schema) if err != nil { t.Fatal(err) } // Marshal from Schema struct to JSON schemaBytes, err := json.Marshal(schema) if err != nil { t.Fatal(err) } } ``` ## Contributions Contributions are very welcome! This project is young and could use more eyes and brains to make everything better. So please fork, code and make pull requests. At least the existing tests should pass, but you're welcome to change those too, as long as the JSON Schema test suite is run and passes. Currently most test for Draft 2019-09 and Draft 2020-12 passes, but there is more code to be done, before those 2 will be fully functional. The JSON Schema parser is fairly slow and could probably be made faster, relatively easy. ## Motivation for creating yet another JSON Schema parser / validator The very nice [gojsonschema](http://github.com/xeipuuv/gojsonschema) was missing some features and we needed some internal functionality, that was hard to build on top of [gojsonschema](http://github.com/xeipuuv/gojsonschema). Furthermore [gojsonschema](http://github.com/xeipuuv/gojsonschema) uses Go's JSON parser, which makes it relatively slow, when parsing JSON documents for validation. This module uses the excellent [jsonparser](https://github.com/buger/jsonparser), which is waaaay faster than Go's builtin parser. golang-github-flowstack-go-jsonschema-0.1.2/deref_test.go000066400000000000000000000035731426774651400234720ustar00rootroot00000000000000package jsonschema import ( _ "embed" "testing" ) var deRefTests = []struct { schema string expectedSchema string }{ { schema: `{"$id":"http://example.com/schema-refs-absolute-uris-defs1.json","properties":{"foo":{"$id":"http://example.com/schema-refs-absolute-uris-defs2.json","definitions":{"inner":{"properties":{"bar":{"type":"string"}}}},"allOf":[{"$ref":"#/definitions/inner"}]}},"allOf":[{"$ref":"schema-refs-absolute-uris-defs2.json"}]}`, expectedSchema: `{"$id":"http://example.com/schema-refs-absolute-uris-defs1.json","allOf":[{"$id":"http://example.com/schema-refs-absolute-uris-defs2.json","definitions":{"inner":{"properties":{"bar":{"type":"string"}}}},"allOf":[{"properties":{"bar":{"type":"string"}}}]}],"properties":{"foo":{"$id":"http://example.com/schema-refs-absolute-uris-defs2.json","definitions":{"inner":{"properties":{"bar":{"type":"string"}}}},"allOf":[{"properties":{"bar":{"type":"string"}}}]}}}`, }, { schema: `{"$schema":"http://json-schema.org/draft-04/schema#","properties":{"foo":{"$ref":"#"}},"additionalProperties":false}`, expectedSchema: `{"$schema":"http://json-schema.org/draft-04/schema#","properties":{"foo":{"$schema":"http://json-schema.org/draft-04/schema#","properties":{"foo":{"$schema":"http://json-schema.org/draft-04/schema#","properties":{"foo":{"$schema":"http://json-schema.org/draft-04/schema#","properties":{"foo":{"$ref":"#"}},"additionalProperties":false}},"additionalProperties":false}},"additionalProperties":false}},"additionalProperties":false}`, }, } func TestDeRef(t *testing.T) { for _, tt := range deRefTests { s, err := New([]byte(tt.schema)) if err != nil { t.Fatal(err) } err = s.DeRef() if err != nil { t.Fatal(err) } if s.String() != tt.expectedSchema { t.Fatalf( "expected de-ref'ed schema to match:\n%s\ngot:\n%s\n", tt.expectedSchema, s.String(), ) } } } golang-github-flowstack-go-jsonschema-0.1.2/go.mod000066400000000000000000000003601426774651400221140ustar00rootroot00000000000000module github.com/flowstack/go-jsonschema go 1.16 require ( github.com/buger/jsonparser v1.1.1 github.com/davecgh/go-spew v1.1.1 // indirect github.com/xeipuuv/gojsonschema v1.2.0 golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d ) golang-github-flowstack-go-jsonschema-0.1.2/go.sum000066400000000000000000000044241426774651400221460ustar00rootroot00000000000000github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs= github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c= github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d h1:20cMwl2fHAzkJMEA+8J4JgqBQcQGzbisXo31MIeenXI= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang-github-flowstack-go-jsonschema-0.1.2/helpers.go000066400000000000000000000063301426774651400230020ustar00rootroot00000000000000package jsonschema import ( "bytes" "fmt" "log" "math/big" "strings" ) func init() { log.SetFlags(log.Ltime | log.Lshortfile) } var ( trueLiteral = []byte("true") falseLiteral = []byte("false") nullLiteral = []byte("null") ) var regexpExtraSpaceChars = string('\ufeff') + string('\u000b') + string('\u00a0') + string('\u2029') + string('\u2003') var regexpControlChars = map[string]string{ `\c@`: `\000`, `\cA`: `\001`, `\cB`: `\002`, `\cC`: `\003`, `\cD`: `\004`, `\cE`: `\005`, `\cF`: `\006`, `\cG`: `\007`, `\cH`: `\008`, `\cI`: `\009`, `\cJ`: `\00A`, `\cK`: `\00B`, `\cL`: `\00C`, `\cM`: `\00D`, `\cN`: `\00E`, `\cO`: `\00F`, `\cP`: `\010`, `\cQ`: `\011`, `\cR`: `\012`, `\cS`: `\013`, `\cT`: `\014`, `\cU`: `\015`, `\cV`: `\016`, `\cW`: `\017`, `\cX`: `\018`, `\cY`: `\019`, `\cZ`: `\01A`, `\c[`: `\01B`, `\c\`: `\01C`, `\c]`: `\01D`, `\c^`: `\01E`, `\c_`: `\01F`, } func addError(err, errs error) error { if err == nil { return errs } if errs == nil { return err } return fmt.Errorf("%w\n%s", errs, err.Error()) } func convertRegexp(re string) string { re = strings.ReplaceAll(re, `\w`, `\pL`) // re = strings.ReplaceAll(re, `\w`, `[0-9A-Za-z_]`) // re = strings.ReplaceAll(re, `\W`, `[^0-9A-Za-z_]`) re = strings.ReplaceAll(re, `\d`, `\pN`) // re = strings.ReplaceAll(re, `\d`, `[0-9]`) // re = strings.ReplaceAll(re, `\D`, `[^0-9]`) re = strings.ReplaceAll(re, `\s`, `[\s`+regexpExtraSpaceChars+`]`) re = strings.ReplaceAll(re, `\S`, `[^\s`+regexpExtraSpaceChars+`]`) // Replace control escape characters with their unicod equivalent for cc, unicode := range regexpControlChars { re = strings.ReplaceAll(re, cc, unicode) re = strings.ReplaceAll(re, strings.ToLower(cc), unicode) } return re } func isInteger(val []byte) bool { floatVal, ok := new(big.Float).SetString(string(val)) if !ok { return false } return floatVal.IsInt() } // This should more or less match what jsonparser detects. // Unfortunately jsonparser doesn't expose it's detect type function. func DetectJSONType(data []byte) ValueType { // Empty if len(data) == 0 { return Unknown } // Object if data[0] == '{' && data[len(data)-1] == '}' { return Object } // Array if data[0] == '[' && data[len(data)-1] == ']' { return Array } // String if data[0] == '"' && data[len(data)-1] == '"' { return String } // Number isInt := true isNum := false numberLoop: for idx, c := range data { switch c { case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': // Do nothing case '-', '+': if idx != 0 { isInt = false isNum = false break numberLoop } // Do nothing case 'e': if idx != 1 { isInt = false isNum = false break numberLoop } // Do nothing case '.': isInt = false isNum = true default: isInt = false isNum = false break numberLoop } } if isNum { if isInteger(data) { isInt = true isNum = false } else { return Number } } if isInt { return Integer } // Null if bytes.Equal(data, nullLiteral) { return Null } // Boolean if bytes.Equal(data, trueLiteral) || bytes.Equal(data, falseLiteral) { return Boolean } // Assume it's a string // TODO: Ensure this is a valid assumption return String } golang-github-flowstack-go-jsonschema-0.1.2/parser.go000066400000000000000000000254051426774651400226400ustar00rootroot00000000000000package jsonschema import ( "encoding/json" "regexp" "github.com/buger/jsonparser" ) func (s *Schema) Parse(jsonSchema []byte) (*Schema, error) { schema := &Schema{raw: jsonSchema, circularThreshold: 3} if s == nil { schema.pointers = &pointers{} schema.refs = &refs{} } else { schema.parent = s // Set the base schema if s.baseURI != nil || s.base == nil { schema.base = s } else if s.base != nil { schema.base = s.base } // Set the root schema if s.root != nil { schema.root = s.root } else { schema.root = s } } if b, err := jsonparser.ParseBoolean(jsonSchema); err == nil { schema.boolean = &b schema.setupValidators() return schema, nil } var errs error // Simplest solution for getting ($)id or $ref, which is needed for separation and de-ref'ing jsonparser.EachKey(jsonSchema, func(idx int, value []byte, vt jsonparser.ValueType, err error) { if err != nil { errs = addError(err, errs) return } switch SchemaProp(idx) { case PropID: schema.ID = NewStringPtr(value) case PropIDDraft04: schema.IDDraft04 = NewStringPtr(value) case PropRef: schema.Ref, err = NewRef(value, vt, schema) errs = addError(err, errs) } }, [][]string{PropID: {"$id"}, PropIDDraft04: {"id"}, PropRef: {"$ref"}}...) id := schema.GetID() if id != "" && schema.Ref == nil { if len(id) > 0 && id[:1] == "#" { // Do not expand or change base uri if s != nil { s.setPointer(id, schema) } } else { var err error schema.baseURI, err = s.ExpandURI(id) if err != nil { addError(err, errs) return nil, errs } schema.pointers = &pointers{"#": schema} if s != nil { s.setPointer(schema.baseURI.String(), schema) } else { schema.setPointer(schema.baseURI.String(), schema) } } } jsonparser.ObjectEach(jsonSchema, func(key []byte, value []byte, vt jsonparser.ValueType, offset int) error { var err error schemaProp, ok := nameToProp[string(key)] if !ok { if schema.unknownProps == nil { schema.unknownProps = []*NamedValue{} } newVal, err := NewValue(value, vt) schema.unknownProps = append(schema.unknownProps, &NamedValue{Name: string(key), Value: newVal}) errs = addError(err, errs) return errs } switch schemaProp { case PropSchema: schema.Schema = NewStringPtr(value) case PropComment: schema.Comment = NewStringPtr(value) case PropTitle: schema.Title = NewStringPtr(value) case PropDescription: schema.Description = NewStringPtr(value) case PropType: schema.Type, err = NewType(value, vt) errs = addError(err, errs) case PropEnum: schema.Enum, err = NewEnum(value, vt) errs = addError(err, errs) case PropDefault: schema.Default, err = NewValue(value, vt) errs = addError(err, errs) case PropExamples: schema.Examples, err = NewValues(value, vt) errs = addError(err, errs) case PropConst: schema.Const, err = NewValue(value, vt) errs = addError(err, errs) case PropReadOnly: tmpBool, err := jsonparser.ParseBoolean(value) schema.ReadOnly = &tmpBool errs = addError(err, errs) case PropWriteOnly: tmpBool, err := jsonparser.ParseBoolean(value) schema.WriteOnly = &tmpBool errs = addError(err, errs) case PropDefinitions: schema.Definitions, err = NewProperties(value, vt, schema) errs = addError(err, errs) case PropIf: schema.If, err = schema.Parse(value) errs = addError(err, errs) case PropThen: schema.Then, err = schema.Parse(value) errs = addError(err, errs) case PropElse: schema.Else, err = schema.Parse(value) errs = addError(err, errs) case PropAllOf: schema.AllOf, err = NewSubSchemas(value, vt, schema) errs = addError(err, errs) case PropAnyOf: schema.AnyOf, err = NewSubSchemas(value, vt, schema) errs = addError(err, errs) case PropOneOf: schema.OneOf, err = NewSubSchemas(value, vt, schema) errs = addError(err, errs) case PropNot: schema.Not, err = schema.Parse(value) errs = addError(err, errs) case PropContentEncoding: schema.ContentEncoding = NewStringPtr(value) case PropContentMediaType: schema.ContentMediaType = NewStringPtr(value) case PropProperties: schema.Properties, err = NewProperties(value, vt, schema) errs = addError(err, errs) case PropRequired: schema.Required, err = NewStrings(value, vt) errs = addError(err, errs) case PropMaxProperties: tmpInt, err := jsonparser.ParseInt(value) schema.MaxProperties = &tmpInt errs = addError(err, errs) case PropMinProperties: tmpInt, err := jsonparser.ParseInt(value) schema.MinProperties = &tmpInt errs = addError(err, errs) case PropDependencies: schema.Dependencies, err = NewDependencies(value, vt, schema) errs = addError(err, errs) case PropPatternProperties: schema.PatternProperties, err = NewProperties(value, vt, schema) errs = addError(err, errs) // Pre-compile the regexps if schema.PatternProperties != nil { schema.patternPropertiesRegexps = &map[string]*regexp.Regexp{} for _, prop := range *schema.PatternProperties { reStr := convertRegexp(prop.Name) re, err := regexp.Compile(reStr) if err != nil { errs = addError(err, errs) } else { (*schema.patternPropertiesRegexps)[prop.Name] = re } } } case PropAdditionalProperties: schema.AdditionalProperties, err = schema.Parse(value) errs = addError(err, errs) case PropPropertyNames: schema.PropertyNames, err = schema.Parse(value) errs = addError(err, errs) case PropItems: schema.Items, err = NewItems(value, vt, schema) errs = addError(err, errs) case PropMaxItems: tmpInt, err := jsonparser.ParseInt(value) schema.MaxItems = &tmpInt errs = addError(err, errs) case PropMinItems: tmpInt, err := jsonparser.ParseInt(value) schema.MinItems = &tmpInt errs = addError(err, errs) case PropUniqueItems: tmpBool, err := jsonparser.ParseBoolean(value) schema.UniqueItems = &tmpBool errs = addError(err, errs) case PropAdditionalItems: schema.AdditionalItems, err = schema.Parse(value) errs = addError(err, errs) case PropContains: schema.Contains, err = schema.Parse(value) errs = addError(err, errs) case PropMaxLength: tmpInt, err := jsonparser.ParseInt(value) schema.MaxLength = &tmpInt errs = addError(err, errs) case PropMinLength: tmpInt, err := jsonparser.ParseInt(value) schema.MinLength = &tmpInt errs = addError(err, errs) case PropFormat: schema.Format = NewStringPtr(value) case PropPattern: schema.Pattern = NewStringPtr(value) reStr := convertRegexp(*schema.Pattern) re, err := regexp.Compile(reStr) if err != nil { errs = addError(err, errs) } else { schema.patternRegexp = re } case PropMultipleOf: tmpNum := json.Number(string(value)) schema.MultipleOf = &tmpNum case PropMaximum: schema.Maximum, err = NewValue(value, vt) errs = addError(err, errs) case PropExclusiveMaximum: schema.ExclusiveMaximum, err = NewValue(value, vt) errs = addError(err, errs) case PropMinimum: schema.Minimum, err = NewValue(value, vt) errs = addError(err, errs) case PropExclusiveMinimum: schema.ExclusiveMinimum, err = NewValue(value, vt) errs = addError(err, errs) } return errs }) schema.setupValidators() return schema, errs } // Cases // - #/deffintions - no change of base uri // - #... - no change of base uri // - http.... - change of base uri // - anything else - change of base uri // - also: base uri changes, but id is not expanded func (s *Schema) setPointer(key string, schema *Schema) { if s != nil { if len(key) > 7 && (key[0:7] != "http://" || key[0:8] != "https://") && s.root != nil && s.root.pointers != nil { (*s.root.pointers)[key] = schema } else if s.pointers != nil { (*s.pointers)[key] = schema } else if s.base != nil && s.base.pointers != nil { (*s.base.pointers)[key] = schema } } } func (s *Schema) getPointer(key string) *Schema { if s != nil { if s.baseURI != nil && s.baseURI.String() == key { return s } if len(key) > 7 && (key[0:7] != "http://" || key[0:8] != "https://") && s.root != nil && s.root.pointers != nil { return (*s.root.pointers)[key] } if s.pointers != nil && (*s.pointers)[key] != nil { return (*s.pointers)[key] } if s.base != nil && s.base.pointers != nil { return (*s.base.pointers)[key] } } return nil } func (s *Schema) setRef(ref *Ref) { if s != nil { if s.root != nil { (*s.root.refs) = append((*s.root.refs), ref) } else { (*s.refs) = append((*s.refs), ref) } } } // NOTE: There is probably a lot of performance to gain here, // e.g. by excluding everything else if $ref is set func (s *Schema) setupValidators() { s.validators = []validatorFunc{} // Always start by validating the value s.validators = append(s.validators, validateValue) if s.boolean != nil { s.validators = append(s.validators, validateBooleanSchema) } if s.Ref != nil { s.validators = append(s.validators, validateRef) return } if s.Items != nil || s.AdditionalItems != nil || s.MaxItems != nil || s.MinItems != nil || s.UniqueItems != nil || s.Contains != nil { s.validators = append(s.validators, validateItems) } if s.Properties != nil || s.PatternProperties != nil || s.AdditionalProperties != nil || s.MaxProperties != nil || s.MinProperties != nil { s.validators = append(s.validators, validateProperties) } if s.PropertyNames != nil { s.validators = append(s.validators, validatePropertyNames) } if s.Type != nil { s.validators = append(s.validators, validateType) } if s.Pattern != nil { s.validators = append(s.validators, validatePattern) } if s.Required != nil { s.validators = append(s.validators, validateRequired) } if s.Dependencies != nil { s.validators = append(s.validators, validateDependencies) } if s.AllOf != nil { s.validators = append(s.validators, validateAllOf) } if s.AnyOf != nil { s.validators = append(s.validators, validateAnyOf) } if s.OneOf != nil { s.validators = append(s.validators, validateOneOf) } if s.Not != nil { s.validators = append(s.validators, validateNot) } if s.MultipleOf != nil { s.validators = append(s.validators, validateMultipleOf) } if s.Maximum != nil || s.ExclusiveMaximum != nil { s.validators = append(s.validators, validateMaximum) } if s.Minimum != nil || s.ExclusiveMinimum != nil { s.validators = append(s.validators, validateMinimum) } if s.MaxLength != nil { s.validators = append(s.validators, validateMaxLength) } if s.MinLength != nil { s.validators = append(s.validators, validateMinLength) } if s.Enum != nil { s.validators = append(s.validators, validateEnum) } if s.Const != nil { s.validators = append(s.validators, validateConst) } if s.If != nil { s.validators = append(s.validators, validateIf) } if s.Format != nil { s.validators = append(s.validators, validateFormat) } } golang-github-flowstack-go-jsonschema-0.1.2/schema.go000066400000000000000000000277711426774651400226140ustar00rootroot00000000000000package jsonschema import ( "bytes" "encoding/json" "errors" "net/url" "regexp" "strconv" "github.com/buger/jsonparser" ) func New(schema []byte) (*Schema, error) { var nilSchema *Schema return nilSchema.Parse(schema) // return new(Schema).Parse(schema) } func NewFromString(schema string) (*Schema, error) { return New([]byte(schema)) } func (s *Schema) SetCircularRefThresHold(threshold int) { s.circularThreshold = threshold } // This it to ensure MarshalJSON doesn't go haywire type tmpSchema Schema type Schema struct { // name contains e.g. the property name, under which this schema was found. // It may not always contain a name, but should at least for schemas with type object. name string // raw contains the raw json schema - necessary in some special cases like de-ref $refs raw []byte // Root schema is the top most schema. root *Schema // Parent schema is the nearest schema, up the stack parent *Schema // Base schema is the nearest schema, up the stack, with a non-pointer (#xxx) ($)id set base *Schema // baseURI is present on any schema with an $id baseURI *url.URL // pointers holds references to schemas with ($)id, collected during parsing - the map key is ($)id pointers *pointers // refs holds pointers to $ref objects to make de-ref'ing easier. // These should only be present on the root schema. refs *refs // circularThreshold is the threshold for when to stop resolving $refs and just print the $ref string // Should only be set on root circularThreshold int // Not sure this is the way to go // Array of validator functions. // These are added after checking for all possible constraints validators []validatorFunc // This is to make it easier to deal with true / false schemas boolean *bool // Unknown properties and their values are stored, so they can be marshalled unknownProps []*NamedValue /* Schema definition fields */ Schema *string `json:"$schema,omitempty"` ID *string `json:"$id,omitempty"` // NOTE: draft-04 has id instead if $id IDDraft04 *string `json:"id,omitempty"` // NOTE: draft-04 has id instead if $id Ref *Ref `json:"$ref,omitempty"` Comment *string `json:"$comment,omitempty"` Title *string `json:"title,omitempty"` Description *string `json:"description,omitempty"` Type *Type `json:"type,omitempty"` /* Common / shared */ // Must have at least 1 value Enum *Enum `json:"enum,omitempty"` Default *Value `json:"default,omitempty"` Examples *Values `json:"examples,omitempty"` // Draft 6 // Only allow 1 value Const *Value `json:"const,omitempty"` // Draft 7 ReadOnly *bool `json:"readOnly,omitempty"` WriteOnly *bool `json:"writeOnly,omitempty"` Definitions *Properties `json:"definitions,omitempty"` // If schemas should look something like (const being the important part): // { "if": { "properties": { "propertyX": { "const": "ValueX" } }, "required": ["propertyX"] } } If *Schema `json:"if,omitempty"` // One (or both?) of these can be omitted. // Both then and else will be ignore, if If is not defined. // If any of them are omitted, the value true is used in their place. // NOTE: It's not entirely obvious in the documentation, if both can be omitted: // https://json-schema.org/understanding-json-schema/reference/conditionals.html#if-then-else Then *Schema `json:"then,omitempty"` Else *Schema `json:"else,omitempty"` AllOf *Schemas `json:"allOf,omitempty"` AnyOf *Schemas `json:"anyOf,omitempty"` OneOf *Schemas `json:"oneOf,omitempty"` Not *Schema `json:"not,omitempty"` ContentEncoding *string `json:"contentEncoding,omitempty"` // e.g. base64 ContentMediaType *string `json:"contentMediaType,omitempty"` // e.g. image/png /* Objects */ Properties *Properties `json:"properties,omitempty"` // Draft 4 requires at least 1 string Required *Strings `json:"required,omitempty"` MaxProperties *int64 `json:"maxProperties,omitempty"` MinProperties *int64 `json:"minProperties,omitempty"` // Dependencies is either: // - if propertyX is set, then propertyY and propertyZ is required // e.g.: { "propertyX": ["propertyY", "propertyZ"] } // - if propertyX is set, then schemaX is also required to match // e.g.: { "propertyX": { "properties": { "propertyY": { "type": "string" } }, "required": ["propertyY"] } } Dependencies *Dependencies `json:"dependencies,omitempty"` // patternProperties is used to match property names against a regex and for each a schema. // It's basically a map of schemas, but with regex instead of property names. PatternProperties *Properties `json:"patternProperties,omitempty"` patternPropertiesRegexps *map[string]*regexp.Regexp // additionalProperties is a schema that will be used to validate any properties // in the instance that are not matched by properties or patternProperties. // Setting it to false means no additional properties will be allowed. AdditionalProperties *Schema `json:"additionalProperties,omitempty"` // // Draft 6 // Useful for enforcing a certain property name format // Property names implies { "type": "string" } // "propertyNames": { "pattern": "^[A-Za-z_][A-Za-z0-9_]*$"} PropertyNames *Schema `json:"propertyNames,omitempty"` /* Arrays */ // When items is an array of multiples Schemas, each refers to their own index. Items *Items `json:"items,omitempty"` // TODO: Can actually also be boolean MaxItems *int64 `json:"maxItems,omitempty"` MinItems *int64 `json:"minItems,omitempty"` UniqueItems *bool `json:"uniqueItems,omitempty"` // Should only be evaluated when items is multiple schemas. // Any values that does not have an explicit schmea (multi schema), // will validate according to this schema. // Setting it to false, means that no other values are allowed. AdditionalItems *Schema `json:"additionalItems,omitempty"` // contains only need to match 1 item in the documents array Contains *Schema `json:"contains,omitempty"` /* String */ MaxLength *int64 `json:"maxLength,omitempty"` MinLength *int64 `json:"minLength,omitempty"` Format *string `json:"format,omitempty"` Pattern *string `json:"pattern,omitempty"` patternRegexp *regexp.Regexp /* Integer / number */ // The type (int/float) should of course match the type of the property MultipleOf *json.Number `json:"multipleOf,omitempty"` // Draft 4: x ≥ minimum unless exclusiveMinimum == true, x ≤ maximum unless exclusiveMaximum == true // Draft 6: x ≥ minimum, x > exclusiveMinimum, x ≤ maximum, x < exclusiveMaximum Maximum *Value `json:"maximum,omitempty"` ExclusiveMaximum *Value `json:"exclusiveMaximum,omitempty"` // bool in draft 4 Minimum *Value `json:"minimum,omitempty"` ExclusiveMinimum *Value `json:"exclusiveMinimum,omitempty"` // bool in draft 4 } func (s *Schema) SetUnknown(name string, val *Value) error { for i, up := range s.unknownProps { if up.Name == name { s.unknownProps[i].Value = val return nil } } s.unknownProps = append(s.unknownProps, &NamedValue{Name: name, Value: val}) return nil } func (s *Schema) GetUnknown(name string) (*Value, error) { if s.unknownProps == nil { return nil, errors.New("unknown property not found") } for _, up := range s.unknownProps { if up.Name == name { return up.Value, nil } } return nil, errors.New("unknown property not found") } func (s Schema) MarshalJSON() ([]byte, error) { if s.boolean != nil { return []byte(strconv.FormatBool(*s.boolean)), nil } // Reset the refs' counters, if this is the root object being marshalled if s.root == nil && s.refs != nil { for _, ref := range *s.refs { ref.marshalled = 0 } } circularThreshold := s.circularThreshold if s.root != nil { circularThreshold = s.root.circularThreshold } if s.Ref != nil && s.Ref.Schema != nil && s.Ref.marshalled < circularThreshold { s.Ref.marshalled++ b, err := json.Marshal(tmpSchema(*s.Ref.Schema)) // TODO: Why is this set to 0??? s.Ref.marshalled = 0 return b, err } else if s.Ref != nil && s.Ref.String != nil { // All of the following is basically to make it possible to keep ignored properties // and marshal them back - otherwise we could just do this: // return []byte(fmt.Sprintf(`{"$ref": "%s"}`, *s.Ref.String)), nil // Make a copy of the schema newSchema, err := New(s.raw) if err != nil { return nil, err } // Remove any items, properties and definitions, that might hold more $refs // newSchema.Items = nil // newSchema.Properties = nil // newSchema.Definitions = nil // Set the ref again, but without the Schema part newSchema.Ref = &Ref{ String: s.Ref.String, } // Now marshal the new schema without refs return json.Marshal(tmpSchema(*newSchema)) } b, err := json.Marshal(tmpSchema(s)) // Set unknown properties for _, up := range s.unknownProps { val, err := up.Value.MarshalJSON() if err != nil { return nil, err } b, err = jsonparser.Set(b, val, up.Name) if err != nil { return nil, err } } return b, err } func (s *Schema) UnmarshalJSON(schema []byte) error { newSchema, err := New(schema) *s = *newSchema return err } func (s Schema) String() string { schema, err := s.MarshalJSON() if err != nil { return "" } return string(schema) } func (s Schema) Pretty() string { schema := s.String() var out bytes.Buffer json.Indent(&out, []byte(schema), "", " ") return out.String() } func (s *Schema) findPatternProperties(key []byte) []*Schema { if s.patternPropertiesRegexps == nil { return nil } schemas := []*Schema{} for reStr, re := range *s.patternPropertiesRegexps { if re.Match(key) { prop, ok := (*s.PatternProperties).GetProperty(reStr) if ok { schemas = append(schemas, prop.Property) } } } if len(schemas) > 0 { return schemas } return nil } func (s Schema) IsDraft4() bool { if s.Schema != nil { if *s.Schema == "http://json-schema.org/draft-04/schema#" { return true } if *s.Schema == "http://json-schema.org/draft-05/schema#" { // Draft 5 was a no-change patch for Draft 4 return true } if *s.Schema == "http://json-schema.org/schema#" { // Means "latest schema", this was deprectaed after Draft 4 return true } } return (s.Schema != nil && *s.Schema == "http://json-schema.org/draft-04/schema#") } func (s Schema) IsDraft6() bool { return (s.Schema != nil && *s.Schema == "http://json-schema.org/draft-06/schema#") } func (s Schema) IsDraft7() bool { return (s.Schema != nil && *s.Schema == "http://json-schema.org/draft-07/schema#") } func (s Schema) GetID() string { if s.ID != nil { return *s.ID } if s.IDDraft04 != nil { return *s.IDDraft04 } return "" } func (s *Schema) SetID(id string) { if s.IsDraft4() { *s.IDDraft04 = id } else { *s.ID = id } } // Checks if everything is nil and thereby an empty schema, similar to a "true" schema // TODO: Update with 20xx-xx props func (s Schema) IsEmpty() bool { return ((s.boolean == nil) && (s.unknownProps == nil) && (s.Schema == nil) && (s.ID == nil) && (s.IDDraft04 == nil) && (s.Ref == nil) && (s.Comment == nil) && (s.Title == nil) && (s.Description == nil) && (s.Type == nil) && (s.Enum == nil) && (s.Default == nil) && (s.Const == nil) && (s.Examples == nil) && (s.ReadOnly == nil) && (s.WriteOnly == nil) && (s.Definitions == nil) && (s.If == nil) && (s.Then == nil) && (s.Else == nil) && (s.AllOf == nil) && (s.AnyOf == nil) && (s.OneOf == nil) && (s.Not == nil) && (s.ContentEncoding == nil) && (s.ContentMediaType == nil) && (s.Properties == nil) && (s.Required == nil) && (s.MaxProperties == nil) && (s.MinProperties == nil) && (s.Dependencies == nil) && (s.PatternProperties == nil) && (s.AdditionalProperties == nil) && (s.PropertyNames == nil) && (s.Items == nil) && (s.MaxItems == nil) && (s.MinItems == nil) && (s.UniqueItems == nil) && (s.AdditionalItems == nil) && (s.Contains == nil) && (s.MaxLength == nil) && (s.MinLength == nil) && (s.Format == nil) && (s.Pattern == nil) && (s.MultipleOf == nil) && (s.Maximum == nil) && (s.ExclusiveMaximum == nil) && (s.Minimum == nil) && (s.ExclusiveMinimum == nil)) } golang-github-flowstack-go-jsonschema-0.1.2/schema_refs.go000066400000000000000000000176071426774651400236300ustar00rootroot00000000000000package jsonschema import ( "errors" "fmt" "io/ioutil" "net/http" "net/url" "strings" "github.com/buger/jsonparser" ) // Relevant docs: // https://json-schema.org/understanding-json-schema/structuring.html // Anything starting with # means: // Go to base schema -> find whatever is after # func unescapeRefPath(refPath string) string { var err error var ref, frag string refParts := strings.Split(refPath, "#") if len(refParts) == 1 { frag = refParts[0] } else if len(refParts) > 1 { ref = refParts[0] frag = strings.Join(refParts[1:], "#") } frag, err = url.QueryUnescape(frag) if err != nil { return "" } frag = strings.ReplaceAll(frag, "~0", "~") frag = strings.ReplaceAll(frag, "~1", "/") if ref != "" && frag != "" { return ref + "#" + frag } return ref + frag } func escapeRefPath(refPath string) string { var err error var ref, frag string refParts := strings.Split(refPath, "#") if len(refParts) == 1 { frag = refParts[0] } else if len(refParts) > 1 { ref = refParts[0] frag = strings.Join(refParts[1:], "#") } frag, err = url.QueryUnescape(frag) if err != nil { return "" } frag = strings.ReplaceAll(frag, "~", "~0") frag = strings.ReplaceAll(frag, "/", "~1") if ref != "" && frag != "" { return ref + "#" + frag } return ref + frag } // ExpandURI attempts to resolve a uri against the current Base URI func (s *Schema) ExpandURI(uri string) (*url.URL, error) { // If uri is empty, it is seen as invalid if len(uri) == 0 { return nil, errors.New("URI is invalid") } // If uri starts with #, it should not be expanded further if len(uri) > 0 && uri[:1] == "#" { return url.Parse(uri) } // Parse uri uriParsed, err := url.Parse(uri) if err != nil { return nil, errors.New("URI is invalid") } // If uri starts with http or https it is already expanded as much as possible if uriParsed.Scheme == "http" || uriParsed.Scheme == "https" { return uriParsed, nil } // Try to get the current Base URI var curBaseURI *url.URL if s != nil { if s.baseURI != nil { curBaseURI = s.baseURI } else if s.base != nil && s.base.baseURI != nil { curBaseURI = s.base.baseURI } } // If both Base URI and uri is valid, we'll merge and return the result if curBaseURI != nil { path := uriParsed.Path if uriParsed.Fragment != "" { path += "#" + uriParsed.Fragment } return curBaseURI.Parse(path) } // If Base URI is not found, uri is returned as is return uriParsed, nil } func (s *Schema) AddSchema(schema *Schema) error { return s.AddSchemaString(schema.String()) } func (s *Schema) AddSchemaString(schemaString string) error { if s == nil { return nil } _, err := s.Parse([]byte(schemaString)) return err } func (s *Schema) DeRef() error { var err error if s == nil { return nil } root := s if s.root != nil { root = s.root } if root.refs != nil { for _, ref := range *root.refs { if ref.Schema == nil { ref.Schema, err = ref.parent.ResolveRef(ref) if err != nil { return err } } } } return nil } func (s *Schema) ResolveRef(ref *Ref) (*Schema, error) { // If Schema is set, it's a cached version if ref.Schema != nil { return ref.Schema, nil } // If String is nil or empty, the $ref is invalid if ref.String == nil || len(*ref.String) == 0 { return nil, errors.New("$ref is invalid") } refStr := *ref.String baseSchema := s if s != nil && s.baseURI == nil && s.base != nil { baseSchema = s.base } // Check for base schema reference if refStr[:1] == "#" { // Check if this is a base schema reference with no path to a sub schema if refStr == "#" { return baseSchema, nil } if len(refStr) > 1 && refStr[:2] != "#/" { refSchema := baseSchema.getPointer(refStr) if refSchema != nil { return refSchema, nil } return nil, fmt.Errorf("unable to find ref: %s", refStr) } // Find the path pathParts := strings.Split(strings.Trim(refStr[1:], "/"), "/") if len(pathParts) == 0 { return baseSchema, nil } for i := 0; i < len(pathParts); i++ { pathParts[i] = unescapeRefPath(pathParts[i]) switch pathParts[i] { case "definitions": if i >= (len(pathParts) - 1) { return nil, errors.New("#/definitions is not a valid schema") } i++ pathParts[i] = unescapeRefPath(pathParts[i]) baseProp, ok := (*baseSchema.Definitions).GetProperty(pathParts[i]) if ok { baseSchema = baseProp.Property } case "properties": if i >= (len(pathParts) - 1) { return nil, errors.New("#/properties is not a valid schema") } i++ pathParts[i] = unescapeRefPath(pathParts[i]) baseProp, ok := (*baseSchema.Properties).GetProperty(pathParts[i]) if ok { baseSchema = baseProp.Property } case "items": if baseSchema.Items.Boolean != nil { baseSchema = &Schema{boolean: baseSchema.boolean} } else if baseSchema.Items.Schema != nil { baseSchema = baseSchema.Items.Schema } if i >= (len(pathParts) - 1) { return nil, errors.New("#/items is not a valid schema") } i++ idx, err := jsonparser.ParseInt([]byte(pathParts[i])) if err != nil { return nil, errors.New("unable to parse item's index") } baseSchema = (*baseSchema.Items.Schemas)[idx] default: if isInteger([]byte(pathParts[i])) { pathParts[i] = fmt.Sprintf("[%s]", pathParts[i]) } else { pathParts[i] = unescapeRefPath(pathParts[i]) } rawBase, _, _, err := jsonparser.Get(baseSchema.raw, pathParts[i]) if err != nil { return nil, fmt.Errorf("unable to find schema at path: %s", *ref.String) } baseSchema, err = baseSchema.Parse(rawBase) if err != nil { return nil, fmt.Errorf("unable to find schema at path: %s", *ref.String) } } } return baseSchema, nil } else { refURI, err := baseSchema.ExpandURI(refStr) if err != nil { return nil, err } switch refURI.String() { case "http://json-schema.org/draft-04/schema": baseSchema = Draft04Schema case "http://json-schema.org/draft-05/schema": baseSchema = Draft04Schema case "http://json-schema.org/schema": baseSchema = Draft04Schema case "http://json-schema.org/draft-06/schema": baseSchema = Draft06Schema case "http://json-schema.org/draft-07/schema": baseSchema = Draft07Schema default: if s != nil { frag := refURI.Fragment refURI.Fragment = "" baseSchema = s.getPointer(refURI.String()) if baseSchema != nil && frag != "" { frag = "#" + frag return baseSchema.ResolveRef(&Ref{String: &frag}) } refURI.Fragment = frag } } // Fetch the schema if baseSchema == nil { if err != nil { return nil, addError(errors.New("ref contains invalid URL"), err) } // TODO: We should probably accept query params schemaURL := fmt.Sprintf( "%s://%s%s%s", refURI.Scheme, refURI.User.String(), refURI.Host, refURI.Path, ) res, err := http.Get(schemaURL) if err != nil { return nil, err } body, err := ioutil.ReadAll(res.Body) if err != nil { return nil, err } res.Body.Close() // Add the $id to the schema, if it does not exist idKey := "$id" if s != nil && s.root != nil { if s.root.IsDraft4() { idKey = "id" } } _, _, _, err = jsonparser.Get(body, idKey) if err != nil { id := []byte(`"` + strings.ReplaceAll(schemaURL, `"`, `\"`) + `"`) body, err = jsonparser.Set(body, id, idKey) if err != nil { return nil, err } } baseSchema, err := baseSchema.Parse(body) if err != nil { return nil, err } refURI.Fragment = "" baseSchema.baseURI = refURI // log.Println(baseSchema) s.setPointer(refURI.String(), baseSchema) return baseSchema, nil } if baseSchema == nil { return nil, errors.New("unable to fetch the specified schema: " + refStr) } if refURI.Fragment != "" { fragment := fmt.Sprintf("#%s", refURI.Fragment) return baseSchema.ResolveRef(&Ref{String: &fragment}) } return baseSchema, err } } golang-github-flowstack-go-jsonschema-0.1.2/schema_refs_test.go000066400000000000000000000034231426774651400246560ustar00rootroot00000000000000package jsonschema import ( "testing" ) func TestAddSchema(t *testing.T) { var testSchema = `{"$id":"http://example.com/schemas/thing","properties":{"id":{"type":"number"},"item":{"$ref":"http://example.com/schemas/item"}}}` var testRefSchemaItem = `{"$id":"http://example.com/schemas/item","properties":{"id":{"type":"number"},"label":{"type":"string"},"subitem1":{"$ref":"http://example.com/schemas/subitem"},"subitem2":{"$ref":"http://example.com/schemas/subitem"}}}` var testRefSchemaSubitem = `{"$id":"http://example.com/schemas/subitem","properties":{"id":{"type":"number"},"label":{"type":"string"}}}` var testDoc = `{"id":123,"item":{"id":321,"label":"item","subitem1":{"id":789,"label":"subitem1"},"subitem2":{"id":987,"label":"subitem2"}}}` var testDocInvalid = `{"id":123,"item":{"id":321,"label":"item","subitem1":{"id":789,"label":"subitem1"},"subitem2":{"id":"987","label":"subitem2"}}}` var expectedError = `value "987" is of type string, but should be of type: number` schema, err := NewFromString(testSchema) if err != nil { t.Fatal(err) } // Add the last / deepest schema first to test the logic works correctly err = schema.AddSchemaString(testRefSchemaSubitem) if err != nil { t.Fatal(err) } err = schema.AddSchemaString(testRefSchemaItem) if err != nil { t.Fatal(err) } err = schema.DeRef() if err != nil { t.Fatal(err) } valid, err := schema.Validate([]byte(testDoc)) if err != nil { t.Fatalf(`expected error to be empty, got: %s`, err.Error()) } else if !valid { t.Fatal(`expected document to be valid`) } valid, err = schema.Validate([]byte(testDocInvalid)) if err == nil || err.Error() != expectedError { t.Fatalf(`unexpected empty error, expected: %s`, expectedError) } else if valid { t.Fatal(`expected document to be invalid`) } } golang-github-flowstack-go-jsonschema-0.1.2/schema_test.go000066400000000000000000000060711426774651400236410ustar00rootroot00000000000000package jsonschema import ( "encoding/json" "errors" "testing" ) func TestBooleanSchema(t *testing.T) { var testSchema = `true` schema, err := NewFromString(testSchema) if err != nil { t.Fatal(err) } newSchema, err := json.Marshal(schema) if err != nil { t.Fatal(err) } if testSchema != string(newSchema) { t.Fatalf("expected schemas to be equal, but got:\nexpected:\n%s\nactual:\n%s \n", testSchema, string(newSchema)) } } func TestParserSimple(t *testing.T) { var testSchema = `{"$id":"bla","const":null,"properties":{"bla":{"type":["string","null"]},"yadda":{"enum":["abc",123,1.23,null,false]}}}` schema, err := NewFromString(testSchema) if err != nil { t.Fatal(err) } newSchema, err := json.Marshal(schema) if err != nil { t.Fatal(err) } if testSchema != string(newSchema) { t.Fatalf("expected schemas to be equal, but got:\nexpected:\n%s\nactual:\n%s \n", testSchema, string(newSchema)) } } func TestParserKeepSorting(t *testing.T) { var testSchema = `{"$id":"bla","const":null,"properties":{"yadda":{"type":["string","null"]},"bla":{"enum":["abc",123,1.23,null,false]}}}` schema, err := NewFromString(testSchema) if err != nil { t.Fatal(err) } parsedSchema := schema.String() if testSchema != parsedSchema { t.Fatalf("expected schemas to be equal, but got:\nexpected:\n%s\nactual:\n%s \n", testSchema, parsedSchema) } } func TestItems(t *testing.T) { var testSchema = `{"properties":{"itemField":{"type":"array","items":{"type":"string"}},"itemsField":{"type":"array","items":[{"type":"string"}]}}}` schema, err := NewFromString(testSchema) if err != nil { t.Fatal(err) } newSchema, err := json.Marshal(schema) if err != nil { t.Fatal(err) } if testSchema != string(newSchema) { t.Fatalf("expected schemas to be equal, but got:\nexpected:\n%s\nactual:\n%s \n", testSchema, string(newSchema)) } } func TestUnknowns(t *testing.T) { var testSchema = `{"someField":"someName","stringField":{"type":"string"}}` schema, err := NewFromString(testSchema) if err != nil { t.Fatal(err) } someField, err := schema.GetUnknown("someField") if err != nil { t.Fatal(err) } if someField == nil { t.Fatal(errors.New("unknown property someField is nil")) } if someField.String == nil { t.Fatal(errors.New("unknown property someField is not a string")) } if *someField.String != "someName" { t.Fatal(errors.New(`unknown property someField is not "someName"`)) } stringField, err := schema.GetUnknown("stringField") if err != nil { t.Fatal(err) } if stringField == nil { t.Fatal(errors.New("unknown property stringField is nil")) } if stringField.Object == nil { t.Fatal(errors.New("unknown property stringField is not an object")) } if typ, ok := (*stringField.Object)["type"]; !ok || *typ.String != "string" { t.Fatal(errors.New(`unknown property stringField type is not "string"`)) } newSchema, err := json.Marshal(schema) if err != nil { t.Fatal(err) } if testSchema != string(newSchema) { t.Fatalf("expected schemas to be equal, but got:\nexpected:\n%s\nactual:\n%s \n", testSchema, string(newSchema)) } } golang-github-flowstack-go-jsonschema-0.1.2/schema_types.go000066400000000000000000000335311426774651400240270ustar00rootroot00000000000000package jsonschema import ( "bytes" "encoding/json" "fmt" "log" "strings" "github.com/buger/jsonparser" ) type refs []*Ref func (r *refs) String() string { str := "" if r != nil { for _, r := range *r { if r != nil && r.String != nil { str += fmt.Sprintf("ref %s\n", *r.String) } else { str += "empty ref found\n" } } } return str } type pointers map[string]*Schema func (p *pointers) String() string { str := "" if p != nil { for k, s := range *p { if s != nil { str += fmt.Sprintf("pointer for %s\n%s\n", k, s.String()) } else { str += fmt.Sprintf("pointer for %s is empty\n", k) } } } return str } type ValueType uint8 type SchemaProp uint8 // These are the same as jsonparser.ValueType - except Integer, which jsonparser does not have const ( NotExist ValueType = iota String Number Object Array Boolean Null Unknown Integer ) func (v ValueType) String() string { switch v { case NotExist: return "non-existent" case String: return "string" case Number: return "number" case Integer: return "integer" case Object: return "object" case Array: return "array" case Boolean: return "boolean" case Null: return "null" case Unknown: fallthrough default: return "unknown" } } func (v ValueType) ParserValueType() jsonparser.ValueType { switch v { case NotExist: return jsonparser.NotExist case String: return jsonparser.String case Number: return jsonparser.Number case Integer: return jsonparser.Number case Object: return jsonparser.Object case Array: return jsonparser.Array case Boolean: return jsonparser.Boolean case Null: return jsonparser.Null case Unknown: fallthrough default: return jsonparser.Unknown } } // TODO: Update with 20xx-xx props const ( PropSchema SchemaProp = iota PropID PropIDDraft04 PropRef PropComment PropTitle PropDescription PropType PropEnum PropDefault PropConst PropExamples PropReadOnly PropWriteOnly PropDefinitions PropIf PropThen PropElse PropAllOf PropAnyOf PropOneOf PropNot PropContentEncoding PropContentMediaType PropProperties PropRequired PropMaxProperties PropMinProperties PropDependencies PropPatternProperties PropAdditionalProperties PropPropertyNames PropItems PropMaxItems PropMinItems PropUniqueItems PropAdditionalItems PropContains PropMaxLength PropMinLength PropFormat PropPattern PropMultipleOf PropMaximum PropExclusiveMaximum PropMinimum PropExclusiveMinimum ) // TODO: Update with 20xx-xx props var propNames = [][]string{ PropSchema: {"$schema"}, PropID: {"$id"}, PropIDDraft04: {"id"}, PropRef: {"$ref"}, PropComment: {"$comment"}, PropTitle: {"title"}, PropDescription: {"description"}, PropType: {"type"}, PropEnum: {"enum"}, PropDefault: {"default"}, PropConst: {"const"}, PropExamples: {"examples"}, PropReadOnly: {"readOnly"}, PropWriteOnly: {"writeOnly"}, PropDefinitions: {"definitions"}, PropIf: {"if"}, PropThen: {"then"}, PropElse: {"else"}, PropAllOf: {"allOf"}, PropAnyOf: {"anyOf"}, PropOneOf: {"oneOf"}, PropNot: {"not"}, PropContentEncoding: {"contentEncoding"}, PropContentMediaType: {"contentMediaType"}, PropProperties: {"properties"}, PropRequired: {"required"}, PropMaxProperties: {"maxProperties"}, PropMinProperties: {"minProperties"}, PropDependencies: {"dependencies"}, PropPatternProperties: {"patternProperties"}, PropAdditionalProperties: {"additionalProperties"}, PropPropertyNames: {"propertyNames"}, PropItems: {"items"}, PropMaxItems: {"maxItems"}, PropMinItems: {"minItems"}, PropUniqueItems: {"uniqueItems"}, PropAdditionalItems: {"additionalItems"}, PropContains: {"contains"}, PropMaxLength: {"maxLength"}, PropMinLength: {"minLength"}, PropFormat: {"format"}, PropPattern: {"pattern"}, PropMultipleOf: {"multipleOf"}, PropMaximum: {"maximum"}, PropExclusiveMaximum: {"exclusiveMaximum"}, PropMinimum: {"minimum"}, PropExclusiveMinimum: {"exclusiveMinimum"}, } // TODO: Update with 20xx-xx props var nameToProp = map[string]SchemaProp{ "$schema": PropSchema, "$id": PropID, "id": PropIDDraft04, "$ref": PropRef, "$comment": PropComment, "title": PropTitle, "description": PropDescription, "type": PropType, "enum": PropEnum, "default": PropDefault, "const": PropConst, "examples": PropExamples, "readOnly": PropReadOnly, "writeOnly": PropWriteOnly, "definitions": PropDefinitions, "if": PropIf, "then": PropThen, "else": PropElse, "allOf": PropAllOf, "anyOf": PropAnyOf, "oneOf": PropOneOf, "not": PropNot, "contentEncoding": PropContentEncoding, "contentMediaType": PropContentMediaType, "properties": PropProperties, "required": PropRequired, "maxProperties": PropMaxProperties, "minProperties": PropMinProperties, "dependencies": PropDependencies, "patternProperties": PropPatternProperties, "additionalProperties": PropAdditionalProperties, "propertyNames": PropPropertyNames, "items": PropItems, "maxItems": PropMaxItems, "minItems": PropMinItems, "uniqueItems": PropUniqueItems, "additionalItems": PropAdditionalItems, "contains": PropContains, "maxLength": PropMaxLength, "minLength": PropMinLength, "format": PropFormat, "pattern": PropPattern, "multipleOf": PropMultipleOf, "maximum": PropMaximum, "exclusiveMaximum": PropExclusiveMaximum, "minimum": PropMinimum, "exclusiveMinimum": PropExclusiveMinimum, } func NewStringPtr(b []byte) *string { unescaped, err := jsonparser.Unescape(b, nil) if err != nil { return nil } tmpStr := string(unescaped) return &tmpStr } // func (e Ref) MarshalJSON() ([]byte, error) { // b, err := json.Marshal(tmpEnum(e)) // return b,err // } type Enum []*Value type tmpEnum Enum // To ensure MarshalJSON doesn't go haywire func (e Enum) MarshalJSON() ([]byte, error) { b, err := json.Marshal(tmpEnum(e)) return b, err } func NewEnum(jsonVal []byte, vt jsonparser.ValueType) (*Enum, error) { var errs error if vt == jsonparser.Array { enum := Enum{} jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } val, err := NewValue(value, dataType) if err != nil { errs = addError(err, errs) return } enum = append(enum, val) }) if errs != nil { return nil, errs } return &enum, nil } return nil, fmt.Errorf("expected enum to be an array, got: %s", vt.String()) } type Dependencies map[string]*Dependency type tmpDependencies Dependencies // To ensure MarshalJSON doesn't go haywire func (d Dependencies) MarshalJSON() ([]byte, error) { b, err := json.Marshal(tmpDependencies(d)) return b, err } func NewDependencies(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Dependencies, error) { if vt == jsonparser.Object { dependencies := Dependencies{} err := jsonparser.ObjectEach(jsonVal, func(key []byte, value []byte, dataType jsonparser.ValueType, offset int) error { var err error dependencies[string(key)], err = NewDependency(value, dataType, parentSchema) return err }) if err != nil { return nil, err } return &dependencies, nil } return nil, fmt.Errorf("expected properties to be object, got: %s", vt.String()) } // Properties are build like this, instead of map[string]*Schema, // to make it possible to Marshal with original sort order of fields type NamedProperty struct { Name string Property *Schema } type Properties []*NamedProperty // type tmpProperties Properties // To ensure MarshalJSON doesn't go haywire func (p Properties) GetProperty(name string) (*NamedProperty, bool) { for _, prop := range p { if prop.Name == name { return prop, true } } return nil, false } func (p Properties) MarshalJSON() ([]byte, error) { propsData := []byte("{") buf := bytes.NewBuffer(propsData) for i, prop := range p { fieldVal, err := json.Marshal(prop.Property) if err != nil { log.Println(err) return nil, err } escapedFieldName := strings.ReplaceAll(prop.Name, `\`, `\\`) escapedFieldName = strings.ReplaceAll(escapedFieldName, `"`, `\"`) escapedFieldName = strings.ReplaceAll(escapedFieldName, "\n", `\n`) escapedFieldName = strings.ReplaceAll(escapedFieldName, "\r", `\r`) escapedFieldName = strings.ReplaceAll(escapedFieldName, "\t", `\t`) escapedFieldName = strings.ReplaceAll(escapedFieldName, "\f", `\u000c`) fmt.Fprintf(buf, `"%s": %s`, escapedFieldName, string(fieldVal)) if i < len(p)-1 { fmt.Fprint(buf, `,`) } } fmt.Fprint(buf, `}`) return buf.Bytes(), nil } func NewProperties(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Properties, error) { if vt == jsonparser.Object { props := Properties{} err := jsonparser.ObjectEach(jsonVal, func(key []byte, value []byte, dataType jsonparser.ValueType, offset int) error { var err error prop := &NamedProperty{ Name: string(key), } prop.Property, err = parentSchema.Parse(value) if err != nil { return err } props = append(props, prop) return err }) if err != nil { return nil, err } return &props, nil } return nil, fmt.Errorf("expected properties to be object, got: %s", vt.String()) } // type Definitions map[string]*Schema // type tmpDefinitions Definitions // To ensure MarshalJSON doesn't go haywire // func (p Definitions) MarshalJSON() ([]byte, error) { // b, err := json.Marshal(tmpDefinitions(p)) // return b, err // } // func NewDefinitions(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Properties, error) { // if vt == jsonparser.Object { // props := Properties{schemas: map[string]*Schema{}, sortedFields: []string{}} // err := jsonparser.ObjectEach(jsonVal, func(key []byte, value []byte, dataType jsonparser.ValueType, offset int) error { // var err error // props.schemas[string(key)], err = parentSchema.Parse(value) // props.sortedFields = append(props.sortedFields, string(key)) // return err // }) // if err != nil { // return nil, err // } // return &props, nil // } // return nil, fmt.Errorf("expected properties to be object, got: %s", vt.String()) // } type Schemas []*Schema type tmpSchemas Schemas // To ensure MarshalJSON doesn't go haywire func (s Schemas) MarshalJSON() ([]byte, error) { b, err := json.Marshal(tmpSchemas(s)) return b, err } func NewSubSchemas(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Schemas, error) { var errs error if vt == jsonparser.Array { schemas := Schemas{} jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } if dataType == jsonparser.Object || dataType == jsonparser.Boolean { schema, err := parentSchema.Parse(value) if err != nil { errs = addError(err, errs) return } schemas = append(schemas, schema) } else { errs = addError(fmt.Errorf("expected type to be object or boolean, got: %s", vt.String()), errs) } }) if errs != nil { return nil, errs } return &schemas, nil } return nil, fmt.Errorf("expected enum to be an array, got: %s", vt.String()) } type Strings []*string type tmpStrings Strings // To ensure MarshalJSON doesn't go haywire func (p Strings) MarshalJSON() ([]byte, error) { b, err := json.Marshal(tmpStrings(p)) return b, err } func NewStrings(jsonVal []byte, vt jsonparser.ValueType) (*Strings, error) { var errs error if vt == jsonparser.Array { strings := Strings{} jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } if dataType == jsonparser.String { unescaped, err := jsonparser.Unescape(value, nil) if err != nil { errs = addError(parseErr, errs) return } tmpStr := string(unescaped) strings = append(strings, &tmpStr) } else { errs = addError(fmt.Errorf("expected type to be string, got: %s", vt.String()), errs) } }) if errs != nil { return nil, errs } return &strings, nil } return nil, fmt.Errorf("expected enum to be an array, got: %s", vt.String()) } type Values []*Value type tmpValues Values // To ensure MarshalJSON doesn't go haywire func (v Values) MarshalJSON() ([]byte, error) { b, err := json.Marshal(tmpValues(v)) return b, err } func NewValues(jsonVal []byte, vt jsonparser.ValueType) (*Values, error) { var errs error if vt == jsonparser.Array { values := Values{} jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } val, err := NewValue(value, dataType) if err != nil { errs = addError(err, errs) return } values = append(values, val) }) if errs != nil { return nil, errs } return &values, nil } return nil, fmt.Errorf("expected enum to be an array, got: %s", vt.String()) } golang-github-flowstack-go-jsonschema-0.1.2/schema_types_oneof.go000066400000000000000000000166221426774651400252170ustar00rootroot00000000000000package jsonschema import ( "bytes" "encoding/json" "errors" "fmt" "math/big" "reflect" "github.com/buger/jsonparser" ) type Ref struct { String *string Schema *Schema `json:"-"` // This is needed for de-ref'ing parent *Schema // This is needed for marshalling marshalled int } func (r Ref) MarshalJSON() ([]byte, error) { if r.String != nil { b, err := json.Marshal(r.String) return b, err } return nil, nil } func NewRef(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Ref, error) { if parentSchema == nil { return nil, errors.New("unable to set ref on non-existing schema") } // Anything but a string is an error if vt != jsonparser.String { return nil, errors.New("unable to parse 1ref") } tmpVal := string(jsonVal) ref := &Ref{ String: &tmpVal, parent: parentSchema, } parentSchema.setRef(ref) return ref, nil } type Type struct { String *string Strings *[]*string } func (t *Type) Has(vt ValueType) bool { if t == nil { return false } if t.String != nil { if vt.String() == *t.String { return true } } else if t.Strings != nil { for _, str := range *t.Strings { if vt.String() == *str { return true } } } return false } func (t Type) MarshalJSON() ([]byte, error) { if t.String != nil { b, err := json.Marshal(t.String) return b, err } else if t.Strings != nil { b, err := json.Marshal(t.Strings) return b, err } return nil, nil } func NewType(jsonVal []byte, vt jsonparser.ValueType) (*Type, error) { if vt == jsonparser.Array { typ := &Type{Strings: &[]*string{}} var errs error jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } tmpVal := string(value) *typ.Strings = append(*typ.Strings, &tmpVal) }) return typ, errs } else { tmpVal := string(jsonVal) return &Type{String: &tmpVal}, nil } } type Items struct { Schema *Schema Schemas *Schemas Boolean *bool } func (i Items) MarshalJSON() ([]byte, error) { if i.Schema != nil { b, err := json.Marshal(i.Schema) return b, err } else if i.Schemas != nil { b, err := json.Marshal(i.Schemas) return b, err } else if i.Boolean != nil { b, err := json.Marshal(i.Boolean) return b, err } return nil, nil } func NewItems(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Items, error) { var err error items := Items{} var errs error switch vt { case jsonparser.Object: items.Schema, err = parentSchema.Parse(jsonVal) if err != nil { errs = addError(err, errs) } case jsonparser.Array: items.Schemas, err = NewSubSchemas(jsonVal, vt, parentSchema) if err != nil { errs = addError(err, errs) } case jsonparser.Boolean: var tmpBool bool tmpBool, err = jsonparser.ParseBoolean(jsonVal) if err != nil { errs = addError(err, errs) } items.Boolean = &tmpBool default: errs = addError(fmt.Errorf("expected an object, got: %s", vt.String()), errs) } if errs != nil { return nil, errs } return &items, nil } type Dependency struct { Schema *Schema Strings *Strings } func (i Dependency) MarshalJSON() ([]byte, error) { if i.Schema != nil { b, err := json.Marshal(i.Schema) return b, err } else if i.Strings != nil { b, err := json.Marshal(i.Strings) return b, err } return nil, nil } func NewDependency(jsonVal []byte, vt jsonparser.ValueType, parentSchema *Schema) (*Dependency, error) { var err error dependency := Dependency{} var errs error switch vt { case jsonparser.Boolean: fallthrough case jsonparser.Object: dependency.Schema, err = parentSchema.Parse(jsonVal) if err != nil { errs = addError(err, errs) } case jsonparser.Array: strings := Strings{} jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } if dataType == jsonparser.String { strings = append(strings, NewStringPtr(value)) } else { errs = addError(fmt.Errorf("expected a string, got: %s", dataType.String()), errs) } }) dependency.Strings = &strings default: errs = addError(fmt.Errorf("expected an array or object, got: %s", vt.String()), errs) } if errs != nil { return nil, errs } return &dependency, nil } type Value struct { String *string Number *big.Float Boolean *bool Null *bool Object *map[string]*Value Array *[]*Value raw []byte valueType ValueType } func (v Value) Raw() []byte { return v.raw } func (v Value) MarshalJSON() ([]byte, error) { if v.String != nil { return json.Marshal(v.String) } else if v.Number != nil { return []byte(v.Number.Text('g', -1)), nil } else if v.Boolean != nil { return json.Marshal(v.Boolean) } else if v.Null != nil { return []byte("null"), nil } else if v.Object != nil { return json.Marshal(v.Object) } else if v.Array != nil { return json.Marshal(v.Array) } return nil, nil } func NewValue(jsonVal []byte, vt jsonparser.ValueType) (*Value, error) { var err error val := Value{valueType: ValueType(vt)} if vt == jsonparser.Object || vt == jsonparser.Array { buf := &bytes.Buffer{} json.Compact(buf, jsonVal) val.raw = buf.Bytes() } else { val.raw = jsonVal } switch vt { case jsonparser.String: var str string str, err = jsonparser.ParseString(jsonVal) val.String = &str case jsonparser.Number: var num *big.Float num, ok := new(big.Float).SetString(string(jsonVal)) if !ok { err = errors.New("unable to parse value as number") } val.Number = num case jsonparser.Boolean: var boolean bool boolean, err = jsonparser.ParseBoolean(jsonVal) val.Boolean = &boolean case jsonparser.Null: null := true val.Null = &null case jsonparser.Object: val.raw = sortObject(val.raw) tmpObject := map[string]*Value{} err := jsonparser.ObjectEach(jsonVal, func(key []byte, value []byte, dataType jsonparser.ValueType, offset int) error { var err error tmpObject[string(key)], err = NewValue(value, dataType) return err }) if err != nil { return nil, err } val.Object = &tmpObject case jsonparser.Array: tmpArray := []*Value{} var errs error jsonparser.ArrayEach(jsonVal, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { if parseErr != nil { errs = addError(parseErr, errs) return } tmpVal, err := NewValue(value, dataType) if err != nil { errs = addError(err, errs) return } tmpArray = append(tmpArray, tmpVal) }) if errs != nil { return nil, errs } val.Array = &tmpArray default: return nil, fmt.Errorf("unexpexted type: %s", vt.String()) } if err != nil { return nil, err } return &val, nil } func (v *Value) Equal(val *Value) bool { if v == nil && val == nil { return true } if v != nil && val == nil { return false } if v.String != nil && val.String != nil { return (*v.String == *val.String) } if v.Number != nil && val.Number != nil { return v.Number.Cmp(val.Number) == 0 } if v.Boolean != nil && val.Boolean != nil { return (*v.Boolean == *val.Boolean) } if v.Null != nil && val.Null != nil { return (*v.Null == *val.Null) } if v.Object != nil && val.Object != nil { return reflect.DeepEqual(*v.Object, *val.Object) } if v.Array != nil && val.Array != nil { return reflect.DeepEqual(*v.Array, *val.Array) } return false } type NamedValue struct { Name string *Value } golang-github-flowstack-go-jsonschema-0.1.2/schemas.go000066400000000000000000000020261426774651400227610ustar00rootroot00000000000000package jsonschema import ( _ "embed" "fmt" ) // TODO: Update with 20xx-xx props var ( //go:embed schemas/draft-04.json draft04Source []byte //go:embed schemas/draft-06.json draft06Source []byte //go:embed schemas/draft-07.json draft07Source []byte Draft04Schema *Schema Draft06Schema *Schema Draft07Schema *Schema ) func init() { if draft04Source == nil { panic("can't start without schemas/draft-04.json") } if draft06Source == nil { panic("can't start without schemas/draft-06.json") } if draft07Source == nil { panic("can't start without schemas/draft-07.json") } var err error Draft04Schema, err = New(draft04Source) if err != nil { panic(fmt.Errorf("can't start without schemas/draft-04.json\n%s", err.Error())) } Draft06Schema, err = New(draft06Source) if err != nil { panic(fmt.Errorf("can't start without schemas/draft-06.json\n%s", err.Error())) } Draft07Schema, err = New(draft07Source) if err != nil { panic(fmt.Errorf("can't start without schemas/draft-07.json\n%s", err.Error())) } } golang-github-flowstack-go-jsonschema-0.1.2/schemas/000077500000000000000000000000001426774651400224325ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/schemas/draft-04.json000066400000000000000000000104051426774651400246460ustar00rootroot00000000000000{ "id": "http://json-schema.org/draft-04/schema#", "$schema": "http://json-schema.org/draft-04/schema#", "description": "Core schema meta-schema", "definitions": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$ref": "#" } }, "positiveInteger": { "type": "integer", "minimum": 0 }, "positiveIntegerDefault0": { "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ] }, "simpleTypes": { "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] }, "stringArray": { "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true } }, "type": "object", "properties": { "id": { "type": "string" }, "$schema": { "type": "string" }, "title": { "type": "string" }, "description": { "type": "string" }, "default": {}, "multipleOf": { "type": "number", "minimum": 0, "exclusiveMinimum": true }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "boolean", "default": false }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "boolean", "default": false }, "maxLength": { "$ref": "#/definitions/positiveInteger" }, "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "additionalItems": { "anyOf": [ { "type": "boolean" }, { "$ref": "#" } ], "default": {} }, "items": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/schemaArray" } ], "default": {} }, "maxItems": { "$ref": "#/definitions/positiveInteger" }, "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "maxProperties": { "$ref": "#/definitions/positiveInteger" }, "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" }, "required": { "$ref": "#/definitions/stringArray" }, "additionalProperties": { "anyOf": [ { "type": "boolean" }, { "$ref": "#" } ], "default": {} }, "definitions": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "properties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "dependencies": { "type": "object", "additionalProperties": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/stringArray" } ] } }, "enum": { "type": "array", "minItems": 1, "uniqueItems": true }, "type": { "anyOf": [ { "$ref": "#/definitions/simpleTypes" }, { "type": "array", "items": { "$ref": "#/definitions/simpleTypes" }, "minItems": 1, "uniqueItems": true } ] }, "format": { "type": "string" }, "allOf": { "$ref": "#/definitions/schemaArray" }, "anyOf": { "$ref": "#/definitions/schemaArray" }, "oneOf": { "$ref": "#/definitions/schemaArray" }, "not": { "$ref": "#" } }, "dependencies": { "exclusiveMaximum": [ "maximum" ], "exclusiveMinimum": [ "minimum" ] }, "default": {} } golang-github-flowstack-go-jsonschema-0.1.2/schemas/draft-06.json000066400000000000000000000106211426774651400246500ustar00rootroot00000000000000{ "$schema": "http://json-schema.org/draft-06/schema#", "$id": "http://json-schema.org/draft-06/schema#", "title": "Core schema meta-schema", "definitions": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$ref": "#" } }, "nonNegativeInteger": { "type": "integer", "minimum": 0 }, "nonNegativeIntegerDefault0": { "allOf": [ { "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 } ] }, "simpleTypes": { "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] }, "stringArray": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] } }, "type": ["object", "boolean"], "properties": { "$id": { "type": "string", "format": "uri-reference" }, "$schema": { "type": "string", "format": "uri" }, "$ref": { "type": "string", "format": "uri-reference" }, "title": { "type": "string" }, "description": { "type": "string" }, "default": {}, "examples": { "type": "array", "items": {} }, "multipleOf": { "type": "number", "exclusiveMinimum": 0 }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "number" }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "number" }, "maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "additionalItems": { "$ref": "#" }, "items": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/schemaArray" } ], "default": {} }, "maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "contains": { "$ref": "#" }, "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "required": { "$ref": "#/definitions/stringArray" }, "additionalProperties": { "$ref": "#" }, "definitions": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "properties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$ref": "#" }, "propertyNames": { "format": "regex" }, "default": {} }, "dependencies": { "type": "object", "additionalProperties": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/stringArray" } ] } }, "propertyNames": { "$ref": "#" }, "const": {}, "enum": { "type": "array", "minItems": 1, "uniqueItems": true }, "type": { "anyOf": [ { "$ref": "#/definitions/simpleTypes" }, { "type": "array", "items": { "$ref": "#/definitions/simpleTypes" }, "minItems": 1, "uniqueItems": true } ] }, "format": { "type": "string" }, "allOf": { "$ref": "#/definitions/schemaArray" }, "anyOf": { "$ref": "#/definitions/schemaArray" }, "oneOf": { "$ref": "#/definitions/schemaArray" }, "not": { "$ref": "#" } }, "default": {} } golang-github-flowstack-go-jsonschema-0.1.2/schemas/draft-07.json000066400000000000000000000115631426774651400246570ustar00rootroot00000000000000{ "$schema": "http://json-schema.org/draft-07/schema#", "$id": "http://json-schema.org/draft-07/schema#", "title": "Core schema meta-schema", "definitions": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$ref": "#" } }, "nonNegativeInteger": { "type": "integer", "minimum": 0 }, "nonNegativeIntegerDefault0": { "allOf": [ { "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 } ] }, "simpleTypes": { "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] }, "stringArray": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] } }, "type": ["object", "boolean"], "properties": { "$id": { "type": "string", "format": "uri-reference" }, "$schema": { "type": "string", "format": "uri" }, "$ref": { "type": "string", "format": "uri-reference" }, "$comment": { "type": "string" }, "title": { "type": "string" }, "description": { "type": "string" }, "default": true, "readOnly": { "type": "boolean", "default": false }, "writeOnly": { "type": "boolean", "default": false }, "examples": { "type": "array", "items": true }, "multipleOf": { "type": "number", "exclusiveMinimum": 0 }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "number" }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "number" }, "maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "additionalItems": { "$ref": "#" }, "items": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/schemaArray" } ], "default": true }, "maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "contains": { "$ref": "#" }, "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "required": { "$ref": "#/definitions/stringArray" }, "additionalProperties": { "$ref": "#" }, "definitions": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "properties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$ref": "#" }, "propertyNames": { "format": "regex" }, "default": {} }, "dependencies": { "type": "object", "additionalProperties": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/stringArray" } ] } }, "propertyNames": { "$ref": "#" }, "const": true, "enum": { "type": "array", "items": true, "minItems": 1, "uniqueItems": true }, "type": { "anyOf": [ { "$ref": "#/definitions/simpleTypes" }, { "type": "array", "items": { "$ref": "#/definitions/simpleTypes" }, "minItems": 1, "uniqueItems": true } ] }, "format": { "type": "string" }, "contentMediaType": { "type": "string" }, "contentEncoding": { "type": "string" }, "if": { "$ref": "#" }, "then": { "$ref": "#" }, "else": { "$ref": "#" }, "allOf": { "$ref": "#/definitions/schemaArray" }, "anyOf": { "$ref": "#/definitions/schemaArray" }, "oneOf": { "$ref": "#/definitions/schemaArray" }, "not": { "$ref": "#" } }, "default": true } golang-github-flowstack-go-jsonschema-0.1.2/schemas/draft-2019-09.json000066400000000000000000000033711426774651400252500ustar00rootroot00000000000000{ "$schema": "https://json-schema.org/draft/2019-09/schema", "$id": "https://json-schema.org/draft/2019-09/schema", "$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/core": true, "https://json-schema.org/draft/2019-09/vocab/applicator": true, "https://json-schema.org/draft/2019-09/vocab/validation": true, "https://json-schema.org/draft/2019-09/vocab/meta-data": true, "https://json-schema.org/draft/2019-09/vocab/format": false, "https://json-schema.org/draft/2019-09/vocab/content": true }, "$recursiveAnchor": true, "title": "Core and Validation specifications meta-schema", "allOf": [ {"$ref": "meta/core"}, {"$ref": "meta/applicator"}, {"$ref": "meta/validation"}, {"$ref": "meta/meta-data"}, {"$ref": "meta/format"}, {"$ref": "meta/content"} ], "type": ["object", "boolean"], "properties": { "definitions": { "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.", "type": "object", "additionalProperties": { "$recursiveRef": "#" }, "default": {} }, "dependencies": { "$comment": "\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"", "type": "object", "additionalProperties": { "anyOf": [ { "$recursiveRef": "#" }, { "$ref": "meta/validation#/$defs/stringArray" } ] } } } } golang-github-flowstack-go-jsonschema-0.1.2/schemas/draft-2020-12.json000066400000000000000000000046241426774651400252340ustar00rootroot00000000000000{ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/schema", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true, "https://json-schema.org/draft/2020-12/vocab/applicator": true, "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, "https://json-schema.org/draft/2020-12/vocab/validation": true, "https://json-schema.org/draft/2020-12/vocab/meta-data": true, "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, "https://json-schema.org/draft/2020-12/vocab/content": true }, "$dynamicAnchor": "meta", "title": "Core and Validation specifications meta-schema", "allOf": [ {"$ref": "meta/core"}, {"$ref": "meta/applicator"}, {"$ref": "meta/unevaluated"}, {"$ref": "meta/validation"}, {"$ref": "meta/meta-data"}, {"$ref": "meta/format-annotation"}, {"$ref": "meta/content"} ], "type": ["object", "boolean"], "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.", "properties": { "definitions": { "$comment": "\"definitions\" has been replaced by \"$defs\".", "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "deprecated": true, "default": {} }, "dependencies": { "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.", "type": "object", "additionalProperties": { "anyOf": [ { "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" } ] }, "deprecated": true, "default": {} }, "$recursiveAnchor": { "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".", "$ref": "meta/core#/$defs/anchorString", "deprecated": true }, "$recursiveRef": { "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".", "$ref": "meta/core#/$defs/uriReferenceString", "deprecated": true } } } golang-github-flowstack-go-jsonschema-0.1.2/testdata/000077500000000000000000000000001426774651400226205ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft-04.schema.json000066400000000000000000000104051426774651400262730ustar00rootroot00000000000000{ "id": "http://json-schema.org/draft-04/schema#", "$schema": "http://json-schema.org/draft-04/schema#", "description": "Core schema meta-schema", "definitions": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$ref": "#" } }, "positiveInteger": { "type": "integer", "minimum": 0 }, "positiveIntegerDefault0": { "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ] }, "simpleTypes": { "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] }, "stringArray": { "type": "array", "items": { "type": "string" }, "minItems": 1, "uniqueItems": true } }, "type": "object", "properties": { "id": { "type": "string" }, "$schema": { "type": "string" }, "title": { "type": "string" }, "description": { "type": "string" }, "default": {}, "multipleOf": { "type": "number", "minimum": 0, "exclusiveMinimum": true }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "boolean", "default": false }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "boolean", "default": false }, "maxLength": { "$ref": "#/definitions/positiveInteger" }, "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "additionalItems": { "anyOf": [ { "type": "boolean" }, { "$ref": "#" } ], "default": {} }, "items": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/schemaArray" } ], "default": {} }, "maxItems": { "$ref": "#/definitions/positiveInteger" }, "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "maxProperties": { "$ref": "#/definitions/positiveInteger" }, "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" }, "required": { "$ref": "#/definitions/stringArray" }, "additionalProperties": { "anyOf": [ { "type": "boolean" }, { "$ref": "#" } ], "default": {} }, "definitions": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "properties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "dependencies": { "type": "object", "additionalProperties": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/stringArray" } ] } }, "enum": { "type": "array", "minItems": 1, "uniqueItems": true }, "type": { "anyOf": [ { "$ref": "#/definitions/simpleTypes" }, { "type": "array", "items": { "$ref": "#/definitions/simpleTypes" }, "minItems": 1, "uniqueItems": true } ] }, "format": { "type": "string" }, "allOf": { "$ref": "#/definitions/schemaArray" }, "anyOf": { "$ref": "#/definitions/schemaArray" }, "oneOf": { "$ref": "#/definitions/schemaArray" }, "not": { "$ref": "#" } }, "dependencies": { "exclusiveMaximum": [ "maximum" ], "exclusiveMinimum": [ "minimum" ] }, "default": {} } golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft-06.schema.json000066400000000000000000000106211426774651400262750ustar00rootroot00000000000000{ "$schema": "http://json-schema.org/draft-06/schema#", "$id": "http://json-schema.org/draft-06/schema#", "title": "Core schema meta-schema", "definitions": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$ref": "#" } }, "nonNegativeInteger": { "type": "integer", "minimum": 0 }, "nonNegativeIntegerDefault0": { "allOf": [ { "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 } ] }, "simpleTypes": { "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] }, "stringArray": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] } }, "type": ["object", "boolean"], "properties": { "$id": { "type": "string", "format": "uri-reference" }, "$schema": { "type": "string", "format": "uri" }, "$ref": { "type": "string", "format": "uri-reference" }, "title": { "type": "string" }, "description": { "type": "string" }, "default": {}, "examples": { "type": "array", "items": {} }, "multipleOf": { "type": "number", "exclusiveMinimum": 0 }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "number" }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "number" }, "maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "additionalItems": { "$ref": "#" }, "items": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/schemaArray" } ], "default": {} }, "maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "contains": { "$ref": "#" }, "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "required": { "$ref": "#/definitions/stringArray" }, "additionalProperties": { "$ref": "#" }, "definitions": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "properties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$ref": "#" }, "propertyNames": { "format": "regex" }, "default": {} }, "dependencies": { "type": "object", "additionalProperties": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/stringArray" } ] } }, "propertyNames": { "$ref": "#" }, "const": {}, "enum": { "type": "array", "minItems": 1, "uniqueItems": true }, "type": { "anyOf": [ { "$ref": "#/definitions/simpleTypes" }, { "type": "array", "items": { "$ref": "#/definitions/simpleTypes" }, "minItems": 1, "uniqueItems": true } ] }, "format": { "type": "string" }, "allOf": { "$ref": "#/definitions/schemaArray" }, "anyOf": { "$ref": "#/definitions/schemaArray" }, "oneOf": { "$ref": "#/definitions/schemaArray" }, "not": { "$ref": "#" } }, "default": {} } golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft-07.schema.json000066400000000000000000000115631426774651400263040ustar00rootroot00000000000000{ "$schema": "http://json-schema.org/draft-07/schema#", "$id": "http://json-schema.org/draft-07/schema#", "title": "Core schema meta-schema", "definitions": { "schemaArray": { "type": "array", "minItems": 1, "items": { "$ref": "#" } }, "nonNegativeInteger": { "type": "integer", "minimum": 0 }, "nonNegativeIntegerDefault0": { "allOf": [ { "$ref": "#/definitions/nonNegativeInteger" }, { "default": 0 } ] }, "simpleTypes": { "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ] }, "stringArray": { "type": "array", "items": { "type": "string" }, "uniqueItems": true, "default": [] } }, "type": ["object", "boolean"], "properties": { "$id": { "type": "string", "format": "uri-reference" }, "$schema": { "type": "string", "format": "uri" }, "$ref": { "type": "string", "format": "uri-reference" }, "$comment": { "type": "string" }, "title": { "type": "string" }, "description": { "type": "string" }, "default": true, "readOnly": { "type": "boolean", "default": false }, "writeOnly": { "type": "boolean", "default": false }, "examples": { "type": "array", "items": true }, "multipleOf": { "type": "number", "exclusiveMinimum": 0 }, "maximum": { "type": "number" }, "exclusiveMaximum": { "type": "number" }, "minimum": { "type": "number" }, "exclusiveMinimum": { "type": "number" }, "maxLength": { "$ref": "#/definitions/nonNegativeInteger" }, "minLength": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "pattern": { "type": "string", "format": "regex" }, "additionalItems": { "$ref": "#" }, "items": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/schemaArray" } ], "default": true }, "maxItems": { "$ref": "#/definitions/nonNegativeInteger" }, "minItems": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "uniqueItems": { "type": "boolean", "default": false }, "contains": { "$ref": "#" }, "maxProperties": { "$ref": "#/definitions/nonNegativeInteger" }, "minProperties": { "$ref": "#/definitions/nonNegativeIntegerDefault0" }, "required": { "$ref": "#/definitions/stringArray" }, "additionalProperties": { "$ref": "#" }, "definitions": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "properties": { "type": "object", "additionalProperties": { "$ref": "#" }, "default": {} }, "patternProperties": { "type": "object", "additionalProperties": { "$ref": "#" }, "propertyNames": { "format": "regex" }, "default": {} }, "dependencies": { "type": "object", "additionalProperties": { "anyOf": [ { "$ref": "#" }, { "$ref": "#/definitions/stringArray" } ] } }, "propertyNames": { "$ref": "#" }, "const": true, "enum": { "type": "array", "items": true, "minItems": 1, "uniqueItems": true }, "type": { "anyOf": [ { "$ref": "#/definitions/simpleTypes" }, { "type": "array", "items": { "$ref": "#/definitions/simpleTypes" }, "minItems": 1, "uniqueItems": true } ] }, "format": { "type": "string" }, "contentMediaType": { "type": "string" }, "contentEncoding": { "type": "string" }, "if": { "$ref": "#" }, "then": { "$ref": "#" }, "else": { "$ref": "#" }, "allOf": { "$ref": "#/definitions/schemaArray" }, "anyOf": { "$ref": "#/definitions/schemaArray" }, "oneOf": { "$ref": "#/definitions/schemaArray" }, "not": { "$ref": "#" } }, "default": true } golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft-2019-09.schema.json000066400000000000000000000033711426774651400266750ustar00rootroot00000000000000{ "$schema": "https://json-schema.org/draft/2019-09/schema", "$id": "https://json-schema.org/draft/2019-09/schema", "$vocabulary": { "https://json-schema.org/draft/2019-09/vocab/core": true, "https://json-schema.org/draft/2019-09/vocab/applicator": true, "https://json-schema.org/draft/2019-09/vocab/validation": true, "https://json-schema.org/draft/2019-09/vocab/meta-data": true, "https://json-schema.org/draft/2019-09/vocab/format": false, "https://json-schema.org/draft/2019-09/vocab/content": true }, "$recursiveAnchor": true, "title": "Core and Validation specifications meta-schema", "allOf": [ {"$ref": "meta/core"}, {"$ref": "meta/applicator"}, {"$ref": "meta/validation"}, {"$ref": "meta/meta-data"}, {"$ref": "meta/format"}, {"$ref": "meta/content"} ], "type": ["object", "boolean"], "properties": { "definitions": { "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.", "type": "object", "additionalProperties": { "$recursiveRef": "#" }, "default": {} }, "dependencies": { "$comment": "\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"", "type": "object", "additionalProperties": { "anyOf": [ { "$recursiveRef": "#" }, { "$ref": "meta/validation#/$defs/stringArray" } ] } } } } golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft-2020-12.schema.json000066400000000000000000000046241426774651400266610ustar00rootroot00000000000000{ "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://json-schema.org/draft/2020-12/schema", "$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true, "https://json-schema.org/draft/2020-12/vocab/applicator": true, "https://json-schema.org/draft/2020-12/vocab/unevaluated": true, "https://json-schema.org/draft/2020-12/vocab/validation": true, "https://json-schema.org/draft/2020-12/vocab/meta-data": true, "https://json-schema.org/draft/2020-12/vocab/format-annotation": true, "https://json-schema.org/draft/2020-12/vocab/content": true }, "$dynamicAnchor": "meta", "title": "Core and Validation specifications meta-schema", "allOf": [ {"$ref": "meta/core"}, {"$ref": "meta/applicator"}, {"$ref": "meta/unevaluated"}, {"$ref": "meta/validation"}, {"$ref": "meta/meta-data"}, {"$ref": "meta/format-annotation"}, {"$ref": "meta/content"} ], "type": ["object", "boolean"], "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.", "properties": { "definitions": { "$comment": "\"definitions\" has been replaced by \"$defs\".", "type": "object", "additionalProperties": { "$dynamicRef": "#meta" }, "deprecated": true, "default": {} }, "dependencies": { "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.", "type": "object", "additionalProperties": { "anyOf": [ { "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" } ] }, "deprecated": true, "default": {} }, "$recursiveAnchor": { "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".", "$ref": "meta/core#/$defs/anchorString", "deprecated": true }, "$recursiveRef": { "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".", "$ref": "meta/core#/$defs/uriReferenceString", "deprecated": true } } } golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/000077500000000000000000000000001426774651400244625ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/additionalItems.json000066400000000000000000000103731426774651400304730ustar00rootroot00000000000000[ { "description": "additionalItems as schema", "schema": { "items": [{}], "additionalItems": {"type": "integer"} }, "tests": [ { "description": "additional items match schema", "data": [ null, 2, 3, 4 ], "valid": true }, { "description": "additional items do not match schema", "data": [ null, 2, 3, "foo" ], "valid": false } ] }, { "description": "when items is schema, additionalItems does nothing", "schema": { "items": {}, "additionalItems": false }, "tests": [ { "description": "all items match schema", "data": [ 1, 2, 3, 4, 5 ], "valid": true } ] }, { "description": "array of items with no additionalItems permitted", "schema": { "items": [{}, {}, {}], "additionalItems": false }, "tests": [ { "description": "empty array", "data": [ ], "valid": true }, { "description": "fewer number of items present (1)", "data": [ 1 ], "valid": true }, { "description": "fewer number of items present (2)", "data": [ 1, 2 ], "valid": true }, { "description": "equal number of items present", "data": [ 1, 2, 3 ], "valid": true }, { "description": "additional items are not permitted", "data": [ 1, 2, 3, 4 ], "valid": false } ] }, { "description": "additionalItems as false without items", "schema": {"additionalItems": false}, "tests": [ { "description": "items defaults to empty schema so everything is valid", "data": [ 1, 2, 3, 4, 5 ], "valid": true }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true } ] }, { "description": "additionalItems are allowed by default", "schema": {"items": [{"type": "integer"}]}, "tests": [ { "description": "only the first item is validated", "data": [1, "foo", false], "valid": true } ] }, { "description": "additionalItems should not look in applicators, valid case", "schema": { "allOf": [ { "items": [ { "type": "integer" } ] } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, null ], "valid": true } ] }, { "description": "additionalItems should not look in applicators, invalid case", "schema": { "allOf": [ { "items": [ { "type": "integer" }, { "type": "string" } ] } ], "items": [ {"type": "integer" } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, "hello" ], "valid": false } ] }, { "description": "items validation adjusts the starting index for additionalItems", "schema": { "items": [ { "type": "string" } ], "additionalItems": { "type": "integer" } }, "tests": [ { "description": "valid items", "data": [ "x", 2, 3 ], "valid": true }, { "description": "wrong type of second item", "data": [ "x", "y" ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/additionalProperties.json000066400000000000000000000077541426774651400315570ustar00rootroot00000000000000[ { "description": "additionalProperties being false does not allow other properties", "schema": { "properties": {"foo": {}, "bar": {}}, "patternProperties": { "^v": {} }, "additionalProperties": false }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : "boom"}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobarbaz", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true }, { "description": "patternProperties are not additional properties", "data": {"foo":1, "vroom": 2}, "valid": true } ] }, { "description": "non-ASCII pattern with additionalProperties", "schema": { "patternProperties": {"^á": {}}, "additionalProperties": false }, "tests": [ { "description": "matching the pattern is valid", "data": {"ármányos": 2}, "valid": true }, { "description": "not matching the pattern is invalid", "data": {"élmény": 2}, "valid": false } ] }, { "description": "additionalProperties allows a schema which should validate", "schema": { "properties": {"foo": {}, "bar": {}}, "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional valid property is valid", "data": {"foo" : 1, "bar" : 2, "quux" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : 12}, "valid": false } ] }, { "description": "additionalProperties can exist by itself", "schema": { "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "an additional valid property is valid", "data": {"foo" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1}, "valid": false } ] }, { "description": "additionalProperties are allowed by default", "schema": {"properties": {"foo": {}, "bar": {}}}, "tests": [ { "description": "additional properties are allowed", "data": {"foo": 1, "bar": 2, "quux": true}, "valid": true } ] }, { "description": "additionalProperties should not look in applicators", "schema": { "allOf": [ {"properties": {"foo": {}}} ], "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "properties defined in allOf are not examined", "data": {"foo": 1, "bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/allOf.json000066400000000000000000000171471426774651400264240ustar00rootroot00000000000000[ { "description": "allOf", "schema": { "allOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "allOf", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "mismatch second", "data": {"foo": "baz"}, "valid": false }, { "description": "mismatch first", "data": {"bar": 2}, "valid": false }, { "description": "wrong type", "data": {"foo": "baz", "bar": "quux"}, "valid": false } ] }, { "description": "allOf with base schema", "schema": { "properties": {"bar": {"type": "integer"}}, "required": ["bar"], "allOf" : [ { "properties": { "foo": {"type": "string"} }, "required": ["foo"] }, { "properties": { "baz": {"type": "null"} }, "required": ["baz"] } ] }, "tests": [ { "description": "valid", "data": {"foo": "quux", "bar": 2, "baz": null}, "valid": true }, { "description": "mismatch base schema", "data": {"foo": "quux", "baz": null}, "valid": false }, { "description": "mismatch first allOf", "data": {"bar": 2, "baz": null}, "valid": false }, { "description": "mismatch second allOf", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "mismatch both", "data": {"bar": 2}, "valid": false } ] }, { "description": "allOf simple types", "schema": { "allOf": [ {"maximum": 30}, {"minimum": 20} ] }, "tests": [ { "description": "valid", "data": 25, "valid": true }, { "description": "mismatch one", "data": 35, "valid": false } ] }, { "description": "allOf with boolean schemas, all true", "schema": {"allOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "allOf with boolean schemas, some false", "schema": {"allOf": [true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with boolean schemas, all false", "schema": {"allOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with one empty schema", "schema": { "allOf": [ {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with two empty schemas", "schema": { "allOf": [ {}, {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with the first empty schema", "schema": { "allOf": [ {}, { "type": "number" } ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with the last empty schema", "schema": { "allOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "nested allOf, to check validation semantics", "schema": { "allOf": [ { "allOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "allOf combined with anyOf, oneOf", "schema": { "allOf": [ { "multipleOf": 2 } ], "anyOf": [ { "multipleOf": 3 } ], "oneOf": [ { "multipleOf": 5 } ] }, "tests": [ { "description": "allOf: false, anyOf: false, oneOf: false", "data": 1, "valid": false }, { "description": "allOf: false, anyOf: false, oneOf: true", "data": 5, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: false", "data": 3, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: true", "data": 15, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: false", "data": 2, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: true", "data": 10, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: false", "data": 6, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: true", "data": 30, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/anchor.json000066400000000000000000000075461426774651400266430ustar00rootroot00000000000000[ { "description": "Location-independent identifier", "schema": { "$ref": "#foo", "$defs": { "A": { "$anchor": "foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with absolute URI", "schema": { "$ref": "http://localhost:1234/bar#foo", "$defs": { "A": { "$id": "http://localhost:1234/bar", "$anchor": "foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with base URI change in subschema", "schema": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#foo", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$anchor": "foo", "type": "integer" } } } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "$anchor inside an enum is not a real identifier", "comment": "the implementation must not be confused by an $anchor buried in the enum", "schema": { "$defs": { "anchor_in_enum": { "enum": [ { "$anchor": "my_anchor", "type": "null" } ] }, "real_identifier_in_schema": { "$anchor": "my_anchor", "type": "string" }, "zzz_anchor_in_const": { "const": { "$anchor": "my_anchor", "type": "null" } } }, "anyOf": [ { "$ref": "#/$defs/anchor_in_enum" }, { "$ref": "#my_anchor" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "$anchor": "my_anchor", "type": "null" }, "valid": true }, { "description": "in implementations that strip $anchor, this may match either $def", "data": { "type": "null" }, "valid": false }, { "description": "match $ref to $anchor", "data": "a string to match #/$defs/anchor_in_enum", "valid": true }, { "description": "no match on enum or $ref to $anchor", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/anyOf.json000066400000000000000000000113331426774651400264320ustar00rootroot00000000000000[ { "description": "anyOf", "schema": { "anyOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first anyOf valid", "data": 1, "valid": true }, { "description": "second anyOf valid", "data": 2.5, "valid": true }, { "description": "both anyOf valid", "data": 3, "valid": true }, { "description": "neither anyOf valid", "data": 1.5, "valid": false } ] }, { "description": "anyOf with base schema", "schema": { "type": "string", "anyOf" : [ { "maxLength": 2 }, { "minLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one anyOf valid", "data": "foobar", "valid": true }, { "description": "both anyOf invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf with boolean schemas, all true", "schema": {"anyOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, some true", "schema": {"anyOf": [true, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, all false", "schema": {"anyOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf complex types", "schema": { "anyOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first anyOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second anyOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both anyOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "neither anyOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "anyOf with one empty schema", "schema": { "anyOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is valid", "data": 123, "valid": true } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/boolean_schema.json000066400000000000000000000054021426774651400303150ustar00rootroot00000000000000[ { "description": "boolean schema 'true'", "schema": true, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is valid", "data": "foo", "valid": true }, { "description": "boolean true is valid", "data": true, "valid": true }, { "description": "boolean false is valid", "data": false, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "object is valid", "data": {"foo": "bar"}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true }, { "description": "array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "boolean schema 'false'", "schema": false, "tests": [ { "description": "number is invalid", "data": 1, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "boolean true is invalid", "data": true, "valid": false }, { "description": "boolean false is invalid", "data": false, "valid": false }, { "description": "null is invalid", "data": null, "valid": false }, { "description": "object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/const.json000066400000000000000000000225641426774651400265140ustar00rootroot00000000000000[ { "description": "const validation", "schema": {"const": 2}, "tests": [ { "description": "same value is valid", "data": 2, "valid": true }, { "description": "another value is invalid", "data": 5, "valid": false }, { "description": "another type is invalid", "data": "a", "valid": false } ] }, { "description": "const with object", "schema": {"const": {"foo": "bar", "baz": "bax"}}, "tests": [ { "description": "same object is valid", "data": {"foo": "bar", "baz": "bax"}, "valid": true }, { "description": "same object with different property order is valid", "data": {"baz": "bax", "foo": "bar"}, "valid": true }, { "description": "another object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "another type is invalid", "data": [1, 2], "valid": false } ] }, { "description": "const with array", "schema": {"const": [{ "foo": "bar" }]}, "tests": [ { "description": "same array is valid", "data": [{"foo": "bar"}], "valid": true }, { "description": "another array item is invalid", "data": [2], "valid": false }, { "description": "array with additional items is invalid", "data": [1, 2, 3], "valid": false } ] }, { "description": "const with null", "schema": {"const": null}, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "not null is invalid", "data": 0, "valid": false } ] }, { "description": "const with false does not match 0", "schema": {"const": false}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "const with true does not match 1", "schema": {"const": true}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "const with [false] does not match [0]", "schema": {"const": [false]}, "tests": [ { "description": "[false] is valid", "data": [false], "valid": true }, { "description": "[0] is invalid", "data": [0], "valid": false }, { "description": "[0.0] is invalid", "data": [0.0], "valid": false } ] }, { "description": "const with [true] does not match [1]", "schema": {"const": [true]}, "tests": [ { "description": "[true] is valid", "data": [true], "valid": true }, { "description": "[1] is invalid", "data": [1], "valid": false }, { "description": "[1.0] is invalid", "data": [1.0], "valid": false } ] }, { "description": "const with {\"a\": false} does not match {\"a\": 0}", "schema": {"const": {"a": false}}, "tests": [ { "description": "{\"a\": false} is valid", "data": {"a": false}, "valid": true }, { "description": "{\"a\": 0} is invalid", "data": {"a": 0}, "valid": false }, { "description": "{\"a\": 0.0} is invalid", "data": {"a": 0.0}, "valid": false } ] }, { "description": "const with {\"a\": true} does not match {\"a\": 1}", "schema": {"const": {"a": true}}, "tests": [ { "description": "{\"a\": true} is valid", "data": {"a": true}, "valid": true }, { "description": "{\"a\": 1} is invalid", "data": {"a": 1}, "valid": false }, { "description": "{\"a\": 1.0} is invalid", "data": {"a": 1.0}, "valid": false } ] }, { "description": "const with 0 does not match other zero-like types", "schema": {"const": 0}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "empty string is invalid", "data": "", "valid": false } ] }, { "description": "const with 1 does not match true", "schema": {"const": 1}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "const with -2.0 matches integer and float types", "schema": {"const": -2.0}, "tests": [ { "description": "integer -2 is valid", "data": -2, "valid": true }, { "description": "integer 2 is invalid", "data": 2, "valid": false }, { "description": "float -2.0 is valid", "data": -2.0, "valid": true }, { "description": "float 2.0 is invalid", "data": 2.0, "valid": false }, { "description": "float -2.00001 is invalid", "data": -2.00001, "valid": false } ] }, { "description": "float and integers are equal up to 64-bit representation limits", "schema": {"const": 9007199254740992}, "tests": [ { "description": "integer is valid", "data": 9007199254740992, "valid": true }, { "description": "integer minus one is invalid", "data": 9007199254740991, "valid": false }, { "description": "float is valid", "data": 9007199254740992.0, "valid": true }, { "description": "float minus one is invalid", "data": 9007199254740991.0, "valid": false } ] }, { "description": "nul characters in strings", "schema": { "const": "hello\u0000there" }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/contains.json000066400000000000000000000102721426774651400271750ustar00rootroot00000000000000[ { "description": "contains keyword validation", "schema": { "contains": {"minimum": 5} }, "tests": [ { "description": "array with item matching schema (5) is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with item matching schema (6) is valid", "data": [3, 4, 6], "valid": true }, { "description": "array with two items matching schema (5, 6) is valid", "data": [3, 4, 5, 6], "valid": true }, { "description": "array without items matching schema is invalid", "data": [2, 3, 4], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "not array is valid", "data": {}, "valid": true } ] }, { "description": "contains keyword with const keyword", "schema": { "contains": { "const": 5 } }, "tests": [ { "description": "array with item 5 is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with two items 5 is valid", "data": [3, 4, 5, 5], "valid": true }, { "description": "array without item 5 is invalid", "data": [1, 2, 3, 4], "valid": false } ] }, { "description": "contains keyword with boolean schema true", "schema": {"contains": true}, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] }, { "description": "contains keyword with boolean schema false", "schema": {"contains": false}, "tests": [ { "description": "any non-empty array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "non-arrays are valid", "data": "contains does not apply to strings", "valid": true } ] }, { "description": "items + contains", "schema": { "items": { "multipleOf": 2 }, "contains": { "multipleOf": 3 } }, "tests": [ { "description": "matches items, does not match contains", "data": [ 2, 4, 8 ], "valid": false }, { "description": "does not match items, matches contains", "data": [ 3, 6, 9 ], "valid": false }, { "description": "matches both items and contains", "data": [ 6, 12 ], "valid": true }, { "description": "matches neither items nor contains", "data": [ 1, 5 ], "valid": false } ] }, { "description": "contains with false if subschema", "schema": { "contains": { "if": false, "else": true } }, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/content.json000066400000000000000000000077771426774651400270510ustar00rootroot00000000000000[ { "description": "validation of string-encoded content based on media type", "schema": { "contentMediaType": "application/json" }, "tests": [ { "description": "a valid JSON document", "data": "{\"foo\": \"bar\"}", "valid": true }, { "description": "an invalid JSON document; validates true", "data": "{:}", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary string-encoding", "schema": { "contentEncoding": "base64" }, "tests": [ { "description": "a valid base64 string", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "an invalid base64 string (% is not a valid character); validates true", "data": "eyJmb28iOi%iYmFyIn0K", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary-encoded media type documents", "schema": { "contentMediaType": "application/json", "contentEncoding": "base64" }, "tests": [ { "description": "a valid base64-encoded JSON document", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "a validly-encoded invalid JSON document; validates true", "data": "ezp9Cg==", "valid": true }, { "description": "an invalid base64 string that is valid JSON; validates true", "data": "{}", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary-encoded media type documents with schema", "schema": { "contentMediaType": "application/json", "contentEncoding": "base64", "contentSchema": { "required": ["foo"], "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "a valid base64-encoded JSON document", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "another valid base64-encoded JSON document", "data": "eyJib28iOiAyMCwgImZvbyI6ICJiYXoifQ==", "valid": true }, { "description": "an invalid base64-encoded JSON document; validates true", "data": "eyJib28iOiAyMH0=", "valid": true }, { "description": "an empty object as a base64-encoded JSON document; validates true", "data": "e30=", "valid": true }, { "description": "an empty array as a base64-encoded JSON document", "data": "W10=", "valid": true }, { "description": "a validly-encoded invalid JSON document; validates true", "data": "ezp9Cg==", "valid": true }, { "description": "an invalid base64 string that is valid JSON; validates true", "data": "{}", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/default.json000066400000000000000000000042671426774651400270120ustar00rootroot00000000000000[ { "description": "invalid type for default", "schema": { "properties": { "foo": { "type": "integer", "default": [] } } }, "tests": [ { "description": "valid when property is specified", "data": {"foo": 13}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "invalid string value for default", "schema": { "properties": { "bar": { "type": "string", "minLength": 4, "default": "bad" } } }, "tests": [ { "description": "valid when property is specified", "data": {"bar": "good"}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "the default keyword does not do anything if the property is missing", "schema": { "type": "object", "properties": { "alpha": { "type": "number", "maximum": 3, "default": 5 } } }, "tests": [ { "description": "an explicit property value is checked against maximum (passing)", "data": { "alpha": 1 }, "valid": true }, { "description": "an explicit property value is checked against maximum (failing)", "data": { "alpha": 5 }, "valid": false }, { "description": "missing properties are not filled in with the default", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/defs.json000066400000000000000000000010401426774651400262710ustar00rootroot00000000000000[ { "description": "validate definition against metaschema", "schema": {"$ref": "https://json-schema.org/draft/2019-09/schema"}, "tests": [ { "description": "valid definition schema", "data": {"$defs": {"foo": {"type": "integer"}}}, "valid": true }, { "description": "invalid definition schema", "data": {"$defs": {"foo": {"type": 1}}}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/dependentRequired.json000066400000000000000000000075501426774651400310330ustar00rootroot00000000000000[ { "description": "single dependency", "schema": {"dependentRequired": {"bar": ["foo"]}}, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependant", "data": {"foo": 1}, "valid": true }, { "description": "with dependency", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "missing dependency", "data": {"bar": 2}, "valid": false }, { "description": "ignores arrays", "data": ["bar"], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "empty dependents", "schema": {"dependentRequired": {"bar": []}}, "tests": [ { "description": "empty object", "data": {}, "valid": true }, { "description": "object with one property", "data": {"bar": 2}, "valid": true }, { "description": "non-object is valid", "data": 1, "valid": true } ] }, { "description": "multiple dependents required", "schema": {"dependentRequired": {"quux": ["foo", "bar"]}}, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependants", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "with dependencies", "data": {"foo": 1, "bar": 2, "quux": 3}, "valid": true }, { "description": "missing dependency", "data": {"foo": 1, "quux": 2}, "valid": false }, { "description": "missing other dependency", "data": {"bar": 1, "quux": 2}, "valid": false }, { "description": "missing both dependencies", "data": {"quux": 1}, "valid": false } ] }, { "description": "dependencies with escaped characters", "schema": { "dependentRequired": { "foo\nbar": ["foo\rbar"], "foo\"bar": ["foo'bar"] } }, "tests": [ { "description": "CRLF", "data": { "foo\nbar": 1, "foo\rbar": 2 }, "valid": true }, { "description": "quoted quotes", "data": { "foo'bar": 1, "foo\"bar": 2 }, "valid": true }, { "description": "CRLF missing dependent", "data": { "foo\nbar": 1, "foo": 2 }, "valid": false }, { "description": "quoted quotes missing dependent", "data": { "foo\"bar": 2 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/dependentSchemas.json000066400000000000000000000062331426774651400306330ustar00rootroot00000000000000[ { "description": "single dependency", "schema": { "dependentSchemas": { "bar": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "integer"} } } } }, "tests": [ { "description": "valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "no dependency", "data": {"foo": "quux"}, "valid": true }, { "description": "wrong type", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "wrong type other", "data": {"foo": 2, "bar": "quux"}, "valid": false }, { "description": "wrong type both", "data": {"foo": "quux", "bar": "quux"}, "valid": false } ] }, { "description": "boolean subschemas", "schema": { "dependentSchemas": { "foo": true, "bar": false } }, "tests": [ { "description": "object with property having schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property having schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "dependencies with escaped characters", "schema": { "dependentSchemas": { "foo\tbar": {"minProperties": 4}, "foo'bar": {"required": ["foo\"bar"]} } }, "tests": [ { "description": "quoted tab", "data": { "foo\tbar": 1, "a": 2, "b": 3, "c": 4 }, "valid": true }, { "description": "quoted quote", "data": { "foo'bar": {"foo\"bar": 1} }, "valid": false }, { "description": "quoted tab invalid under dependent schema", "data": { "foo\tbar": 1, "a": 2 }, "valid": false }, { "description": "quoted quote invalid under dependent schema", "data": {"foo'bar": 1}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/enum.json000066400000000000000000000146431426774651400263310ustar00rootroot00000000000000[ { "description": "simple enum validation", "schema": {"enum": [1, 2, 3]}, "tests": [ { "description": "one of the enum is valid", "data": 1, "valid": true }, { "description": "something else is invalid", "data": 4, "valid": false } ] }, { "description": "heterogeneous enum validation", "schema": {"enum": [6, "foo", [], true, {"foo": 12}]}, "tests": [ { "description": "one of the enum is valid", "data": [], "valid": true }, { "description": "something else is invalid", "data": null, "valid": false }, { "description": "objects are deep compared", "data": {"foo": false}, "valid": false }, { "description": "valid object matches", "data": {"foo": 12}, "valid": true }, { "description": "extra properties in object is invalid", "data": {"foo": 12, "boo": 42}, "valid": false } ] }, { "description": "heterogeneous enum-with-null validation", "schema": { "enum": [6, null] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "number is valid", "data": 6, "valid": true }, { "description": "something else is invalid", "data": "test", "valid": false } ] }, { "description": "enums in properties", "schema": { "type":"object", "properties": { "foo": {"enum":["foo"]}, "bar": {"enum":["bar"]} }, "required": ["bar"] }, "tests": [ { "description": "both properties are valid", "data": {"foo":"foo", "bar":"bar"}, "valid": true }, { "description": "wrong foo value", "data": {"foo":"foot", "bar":"bar"}, "valid": false }, { "description": "wrong bar value", "data": {"foo":"foo", "bar":"bart"}, "valid": false }, { "description": "missing optional property is valid", "data": {"bar":"bar"}, "valid": true }, { "description": "missing required property is invalid", "data": {"foo":"foo"}, "valid": false }, { "description": "missing all properties is invalid", "data": {}, "valid": false } ] }, { "description": "enum with escaped characters", "schema": { "enum": ["foo\nbar", "foo\rbar"] }, "tests": [ { "description": "member 1 is valid", "data": "foo\nbar", "valid": true }, { "description": "member 2 is valid", "data": "foo\rbar", "valid": true }, { "description": "another string is invalid", "data": "abc", "valid": false } ] }, { "description": "enum with false does not match 0", "schema": {"enum": [false]}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "enum with true does not match 1", "schema": {"enum": [true]}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "enum with 0 does not match false", "schema": {"enum": [0]}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true } ] }, { "description": "enum with 1 does not match true", "schema": {"enum": [1]}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "nul characters in strings", "schema": { "enum": [ "hello\u0000there" ] }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/exclusiveMaximum.json000066400000000000000000000014071426774651400307240ustar00rootroot00000000000000[ { "description": "exclusiveMaximum validation", "schema": { "exclusiveMaximum": 3.0 }, "tests": [ { "description": "below the exclusiveMaximum is valid", "data": 2.2, "valid": true }, { "description": "boundary point is invalid", "data": 3.0, "valid": false }, { "description": "above the exclusiveMaximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/exclusiveMinimum.json000066400000000000000000000014071426774651400307220ustar00rootroot00000000000000[ { "description": "exclusiveMinimum validation", "schema": { "exclusiveMinimum": 1.1 }, "tests": [ { "description": "above the exclusiveMinimum is valid", "data": 1.2, "valid": true }, { "description": "boundary point is invalid", "data": 1.1, "valid": false }, { "description": "below the exclusiveMinimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/format.json000066400000000000000000000565531426774651400266630ustar00rootroot00000000000000[ { "description": "email format", "schema": { "format": "email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid email string is only an annotation by default", "data": "2962", "valid": true } ] }, { "description": "idn-email format", "schema": { "format": "idn-email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid idn-email string is only an annotation by default", "data": "2962", "valid": true } ] }, { "description": "regex format", "schema": { "format": "regex" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid regex string is only an annotation by default", "data": "^(abc]", "valid": true } ] }, { "description": "ipv4 format", "schema": { "format": "ipv4" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid ipv4 string is only an annotation by default", "data": "127.0.0.0.1", "valid": true } ] }, { "description": "ipv6 format", "schema": { "format": "ipv6" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid ipv6 string is only an annotation by default", "data": "12345::", "valid": true } ] }, { "description": "idn-hostname format", "schema": { "format": "idn-hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid idn-hostname string is only an annotation by default", "data": "〮실례.테스트", "valid": true } ] }, { "description": "hostname format", "schema": { "format": "hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid hostname string is only an annotation by default", "data": "-a-host-name-that-starts-with--", "valid": true } ] }, { "description": "date format", "schema": { "format": "date" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid date string is only an annotation by default", "data": "06/19/1963", "valid": true } ] }, { "description": "date-time format", "schema": { "format": "date-time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid date-time string is only an annotation by default", "data": "1990-02-31T15:59:60.123-08:00", "valid": true } ] }, { "description": "time format", "schema": { "format": "time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid time string is only an annotation by default", "data": "08:30:06 PST", "valid": true } ] }, { "description": "json-pointer format", "schema": { "format": "json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid json-pointer string is only an annotation by default", "data": "/foo/bar~", "valid": true } ] }, { "description": "relative-json-pointer format", "schema": { "format": "relative-json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid relative-json-pointer string is only an annotation by default", "data": "/foo/bar", "valid": true } ] }, { "description": "iri format", "schema": { "format": "iri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid iri string is only an annotation by default", "data": "http://2001:0db8:85a3:0000:0000:8a2e:0370:7334", "valid": true } ] }, { "description": "iri-reference format", "schema": { "format": "iri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid iri-reference string is only an annotation by default", "data": "\\\\WINDOWS\\filëßåré", "valid": true } ] }, { "description": "uri format", "schema": { "format": "uri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uri string is only an annotation by default", "data": "//foo.bar/?baz=qux#quux", "valid": true } ] }, { "description": "uri-reference format", "schema": { "format": "uri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uri-reference string is only an annotation by default", "data": "\\\\WINDOWS\\fileshare", "valid": true } ] }, { "description": "uri-template format", "schema": { "format": "uri-template" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uri-template string is only an annotation by default", "data": "http://example.com/dictionary/{term:1}/{term", "valid": true } ] }, { "description": "uuid format", "schema": { "format": "uuid" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uuid string is only an annotation by default", "data": "2eb8aa08-aa98-11ea-b4aa-73b441d1638", "valid": true } ] }, { "description": "duration format", "schema": { "format": "duration" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid duration string is only an annotation by default", "data": "PT1D", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/id.json000066400000000000000000000210571426774651400257560ustar00rootroot00000000000000[ { "description": "Invalid use of fragments in location-independent $id", "schema": {"$ref": "https://json-schema.org/draft/2019-09/schema"}, "tests": [ { "description": "Identifier name", "data": { "$ref": "#foo", "$defs": { "A": { "$id": "#foo", "type": "integer" } } }, "valid": false }, { "description": "Identifier name and no ref", "data": { "$defs": { "A": { "$id": "#foo" } } }, "valid": false }, { "description": "Identifier path", "data": { "$ref": "#/a/b", "$defs": { "A": { "$id": "#/a/b", "type": "integer" } } }, "valid": false }, { "description": "Identifier name with absolute URI", "data": { "$ref": "http://localhost:1234/bar#foo", "$defs": { "A": { "$id": "http://localhost:1234/bar#foo", "type": "integer" } } }, "valid": false }, { "description": "Identifier path with absolute URI", "data": { "$ref": "http://localhost:1234/bar#/a/b", "$defs": { "A": { "$id": "http://localhost:1234/bar#/a/b", "type": "integer" } } }, "valid": false }, { "description": "Identifier name with base URI change in subschema", "data": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#foo", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$id": "#foo", "type": "integer" } } } } }, "valid": false }, { "description": "Identifier path with base URI change in subschema", "data": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#/a/b", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$id": "#/a/b", "type": "integer" } } } } }, "valid": false } ] }, { "description": "Valid use of empty fragments in location-independent $id", "comment": "These are allowed but discouraged", "schema": { "$ref": "https://json-schema.org/draft/2019-09/schema" }, "tests": [ { "description": "Identifier name with absolute URI", "data": { "$ref": "http://localhost:1234/bar", "$defs": { "A": { "$id": "http://localhost:1234/bar#", "type": "integer" } } }, "valid": true }, { "description": "Identifier name with base URI change in subschema", "data": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#/$defs/B", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$id": "#", "type": "integer" } } } } }, "valid": true } ] }, { "description": "Unnormalized $ids are allowed but discouraged", "schema": { "$ref": "https://json-schema.org/draft/2019-09/schema" }, "tests": [ { "description": "Unnormalized identifier", "data": { "$ref": "http://localhost:1234/foo/baz", "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz", "type": "integer" } } }, "valid": true }, { "description": "Unnormalized identifier and no ref", "data": { "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz", "type": "integer" } } }, "valid": true }, { "description": "Unnormalized identifier with empty fragment", "data": { "$ref": "http://localhost:1234/foo/baz", "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz#", "type": "integer" } } }, "valid": true }, { "description": "Unnormalized identifier with empty fragment and no ref", "data": { "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz#", "type": "integer" } } }, "valid": true } ] }, { "description": "$id inside an enum is not a real identifier", "comment": "the implementation must not be confused by an $id buried in the enum", "schema": { "$defs": { "id_in_enum": { "enum": [ { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } ] }, "real_id_in_schema": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "string" }, "zzz_id_in_const": { "const": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } } }, "anyOf": [ { "$ref": "#/$defs/id_in_enum" }, { "$ref": "https://localhost:1234/id/my_identifier.json" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" }, "valid": true }, { "description": "match $ref to $id", "data": "a string to match #/$defs/id_in_enum", "valid": true }, { "description": "no match on enum or $ref to $id", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/if-then-else.json000066400000000000000000000153221426774651400276400ustar00rootroot00000000000000[ { "description": "ignore if without then or else", "schema": { "if": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone if", "data": 0, "valid": true }, { "description": "valid when invalid against lone if", "data": "hello", "valid": true } ] }, { "description": "ignore then without if", "schema": { "then": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone then", "data": 0, "valid": true }, { "description": "valid when invalid against lone then", "data": "hello", "valid": true } ] }, { "description": "ignore else without if", "schema": { "else": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone else", "data": 0, "valid": true }, { "description": "valid when invalid against lone else", "data": "hello", "valid": true } ] }, { "description": "if and then without else", "schema": { "if": { "exclusiveMaximum": 0 }, "then": { "minimum": -10 } }, "tests": [ { "description": "valid through then", "data": -1, "valid": true }, { "description": "invalid through then", "data": -100, "valid": false }, { "description": "valid when if test fails", "data": 3, "valid": true } ] }, { "description": "if and else without then", "schema": { "if": { "exclusiveMaximum": 0 }, "else": { "multipleOf": 2 } }, "tests": [ { "description": "valid when if test passes", "data": -1, "valid": true }, { "description": "valid through else", "data": 4, "valid": true }, { "description": "invalid through else", "data": 3, "valid": false } ] }, { "description": "validate against correct branch, then vs else", "schema": { "if": { "exclusiveMaximum": 0 }, "then": { "minimum": -10 }, "else": { "multipleOf": 2 } }, "tests": [ { "description": "valid through then", "data": -1, "valid": true }, { "description": "invalid through then", "data": -100, "valid": false }, { "description": "valid through else", "data": 4, "valid": true }, { "description": "invalid through else", "data": 3, "valid": false } ] }, { "description": "non-interference across combined schemas", "schema": { "allOf": [ { "if": { "exclusiveMaximum": 0 } }, { "then": { "minimum": -10 } }, { "else": { "multipleOf": 2 } } ] }, "tests": [ { "description": "valid, but would have been invalid through then", "data": -100, "valid": true }, { "description": "valid, but would have been invalid through else", "data": 3, "valid": true } ] }, { "description": "if with boolean schema true", "schema": { "if": true, "then": { "const": "then" }, "else": { "const": "else" } }, "tests": [ { "description": "boolean schema true in if always chooses the then path (valid)", "data": "then", "valid": true }, { "description": "boolean schema true in if always chooses the then path (invalid)", "data": "else", "valid": false } ] }, { "description": "if with boolean schema false", "schema": { "if": false, "then": { "const": "then" }, "else": { "const": "else" } }, "tests": [ { "description": "boolean schema false in if always chooses the else path (invalid)", "data": "then", "valid": false }, { "description": "boolean schema false in if always chooses the else path (valid)", "data": "else", "valid": true } ] }, { "description": "if appears at the end when serialized (keyword processing sequence)", "schema": { "then": { "const": "yes" }, "else": { "const": "other" }, "if": { "maxLength": 4 } }, "tests": [ { "description": "yes redirects to then and passes", "data": "yes", "valid": true }, { "description": "other redirects to else and passes", "data": "other", "valid": true }, { "description": "no redirects to then and fails", "data": "no", "valid": false }, { "description": "invalid redirects to else and fails", "data": "invalid", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/infinite-loop-detection.json000066400000000000000000000017241426774651400321110ustar00rootroot00000000000000[ { "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", "schema": { "$defs": { "int": { "type": "integer" } }, "allOf": [ { "properties": { "foo": { "$ref": "#/$defs/int" } } }, { "additionalProperties": { "$ref": "#/$defs/int" } } ] }, "tests": [ { "description": "passing case", "data": { "foo": 1 }, "valid": true }, { "description": "failing case", "data": { "foo": "a string" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/items.json000066400000000000000000000161611426774651400265030ustar00rootroot00000000000000[ { "description": "a schema given for items", "schema": { "items": {"type": "integer"} }, "tests": [ { "description": "valid items", "data": [ 1, 2, 3 ], "valid": true }, { "description": "wrong type of items", "data": [1, "x"], "valid": false }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "length": 1 }, "valid": true } ] }, { "description": "an array of schemas for items", "schema": { "items": [ {"type": "integer"}, {"type": "string"} ] }, "tests": [ { "description": "correct types", "data": [ 1, "foo" ], "valid": true }, { "description": "wrong types", "data": [ "foo", 1 ], "valid": false }, { "description": "incomplete array of items", "data": [ 1 ], "valid": true }, { "description": "array with additional items", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array", "data": [ ], "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "1": "valid", "length": 2 }, "valid": true } ] }, { "description": "items with boolean schema (true)", "schema": {"items": true}, "tests": [ { "description": "any array is valid", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schema (false)", "schema": {"items": false}, "tests": [ { "description": "any non-empty array is invalid", "data": [ 1, "foo", true ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schemas", "schema": { "items": [true, false] }, "tests": [ { "description": "array with one item is valid", "data": [ 1 ], "valid": true }, { "description": "array with two items is invalid", "data": [ 1, "foo" ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items and subitems", "schema": { "$defs": { "item": { "type": "array", "additionalItems": false, "items": [ { "$ref": "#/$defs/sub-item" }, { "$ref": "#/$defs/sub-item" } ] }, "sub-item": { "type": "object", "required": ["foo"] } }, "type": "array", "additionalItems": false, "items": [ { "$ref": "#/$defs/item" }, { "$ref": "#/$defs/item" }, { "$ref": "#/$defs/item" } ] }, "tests": [ { "description": "valid items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": true }, { "description": "too many items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "too many sub-items", "data": [ [ {"foo": null}, {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong item", "data": [ {"foo": null}, [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong sub-item", "data": [ [ {}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "fewer items is valid", "data": [ [ {"foo": null} ], [ {"foo": null} ] ], "valid": true } ] }, { "description": "nested items", "schema": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "number" } } } } }, "tests": [ { "description": "valid nested array", "data": [[[[1]], [[2],[3]]], [[[4], [5], [6]]]], "valid": true }, { "description": "nested array with invalid type", "data": [[[["1"]], [[2],[3]]], [[[4], [5], [6]]]], "valid": false }, { "description": "not deep enough", "data": [[[1], [2],[3]], [[4], [5], [6]]], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/maxContains.json000066400000000000000000000042431426774651400276440ustar00rootroot00000000000000[ { "description": "maxContains without contains is ignored", "schema": { "maxContains": 1 }, "tests": [ { "description": "one item valid against lone maxContains", "data": [ 1 ], "valid": true }, { "description": "two items still valid against lone maxContains", "data": [ 1, 2 ], "valid": true } ] }, { "description": "maxContains with contains", "schema": { "contains": {"const": 1}, "maxContains": 1 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "all elements match, valid maxContains", "data": [ 1 ], "valid": true }, { "description": "all elements match, invalid maxContains", "data": [ 1, 1 ], "valid": false }, { "description": "some elements match, valid maxContains", "data": [ 1, 2 ], "valid": true }, { "description": "some elements match, invalid maxContains", "data": [ 1, 2, 1 ], "valid": false } ] }, { "description": "minContains < maxContains", "schema": { "contains": {"const": 1}, "minContains": 1, "maxContains": 3 }, "tests": [ { "description": "actual < minContains < maxContains", "data": [ ], "valid": false }, { "description": "minContains < actual < maxContains", "data": [ 1, 1 ], "valid": true }, { "description": "minContains < maxContains < actual", "data": [ 1, 1, 1, 1 ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/maxItems.json000066400000000000000000000013021426774651400271400ustar00rootroot00000000000000[ { "description": "maxItems validation", "schema": {"maxItems": 2}, "tests": [ { "description": "shorter is valid", "data": [1], "valid": true }, { "description": "exact length is valid", "data": [1, 2], "valid": true }, { "description": "too long is invalid", "data": [1, 2, 3], "valid": false }, { "description": "ignores non-arrays", "data": "foobar", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/maxLength.json000066400000000000000000000016001426774651400273010ustar00rootroot00000000000000[ { "description": "maxLength validation", "schema": {"maxLength": 2}, "tests": [ { "description": "shorter is valid", "data": "f", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too long is invalid", "data": "foo", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true }, { "description": "two supplementary Unicode code points is long enough", "data": "\uD83D\uDCA9\uD83D\uDCA9", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/maxProperties.json000066400000000000000000000027321426774651400302230ustar00rootroot00000000000000[ { "description": "maxProperties validation", "schema": {"maxProperties": 2}, "tests": [ { "description": "shorter is valid", "data": {"foo": 1}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "too long is invalid", "data": {"foo": 1, "bar": 2, "baz": 3}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "maxProperties = 0 means the object is empty", "schema": { "maxProperties": 0 }, "tests": [ { "description": "no properties is valid", "data": {}, "valid": true }, { "description": "one property is invalid", "data": { "foo": 1 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/maximum.json000066400000000000000000000027041426774651400270350ustar00rootroot00000000000000[ { "description": "maximum validation", "schema": {"maximum": 3.0}, "tests": [ { "description": "below the maximum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 3.0, "valid": true }, { "description": "above the maximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "maximum validation with unsigned integer", "schema": {"maximum": 300}, "tests": [ { "description": "below the maximum is invalid", "data": 299.97, "valid": true }, { "description": "boundary point integer is valid", "data": 300, "valid": true }, { "description": "boundary point float is valid", "data": 300.00, "valid": true }, { "description": "above the maximum is invalid", "data": 300.5, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/minContains.json000066400000000000000000000113501426774651400276370ustar00rootroot00000000000000[ { "description": "minContains without contains is ignored", "schema": { "minContains": 1 }, "tests": [ { "description": "one item valid against lone minContains", "data": [ 1 ], "valid": true }, { "description": "zero items still valid against lone minContains", "data": [], "valid": true } ] }, { "description": "minContains=1 with contains", "schema": { "contains": {"const": 1}, "minContains": 1 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "no elements match", "data": [ 2 ], "valid": false }, { "description": "single element matches, valid minContains", "data": [ 1 ], "valid": true }, { "description": "some elements match, valid minContains", "data": [ 1, 2 ], "valid": true }, { "description": "all elements match, valid minContains", "data": [ 1, 1 ], "valid": true } ] }, { "description": "minContains=2 with contains", "schema": { "contains": {"const": 1}, "minContains": 2 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "all elements match, invalid minContains", "data": [ 1 ], "valid": false }, { "description": "some elements match, invalid minContains", "data": [ 1, 2 ], "valid": false }, { "description": "all elements match, valid minContains (exactly as needed)", "data": [ 1, 1 ], "valid": true }, { "description": "all elements match, valid minContains (more than needed)", "data": [ 1, 1, 1 ], "valid": true }, { "description": "some elements match, valid minContains", "data": [ 1, 2, 1 ], "valid": true } ] }, { "description": "maxContains = minContains", "schema": { "contains": {"const": 1}, "maxContains": 2, "minContains": 2 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "all elements match, invalid minContains", "data": [ 1 ], "valid": false }, { "description": "all elements match, invalid maxContains", "data": [ 1, 1, 1 ], "valid": false }, { "description": "all elements match, valid maxContains and minContains", "data": [ 1, 1 ], "valid": true } ] }, { "description": "maxContains < minContains", "schema": { "contains": {"const": 1}, "maxContains": 1, "minContains": 3 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "invalid minContains", "data": [ 1 ], "valid": false }, { "description": "invalid maxContains", "data": [ 1, 1, 1 ], "valid": false }, { "description": "invalid maxContains and minContains", "data": [ 1, 1 ], "valid": false } ] }, { "description": "minContains = 0", "schema": { "contains": {"const": 1}, "minContains": 0 }, "tests": [ { "description": "empty data", "data": [ ], "valid": true }, { "description": "minContains = 0 makes contains always pass", "data": [ 2 ], "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/minItems.json000066400000000000000000000012651426774651400271460ustar00rootroot00000000000000[ { "description": "minItems validation", "schema": {"minItems": 1}, "tests": [ { "description": "longer is valid", "data": [1, 2], "valid": true }, { "description": "exact length is valid", "data": [1], "valid": true }, { "description": "too short is invalid", "data": [], "valid": false }, { "description": "ignores non-arrays", "data": "", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/minLength.json000066400000000000000000000015661426774651400273120ustar00rootroot00000000000000[ { "description": "minLength validation", "schema": {"minLength": 2}, "tests": [ { "description": "longer is valid", "data": "foo", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too short is invalid", "data": "f", "valid": false }, { "description": "ignores non-strings", "data": 1, "valid": true }, { "description": "one supplementary Unicode code point is not long enough", "data": "\uD83D\uDCA9", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/minProperties.json000066400000000000000000000017541426774651400302240ustar00rootroot00000000000000[ { "description": "minProperties validation", "schema": {"minProperties": 1}, "tests": [ { "description": "longer is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1}, "valid": true }, { "description": "too short is invalid", "data": {}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/minimum.json000066400000000000000000000036121426774651400270320ustar00rootroot00000000000000[ { "description": "minimum validation", "schema": {"minimum": 1.1}, "tests": [ { "description": "above the minimum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 1.1, "valid": true }, { "description": "below the minimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "minimum validation with signed integer", "schema": {"minimum": -2}, "tests": [ { "description": "negative above the minimum is valid", "data": -1, "valid": true }, { "description": "positive above the minimum is valid", "data": 0, "valid": true }, { "description": "boundary point is valid", "data": -2, "valid": true }, { "description": "boundary point with float is valid", "data": -2.0, "valid": true }, { "description": "float below the minimum is invalid", "data": -2.0001, "valid": false }, { "description": "int below the minimum is invalid", "data": -3, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/multipleOf.json000066400000000000000000000035771426774651400275110ustar00rootroot00000000000000[ { "description": "by int", "schema": {"multipleOf": 2}, "tests": [ { "description": "int by int", "data": 10, "valid": true }, { "description": "int by int fail", "data": 7, "valid": false }, { "description": "ignores non-numbers", "data": "foo", "valid": true } ] }, { "description": "by number", "schema": {"multipleOf": 1.5}, "tests": [ { "description": "zero is multiple of anything", "data": 0, "valid": true }, { "description": "4.5 is multiple of 1.5", "data": 4.5, "valid": true }, { "description": "35 is not multiple of 1.5", "data": 35, "valid": false } ] }, { "description": "by small number", "schema": {"multipleOf": 0.0001}, "tests": [ { "description": "0.0075 is multiple of 0.0001", "data": 0.0075, "valid": true }, { "description": "0.00751 is not multiple of 0.0001", "data": 0.00751, "valid": false } ] }, { "description": "invalid instance should not raise error when float division = inf", "schema": {"type": "integer", "multipleOf": 0.123456789}, "tests": [ { "description": "always invalid, but naive implementations may raise an overflow error", "data": 1e308, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/not.json000066400000000000000000000053761426774651400261700ustar00rootroot00000000000000[ { "description": "not", "schema": { "not": {"type": "integer"} }, "tests": [ { "description": "allowed", "data": "foo", "valid": true }, { "description": "disallowed", "data": 1, "valid": false } ] }, { "description": "not multiple types", "schema": { "not": {"type": ["integer", "boolean"]} }, "tests": [ { "description": "valid", "data": "foo", "valid": true }, { "description": "mismatch", "data": 1, "valid": false }, { "description": "other mismatch", "data": true, "valid": false } ] }, { "description": "not more complex schema", "schema": { "not": { "type": "object", "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "match", "data": 1, "valid": true }, { "description": "other match", "data": {"foo": 1}, "valid": true }, { "description": "mismatch", "data": {"foo": "bar"}, "valid": false } ] }, { "description": "forbidden property", "schema": { "properties": { "foo": { "not": {} } } }, "tests": [ { "description": "property present", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "property absent", "data": {"bar": 1, "baz": 2}, "valid": true } ] }, { "description": "not with boolean schema true", "schema": {"not": true}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "not with boolean schema false", "schema": {"not": false}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/oneOf.json000066400000000000000000000161231426774651400264260ustar00rootroot00000000000000[ { "description": "oneOf", "schema": { "oneOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first oneOf valid", "data": 1, "valid": true }, { "description": "second oneOf valid", "data": 2.5, "valid": true }, { "description": "both oneOf valid", "data": 3, "valid": false }, { "description": "neither oneOf valid", "data": 1.5, "valid": false } ] }, { "description": "oneOf with base schema", "schema": { "type": "string", "oneOf" : [ { "minLength": 2 }, { "maxLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one oneOf valid", "data": "foobar", "valid": true }, { "description": "both oneOf valid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all true", "schema": {"oneOf": [true, true, true]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, one true", "schema": {"oneOf": [true, false, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "oneOf with boolean schemas, more than one true", "schema": {"oneOf": [true, true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all false", "schema": {"oneOf": [false, false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf complex types", "schema": { "oneOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second oneOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both oneOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": false }, { "description": "neither oneOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "oneOf with empty schema", "schema": { "oneOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "one valid - valid", "data": "foo", "valid": true }, { "description": "both valid - invalid", "data": 123, "valid": false } ] }, { "description": "oneOf with required", "schema": { "type": "object", "oneOf": [ { "required": ["foo", "bar"] }, { "required": ["foo", "baz"] } ] }, "tests": [ { "description": "both invalid - invalid", "data": {"bar": 2}, "valid": false }, { "description": "first valid - valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "second valid - valid", "data": {"foo": 1, "baz": 3}, "valid": true }, { "description": "both valid - invalid", "data": {"foo": 1, "bar": 2, "baz" : 3}, "valid": false } ] }, { "description": "oneOf with missing optional property", "schema": { "oneOf": [ { "properties": { "bar": true, "baz": true }, "required": ["bar"] }, { "properties": { "foo": true }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid", "data": {"bar": 8}, "valid": true }, { "description": "second oneOf valid", "data": {"foo": "foo"}, "valid": true }, { "description": "both oneOf valid", "data": {"foo": "foo", "bar": 8}, "valid": false }, { "description": "neither oneOf valid", "data": {"baz": "quux"}, "valid": false } ] }, { "description": "nested oneOf, to check validation semantics", "schema": { "oneOf": [ { "oneOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/000077500000000000000000000000001426774651400263075ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/bignum.json000066400000000000000000000057111426774651400304670ustar00rootroot00000000000000[ { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a bignum is an integer", "data": 12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a bignum is a number", "data": 98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a negative bignum is an integer", "data": -12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a negative bignum is a number", "data": -98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "string", "schema": {"type": "string"}, "tests": [ { "description": "a bignum is not a string", "data": 98249283749234923498293171823948729348710298301928331, "valid": false } ] }, { "description": "integer comparison", "schema": {"maximum": 18446744073709551615}, "tests": [ { "description": "comparison works for high numbers", "data": 18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision", "schema": { "exclusiveMaximum": 972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for high numbers", "data": 972783798187987123879878123.188781371, "valid": false } ] }, { "description": "integer comparison", "schema": {"minimum": -18446744073709551615}, "tests": [ { "description": "comparison works for very negative numbers", "data": -18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision on negative numbers", "schema": { "exclusiveMinimum": -972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for very negative numbers", "data": -972783798187987123879878123.188781371, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/ecmascript-regex.json000066400000000000000000000202161426774651400324450ustar00rootroot00000000000000[ { "description": "ECMA 262 regex $ does not match trailing newline", "schema": { "type": "string", "pattern": "^abc$" }, "tests": [ { "description": "matches in Python, but should not in jsonschema", "data": "abc\n", "valid": false }, { "description": "should match", "data": "abc", "valid": true } ] }, { "description": "ECMA 262 regex converts \\t to horizontal tab", "schema": { "type": "string", "pattern": "^\\t$" }, "tests": [ { "description": "does not match", "data": "\\t", "valid": false }, { "description": "matches", "data": "\u0009", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and upper letter", "schema": { "type": "string", "pattern": "^\\cC$" }, "tests": [ { "description": "does not match", "data": "\\cC", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and lower letter", "schema": { "type": "string", "pattern": "^\\cc$" }, "tests": [ { "description": "does not match", "data": "\\cc", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 \\d matches ascii digits only", "schema": { "type": "string", "pattern": "^\\d$" }, "tests": [ { "description": "ASCII zero matches", "data": "0", "valid": true }, { "description": "NKO DIGIT ZERO does not match (unlike e.g. Python)", "data": "߀", "valid": false }, { "description": "NKO DIGIT ZERO (as \\u escape) does not match", "data": "\u07c0", "valid": false } ] }, { "description": "ECMA 262 \\D matches everything but ascii digits", "schema": { "type": "string", "pattern": "^\\D$" }, "tests": [ { "description": "ASCII zero does not match", "data": "0", "valid": false }, { "description": "NKO DIGIT ZERO matches (unlike e.g. Python)", "data": "߀", "valid": true }, { "description": "NKO DIGIT ZERO (as \\u escape) matches", "data": "\u07c0", "valid": true } ] }, { "description": "ECMA 262 \\w matches ascii letters only", "schema": { "type": "string", "pattern": "^\\w$" }, "tests": [ { "description": "ASCII 'a' matches", "data": "a", "valid": true }, { "description": "latin-1 e-acute does not match (unlike e.g. Python)", "data": "é", "valid": false } ] }, { "description": "ECMA 262 \\W matches everything but ascii letters", "schema": { "type": "string", "pattern": "^\\W$" }, "tests": [ { "description": "ASCII 'a' does not match", "data": "a", "valid": false }, { "description": "latin-1 e-acute matches (unlike e.g. Python)", "data": "é", "valid": true } ] }, { "description": "ECMA 262 \\s matches whitespace", "schema": { "type": "string", "pattern": "^\\s$" }, "tests": [ { "description": "ASCII space matches", "data": " ", "valid": true }, { "description": "Character tabulation matches", "data": "\t", "valid": true }, { "description": "Line tabulation matches", "data": "\u000b", "valid": true }, { "description": "Form feed matches", "data": "\u000c", "valid": true }, { "description": "latin-1 non-breaking-space matches", "data": "\u00a0", "valid": true }, { "description": "zero-width whitespace matches", "data": "\ufeff", "valid": true }, { "description": "line feed matches (line terminator)", "data": "\u000a", "valid": true }, { "description": "paragraph separator matches (line terminator)", "data": "\u2029", "valid": true }, { "description": "EM SPACE matches (Space_Separator)", "data": "\u2003", "valid": true }, { "description": "Non-whitespace control does not match", "data": "\u0001", "valid": false }, { "description": "Non-whitespace does not match", "data": "\u2013", "valid": false } ] }, { "description": "ECMA 262 \\S matches everything but whitespace", "schema": { "type": "string", "pattern": "^\\S$" }, "tests": [ { "description": "ASCII space does not match", "data": " ", "valid": false }, { "description": "Character tabulation does not match", "data": "\t", "valid": false }, { "description": "Line tabulation does not match", "data": "\u000b", "valid": false }, { "description": "Form feed does not match", "data": "\u000c", "valid": false }, { "description": "latin-1 non-breaking-space does not match", "data": "\u00a0", "valid": false }, { "description": "zero-width whitespace does not match", "data": "\ufeff", "valid": false }, { "description": "line feed does not match (line terminator)", "data": "\u000a", "valid": false }, { "description": "paragraph separator does not match (line terminator)", "data": "\u2029", "valid": false }, { "description": "EM SPACE does not match (Space_Separator)", "data": "\u2003", "valid": false }, { "description": "Non-whitespace control matches", "data": "\u0001", "valid": true }, { "description": "Non-whitespace matches", "data": "\u2013", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/float-overflow.json000066400000000000000000000005511426774651400321510ustar00rootroot00000000000000[ { "description": "all integers are multiples of 0.5, if overflow is handled", "schema": {"type": "integer", "multipleOf": 0.5}, "tests": [ { "description": "valid if optional overflow handling is implemented", "data": 1e308, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/000077500000000000000000000000001426774651400275775ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/date-time.json000066400000000000000000000041421426774651400323440ustar00rootroot00000000000000[ { "description": "validation of date-time strings", "schema": {"format": "date-time"}, "tests": [ { "description": "a valid date-time string", "data": "1963-06-19T08:30:06.283185Z", "valid": true }, { "description": "a valid date-time string without second fraction", "data": "1963-06-19T08:30:06Z", "valid": true }, { "description": "a valid date-time string with plus offset", "data": "1937-01-01T12:00:27.87+00:20", "valid": true }, { "description": "a valid date-time string with minus offset", "data": "1990-12-31T15:59:50.123-08:00", "valid": true }, { "description": "a invalid day in date-time string", "data": "1990-02-31T15:59:60.123-08:00", "valid": false }, { "description": "an invalid offset in date-time string", "data": "1990-12-31T15:59:60-24:00", "valid": false }, { "description": "an invalid date-time string", "data": "06/19/1963 08:30:06 PST", "valid": false }, { "description": "case-insensitive T and Z", "data": "1963-06-19t08:30:06.283185z", "valid": true }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350T01:01:01", "valid": false }, { "description": "invalid non-padded month dates", "data": "1963-6-19T08:30:06.283185Z", "valid": false }, { "description": "invalid non-padded day dates", "data": "1963-06-1T08:30:06.283185Z", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/date.json000066400000000000000000000131301426774651400314050ustar00rootroot00000000000000[ { "description": "validation of date strings", "schema": {"format": "date"}, "tests": [ { "description": "a valid date string", "data": "1963-06-19", "valid": true }, { "description": "a valid date string with 31 days in January", "data": "2020-01-31", "valid": true }, { "description": "a invalid date string with 32 days in January", "data": "2020-01-32", "valid": false }, { "description": "a valid date string with 28 days in February (normal)", "data": "2021-02-28", "valid": true }, { "description": "a invalid date string with 29 days in February (normal)", "data": "2021-02-29", "valid": false }, { "description": "a valid date string with 29 days in February (leap)", "data": "2020-02-29", "valid": true }, { "description": "a invalid date string with 30 days in February (leap)", "data": "2020-02-30", "valid": false }, { "description": "a valid date string with 31 days in March", "data": "2020-03-31", "valid": true }, { "description": "a invalid date string with 32 days in March", "data": "2020-03-32", "valid": false }, { "description": "a valid date string with 30 days in April", "data": "2020-04-30", "valid": true }, { "description": "a invalid date string with 31 days in April", "data": "2020-04-31", "valid": false }, { "description": "a valid date string with 31 days in May", "data": "2020-05-31", "valid": true }, { "description": "a invalid date string with 32 days in May", "data": "2020-05-32", "valid": false }, { "description": "a valid date string with 30 days in June", "data": "2020-06-30", "valid": true }, { "description": "a invalid date string with 31 days in June", "data": "2020-06-31", "valid": false }, { "description": "a valid date string with 31 days in July", "data": "2020-07-31", "valid": true }, { "description": "a invalid date string with 32 days in July", "data": "2020-07-32", "valid": false }, { "description": "a valid date string with 31 days in August", "data": "2020-08-31", "valid": true }, { "description": "a invalid date string with 32 days in August", "data": "2020-08-32", "valid": false }, { "description": "a valid date string with 30 days in September", "data": "2020-09-30", "valid": true }, { "description": "a invalid date string with 31 days in September", "data": "2020-09-31", "valid": false }, { "description": "a valid date string with 31 days in October", "data": "2020-10-31", "valid": true }, { "description": "a invalid date string with 32 days in October", "data": "2020-10-32", "valid": false }, { "description": "a valid date string with 30 days in November", "data": "2020-11-30", "valid": true }, { "description": "a invalid date string with 31 days in November", "data": "2020-11-31", "valid": false }, { "description": "a valid date string with 31 days in December", "data": "2020-12-31", "valid": true }, { "description": "a invalid date string with 32 days in December", "data": "2020-12-32", "valid": false }, { "description": "a invalid date string with invalid month", "data": "2020-13-01", "valid": false }, { "description": "an invalid date string", "data": "06/19/1963", "valid": false }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350", "valid": false }, { "description": "invalidates non-padded month dates", "data": "1998-1-20", "valid": false }, { "description": "invalidates non-padded day dates", "data": "1998-01-1", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/duration.json000066400000000000000000000047401426774651400323240ustar00rootroot00000000000000[ { "description": "validation of duration strings", "schema": {"format": "duration"}, "tests": [ { "description": "a valid duration string", "data": "P4DT12H30M5S", "valid": true }, { "description": "an invalid duration string", "data": "PT1D", "valid": false }, { "description": "no elements present", "data": "P", "valid": false }, { "description": "no time elements present", "data": "P1YT", "valid": false }, { "description": "no date or time elements present", "data": "PT", "valid": false }, { "description": "elements out of order", "data": "P2D1Y", "valid": false }, { "description": "missing time separator", "data": "P1D2H", "valid": false }, { "description": "time element in the date position", "data": "P2S", "valid": false }, { "description": "four years duration", "data": "P4Y", "valid": true }, { "description": "zero time, in seconds", "data": "PT0S", "valid": true }, { "description": "zero time, in days", "data": "P0D", "valid": true }, { "description": "one month duration", "data": "P1M", "valid": true }, { "description": "one minute duration", "data": "PT1M", "valid": true }, { "description": "one and a half days, in hours", "data": "PT36H", "valid": true }, { "description": "one and a half days, in days and hours", "data": "P1DT12H", "valid": true }, { "description": "two weeks", "data": "P2W", "valid": true }, { "description": "weeks cannot be combined with other units", "data": "P1Y2W", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/email.json000066400000000000000000000032331426774651400315620ustar00rootroot00000000000000[ { "description": "validation of e-mail addresses", "schema": {"format": "email"}, "tests": [ { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false }, { "description": "tilde in local part is valid", "data": "te~st@example.com", "valid": true }, { "description": "tilde before local part is valid", "data": "~test@example.com", "valid": true }, { "description": "tilde after local part is valid", "data": "test~@example.com", "valid": true }, { "description": "dot before local part is not valid", "data": ".test@example.com", "valid": false }, { "description": "dot after local part is not valid", "data": "test.@example.com", "valid": false }, { "description": "two separated dots inside local part are valid", "data": "te.s.t@example.com", "valid": true }, { "description": "two subsequent dots inside local part are not valid", "data": "te..st@example.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/hostname.json000066400000000000000000000043531426774651400323150ustar00rootroot00000000000000[ { "description": "validation of host names", "schema": {"format": "hostname"}, "tests": [ { "description": "a valid host name", "data": "www.example.com", "valid": true }, { "description": "a valid punycoded IDN hostname", "data": "xn--4gbwdl.xn--wgbh1c", "valid": true }, { "description": "a host name starting with an illegal character", "data": "-a-host-name-that-starts-with--", "valid": false }, { "description": "a host name containing illegal characters", "data": "not_a_valid_host_name", "valid": false }, { "description": "a host name with a component too long", "data": "a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component", "valid": false }, { "description": "starts with hyphen", "data": "-hostname", "valid": false }, { "description": "ends with hyphen", "data": "hostname-", "valid": false }, { "description": "starts with underscore", "data": "_hostname", "valid": false }, { "description": "ends with underscore", "data": "hostname_", "valid": false }, { "description": "contains underscore", "data": "host_name", "valid": false }, { "description": "maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com", "valid": true }, { "description": "exceeds maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/idn-email.json000066400000000000000000000015031426774651400323300ustar00rootroot00000000000000[ { "description": "validation of an internationalized e-mail addresses", "schema": {"format": "idn-email"}, "tests": [ { "description": "a valid idn e-mail (example@example.test in Hangul)", "data": "실례@실례.테스트", "valid": true }, { "description": "an invalid idn e-mail address", "data": "2962", "valid": false }, { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/idn-hostname.json000066400000000000000000000327721426774651400330730ustar00rootroot00000000000000[ { "description": "validation of internationalized host names", "schema": { "format": "idn-hostname" }, "tests": [ { "description": "a valid host name (example.test in Hangul)", "data": "실례.테스트", "valid": true }, { "description": "illegal first char U+302E Hangul single dot tone mark", "data": "〮실례.테스트", "valid": false }, { "description": "contains illegal char U+302E Hangul single dot tone mark", "data": "실〮례.테스트", "valid": false }, { "description": "a host name with a component too long", "data": "실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실례례테스트례례례례례례례례례례례례례례례례례테스트례례례례례례례례례례례례례례례례례례례테스트례례례례례례례례례례례례테스트례례실례.테스트", "valid": false }, { "description": "invalid label, correct Punycode", "comment": "https://tools.ietf.org/html/rfc5890#section-2.3.2.1 https://tools.ietf.org/html/rfc5891#section-4.4 https://tools.ietf.org/html/rfc3492#section-7.1", "data": "-> $1.00 <--", "valid": false }, { "description": "valid Chinese Punycode", "comment": "https://tools.ietf.org/html/rfc5890#section-2.3.2.1 https://tools.ietf.org/html/rfc5891#section-4.4", "data": "xn--ihqwcrb4cv8a8dqg056pqjye", "valid": true }, { "description": "invalid Punycode", "comment": "https://tools.ietf.org/html/rfc5891#section-4.4 https://tools.ietf.org/html/rfc5890#section-2.3.2.1", "data": "xn--X", "valid": false }, { "description": "U-label contains \"--\" in the 3rd and 4th position", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1 https://tools.ietf.org/html/rfc5890#section-2.3.2.1", "data": "XN--aa---o47jg78q", "valid": false }, { "description": "U-label starts with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "-hello", "valid": false }, { "description": "U-label ends with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "hello-", "valid": false }, { "description": "U-label starts and ends with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "-hello-", "valid": false }, { "description": "Begins with a Spacing Combining Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0903hello", "valid": false }, { "description": "Begins with a Nonspacing Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0300hello", "valid": false }, { "description": "Begins with an Enclosing Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0488hello", "valid": false }, { "description": "Exceptions that are PVALID, left-to-right chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u00df\u03c2\u0f0b\u3007", "valid": true }, { "description": "Exceptions that are PVALID, right-to-left chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u06fd\u06fe", "valid": true }, { "description": "Exceptions that are DISALLOWED, right-to-left chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u0640\u07fa", "valid": false }, { "description": "Exceptions that are DISALLOWED, left-to-right chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6 Note: The two combining marks (U+302E and U+302F) are in the middle and not at the start", "data": "\u3031\u3032\u3033\u3034\u3035\u302e\u302f\u303b", "valid": false }, { "description": "MIDDLE DOT with no preceding 'l'", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "a\u00b7l", "valid": false }, { "description": "MIDDLE DOT with nothing preceding", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "\u00b7l", "valid": false }, { "description": "MIDDLE DOT with no following 'l'", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7a", "valid": false }, { "description": "MIDDLE DOT with nothing following", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7", "valid": false }, { "description": "MIDDLE DOT with surrounding 'l's", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7l", "valid": true }, { "description": "Greek KERAIA not followed by Greek", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375S", "valid": false }, { "description": "Greek KERAIA not followed by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375", "valid": false }, { "description": "Greek KERAIA followed by Greek", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375\u03b2", "valid": true }, { "description": "Hebrew GERESH not preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "A\u05f3\u05d1", "valid": false }, { "description": "Hebrew GERESH not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "\u05f3\u05d1", "valid": false }, { "description": "Hebrew GERESH preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "\u05d0\u05f3\u05d1", "valid": true }, { "description": "Hebrew GERSHAYIM not preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "A\u05f4\u05d1", "valid": false }, { "description": "Hebrew GERSHAYIM not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "\u05f4\u05d1", "valid": false }, { "description": "Hebrew GERSHAYIM preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "\u05d0\u05f4\u05d1", "valid": true }, { "description": "KATAKANA MIDDLE DOT with no Hiragana, Katakana, or Han", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "def\u30fbabc", "valid": false }, { "description": "KATAKANA MIDDLE DOT with no other characters", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb", "valid": false }, { "description": "KATAKANA MIDDLE DOT with Hiragana", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u3041", "valid": true }, { "description": "KATAKANA MIDDLE DOT with Katakana", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u30a1", "valid": true }, { "description": "KATAKANA MIDDLE DOT with Han", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u4e08", "valid": true }, { "description": "Arabic-Indic digits mixed with Extended Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.8", "data": "\u0660\u06f0", "valid": false }, { "description": "Arabic-Indic digits not mixed with Extended Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.8", "data": "\u0628\u0660\u0628", "valid": true }, { "description": "Extended Arabic-Indic digits not mixed with Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.9", "data": "\u06f00", "valid": true }, { "description": "ZERO WIDTH JOINER not preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u0915\u200d\u0937", "valid": false }, { "description": "ZERO WIDTH JOINER not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u200d\u0937", "valid": false }, { "description": "ZERO WIDTH JOINER preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u0915\u094d\u200d\u0937", "valid": true }, { "description": "ZERO WIDTH NON-JOINER preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.1", "data": "\u0915\u094d\u200c\u0937", "valid": true }, { "description": "ZERO WIDTH NON-JOINER not preceded by Virama but matches regexp", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.1 https://www.w3.org/TR/alreq/#h_disjoining_enforcement", "data": "\u0628\u064a\u200c\u0628\u064a", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/ipv4.json000066400000000000000000000032731426774651400313610ustar00rootroot00000000000000[ { "description": "validation of IP addresses", "schema": {"format": "ipv4"}, "tests": [ { "description": "a valid IP address", "data": "192.168.0.1", "valid": true }, { "description": "an IP address with too many components", "data": "127.0.0.0.1", "valid": false }, { "description": "an IP address with out-of-range values", "data": "256.256.256.256", "valid": false }, { "description": "an IP address without 4 components", "data": "127.0", "valid": false }, { "description": "an IP address as an integer", "data": "0x7f000001", "valid": false }, { "description": "an IP address as an integer (decimal)", "data": "2130706433", "valid": false }, { "description": "leading zeroes should be rejected, as they are treated as octals", "comment": "see https://sick.codes/universal-netmask-npm-package-used-by-270000-projects-vulnerable-to-octal-input-data-server-side-request-forgery-remote-file-inclusion-local-file-inclusion-and-more-cve-2021-28918/", "data": "087.10.0.1", "valid": false }, { "description": "value without leading zero is valid", "data": "87.10.0.1", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/ipv6.json000066400000000000000000000120111426774651400313510ustar00rootroot00000000000000[ { "description": "validation of IPv6 addresses", "schema": {"format": "ipv6"}, "tests": [ { "description": "a valid IPv6 address", "data": "::1", "valid": true }, { "description": "an IPv6 address with out-of-range values", "data": "12345::", "valid": false }, { "description": "an IPv6 address with too many components", "data": "1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1", "valid": false }, { "description": "an IPv6 address containing illegal characters", "data": "::laptop", "valid": false }, { "description": "no digits is valid", "data": "::", "valid": true }, { "description": "leading colons is valid", "data": "::42:ff:1", "valid": true }, { "description": "trailing colons is valid", "data": "d6::", "valid": true }, { "description": "missing leading octet is invalid", "data": ":2:3:4:5:6:7:8", "valid": false }, { "description": "missing trailing octet is invalid", "data": "1:2:3:4:5:6:7:", "valid": false }, { "description": "missing leading octet with omitted octets later", "data": ":2:3:4::8", "valid": false }, { "description": "two sets of double colons is invalid", "data": "1::d6::42", "valid": false }, { "description": "mixed format with the ipv4 section as decimal octets", "data": "1::d6:192.168.0.1", "valid": true }, { "description": "mixed format with double colons between the sections", "data": "1:2::192.168.0.1", "valid": true }, { "description": "mixed format with ipv4 section with octet out of range", "data": "1::2:192.168.256.1", "valid": false }, { "description": "mixed format with ipv4 section with a hex octet", "data": "1::2:192.168.ff.1", "valid": false }, { "description": "mixed format with leading double colons (ipv4-mapped ipv6 address)", "data": "::ffff:192.168.0.1", "valid": true }, { "description": "triple colons is invalid", "data": "1:2:3:4:5:::8", "valid": false }, { "description": "8 octets", "data": "1:2:3:4:5:6:7:8", "valid": true }, { "description": "insufficient octets without double colons", "data": "1:2:3:4:5:6:7", "valid": false }, { "description": "no colons is invalid", "data": "1", "valid": false }, { "description": "ipv4 is not ipv6", "data": "127.0.0.1", "valid": false }, { "description": "ipv4 segment must have 4 octets", "data": "1:2:3:4:1.2.3", "valid": false }, { "description": "leading whitespace is invalid", "data": " ::1", "valid": false }, { "description": "trailing whitespace is invalid", "data": "::1 ", "valid": false }, { "description": "netmask is not a part of ipv6 address", "data": "fe80::/64", "valid": false }, { "description": "zone id is not a part of ipv6 address", "data": "fe80::a%eth1", "valid": false }, { "description": "a long valid ipv6", "data": "1000:1000:1000:1000:1000:1000:255.255.255.255", "valid": true }, { "description": "a long invalid ipv6, below length limit, first", "data": "100:100:100:100:100:100:255.255.255.255.255", "valid": false }, { "description": "a long invalid ipv6, below length limit, second", "data": "100:100:100:100:100:100:100:255.255.255.255", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/iri-reference.json000066400000000000000000000024411426774651400332120ustar00rootroot00000000000000[ { "description": "validation of IRI References", "schema": {"format": "iri-reference"}, "tests": [ { "description": "a valid IRI", "data": "http://ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid protocol-relative IRI Reference", "data": "//ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid relative IRI Reference", "data": "/âππ", "valid": true }, { "description": "an invalid IRI Reference", "data": "\\\\WINDOWS\\filëßåré", "valid": false }, { "description": "a valid IRI Reference", "data": "âππ", "valid": true }, { "description": "a valid IRI fragment", "data": "#ƒrägmênt", "valid": true }, { "description": "an invalid IRI fragment", "data": "#ƒräg\\mênt", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/iri.json000066400000000000000000000034531426774651400312620ustar00rootroot00000000000000[ { "description": "validation of IRIs", "schema": {"format": "iri"}, "tests": [ { "description": "a valid IRI with anchor tag", "data": "http://ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid IRI with anchor tag and parentheses", "data": "http://ƒøø.com/blah_(wîkïpédiå)_blah#ßité-1", "valid": true }, { "description": "a valid IRI with URL-encoded stuff", "data": "http://ƒøø.ßår/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid IRI with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid IRI based on IPv6", "data": "http://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", "valid": true }, { "description": "an invalid IRI based on IPv6", "data": "http://2001:0db8:85a3:0000:0000:8a2e:0370:7334", "valid": false }, { "description": "an invalid relative IRI Reference", "data": "/abc", "valid": false }, { "description": "an invalid IRI", "data": "\\\\WINDOWS\\filëßåré", "valid": false }, { "description": "an invalid IRI though valid IRI reference", "data": "âππ", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/json-pointer.json000066400000000000000000000132121426774651400331200ustar00rootroot00000000000000[ { "description": "validation of JSON-pointers (JSON String Representation)", "schema": {"format": "json-pointer"}, "tests": [ { "description": "a valid JSON-pointer", "data": "/foo/bar~0/baz~1/%a", "valid": true }, { "description": "not a valid JSON-pointer (~ not escaped)", "data": "/foo/bar~", "valid": false }, { "description": "valid JSON-pointer with empty segment", "data": "/foo//bar", "valid": true }, { "description": "valid JSON-pointer with the last empty segment", "data": "/foo/bar/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #1", "data": "", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #2", "data": "/foo", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #3", "data": "/foo/0", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #4", "data": "/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #5", "data": "/a~1b", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #6", "data": "/c%d", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #7", "data": "/e^f", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #8", "data": "/g|h", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #9", "data": "/i\\j", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #10", "data": "/k\"l", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #11", "data": "/ ", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #12", "data": "/m~0n", "valid": true }, { "description": "valid JSON-pointer used adding to the last array position", "data": "/foo/-", "valid": true }, { "description": "valid JSON-pointer (- used as object member name)", "data": "/foo/-/bar", "valid": true }, { "description": "valid JSON-pointer (multiple escaped characters)", "data": "/~1~0~0~1~1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #1", "data": "/~1.1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #2", "data": "/~0.1", "valid": true }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #1", "data": "#", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #2", "data": "#/", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #3", "data": "#a", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #1", "data": "/~0~", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #2", "data": "/~0/~", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #1", "data": "/~2", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #2", "data": "/~-1", "valid": false }, { "description": "not a valid JSON-pointer (multiple characters not escaped)", "data": "/~~", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #1", "data": "a", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #2", "data": "0", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #3", "data": "a/a", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/regex.json000066400000000000000000000007451426774651400316120ustar00rootroot00000000000000[ { "description": "validation of regular expressions", "schema": {"format": "regex"}, "tests": [ { "description": "a valid regular expression", "data": "([abc])+\\s+$", "valid": true }, { "description": "a regular expression with unclosed parens is invalid", "data": "^(abc]", "valid": false } ] } ] relative-json-pointer.json000066400000000000000000000031671426774651400346620ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format[ { "description": "validation of Relative JSON Pointers (RJP)", "schema": {"format": "relative-json-pointer"}, "tests": [ { "description": "a valid upwards RJP", "data": "1", "valid": true }, { "description": "a valid downwards RJP", "data": "0/foo/bar", "valid": true }, { "description": "a valid up and then down RJP, with array index", "data": "2/0/baz/1/zip", "valid": true }, { "description": "a valid RJP taking the member or index name", "data": "0#", "valid": true }, { "description": "an invalid RJP that is a valid JSON Pointer", "data": "/foo/bar", "valid": false }, { "description": "negative prefix", "data": "-1/foo/bar", "valid": false }, { "description": "## is not a valid json-pointer", "data": "0##", "valid": false }, { "description": "zero cannot be followed by other digits, plus json-pointer", "data": "01/a", "valid": false }, { "description": "zero cannot be followed by other digits, plus octothorpe", "data": "01#", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/time.json000066400000000000000000000064221426774651400314340ustar00rootroot00000000000000[ { "description": "validation of time strings", "schema": {"format": "time"}, "tests": [ { "description": "a valid time string", "data": "08:30:06Z", "valid": true }, { "description": "a valid time string with leap second", "data": "23:59:60Z", "valid": true }, { "description": "a valid time string with leap second with offset", "data": "15:59:60-08:00", "valid": true }, { "description": "a valid time string with second fraction", "data": "23:20:50.52Z", "valid": true }, { "description": "a valid time string with precise second fraction", "data": "08:30:06.283185Z", "valid": true }, { "description": "a valid time string with plus offset", "data": "08:30:06+00:20", "valid": true }, { "description": "a valid time string with minus offset", "data": "08:30:06-08:00", "valid": true }, { "description": "a valid time string with case-insensitive Z", "data": "08:30:06z", "valid": true }, { "description": "an invalid time string with invalid hour", "data": "24:00:00Z", "valid": false }, { "description": "an invalid time string with invalid minute", "data": "00:60:00Z", "valid": false }, { "description": "an invalid time string with invalid second", "data": "00:00:61Z", "valid": false }, { "description": "an invalid time string with invalid leap second (wrong hour)", "data": "22:59:60Z", "valid": false }, { "description": "an invalid time string with invalid leap second (wrong minute)", "data": "23:58:60Z", "valid": false }, { "description": "an invalid time string with invalid time numoffset hour", "data": "01:02:03+24:00", "valid": false }, { "description": "an invalid time string with invalid time numoffset minute", "data": "01:02:03+00:60", "valid": false }, { "description": "an invalid time string with invalid time with both Z and numoffset", "data": "01:02:03Z+00:30", "valid": false }, { "description": "an invalid time string", "data": "08:30:06 PST", "valid": false }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "01:01:01,1111", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/uri-reference.json000066400000000000000000000023661426774651400332340ustar00rootroot00000000000000[ { "description": "validation of URI References", "schema": {"format": "uri-reference"}, "tests": [ { "description": "a valid URI", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid relative URI Reference", "data": "/abc", "valid": true }, { "description": "an invalid URI Reference", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "a valid URI Reference", "data": "abc", "valid": true }, { "description": "a valid URI fragment", "data": "#fragment", "valid": true }, { "description": "an invalid URI fragment", "data": "#frag\\ment", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/uri-template.json000066400000000000000000000015601426774651400331040ustar00rootroot00000000000000[ { "description": "format: uri-template", "schema": {"format": "uri-template"}, "tests": [ { "description": "a valid uri-template", "data": "http://example.com/dictionary/{term:1}/{term}", "valid": true }, { "description": "an invalid uri-template", "data": "http://example.com/dictionary/{term:1}/{term", "valid": false }, { "description": "a valid uri-template without variables", "data": "http://example.com/dictionary", "valid": true }, { "description": "a valid relative uri-template", "data": "dictionary/{term:1}/{term}", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/uri.json000066400000000000000000000071631426774651400313000ustar00rootroot00000000000000[ { "description": "validation of URIs", "schema": {"format": "uri"}, "tests": [ { "description": "a valid URL with anchor tag", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid URL with anchor tag and parentheses", "data": "http://foo.com/blah_(wikipedia)_blah#cite-1", "valid": true }, { "description": "a valid URL with URL-encoded stuff", "data": "http://foo.bar/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid puny-coded URL ", "data": "http://xn--nw2a.xn--j6w193g/", "valid": true }, { "description": "a valid URL with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid URL based on IPv4", "data": "http://223.255.255.254", "valid": true }, { "description": "a valid URL with ftp scheme", "data": "ftp://ftp.is.co.za/rfc/rfc1808.txt", "valid": true }, { "description": "a valid URL for a simple text file", "data": "http://www.ietf.org/rfc/rfc2396.txt", "valid": true }, { "description": "a valid URL ", "data": "ldap://[2001:db8::7]/c=GB?objectClass?one", "valid": true }, { "description": "a valid mailto URI", "data": "mailto:John.Doe@example.com", "valid": true }, { "description": "a valid newsgroup URI", "data": "news:comp.infosystems.www.servers.unix", "valid": true }, { "description": "a valid tel URI", "data": "tel:+1-816-555-1212", "valid": true }, { "description": "a valid URN", "data": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", "valid": true }, { "description": "an invalid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": false }, { "description": "an invalid relative URI Reference", "data": "/abc", "valid": false }, { "description": "an invalid URI", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "an invalid URI though valid URI reference", "data": "abc", "valid": false }, { "description": "an invalid URI with spaces", "data": "http:// shouldfail.com", "valid": false }, { "description": "an invalid URI with spaces and missing scheme", "data": ":// should fail", "valid": false }, { "description": "an invalid URI with comma in scheme", "data": "bar,baz:foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/format/uuid.json000066400000000000000000000042601426774651400314420ustar00rootroot00000000000000[ { "description": "uuid format", "schema": { "format": "uuid" }, "tests": [ { "description": "all upper-case", "data": "2EB8AA08-AA98-11EA-B4AA-73B441D16380", "valid": true }, { "description": "all lower-case", "data": "2eb8aa08-aa98-11ea-b4aa-73b441d16380", "valid": true }, { "description": "mixed case", "data": "2eb8aa08-AA98-11ea-B4Aa-73B441D16380", "valid": true }, { "description": "all zeroes is valid", "data": "00000000-0000-0000-0000-000000000000", "valid": true }, { "description": "wrong length", "data": "2eb8aa08-aa98-11ea-b4aa-73b441d1638", "valid": false }, { "description": "missing section", "data": "2eb8aa08-aa98-11ea-73b441d16380", "valid": false }, { "description": "bad characters (not hex)", "data": "2eb8aa08-aa98-11ea-b4ga-73b441d16380", "valid": false }, { "description": "no dashes", "data": "2eb8aa08aa9811eab4aa73b441d16380", "valid": false }, { "description": "valid version 4", "data": "98d80576-482e-427f-8434-7f86890ab222", "valid": true }, { "description": "valid version 5", "data": "99c17cbb-656f-564a-940f-1a4568f03487", "valid": true }, { "description": "hypothetical version 6", "data": "99c17cbb-656f-664a-940f-1a4568f03487", "valid": true }, { "description": "hypothetical version 15", "data": "99c17cbb-656f-f64a-940f-1a4568f03487", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/non-bmp-regex.json000066400000000000000000000045361426774651400316700ustar00rootroot00000000000000[ { "description": "Proper UTF-16 surrogate pair handling: pattern", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "pattern": "^🐲*$" }, "tests": [ { "description": "matches empty", "data": "", "valid": true }, { "description": "matches single", "data": "🐲", "valid": true }, { "description": "matches two", "data": "🐲🐲", "valid": true }, { "description": "doesn't match one", "data": "🐉", "valid": false }, { "description": "doesn't match two", "data": "🐉🐉", "valid": false }, { "description": "doesn't match one ASCII", "data": "D", "valid": false }, { "description": "doesn't match two ASCII", "data": "DD", "valid": false } ] }, { "description": "Proper UTF-16 surrogate pair handling: patternProperties", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "patternProperties": { "^🐲*$": { "type": "integer" } } }, "tests": [ { "description": "matches empty", "data": { "": 1 }, "valid": true }, { "description": "matches single", "data": { "🐲": 1 }, "valid": true }, { "description": "matches two", "data": { "🐲🐲": 1 }, "valid": true }, { "description": "doesn't match one", "data": { "🐲": "hello" }, "valid": false }, { "description": "doesn't match two", "data": { "🐲🐲": "hello" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/refOfUnknownKeyword.json000066400000000000000000000022141426774651400331670ustar00rootroot00000000000000[ { "description": "reference of a root arbitrary keyword ", "schema": { "unknown-keyword": {"type": "integer"}, "properties": { "bar": {"$ref": "#/unknown-keyword"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "reference of an arbitrary keyword of a sub-schema", "schema": { "properties": { "foo": {"unknown-keyword": {"type": "integer"}}, "bar": {"$ref": "#/properties/foo/unknown-keyword"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/optional/unicode.json000066400000000000000000000127301426774651400306330ustar00rootroot00000000000000[ { "description": "unicode semantics should be used for all pattern matching", "schema": { "pattern": "\\wcole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode matching is case-sensitive", "data": "LES HIVERS DE MON ENFANCE ÉTAIENT DES SAISONS LONGUES, LONGUES. NOUS VIVIONS EN TROIS LIEUX: L'ÉCOLE, L'ÉGLISE ET LA PATINOIRE; MAIS LA VRAIE VIE ÉTAIT SUR LA PATINOIRE.", "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "pattern": "[a-z]cole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "ascii characters match", "data": "Les hivers de mon enfance etaient des saisons longues, longues. Nous vivions en trois lieux: l'ecole, l'eglise et la patinoire; mais la vraie vie etait sur la patinoire.", "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "pattern": "^\\d+$" }, "tests": [ { "description": "ascii digits", "data": "42", "valid": true }, { "description": "ascii non-digits", "data": "-%#", "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": "৪২", "valid": true } ] }, { "description": "unicode semantics should be used for all patternProperties matching", "schema": { "type": "object", "patternProperties": { "\\wcole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": true }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": true }, { "description": "unicode matching is case-sensitive", "data": { "L'ÉCOLE": "PAS DE VRAIE VIE" }, "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "type": "object", "patternProperties": { "[a-z]cole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": false }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": false }, { "description": "ascii characters match", "data": { "l'ecole": "pas de vraie vie" }, "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "type": "object", "patternProperties": { "^\\d+$": true }, "additionalProperties": false }, "tests": [ { "description": "ascii digits", "data": { "42": "life, the universe, and everything" }, "valid": true }, { "description": "ascii non-digits", "data": { "-%#": "spending the year dead for tax reasons" }, "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": { "৪২": "khajit has wares if you have coin" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/pattern.json000066400000000000000000000030031426774651400270260ustar00rootroot00000000000000[ { "description": "pattern validation", "schema": {"pattern": "^a*$"}, "tests": [ { "description": "a matching pattern is valid", "data": "aaa", "valid": true }, { "description": "a non-matching pattern is invalid", "data": "abc", "valid": false }, { "description": "ignores booleans", "data": true, "valid": true }, { "description": "ignores integers", "data": 123, "valid": true }, { "description": "ignores floats", "data": 1.0, "valid": true }, { "description": "ignores objects", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores null", "data": null, "valid": true } ] }, { "description": "pattern is not anchored", "schema": {"pattern": "a+"}, "tests": [ { "description": "matches a substring", "data": "xxaayy", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/patternProperties.json000066400000000000000000000112511426774651400311070ustar00rootroot00000000000000[ { "description": "patternProperties validates properties matching a regex", "schema": { "patternProperties": { "f.*o": {"type": "integer"} } }, "tests": [ { "description": "a single valid match is valid", "data": {"foo": 1}, "valid": true }, { "description": "multiple valid matches is valid", "data": {"foo": 1, "foooooo" : 2}, "valid": true }, { "description": "a single invalid match is invalid", "data": {"foo": "bar", "fooooo": 2}, "valid": false }, { "description": "multiple invalid matches is invalid", "data": {"foo": "bar", "foooooo" : "baz"}, "valid": false }, { "description": "ignores arrays", "data": ["foo"], "valid": true }, { "description": "ignores strings", "data": "foo", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "multiple simultaneous patternProperties are validated", "schema": { "patternProperties": { "a*": {"type": "integer"}, "aaa*": {"maximum": 20} } }, "tests": [ { "description": "a single valid match is valid", "data": {"a": 21}, "valid": true }, { "description": "a simultaneous match is valid", "data": {"aaaa": 18}, "valid": true }, { "description": "multiple matches is valid", "data": {"a": 21, "aaaa": 18}, "valid": true }, { "description": "an invalid due to one is invalid", "data": {"a": "bar"}, "valid": false }, { "description": "an invalid due to the other is invalid", "data": {"aaaa": 31}, "valid": false }, { "description": "an invalid due to both is invalid", "data": {"aaa": "foo", "aaaa": 31}, "valid": false } ] }, { "description": "regexes are not anchored by default and are case sensitive", "schema": { "patternProperties": { "[0-9]{2,}": { "type": "boolean" }, "X_": { "type": "string" } } }, "tests": [ { "description": "non recognized members are ignored", "data": { "answer 1": "42" }, "valid": true }, { "description": "recognized members are accounted for", "data": { "a31b": null }, "valid": false }, { "description": "regexes are case sensitive", "data": { "a_x_3": 3 }, "valid": true }, { "description": "regexes are case sensitive, 2", "data": { "a_X_3": 3 }, "valid": false } ] }, { "description": "patternProperties with boolean schemas", "schema": { "patternProperties": { "f.*": true, "b.*": false } }, "tests": [ { "description": "object with property matching schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property matching schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "object with a property matching both true and false is invalid", "data": {"foobar":1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/properties.json000066400000000000000000000120341426774651400275510ustar00rootroot00000000000000[ { "description": "object properties validation", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "string"} } }, "tests": [ { "description": "both properties present and valid is valid", "data": {"foo": 1, "bar": "baz"}, "valid": true }, { "description": "one property invalid is invalid", "data": {"foo": 1, "bar": {}}, "valid": false }, { "description": "both properties invalid is invalid", "data": {"foo": [], "bar": {}}, "valid": false }, { "description": "doesn't invalidate other properties", "data": {"quux": []}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "properties, patternProperties, additionalProperties interaction", "schema": { "properties": { "foo": {"type": "array", "maxItems": 3}, "bar": {"type": "array"} }, "patternProperties": {"f.o": {"minItems": 2}}, "additionalProperties": {"type": "integer"} }, "tests": [ { "description": "property validates property", "data": {"foo": [1, 2]}, "valid": true }, { "description": "property invalidates property", "data": {"foo": [1, 2, 3, 4]}, "valid": false }, { "description": "patternProperty invalidates property", "data": {"foo": []}, "valid": false }, { "description": "patternProperty validates nonproperty", "data": {"fxo": [1, 2]}, "valid": true }, { "description": "patternProperty invalidates nonproperty", "data": {"fxo": []}, "valid": false }, { "description": "additionalProperty ignores property", "data": {"bar": []}, "valid": true }, { "description": "additionalProperty validates others", "data": {"quux": 3}, "valid": true }, { "description": "additionalProperty invalidates others", "data": {"quux": "foo"}, "valid": false } ] }, { "description": "properties with boolean schema", "schema": { "properties": { "foo": true, "bar": false } }, "tests": [ { "description": "no property present is valid", "data": {}, "valid": true }, { "description": "only 'true' property present is valid", "data": {"foo": 1}, "valid": true }, { "description": "only 'false' property present is invalid", "data": {"bar": 2}, "valid": false }, { "description": "both properties present is invalid", "data": {"foo": 1, "bar": 2}, "valid": false } ] }, { "description": "properties with escaped characters", "schema": { "properties": { "foo\nbar": {"type": "number"}, "foo\"bar": {"type": "number"}, "foo\\bar": {"type": "number"}, "foo\rbar": {"type": "number"}, "foo\tbar": {"type": "number"}, "foo\fbar": {"type": "number"} } }, "tests": [ { "description": "object with all numbers is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1", "foo\\bar": "1", "foo\rbar": "1", "foo\tbar": "1", "foo\fbar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/propertyNames.json000066400000000000000000000055771426774651400302430ustar00rootroot00000000000000[ { "description": "propertyNames validation", "schema": { "propertyNames": {"maxLength": 3} }, "tests": [ { "description": "all property names valid", "data": { "f": {}, "foo": {} }, "valid": true }, { "description": "some property names invalid", "data": { "foo": {}, "foobar": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [1, 2, 3, 4], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "propertyNames validation with pattern", "schema": { "propertyNames": { "pattern": "^a+$" } }, "tests": [ { "description": "matching property names valid", "data": { "a": {}, "aa": {}, "aaa": {} }, "valid": true }, { "description": "non-matching property name is invalid", "data": { "aaA": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema true", "schema": {"propertyNames": true}, "tests": [ { "description": "object with any properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema false", "schema": {"propertyNames": false}, "tests": [ { "description": "object with any properties is invalid", "data": {"foo": 1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/recursiveRef.json000066400000000000000000000320451426774651400300250ustar00rootroot00000000000000[ { "description": "$recursiveRef without $recursiveAnchor works like $ref", "schema": { "properties": { "foo": { "$recursiveRef": "#" } }, "additionalProperties": false }, "tests": [ { "description": "match", "data": {"foo": false}, "valid": true }, { "description": "recursive match", "data": { "foo": { "foo": false } }, "valid": true }, { "description": "mismatch", "data": { "bar": false }, "valid": false }, { "description": "recursive mismatch", "data": { "foo": { "bar": false } }, "valid": false } ] }, { "description": "$recursiveRef without using nesting", "schema": { "$id": "http://localhost:4242/recursiveRef2/schema.json", "$defs": { "myobject": { "$id": "myobject.json", "$recursiveAnchor": true, "anyOf": [ { "type": "string" }, { "type": "object", "additionalProperties": { "$recursiveRef": "#" } } ] } }, "anyOf": [ { "type": "integer" }, { "$ref": "#/$defs/myobject" } ] }, "tests": [ { "description": "integer matches at the outer level", "data": 1, "valid": true }, { "description": "single level match", "data": { "foo": "hi" }, "valid": true }, { "description": "integer does not match as a property value", "data": { "foo": 1 }, "valid": false }, { "description": "two levels, properties match with inner definition", "data": { "foo": { "bar": "hi" } }, "valid": true }, { "description": "two levels, no match", "data": { "foo": { "bar": 1 } }, "valid": false } ] }, { "description": "$recursiveRef with nesting", "schema": { "$id": "http://localhost:4242/recursiveRef3/schema.json", "$recursiveAnchor": true, "$defs": { "myobject": { "$id": "myobject.json", "$recursiveAnchor": true, "anyOf": [ { "type": "string" }, { "type": "object", "additionalProperties": { "$recursiveRef": "#" } } ] } }, "anyOf": [ { "type": "integer" }, { "$ref": "#/$defs/myobject" } ] }, "tests": [ { "description": "integer matches at the outer level", "data": 1, "valid": true }, { "description": "single level match", "data": { "foo": "hi" }, "valid": true }, { "description": "integer now matches as a property value", "data": { "foo": 1 }, "valid": true }, { "description": "two levels, properties match with inner definition", "data": { "foo": { "bar": "hi" } }, "valid": true }, { "description": "two levels, properties match with $recursiveRef", "data": { "foo": { "bar": 1 } }, "valid": true } ] }, { "description": "$recursiveRef with $recursiveAnchor: false works like $ref", "schema": { "$id": "http://localhost:4242/recursiveRef4/schema.json", "$recursiveAnchor": false, "$defs": { "myobject": { "$id": "myobject.json", "$recursiveAnchor": false, "anyOf": [ { "type": "string" }, { "type": "object", "additionalProperties": { "$recursiveRef": "#" } } ] } }, "anyOf": [ { "type": "integer" }, { "$ref": "#/$defs/myobject" } ] }, "tests": [ { "description": "integer matches at the outer level", "data": 1, "valid": true }, { "description": "single level match", "data": { "foo": "hi" }, "valid": true }, { "description": "integer does not match as a property value", "data": { "foo": 1 }, "valid": false }, { "description": "two levels, properties match with inner definition", "data": { "foo": { "bar": "hi" } }, "valid": true }, { "description": "two levels, integer does not match as a property value", "data": { "foo": { "bar": 1 } }, "valid": false } ] }, { "description": "$recursiveRef with no $recursiveAnchor works like $ref", "schema": { "$id": "http://localhost:4242/recursiveRef5/schema.json", "$defs": { "myobject": { "$id": "myobject.json", "$recursiveAnchor": false, "anyOf": [ { "type": "string" }, { "type": "object", "additionalProperties": { "$recursiveRef": "#" } } ] } }, "anyOf": [ { "type": "integer" }, { "$ref": "#/$defs/myobject" } ] }, "tests": [ { "description": "integer matches at the outer level", "data": 1, "valid": true }, { "description": "single level match", "data": { "foo": "hi" }, "valid": true }, { "description": "integer does not match as a property value", "data": { "foo": 1 }, "valid": false }, { "description": "two levels, properties match with inner definition", "data": { "foo": { "bar": "hi" } }, "valid": true }, { "description": "two levels, integer does not match as a property value", "data": { "foo": { "bar": 1 } }, "valid": false } ] }, { "description": "$recursiveRef with no $recursiveAnchor in the initial target schema resource", "schema": { "$id": "http://localhost:4242/recursiveRef6/base.json", "$recursiveAnchor": true, "anyOf": [ { "type": "boolean" }, { "type": "object", "additionalProperties": { "$id": "http://localhost:4242/recursiveRef6/inner.json", "$comment": "there is no $recursiveAnchor: true here, so we do NOT recurse to the base", "anyOf": [ { "type": "integer" }, { "type": "object", "additionalProperties": { "$recursiveRef": "#" } } ] } } ] }, "tests": [ { "description": "leaf node does not match; no recursion", "data": { "foo": true }, "valid": false }, { "description": "leaf node matches: recursion uses the inner schema", "data": { "foo": { "bar": 1 } }, "valid": true }, { "description": "leaf node does not match: recursion uses the inner schema", "data": { "foo": { "bar": true } }, "valid": false } ] }, { "description": "$recursiveRef with no $recursiveAnchor in the outer schema resource", "schema": { "$id": "http://localhost:4242/recursiveRef7/base.json", "anyOf": [ { "type": "boolean" }, { "type": "object", "additionalProperties": { "$id": "http://localhost:4242/recursiveRef7/inner.json", "$recursiveAnchor": true, "anyOf": [ { "type": "integer" }, { "type": "object", "additionalProperties": { "$recursiveRef": "#" } } ] } } ] }, "tests": [ { "description": "leaf node does not match; no recursion", "data": { "foo": true }, "valid": false }, { "description": "leaf node matches: recursion only uses inner schema", "data": { "foo": { "bar": 1 } }, "valid": true }, { "description": "leaf node does not match: recursion only uses inner schema", "data": { "foo": { "bar": true } }, "valid": false } ] }, { "description": "multiple dynamic paths to the $recursiveRef keyword", "schema": { "$id": "recursiveRef8_main.json", "$defs": { "inner": { "$id": "recursiveRef8_inner.json", "$recursiveAnchor": true, "title": "inner", "additionalProperties": { "$recursiveRef": "#" } } }, "if": { "propertyNames": { "pattern": "^[a-m]" } }, "then": { "title": "any type of node", "$id": "recursiveRef8_anyLeafNode.json", "$recursiveAnchor": true, "$ref": "recursiveRef8_main.json#/$defs/inner" }, "else": { "title": "integer node", "$id": "recursiveRef8_integerNode.json", "$recursiveAnchor": true, "type": [ "object", "integer" ], "$ref": "recursiveRef8_main.json#/$defs/inner" } }, "tests": [ { "description": "recurse to anyLeafNode - floats are allowed", "data": { "alpha": 1.1 }, "valid": true }, { "description": "recurse to integerNode - floats are not allowed", "data": { "november": 1.1 }, "valid": false } ] }, { "description": "dynamic $recursiveRef destination (not predictable at schema compile time)", "schema": { "$id": "main.json", "$defs": { "inner": { "$id": "inner.json", "$recursiveAnchor": true, "title": "inner", "additionalProperties": { "$recursiveRef": "#" } } }, "if": { "propertyNames": { "pattern": "^[a-m]" } }, "then": { "title": "any type of node", "$id": "anyLeafNode.json", "$recursiveAnchor": true, "$ref": "main.json#/$defs/inner" }, "else": { "title": "integer node", "$id": "integerNode.json", "$recursiveAnchor": true, "type": [ "object", "integer" ], "$ref": "main.json#/$defs/inner" } }, "tests": [ { "description": "numeric node", "data": { "alpha": 1.1 }, "valid": true }, { "description": "integer node", "data": { "november": 1.1 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/ref.json000066400000000000000000000365011426774651400261360ustar00rootroot00000000000000[ { "description": "root pointer ref", "schema": { "properties": { "foo": {"$ref": "#"} }, "additionalProperties": false }, "tests": [ { "description": "match", "data": {"foo": false}, "valid": true }, { "description": "recursive match", "data": {"foo": {"foo": false}}, "valid": true }, { "description": "mismatch", "data": {"bar": false}, "valid": false }, { "description": "recursive mismatch", "data": {"foo": {"bar": false}}, "valid": false } ] }, { "description": "relative pointer ref to object", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "relative pointer ref to array", "schema": { "items": [ {"type": "integer"}, {"$ref": "#/items/0"} ] }, "tests": [ { "description": "match array", "data": [1, 2], "valid": true }, { "description": "mismatch array", "data": [1, "foo"], "valid": false } ] }, { "description": "escaped pointer ref", "schema": { "$defs": { "tilde~field": {"type": "integer"}, "slash/field": {"type": "integer"}, "percent%field": {"type": "integer"} }, "properties": { "tilde": {"$ref": "#/$defs/tilde~0field"}, "slash": {"$ref": "#/$defs/slash~1field"}, "percent": {"$ref": "#/$defs/percent%25field"} } }, "tests": [ { "description": "slash invalid", "data": {"slash": "aoeu"}, "valid": false }, { "description": "tilde invalid", "data": {"tilde": "aoeu"}, "valid": false }, { "description": "percent invalid", "data": {"percent": "aoeu"}, "valid": false }, { "description": "slash valid", "data": {"slash": 123}, "valid": true }, { "description": "tilde valid", "data": {"tilde": 123}, "valid": true }, { "description": "percent valid", "data": {"percent": 123}, "valid": true } ] }, { "description": "nested refs", "schema": { "$defs": { "a": {"type": "integer"}, "b": {"$ref": "#/$defs/a"}, "c": {"$ref": "#/$defs/b"} }, "$ref": "#/$defs/c" }, "tests": [ { "description": "nested ref valid", "data": 5, "valid": true }, { "description": "nested ref invalid", "data": "a", "valid": false } ] }, { "description": "ref applies alongside sibling keywords", "schema": { "$defs": { "reffed": { "type": "array" } }, "properties": { "foo": { "$ref": "#/$defs/reffed", "maxItems": 2 } } }, "tests": [ { "description": "ref valid, maxItems valid", "data": { "foo": [] }, "valid": true }, { "description": "ref valid, maxItems invalid", "data": { "foo": [1, 2, 3] }, "valid": false }, { "description": "ref invalid", "data": { "foo": "string" }, "valid": false } ] }, { "description": "remote ref, containing refs itself", "schema": {"$ref": "https://json-schema.org/draft/2019-09/schema"}, "tests": [ { "description": "remote ref valid", "data": {"minLength": 1}, "valid": true }, { "description": "remote ref invalid", "data": {"minLength": -1}, "valid": false } ] }, { "description": "property named $ref that is not a reference", "schema": { "properties": { "$ref": {"type": "string"} } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "property named $ref, containing an actual $ref", "schema": { "properties": { "$ref": {"$ref": "#/$defs/is-string"} }, "$defs": { "is-string": { "type": "string" } } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "$ref to boolean schema true", "schema": { "$ref": "#/$defs/bool", "$defs": { "bool": true } }, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "$ref to boolean schema false", "schema": { "$ref": "#/$defs/bool", "$defs": { "bool": false } }, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "Recursive references between schemas", "schema": { "$id": "http://localhost:1234/tree", "description": "tree of nodes", "type": "object", "properties": { "meta": {"type": "string"}, "nodes": { "type": "array", "items": {"$ref": "node"} } }, "required": ["meta", "nodes"], "$defs": { "node": { "$id": "http://localhost:1234/node", "description": "node", "type": "object", "properties": { "value": {"type": "number"}, "subtree": {"$ref": "tree"} }, "required": ["value"] } } }, "tests": [ { "description": "valid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": 1.1}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": true }, { "description": "invalid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": "string is invalid"}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": false } ] }, { "description": "refs with quote", "schema": { "properties": { "foo\"bar": {"$ref": "#/$defs/foo%22bar"} }, "$defs": { "foo\"bar": {"type": "number"} } }, "tests": [ { "description": "object with numbers is valid", "data": { "foo\"bar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\"bar": "1" }, "valid": false } ] }, { "description": "ref creates new scope when adjacent to keywords", "schema": { "$defs": { "A": { "unevaluatedProperties": false } }, "properties": { "prop1": { "type": "string" } }, "$ref": "#/$defs/A" }, "tests": [ { "description": "referenced subschema doesn't see annotations from properties", "data": { "prop1": "match" }, "valid": false } ] }, { "description": "naive replacement of $ref with its destination is not correct", "schema": { "$defs": { "a_string": { "type": "string" } }, "enum": [ { "$ref": "#/$defs/a_string" } ] }, "tests": [ { "description": "do not evaluate the $ref inside the enum, matching any string", "data": "this is a string", "valid": false }, { "description": "do not evaluate the $ref inside the enum, definition exact match", "data": { "type": "string" }, "valid": false }, { "description": "match the enum exactly", "data": { "$ref": "#/$defs/a_string" }, "valid": true } ] }, { "description": "refs with relative uris and defs", "schema": { "$id": "http://example.com/schema-relative-uri-defs1.json", "properties": { "foo": { "$id": "schema-relative-uri-defs2.json", "$defs": { "inner": { "properties": { "bar": { "type": "string" } } } }, "$ref": "#/$defs/inner" } }, "$ref": "schema-relative-uri-defs2.json" }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] }, { "description": "relative refs with absolute uris and defs", "schema": { "$id": "http://example.com/schema-refs-absolute-uris-defs1.json", "properties": { "foo": { "$id": "http://example.com/schema-refs-absolute-uris-defs2.json", "$defs": { "inner": { "properties": { "bar": { "type": "string" } } } }, "$ref": "#/$defs/inner" } }, "$ref": "schema-refs-absolute-uris-defs2.json" }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/refRemote.json000066400000000000000000000123341426774651400273100ustar00rootroot00000000000000[ { "description": "remote ref", "schema": {"$ref": "http://localhost:1234/integer.json"}, "tests": [ { "description": "remote ref valid", "data": 1, "valid": true }, { "description": "remote ref invalid", "data": "a", "valid": false } ] }, { "description": "fragment within remote ref", "schema": {"$ref": "http://localhost:1234/subSchemas-defs.json#/$defs/integer"}, "tests": [ { "description": "remote fragment valid", "data": 1, "valid": true }, { "description": "remote fragment invalid", "data": "a", "valid": false } ] }, { "description": "ref within remote ref", "schema": { "$ref": "http://localhost:1234/subSchemas-defs.json#/$defs/refToInteger" }, "tests": [ { "description": "ref within ref valid", "data": 1, "valid": true }, { "description": "ref within ref invalid", "data": "a", "valid": false } ] }, { "description": "base URI change", "schema": { "$id": "http://localhost:1234/", "items": { "$id": "baseUriChange/", "items": {"$ref": "folderInteger.json"} } }, "tests": [ { "description": "base URI change ref valid", "data": [[1]], "valid": true }, { "description": "base URI change ref invalid", "data": [["a"]], "valid": false } ] }, { "description": "base URI change - change folder", "schema": { "$id": "http://localhost:1234/scope_change_defs1.json", "type" : "object", "properties": {"list": {"$ref": "baseUriChangeFolder/"}}, "$defs": { "baz": { "$id": "baseUriChangeFolder/", "type": "array", "items": {"$ref": "folderInteger.json"} } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "base URI change - change folder in subschema", "schema": { "$id": "http://localhost:1234/scope_change_defs2.json", "type" : "object", "properties": {"list": {"$ref": "baseUriChangeFolderInSubschema/#/$defs/bar"}}, "$defs": { "baz": { "$id": "baseUriChangeFolderInSubschema/", "$defs": { "bar": { "type": "array", "items": {"$ref": "folderInteger.json"} } } } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "root ref in remote ref", "schema": { "$id": "http://localhost:1234/object", "type": "object", "properties": { "name": {"$ref": "name-defs.json#/$defs/orNull"} } }, "tests": [ { "description": "string is valid", "data": { "name": "foo" }, "valid": true }, { "description": "null is valid", "data": { "name": null }, "valid": true }, { "description": "object is invalid", "data": { "name": { "name": null } }, "valid": false } ] }, { "description": "remote ref with ref to defs", "schema": { "$id": "http://localhost:1234/schema-remote-ref-ref-defs1.json", "$ref": "ref-and-defs.json" }, "tests": [ { "description": "invalid", "data": { "bar": 1 }, "valid": false }, { "description": "valid", "data": { "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/required.json000066400000000000000000000052061426774651400272000ustar00rootroot00000000000000[ { "description": "required validation", "schema": { "properties": { "foo": {}, "bar": {} }, "required": ["foo"] }, "tests": [ { "description": "present required property is valid", "data": {"foo": 1}, "valid": true }, { "description": "non-present required property is invalid", "data": {"bar": 1}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "required default validation", "schema": { "properties": { "foo": {} } }, "tests": [ { "description": "not required by default", "data": {}, "valid": true } ] }, { "description": "required with empty array", "schema": { "properties": { "foo": {} }, "required": [] }, "tests": [ { "description": "property not required", "data": {}, "valid": true } ] }, { "description": "required with escaped characters", "schema": { "required": [ "foo\nbar", "foo\"bar", "foo\\bar", "foo\rbar", "foo\tbar", "foo\fbar" ] }, "tests": [ { "description": "object with all properties present is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with some properties missing is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/type.json000066400000000000000000000321401426774651400263360ustar00rootroot00000000000000[ { "description": "integer type matches integers", "schema": {"type": "integer"}, "tests": [ { "description": "an integer is an integer", "data": 1, "valid": true }, { "description": "a float with zero fractional part is an integer", "data": 1.0, "valid": true }, { "description": "a float is not an integer", "data": 1.1, "valid": false }, { "description": "a string is not an integer", "data": "foo", "valid": false }, { "description": "a string is still not an integer, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not an integer", "data": {}, "valid": false }, { "description": "an array is not an integer", "data": [], "valid": false }, { "description": "a boolean is not an integer", "data": true, "valid": false }, { "description": "null is not an integer", "data": null, "valid": false } ] }, { "description": "number type matches numbers", "schema": {"type": "number"}, "tests": [ { "description": "an integer is a number", "data": 1, "valid": true }, { "description": "a float with zero fractional part is a number (and an integer)", "data": 1.0, "valid": true }, { "description": "a float is a number", "data": 1.1, "valid": true }, { "description": "a string is not a number", "data": "foo", "valid": false }, { "description": "a string is still not a number, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not a number", "data": {}, "valid": false }, { "description": "an array is not a number", "data": [], "valid": false }, { "description": "a boolean is not a number", "data": true, "valid": false }, { "description": "null is not a number", "data": null, "valid": false } ] }, { "description": "string type matches strings", "schema": {"type": "string"}, "tests": [ { "description": "1 is not a string", "data": 1, "valid": false }, { "description": "a float is not a string", "data": 1.1, "valid": false }, { "description": "a string is a string", "data": "foo", "valid": true }, { "description": "a string is still a string, even if it looks like a number", "data": "1", "valid": true }, { "description": "an empty string is still a string", "data": "", "valid": true }, { "description": "an object is not a string", "data": {}, "valid": false }, { "description": "an array is not a string", "data": [], "valid": false }, { "description": "a boolean is not a string", "data": true, "valid": false }, { "description": "null is not a string", "data": null, "valid": false } ] }, { "description": "object type matches objects", "schema": {"type": "object"}, "tests": [ { "description": "an integer is not an object", "data": 1, "valid": false }, { "description": "a float is not an object", "data": 1.1, "valid": false }, { "description": "a string is not an object", "data": "foo", "valid": false }, { "description": "an object is an object", "data": {}, "valid": true }, { "description": "an array is not an object", "data": [], "valid": false }, { "description": "a boolean is not an object", "data": true, "valid": false }, { "description": "null is not an object", "data": null, "valid": false } ] }, { "description": "array type matches arrays", "schema": {"type": "array"}, "tests": [ { "description": "an integer is not an array", "data": 1, "valid": false }, { "description": "a float is not an array", "data": 1.1, "valid": false }, { "description": "a string is not an array", "data": "foo", "valid": false }, { "description": "an object is not an array", "data": {}, "valid": false }, { "description": "an array is an array", "data": [], "valid": true }, { "description": "a boolean is not an array", "data": true, "valid": false }, { "description": "null is not an array", "data": null, "valid": false } ] }, { "description": "boolean type matches booleans", "schema": {"type": "boolean"}, "tests": [ { "description": "an integer is not a boolean", "data": 1, "valid": false }, { "description": "zero is not a boolean", "data": 0, "valid": false }, { "description": "a float is not a boolean", "data": 1.1, "valid": false }, { "description": "a string is not a boolean", "data": "foo", "valid": false }, { "description": "an empty string is not a boolean", "data": "", "valid": false }, { "description": "an object is not a boolean", "data": {}, "valid": false }, { "description": "an array is not a boolean", "data": [], "valid": false }, { "description": "true is a boolean", "data": true, "valid": true }, { "description": "false is a boolean", "data": false, "valid": true }, { "description": "null is not a boolean", "data": null, "valid": false } ] }, { "description": "null type matches only the null object", "schema": {"type": "null"}, "tests": [ { "description": "an integer is not null", "data": 1, "valid": false }, { "description": "a float is not null", "data": 1.1, "valid": false }, { "description": "zero is not null", "data": 0, "valid": false }, { "description": "a string is not null", "data": "foo", "valid": false }, { "description": "an empty string is not null", "data": "", "valid": false }, { "description": "an object is not null", "data": {}, "valid": false }, { "description": "an array is not null", "data": [], "valid": false }, { "description": "true is not null", "data": true, "valid": false }, { "description": "false is not null", "data": false, "valid": false }, { "description": "null is null", "data": null, "valid": true } ] }, { "description": "multiple types can be specified in an array", "schema": {"type": ["integer", "string"]}, "tests": [ { "description": "an integer is valid", "data": 1, "valid": true }, { "description": "a string is valid", "data": "foo", "valid": true }, { "description": "a float is invalid", "data": 1.1, "valid": false }, { "description": "an object is invalid", "data": {}, "valid": false }, { "description": "an array is invalid", "data": [], "valid": false }, { "description": "a boolean is invalid", "data": true, "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type as array with one item", "schema": { "type": ["string"] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is invalid", "data": 123, "valid": false } ] }, { "description": "type: array or object", "schema": { "type": ["array", "object"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type: array, object or null", "schema": { "type": ["array", "object", "null"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/unevaluatedItems.json000066400000000000000000000316721426774651400307050ustar00rootroot00000000000000[ { "description": "unevaluatedItems true", "schema": { "type": "array", "unevaluatedItems": true }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with unevaluated items", "data": ["foo"], "valid": true } ] }, { "description": "unevaluatedItems false", "schema": { "type": "array", "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with unevaluated items", "data": ["foo"], "valid": false } ] }, { "description": "unevaluatedItems as schema", "schema": { "type": "array", "unevaluatedItems": { "type": "string" } }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with valid unevaluated items", "data": ["foo"], "valid": true }, { "description": "with invalid unevaluated items", "data": [42], "valid": false } ] }, { "description": "unevaluatedItems with uniform items", "schema": { "type": "array", "items": { "type": "string" }, "unevaluatedItems": false }, "tests": [ { "description": "unevaluatedItems doesn't apply", "data": ["foo", "bar"], "valid": true } ] }, { "description": "unevaluatedItems with tuple", "schema": { "type": "array", "items": [ { "type": "string" } ], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": ["foo"], "valid": true }, { "description": "with unevaluated items", "data": ["foo", "bar"], "valid": false } ] }, { "description": "unevaluatedItems with additionalItems", "schema": { "type": "array", "items": [ { "type": "string" } ], "additionalItems": true, "unevaluatedItems": false }, "tests": [ { "description": "unevaluatedItems doesn't apply", "data": ["foo", 42], "valid": true } ] }, { "description": "unevaluatedItems with nested tuple", "schema": { "type": "array", "items": [ { "type": "string" } ], "allOf": [ { "items": [ true, { "type": "number" } ] } ], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": ["foo", 42], "valid": true }, { "description": "with unevaluated items", "data": ["foo", 42, true], "valid": false } ] }, { "description": "unevaluatedItems with nested additionalItems", "schema": { "type": "array", "allOf": [ { "items": [ { "type": "string" } ], "additionalItems": true } ], "unevaluatedItems": false }, "tests": [ { "description": "with no additional items", "data": ["foo"], "valid": true }, { "description": "with additional items", "data": ["foo", 42, true], "valid": true } ] }, { "description": "unevaluatedItems with nested unevaluatedItems", "schema": { "type": "array", "allOf": [ { "items": [ { "type": "string" } ] }, { "unevaluatedItems": true } ], "unevaluatedItems": false }, "tests": [ { "description": "with no additional items", "data": ["foo"], "valid": true }, { "description": "with additional items", "data": ["foo", 42, true], "valid": true } ] }, { "description": "unevaluatedItems with anyOf", "schema": { "type": "array", "items": [ { "const": "foo" } ], "anyOf": [ { "items": [ true, { "const": "bar" } ] }, { "items": [ true, true, { "const": "baz" } ] } ], "unevaluatedItems": false }, "tests": [ { "description": "when one schema matches and has no unevaluated items", "data": ["foo", "bar"], "valid": true }, { "description": "when one schema matches and has unevaluated items", "data": ["foo", "bar", 42], "valid": false }, { "description": "when two schemas match and has no unevaluated items", "data": ["foo", "bar", "baz"], "valid": true }, { "description": "when two schemas match and has unevaluated items", "data": ["foo", "bar", "baz", 42], "valid": false } ] }, { "description": "unevaluatedItems with oneOf", "schema": { "type": "array", "items": [ { "const": "foo" } ], "oneOf": [ { "items": [ true, { "const": "bar" } ] }, { "items": [ true, { "const": "baz" } ] } ], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": ["foo", "bar"], "valid": true }, { "description": "with unevaluated items", "data": ["foo", "bar", 42], "valid": false } ] }, { "description": "unevaluatedItems with not", "schema": { "type": "array", "items": [ { "const": "foo" } ], "not": { "not": { "items": [ true, { "const": "bar" } ] } }, "unevaluatedItems": false }, "tests": [ { "description": "with unevaluated items", "data": ["foo", "bar"], "valid": false } ] }, { "description": "unevaluatedItems with if/then/else", "schema": { "type": "array", "items": [ { "const": "foo" } ], "if": { "items": [ true, { "const": "bar" } ] }, "then": { "items": [ true, true, { "const": "then" } ] }, "else": { "items": [ true, true, true, { "const": "else" } ] }, "unevaluatedItems": false }, "tests": [ { "description": "when if matches and it has no unevaluated items", "data": ["foo", "bar", "then"], "valid": true }, { "description": "when if matches and it has unevaluated items", "data": ["foo", "bar", "then", "else"], "valid": false }, { "description": "when if doesn't match and it has no unevaluated items", "data": ["foo", 42, 42, "else"], "valid": true }, { "description": "when if doesn't match and it has unevaluated items", "data": ["foo", 42, 42, "else", 42], "valid": false } ] }, { "description": "unevaluatedItems with boolean schemas", "schema": { "type": "array", "allOf": [true], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with unevaluated items", "data": ["foo"], "valid": false } ] }, { "description": "unevaluatedItems with $ref", "schema": { "type": "array", "$ref": "#/$defs/bar", "items": [ { "type": "string" } ], "unevaluatedItems": false, "$defs": { "bar": { "items": [ true, { "type": "string" } ] } } }, "tests": [ { "description": "with no unevaluated items", "data": ["foo", "bar"], "valid": true }, { "description": "with unevaluated items", "data": ["foo", "bar", "baz"], "valid": false } ] }, { "description": "unevaluatedItems can't see inside cousins", "schema": { "allOf": [ { "items": [ true ] }, { "unevaluatedItems": false } ] }, "tests": [ { "description": "always fails", "data": [ 1 ], "valid": false } ] }, { "description": "item is evaluated in an uncle schema to unevaluatedItems", "schema": { "type": "object", "properties": { "foo": { "type": "array", "items": [ { "type": "string" } ], "unevaluatedItems": false } }, "anyOf": [ { "properties": { "foo": { "items": [ true, { "type": "string" } ] } } } ] }, "tests": [ { "description": "no extra items", "data": { "foo": [ "test" ] }, "valid": true }, { "description": "uncle keyword evaluation is not significant", "data": { "foo": [ "test", "test" ] }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/unevaluatedProperties.json000066400000000000000000000724101426774651400317530ustar00rootroot00000000000000[ { "description": "unevaluatedProperties true", "schema": { "type": "object", "unevaluatedProperties": true }, "tests": [ { "description": "with no unevaluated properties", "data": {}, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo" }, "valid": true } ] }, { "description": "unevaluatedProperties schema", "schema": { "type": "object", "unevaluatedProperties": { "type": "string", "minLength": 3 } }, "tests": [ { "description": "with no unevaluated properties", "data": {}, "valid": true }, { "description": "with valid unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with invalid unevaluated properties", "data": { "foo": "fo" }, "valid": false } ] }, { "description": "unevaluatedProperties false", "schema": { "type": "object", "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": {}, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo" }, "valid": false } ] }, { "description": "unevaluatedProperties with adjacent properties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with adjacent patternProperties", "schema": { "type": "object", "patternProperties": { "^foo": { "type": "string" } }, "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with adjacent additionalProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "additionalProperties": true, "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "unevaluatedProperties with nested properties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "properties": { "bar": { "type": "string" } } } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with nested patternProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "patternProperties": { "^bar": { "type": "string" } } } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with nested additionalProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "additionalProperties": true } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "unevaluatedProperties with nested unevaluatedProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "unevaluatedProperties": true } ], "unevaluatedProperties": { "type": "string", "maxLength": 2 } }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "unevaluatedProperties with anyOf", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "anyOf": [ { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] }, { "properties": { "baz": { "const": "baz" } }, "required": ["baz"] }, { "properties": { "quux": { "const": "quux" } }, "required": ["quux"] } ], "unevaluatedProperties": false }, "tests": [ { "description": "when one matches and has no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "when one matches and has unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "not-baz" }, "valid": false }, { "description": "when two match and has no unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": true }, { "description": "when two match and has unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz", "quux": "not-quux" }, "valid": false } ] }, { "description": "unevaluatedProperties with oneOf", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "oneOf": [ { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] }, { "properties": { "baz": { "const": "baz" } }, "required": ["baz"] } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar", "quux": "quux" }, "valid": false } ] }, { "description": "unevaluatedProperties with not", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "not": { "not": { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] } }, "unevaluatedProperties": false }, "tests": [ { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with if/then/else", "schema": { "type": "object", "if": { "properties": { "foo": { "const": "then" } }, "required": ["foo"] }, "then": { "properties": { "bar": { "type": "string" } }, "required": ["bar"] }, "else": { "properties": { "baz": { "type": "string" } }, "required": ["baz"] }, "unevaluatedProperties": false }, "tests": [ { "description": "when if is true and has no unevaluated properties", "data": { "foo": "then", "bar": "bar" }, "valid": true }, { "description": "when if is true and has unevaluated properties", "data": { "foo": "then", "bar": "bar", "baz": "baz" }, "valid": false }, { "description": "when if is false and has no unevaluated properties", "data": { "baz": "baz" }, "valid": true }, { "description": "when if is false and has unevaluated properties", "data": { "foo": "else", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with if/then/else, then not defined", "schema": { "type": "object", "if": { "properties": { "foo": { "const": "then" } }, "required": ["foo"] }, "else": { "properties": { "baz": { "type": "string" } }, "required": ["baz"] }, "unevaluatedProperties": false }, "tests": [ { "description": "when if is true and has no unevaluated properties", "data": { "foo": "then", "bar": "bar" }, "valid": false }, { "description": "when if is true and has unevaluated properties", "data": { "foo": "then", "bar": "bar", "baz": "baz" }, "valid": false }, { "description": "when if is false and has no unevaluated properties", "data": { "baz": "baz" }, "valid": true }, { "description": "when if is false and has unevaluated properties", "data": { "foo": "else", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with if/then/else, else not defined", "schema": { "type": "object", "if": { "properties": { "foo": { "const": "then" } }, "required": ["foo"] }, "then": { "properties": { "bar": { "type": "string" } }, "required": ["bar"] }, "unevaluatedProperties": false }, "tests": [ { "description": "when if is true and has no unevaluated properties", "data": { "foo": "then", "bar": "bar" }, "valid": true }, { "description": "when if is true and has unevaluated properties", "data": { "foo": "then", "bar": "bar", "baz": "baz" }, "valid": false }, { "description": "when if is false and has no unevaluated properties", "data": { "baz": "baz" }, "valid": false }, { "description": "when if is false and has unevaluated properties", "data": { "foo": "else", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with dependentSchemas", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "dependentSchemas": { "foo": { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] } }, "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with unevaluated properties", "data": { "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with boolean schemas", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [true], "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with unevaluated properties", "data": { "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with $ref", "schema": { "type": "object", "$ref": "#/$defs/bar", "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false, "$defs": { "bar": { "properties": { "bar": { "type": "string" } } } } }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties can't see inside cousins", "schema": { "allOf": [ { "properties": { "foo": true } }, { "unevaluatedProperties": false } ] }, "tests": [ { "description": "always fails", "data": { "foo": 1 }, "valid": false } ] }, { "description": "nested unevaluatedProperties, outer false, inner true, properties outside", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "unevaluatedProperties": true } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "nested unevaluatedProperties, outer false, inner true, properties inside", "schema": { "type": "object", "allOf": [ { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": true } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "nested unevaluatedProperties, outer true, inner false, properties outside", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "unevaluatedProperties": false } ], "unevaluatedProperties": true }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": false }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "nested unevaluatedProperties, outer true, inner false, properties inside", "schema": { "type": "object", "allOf": [ { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false } ], "unevaluatedProperties": true }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "cousin unevaluatedProperties, true and false, true with properties", "schema": { "type": "object", "allOf": [ { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": true }, { "unevaluatedProperties": false } ] }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": false }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "cousin unevaluatedProperties, true and false, false with properties", "schema": { "type": "object", "allOf": [ { "unevaluatedProperties": true }, { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false } ] }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "property is evaluated in an uncle schema to unevaluatedProperties", "comment": "see https://stackoverflow.com/questions/66936884/deeply-nested-unevaluatedproperties-and-their-expectations", "schema": { "type": "object", "properties": { "foo": { "type": "object", "properties": { "bar": { "type": "string" } }, "unevaluatedProperties": false } }, "anyOf": [ { "properties": { "foo": { "properties": { "faz": { "type": "string" } } } } } ] }, "tests": [ { "description": "no extra properties", "data": { "foo": { "bar": "test" } }, "valid": true }, { "description": "uncle keyword evaluation is not significant", "data": { "foo": { "bar": "test", "faz": "test" } }, "valid": false } ] }, { "description": "in-place applicator siblings, allOf has unevaluated", "schema": { "type": "object", "allOf": [ { "properties": { "foo": true }, "unevaluatedProperties": false } ], "anyOf": [ { "properties": { "bar": true } } ] }, "tests": [ { "description": "base case: both properties present", "data": { "foo": 1, "bar": 1 }, "valid": false }, { "description": "in place applicator siblings, bar is missing", "data": { "foo": 1 }, "valid": true }, { "description": "in place applicator siblings, foo is missing", "data": { "bar": 1 }, "valid": false } ] }, { "description": "in-place applicator siblings, anyOf has unevaluated", "schema": { "type": "object", "allOf": [ { "properties": { "foo": true } } ], "anyOf": [ { "properties": { "bar": true }, "unevaluatedProperties": false } ] }, "tests": [ { "description": "base case: both properties present", "data": { "foo": 1, "bar": 1 }, "valid": false }, { "description": "in place applicator siblings, bar is missing", "data": { "foo": 1 }, "valid": false }, { "description": "in place applicator siblings, foo is missing", "data": { "bar": 1 }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/uniqueItems.json000066400000000000000000000314011426774651400276640ustar00rootroot00000000000000[ { "description": "uniqueItems validation", "schema": {"uniqueItems": true}, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is invalid", "data": [1, 1], "valid": false }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": false }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is invalid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": false }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is invalid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": false }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is invalid", "data": [["foo"], ["foo"]], "valid": false }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "[1] and [true] are unique", "data": [[1], [true]], "valid": true }, { "description": "[0] and [false] are unique", "data": [[0], [false]], "valid": true }, { "description": "nested [1] and [true] are unique", "data": [[[1], "foo"], [[true], "foo"]], "valid": true }, { "description": "nested [0] and [false] are unique", "data": [[[0], "foo"], [[false], "foo"]], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1, "{}"], "valid": true }, { "description": "non-unique heterogeneous types are invalid", "data": [{}, [1], true, null, {}, 1], "valid": false }, { "description": "different objects are unique", "data": [{"a": 1, "b": 2}, {"a": 2, "b": 1}], "valid": true }, { "description": "objects are non-unique despite key order", "data": [{"a": 1, "b": 2}, {"b": 2, "a": 1}], "valid": false }, { "description": "{\"a\": false} and {\"a\": 0} are unique", "data": [{"a": false}, {"a": 0}], "valid": true }, { "description": "{\"a\": true} and {\"a\": 1} are unique", "data": [{"a": true}, {"a": 1}], "valid": true } ] }, { "description": "uniqueItems with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is not valid", "data": [false, true, "foo", "foo"], "valid": false }, { "description": "non-unique array extended from [true, false] is not valid", "data": [true, false, "foo", "foo"], "valid": false } ] }, { "description": "uniqueItems with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] }, { "description": "uniqueItems=false validation", "schema": { "uniqueItems": false }, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is valid", "data": [1, 1], "valid": true }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": true }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": true }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": true }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is valid", "data": [["foo"], ["foo"]], "valid": true }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1], "valid": true }, { "description": "non-unique heterogeneous types are valid", "data": [{}, [1], true, null, {}, 1], "valid": true } ] }, { "description": "uniqueItems=false with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is valid", "data": [false, true, "foo", "foo"], "valid": true }, { "description": "non-unique array extended from [true, false] is valid", "data": [true, false, "foo", "foo"], "valid": true } ] }, { "description": "uniqueItems=false with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2019-09/unknownKeyword.json000066400000000000000000000037201426774651400304230ustar00rootroot00000000000000[ { "description": "$id inside an unknown keyword is not a real identifier", "comment": "the implementation must not be confused by an $id in locations we do not know how to parse", "schema": { "$defs": { "id_in_unknown0": { "not": { "array_of_schemas": [ { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "null" } ] } }, "real_id_in_schema": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "string" }, "id_in_unknown1": { "not": { "object_of_schemas": { "foo": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "integer" } } } } }, "anyOf": [ { "$ref": "#/$defs/id_in_unknown0" }, { "$ref": "#/$defs/id_in_unknown1" }, { "$ref": "https://localhost:1234/unknownKeyword/my_identifier.json" } ] }, "tests": [ { "description": "type matches second anyOf, which has a real schema in it", "data": "a string", "valid": true }, { "description": "type matches non-schema in first anyOf", "data": null, "valid": false }, { "description": "type matches non-schema in third anyOf", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/000077500000000000000000000000001426774651400244445ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/additionalProperties.json000066400000000000000000000077541426774651400315410ustar00rootroot00000000000000[ { "description": "additionalProperties being false does not allow other properties", "schema": { "properties": {"foo": {}, "bar": {}}, "patternProperties": { "^v": {} }, "additionalProperties": false }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : "boom"}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobarbaz", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true }, { "description": "patternProperties are not additional properties", "data": {"foo":1, "vroom": 2}, "valid": true } ] }, { "description": "non-ASCII pattern with additionalProperties", "schema": { "patternProperties": {"^á": {}}, "additionalProperties": false }, "tests": [ { "description": "matching the pattern is valid", "data": {"ármányos": 2}, "valid": true }, { "description": "not matching the pattern is invalid", "data": {"élmény": 2}, "valid": false } ] }, { "description": "additionalProperties allows a schema which should validate", "schema": { "properties": {"foo": {}, "bar": {}}, "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional valid property is valid", "data": {"foo" : 1, "bar" : 2, "quux" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : 12}, "valid": false } ] }, { "description": "additionalProperties can exist by itself", "schema": { "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "an additional valid property is valid", "data": {"foo" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1}, "valid": false } ] }, { "description": "additionalProperties are allowed by default", "schema": {"properties": {"foo": {}, "bar": {}}}, "tests": [ { "description": "additional properties are allowed", "data": {"foo": 1, "bar": 2, "quux": true}, "valid": true } ] }, { "description": "additionalProperties should not look in applicators", "schema": { "allOf": [ {"properties": {"foo": {}}} ], "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "properties defined in allOf are not examined", "data": {"foo": 1, "bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/allOf.json000066400000000000000000000171471426774651400264060ustar00rootroot00000000000000[ { "description": "allOf", "schema": { "allOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "allOf", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "mismatch second", "data": {"foo": "baz"}, "valid": false }, { "description": "mismatch first", "data": {"bar": 2}, "valid": false }, { "description": "wrong type", "data": {"foo": "baz", "bar": "quux"}, "valid": false } ] }, { "description": "allOf with base schema", "schema": { "properties": {"bar": {"type": "integer"}}, "required": ["bar"], "allOf" : [ { "properties": { "foo": {"type": "string"} }, "required": ["foo"] }, { "properties": { "baz": {"type": "null"} }, "required": ["baz"] } ] }, "tests": [ { "description": "valid", "data": {"foo": "quux", "bar": 2, "baz": null}, "valid": true }, { "description": "mismatch base schema", "data": {"foo": "quux", "baz": null}, "valid": false }, { "description": "mismatch first allOf", "data": {"bar": 2, "baz": null}, "valid": false }, { "description": "mismatch second allOf", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "mismatch both", "data": {"bar": 2}, "valid": false } ] }, { "description": "allOf simple types", "schema": { "allOf": [ {"maximum": 30}, {"minimum": 20} ] }, "tests": [ { "description": "valid", "data": 25, "valid": true }, { "description": "mismatch one", "data": 35, "valid": false } ] }, { "description": "allOf with boolean schemas, all true", "schema": {"allOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "allOf with boolean schemas, some false", "schema": {"allOf": [true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with boolean schemas, all false", "schema": {"allOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with one empty schema", "schema": { "allOf": [ {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with two empty schemas", "schema": { "allOf": [ {}, {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with the first empty schema", "schema": { "allOf": [ {}, { "type": "number" } ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with the last empty schema", "schema": { "allOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "nested allOf, to check validation semantics", "schema": { "allOf": [ { "allOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "allOf combined with anyOf, oneOf", "schema": { "allOf": [ { "multipleOf": 2 } ], "anyOf": [ { "multipleOf": 3 } ], "oneOf": [ { "multipleOf": 5 } ] }, "tests": [ { "description": "allOf: false, anyOf: false, oneOf: false", "data": 1, "valid": false }, { "description": "allOf: false, anyOf: false, oneOf: true", "data": 5, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: false", "data": 3, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: true", "data": 15, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: false", "data": 2, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: true", "data": 10, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: false", "data": 6, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: true", "data": 30, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/anchor.json000066400000000000000000000075461426774651400266250ustar00rootroot00000000000000[ { "description": "Location-independent identifier", "schema": { "$ref": "#foo", "$defs": { "A": { "$anchor": "foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with absolute URI", "schema": { "$ref": "http://localhost:1234/bar#foo", "$defs": { "A": { "$id": "http://localhost:1234/bar", "$anchor": "foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with base URI change in subschema", "schema": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#foo", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$anchor": "foo", "type": "integer" } } } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "$anchor inside an enum is not a real identifier", "comment": "the implementation must not be confused by an $anchor buried in the enum", "schema": { "$defs": { "anchor_in_enum": { "enum": [ { "$anchor": "my_anchor", "type": "null" } ] }, "real_identifier_in_schema": { "$anchor": "my_anchor", "type": "string" }, "zzz_anchor_in_const": { "const": { "$anchor": "my_anchor", "type": "null" } } }, "anyOf": [ { "$ref": "#/$defs/anchor_in_enum" }, { "$ref": "#my_anchor" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "$anchor": "my_anchor", "type": "null" }, "valid": true }, { "description": "in implementations that strip $anchor, this may match either $def", "data": { "type": "null" }, "valid": false }, { "description": "match $ref to $anchor", "data": "a string to match #/$defs/anchor_in_enum", "valid": true }, { "description": "no match on enum or $ref to $anchor", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/anyOf.json000066400000000000000000000113331426774651400264140ustar00rootroot00000000000000[ { "description": "anyOf", "schema": { "anyOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first anyOf valid", "data": 1, "valid": true }, { "description": "second anyOf valid", "data": 2.5, "valid": true }, { "description": "both anyOf valid", "data": 3, "valid": true }, { "description": "neither anyOf valid", "data": 1.5, "valid": false } ] }, { "description": "anyOf with base schema", "schema": { "type": "string", "anyOf" : [ { "maxLength": 2 }, { "minLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one anyOf valid", "data": "foobar", "valid": true }, { "description": "both anyOf invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf with boolean schemas, all true", "schema": {"anyOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, some true", "schema": {"anyOf": [true, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, all false", "schema": {"anyOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf complex types", "schema": { "anyOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first anyOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second anyOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both anyOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "neither anyOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "anyOf with one empty schema", "schema": { "anyOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is valid", "data": 123, "valid": true } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/boolean_schema.json000066400000000000000000000054021426774651400302770ustar00rootroot00000000000000[ { "description": "boolean schema 'true'", "schema": true, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is valid", "data": "foo", "valid": true }, { "description": "boolean true is valid", "data": true, "valid": true }, { "description": "boolean false is valid", "data": false, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "object is valid", "data": {"foo": "bar"}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true }, { "description": "array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "boolean schema 'false'", "schema": false, "tests": [ { "description": "number is invalid", "data": 1, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "boolean true is invalid", "data": true, "valid": false }, { "description": "boolean false is invalid", "data": false, "valid": false }, { "description": "null is invalid", "data": null, "valid": false }, { "description": "object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/const.json000066400000000000000000000225641426774651400264760ustar00rootroot00000000000000[ { "description": "const validation", "schema": {"const": 2}, "tests": [ { "description": "same value is valid", "data": 2, "valid": true }, { "description": "another value is invalid", "data": 5, "valid": false }, { "description": "another type is invalid", "data": "a", "valid": false } ] }, { "description": "const with object", "schema": {"const": {"foo": "bar", "baz": "bax"}}, "tests": [ { "description": "same object is valid", "data": {"foo": "bar", "baz": "bax"}, "valid": true }, { "description": "same object with different property order is valid", "data": {"baz": "bax", "foo": "bar"}, "valid": true }, { "description": "another object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "another type is invalid", "data": [1, 2], "valid": false } ] }, { "description": "const with array", "schema": {"const": [{ "foo": "bar" }]}, "tests": [ { "description": "same array is valid", "data": [{"foo": "bar"}], "valid": true }, { "description": "another array item is invalid", "data": [2], "valid": false }, { "description": "array with additional items is invalid", "data": [1, 2, 3], "valid": false } ] }, { "description": "const with null", "schema": {"const": null}, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "not null is invalid", "data": 0, "valid": false } ] }, { "description": "const with false does not match 0", "schema": {"const": false}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "const with true does not match 1", "schema": {"const": true}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "const with [false] does not match [0]", "schema": {"const": [false]}, "tests": [ { "description": "[false] is valid", "data": [false], "valid": true }, { "description": "[0] is invalid", "data": [0], "valid": false }, { "description": "[0.0] is invalid", "data": [0.0], "valid": false } ] }, { "description": "const with [true] does not match [1]", "schema": {"const": [true]}, "tests": [ { "description": "[true] is valid", "data": [true], "valid": true }, { "description": "[1] is invalid", "data": [1], "valid": false }, { "description": "[1.0] is invalid", "data": [1.0], "valid": false } ] }, { "description": "const with {\"a\": false} does not match {\"a\": 0}", "schema": {"const": {"a": false}}, "tests": [ { "description": "{\"a\": false} is valid", "data": {"a": false}, "valid": true }, { "description": "{\"a\": 0} is invalid", "data": {"a": 0}, "valid": false }, { "description": "{\"a\": 0.0} is invalid", "data": {"a": 0.0}, "valid": false } ] }, { "description": "const with {\"a\": true} does not match {\"a\": 1}", "schema": {"const": {"a": true}}, "tests": [ { "description": "{\"a\": true} is valid", "data": {"a": true}, "valid": true }, { "description": "{\"a\": 1} is invalid", "data": {"a": 1}, "valid": false }, { "description": "{\"a\": 1.0} is invalid", "data": {"a": 1.0}, "valid": false } ] }, { "description": "const with 0 does not match other zero-like types", "schema": {"const": 0}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "empty string is invalid", "data": "", "valid": false } ] }, { "description": "const with 1 does not match true", "schema": {"const": 1}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "const with -2.0 matches integer and float types", "schema": {"const": -2.0}, "tests": [ { "description": "integer -2 is valid", "data": -2, "valid": true }, { "description": "integer 2 is invalid", "data": 2, "valid": false }, { "description": "float -2.0 is valid", "data": -2.0, "valid": true }, { "description": "float 2.0 is invalid", "data": 2.0, "valid": false }, { "description": "float -2.00001 is invalid", "data": -2.00001, "valid": false } ] }, { "description": "float and integers are equal up to 64-bit representation limits", "schema": {"const": 9007199254740992}, "tests": [ { "description": "integer is valid", "data": 9007199254740992, "valid": true }, { "description": "integer minus one is invalid", "data": 9007199254740991, "valid": false }, { "description": "float is valid", "data": 9007199254740992.0, "valid": true }, { "description": "float minus one is invalid", "data": 9007199254740991.0, "valid": false } ] }, { "description": "nul characters in strings", "schema": { "const": "hello\u0000there" }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/contains.json000066400000000000000000000102721426774651400271570ustar00rootroot00000000000000[ { "description": "contains keyword validation", "schema": { "contains": {"minimum": 5} }, "tests": [ { "description": "array with item matching schema (5) is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with item matching schema (6) is valid", "data": [3, 4, 6], "valid": true }, { "description": "array with two items matching schema (5, 6) is valid", "data": [3, 4, 5, 6], "valid": true }, { "description": "array without items matching schema is invalid", "data": [2, 3, 4], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "not array is valid", "data": {}, "valid": true } ] }, { "description": "contains keyword with const keyword", "schema": { "contains": { "const": 5 } }, "tests": [ { "description": "array with item 5 is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with two items 5 is valid", "data": [3, 4, 5, 5], "valid": true }, { "description": "array without item 5 is invalid", "data": [1, 2, 3, 4], "valid": false } ] }, { "description": "contains keyword with boolean schema true", "schema": {"contains": true}, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] }, { "description": "contains keyword with boolean schema false", "schema": {"contains": false}, "tests": [ { "description": "any non-empty array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "non-arrays are valid", "data": "contains does not apply to strings", "valid": true } ] }, { "description": "items + contains", "schema": { "items": { "multipleOf": 2 }, "contains": { "multipleOf": 3 } }, "tests": [ { "description": "matches items, does not match contains", "data": [ 2, 4, 8 ], "valid": false }, { "description": "does not match items, matches contains", "data": [ 3, 6, 9 ], "valid": false }, { "description": "matches both items and contains", "data": [ 6, 12 ], "valid": true }, { "description": "matches neither items nor contains", "data": [ 1, 5 ], "valid": false } ] }, { "description": "contains with false if subschema", "schema": { "contains": { "if": false, "else": true } }, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/content.json000066400000000000000000000077771426774651400270330ustar00rootroot00000000000000[ { "description": "validation of string-encoded content based on media type", "schema": { "contentMediaType": "application/json" }, "tests": [ { "description": "a valid JSON document", "data": "{\"foo\": \"bar\"}", "valid": true }, { "description": "an invalid JSON document; validates true", "data": "{:}", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary string-encoding", "schema": { "contentEncoding": "base64" }, "tests": [ { "description": "a valid base64 string", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "an invalid base64 string (% is not a valid character); validates true", "data": "eyJmb28iOi%iYmFyIn0K", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary-encoded media type documents", "schema": { "contentMediaType": "application/json", "contentEncoding": "base64" }, "tests": [ { "description": "a valid base64-encoded JSON document", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "a validly-encoded invalid JSON document; validates true", "data": "ezp9Cg==", "valid": true }, { "description": "an invalid base64 string that is valid JSON; validates true", "data": "{}", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary-encoded media type documents with schema", "schema": { "contentMediaType": "application/json", "contentEncoding": "base64", "contentSchema": { "required": ["foo"], "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "a valid base64-encoded JSON document", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "another valid base64-encoded JSON document", "data": "eyJib28iOiAyMCwgImZvbyI6ICJiYXoifQ==", "valid": true }, { "description": "an invalid base64-encoded JSON document; validates true", "data": "eyJib28iOiAyMH0=", "valid": true }, { "description": "an empty object as a base64-encoded JSON document; validates true", "data": "e30=", "valid": true }, { "description": "an empty array as a base64-encoded JSON document", "data": "W10=", "valid": true }, { "description": "a validly-encoded invalid JSON document; validates true", "data": "ezp9Cg==", "valid": true }, { "description": "an invalid base64 string that is valid JSON; validates true", "data": "{}", "valid": true }, { "description": "ignores non-strings", "data": 100, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/default.json000066400000000000000000000042671426774651400267740ustar00rootroot00000000000000[ { "description": "invalid type for default", "schema": { "properties": { "foo": { "type": "integer", "default": [] } } }, "tests": [ { "description": "valid when property is specified", "data": {"foo": 13}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "invalid string value for default", "schema": { "properties": { "bar": { "type": "string", "minLength": 4, "default": "bad" } } }, "tests": [ { "description": "valid when property is specified", "data": {"bar": "good"}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "the default keyword does not do anything if the property is missing", "schema": { "type": "object", "properties": { "alpha": { "type": "number", "maximum": 3, "default": 5 } } }, "tests": [ { "description": "an explicit property value is checked against maximum (passing)", "data": { "alpha": 1 }, "valid": true }, { "description": "an explicit property value is checked against maximum (failing)", "data": { "alpha": 5 }, "valid": false }, { "description": "missing properties are not filled in with the default", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/defs.json000066400000000000000000000010661426774651400262630ustar00rootroot00000000000000[ { "description": "validate definition against metaschema", "schema": { "$ref": "https://json-schema.org/draft/2020-12/schema" }, "tests": [ { "description": "valid definition schema", "data": {"$defs": {"foo": {"type": "integer"}}}, "valid": true }, { "description": "invalid definition schema", "data": {"$defs": {"foo": {"type": 1}}}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/dependentRequired.json000066400000000000000000000075501426774651400310150ustar00rootroot00000000000000[ { "description": "single dependency", "schema": {"dependentRequired": {"bar": ["foo"]}}, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependant", "data": {"foo": 1}, "valid": true }, { "description": "with dependency", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "missing dependency", "data": {"bar": 2}, "valid": false }, { "description": "ignores arrays", "data": ["bar"], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "empty dependents", "schema": {"dependentRequired": {"bar": []}}, "tests": [ { "description": "empty object", "data": {}, "valid": true }, { "description": "object with one property", "data": {"bar": 2}, "valid": true }, { "description": "non-object is valid", "data": 1, "valid": true } ] }, { "description": "multiple dependents required", "schema": {"dependentRequired": {"quux": ["foo", "bar"]}}, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependants", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "with dependencies", "data": {"foo": 1, "bar": 2, "quux": 3}, "valid": true }, { "description": "missing dependency", "data": {"foo": 1, "quux": 2}, "valid": false }, { "description": "missing other dependency", "data": {"bar": 1, "quux": 2}, "valid": false }, { "description": "missing both dependencies", "data": {"quux": 1}, "valid": false } ] }, { "description": "dependencies with escaped characters", "schema": { "dependentRequired": { "foo\nbar": ["foo\rbar"], "foo\"bar": ["foo'bar"] } }, "tests": [ { "description": "CRLF", "data": { "foo\nbar": 1, "foo\rbar": 2 }, "valid": true }, { "description": "quoted quotes", "data": { "foo'bar": 1, "foo\"bar": 2 }, "valid": true }, { "description": "CRLF missing dependent", "data": { "foo\nbar": 1, "foo": 2 }, "valid": false }, { "description": "quoted quotes missing dependent", "data": { "foo\"bar": 2 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/dependentSchemas.json000066400000000000000000000062331426774651400306150ustar00rootroot00000000000000[ { "description": "single dependency", "schema": { "dependentSchemas": { "bar": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "integer"} } } } }, "tests": [ { "description": "valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "no dependency", "data": {"foo": "quux"}, "valid": true }, { "description": "wrong type", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "wrong type other", "data": {"foo": 2, "bar": "quux"}, "valid": false }, { "description": "wrong type both", "data": {"foo": "quux", "bar": "quux"}, "valid": false } ] }, { "description": "boolean subschemas", "schema": { "dependentSchemas": { "foo": true, "bar": false } }, "tests": [ { "description": "object with property having schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property having schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "dependencies with escaped characters", "schema": { "dependentSchemas": { "foo\tbar": {"minProperties": 4}, "foo'bar": {"required": ["foo\"bar"]} } }, "tests": [ { "description": "quoted tab", "data": { "foo\tbar": 1, "a": 2, "b": 3, "c": 4 }, "valid": true }, { "description": "quoted quote", "data": { "foo'bar": {"foo\"bar": 1} }, "valid": false }, { "description": "quoted tab invalid under dependent schema", "data": { "foo\tbar": 1, "a": 2 }, "valid": false }, { "description": "quoted quote invalid under dependent schema", "data": {"foo'bar": 1}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/dynamicRef.json000066400000000000000000000357111426774651400274270ustar00rootroot00000000000000[ { "description": "A $dynamicRef to a $dynamicAnchor in the same schema resource should behave like a normal $ref to an $anchor", "schema": { "$id": "https://test.json-schema.org/dynamicRef-dynamicAnchor-same-schema/root", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "foo": { "$dynamicAnchor": "items", "type": "string" } } }, "tests": [ { "description": "An array of strings is valid", "data": ["foo", "bar"], "valid": true }, { "description": "An array containing non-strings is invalid", "data": ["foo", 42], "valid": false } ] }, { "description": "A $dynamicRef to an $anchor in the same schema resource should behave like a normal $ref to an $anchor", "schema": { "$id": "https://test.json-schema.org/dynamicRef-anchor-same-schema/root", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "foo": { "$anchor": "items", "type": "string" } } }, "tests": [ { "description": "An array of strings is valid", "data": ["foo", "bar"], "valid": true }, { "description": "An array containing non-strings is invalid", "data": ["foo", 42], "valid": false } ] }, { "description": "A $ref to a $dynamicAnchor in the same schema resource should behave like a normal $ref to an $anchor", "schema": { "$id": "https://test.json-schema.org/ref-dynamicAnchor-same-schema/root", "type": "array", "items": { "$ref": "#items" }, "$defs": { "foo": { "$dynamicAnchor": "items", "type": "string" } } }, "tests": [ { "description": "An array of strings is valid", "data": ["foo", "bar"], "valid": true }, { "description": "An array containing non-strings is invalid", "data": ["foo", 42], "valid": false } ] }, { "description": "A $dynamicRef should resolve to the first $dynamicAnchor still in scope that is encountered when the schema is evaluated", "schema": { "$id": "https://test.json-schema.org/typical-dynamic-resolution/root", "$ref": "list", "$defs": { "foo": { "$dynamicAnchor": "items", "type": "string" }, "list": { "$id": "list", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "items": { "$comment": "This is only needed to satisfy the bookending requirement", "$dynamicAnchor": "items" } } } } }, "tests": [ { "description": "An array of strings is valid", "data": ["foo", "bar"], "valid": true }, { "description": "An array containing non-strings is invalid", "data": ["foo", 42], "valid": false } ] }, { "description": "A $dynamicRef with intermediate scopes that don't include a matching $dynamicAnchor should not affect dynamic scope resolution", "schema": { "$id": "https://test.json-schema.org/dynamic-resolution-with-intermediate-scopes/root", "$ref": "intermediate-scope", "$defs": { "foo": { "$dynamicAnchor": "items", "type": "string" }, "intermediate-scope": { "$id": "intermediate-scope", "$ref": "list" }, "list": { "$id": "list", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "items": { "$comment": "This is only needed to satisfy the bookending requirement", "$dynamicAnchor": "items" } } } } }, "tests": [ { "description": "An array of strings is valid", "data": ["foo", "bar"], "valid": true }, { "description": "An array containing non-strings is invalid", "data": ["foo", 42], "valid": false } ] }, { "description": "An $anchor with the same name as a $dynamicAnchor should not be used for dynamic scope resolution", "schema": { "$id": "https://test.json-schema.org/dynamic-resolution-ignores-anchors/root", "$ref": "list", "$defs": { "foo": { "$anchor": "items", "type": "string" }, "list": { "$id": "list", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "items": { "$comment": "This is only needed to satisfy the bookending requirement", "$dynamicAnchor": "items" } } } } }, "tests": [ { "description": "Any array is valid", "data": ["foo", 42], "valid": true } ] }, { "description": "A $dynamicRef without a matching $dynamicAnchor in the same schema resource should behave like a normal $ref to $anchor", "schema": { "$id": "https://test.json-schema.org/dynamic-resolution-without-bookend/root", "$ref": "list", "$defs": { "foo": { "$dynamicAnchor": "items", "type": "string" }, "list": { "$id": "list", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "items": { "$comment": "This is only needed to give the reference somewhere to resolve to when it behaves like $ref", "$anchor": "items" } } } } }, "tests": [ { "description": "Any array is valid", "data": ["foo", 42], "valid": true } ] }, { "description": "A $dynamicRef with a non-matching $dynamicAnchor in the same schema resource should behave like a normal $ref to $anchor", "schema": { "$id": "https://test.json-schema.org/unmatched-dynamic-anchor/root", "$ref": "list", "$defs": { "foo": { "$dynamicAnchor": "items", "type": "string" }, "list": { "$id": "list", "type": "array", "items": { "$dynamicRef": "#items" }, "$defs": { "items": { "$comment": "This is only needed to give the reference somewhere to resolve to when it behaves like $ref", "$anchor": "items", "$dynamicAnchor": "foo" } } } } }, "tests": [ { "description": "Any array is valid", "data": ["foo", 42], "valid": true } ] }, { "description": "A $dynamicRef that initially resolves to a schema with a matching $dynamicAnchor should resolve to the first $dynamicAnchor in the dynamic scope", "schema": { "$id": "https://test.json-schema.org/relative-dynamic-reference/root", "$dynamicAnchor": "meta", "type": "object", "properties": { "foo": { "const": "pass" } }, "$ref": "extended", "$defs": { "extended": { "$id": "extended", "$dynamicAnchor": "meta", "type": "object", "properties": { "bar": { "$ref": "bar" } } }, "bar": { "$id": "bar", "type": "object", "properties": { "baz": { "$dynamicRef": "extended#meta" } } } } }, "tests": [ { "description": "The recursive part is valid against the root", "data": { "foo": "pass", "bar": { "baz": { "foo": "pass" } } }, "valid": true }, { "description": "The recursive part is not valid against the root", "data": { "foo": "pass", "bar": { "baz": { "foo": "fail" } } }, "valid": false } ] }, { "description": "A $dynamicRef that initially resolves to a schema without a matching $dynamicAnchor should behave like a normal $ref to $anchor", "schema": { "$id": "https://test.json-schema.org/relative-dynamic-reference-without-bookend/root", "$dynamicAnchor": "meta", "type": "object", "properties": { "foo": { "const": "pass" } }, "$ref": "extended", "$defs": { "extended": { "$id": "extended", "$anchor": "meta", "type": "object", "properties": { "bar": { "$ref": "bar" } } }, "bar": { "$id": "bar", "type": "object", "properties": { "baz": { "$dynamicRef": "extended#meta" } } } } }, "tests": [ { "description": "The recursive part doesn't need to validate against the root", "data": { "foo": "pass", "bar": { "baz": { "foo": "fail" } } }, "valid": true } ] }, { "description": "multiple dynamic paths to the $dynamicRef keyword", "schema": { "$id": "https://test.json-schema.org/dynamic-ref-with-multiple-paths/main", "$defs": { "inner": { "$id": "inner", "$dynamicAnchor": "foo", "title": "inner", "additionalProperties": { "$dynamicRef": "#foo" } } }, "if": { "propertyNames": { "pattern": "^[a-m]" } }, "then": { "title": "any type of node", "$id": "anyLeafNode", "$dynamicAnchor": "foo", "$ref": "main#/$defs/inner" }, "else": { "title": "integer node", "$id": "integerNode", "$dynamicAnchor": "foo", "type": [ "object", "integer" ], "$ref": "main#/$defs/inner" } }, "tests": [ { "description": "recurse to anyLeafNode - floats are allowed", "data": { "alpha": 1.1 }, "valid": true }, { "description": "recurse to integerNode - floats are not allowed", "data": { "november": 1.1 }, "valid": false } ] }, { "description": "after leaving a dynamic scope, it should not be used by a $dynamicRef", "schema": { "$id": "https://test.json-schema.org/dynamic-ref-leaving-dynamic-scope/main", "if": { "$id": "first_scope", "$defs": { "thingy": { "$comment": "this is first_scope#thingy", "$dynamicAnchor": "thingy", "type": "number" } } }, "then": { "$id": "second_scope", "$ref": "start", "$defs": { "thingy": { "$comment": "this is second_scope#thingy, the final destination of the $dynamicRef", "$dynamicAnchor": "thingy", "type": "null" } } }, "$defs": { "start": { "$comment": "this is the landing spot from $ref", "$id": "start", "$dynamicRef": "inner_scope#thingy" }, "thingy": { "$comment": "this is the first stop for the $dynamicRef", "$id": "inner_scope", "$dynamicAnchor": "thingy", "type": "string" } } }, "tests": [ { "description": "string matches /$defs/thingy, but the $dynamicRef does not stop here", "data": "a string", "valid": false }, { "description": "first_scope is not in dynamic scope for the $dynamicRef", "data": 42, "valid": false }, { "description": "/then/$defs/thingy is the final stop for the $dynamicRef", "data": null, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/enum.json000066400000000000000000000146431426774651400263130ustar00rootroot00000000000000[ { "description": "simple enum validation", "schema": {"enum": [1, 2, 3]}, "tests": [ { "description": "one of the enum is valid", "data": 1, "valid": true }, { "description": "something else is invalid", "data": 4, "valid": false } ] }, { "description": "heterogeneous enum validation", "schema": {"enum": [6, "foo", [], true, {"foo": 12}]}, "tests": [ { "description": "one of the enum is valid", "data": [], "valid": true }, { "description": "something else is invalid", "data": null, "valid": false }, { "description": "objects are deep compared", "data": {"foo": false}, "valid": false }, { "description": "valid object matches", "data": {"foo": 12}, "valid": true }, { "description": "extra properties in object is invalid", "data": {"foo": 12, "boo": 42}, "valid": false } ] }, { "description": "heterogeneous enum-with-null validation", "schema": { "enum": [6, null] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "number is valid", "data": 6, "valid": true }, { "description": "something else is invalid", "data": "test", "valid": false } ] }, { "description": "enums in properties", "schema": { "type":"object", "properties": { "foo": {"enum":["foo"]}, "bar": {"enum":["bar"]} }, "required": ["bar"] }, "tests": [ { "description": "both properties are valid", "data": {"foo":"foo", "bar":"bar"}, "valid": true }, { "description": "wrong foo value", "data": {"foo":"foot", "bar":"bar"}, "valid": false }, { "description": "wrong bar value", "data": {"foo":"foo", "bar":"bart"}, "valid": false }, { "description": "missing optional property is valid", "data": {"bar":"bar"}, "valid": true }, { "description": "missing required property is invalid", "data": {"foo":"foo"}, "valid": false }, { "description": "missing all properties is invalid", "data": {}, "valid": false } ] }, { "description": "enum with escaped characters", "schema": { "enum": ["foo\nbar", "foo\rbar"] }, "tests": [ { "description": "member 1 is valid", "data": "foo\nbar", "valid": true }, { "description": "member 2 is valid", "data": "foo\rbar", "valid": true }, { "description": "another string is invalid", "data": "abc", "valid": false } ] }, { "description": "enum with false does not match 0", "schema": {"enum": [false]}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "enum with true does not match 1", "schema": {"enum": [true]}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "enum with 0 does not match false", "schema": {"enum": [0]}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true } ] }, { "description": "enum with 1 does not match true", "schema": {"enum": [1]}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "nul characters in strings", "schema": { "enum": [ "hello\u0000there" ] }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/exclusiveMaximum.json000066400000000000000000000014071426774651400307060ustar00rootroot00000000000000[ { "description": "exclusiveMaximum validation", "schema": { "exclusiveMaximum": 3.0 }, "tests": [ { "description": "below the exclusiveMaximum is valid", "data": 2.2, "valid": true }, { "description": "boundary point is invalid", "data": 3.0, "valid": false }, { "description": "above the exclusiveMaximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/exclusiveMinimum.json000066400000000000000000000014071426774651400307040ustar00rootroot00000000000000[ { "description": "exclusiveMinimum validation", "schema": { "exclusiveMinimum": 1.1 }, "tests": [ { "description": "above the exclusiveMinimum is valid", "data": 1.2, "valid": true }, { "description": "boundary point is invalid", "data": 1.1, "valid": false }, { "description": "below the exclusiveMinimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/format.json000066400000000000000000000565531426774651400266450ustar00rootroot00000000000000[ { "description": "email format", "schema": { "format": "email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid email string is only an annotation by default", "data": "2962", "valid": true } ] }, { "description": "idn-email format", "schema": { "format": "idn-email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid idn-email string is only an annotation by default", "data": "2962", "valid": true } ] }, { "description": "regex format", "schema": { "format": "regex" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid regex string is only an annotation by default", "data": "^(abc]", "valid": true } ] }, { "description": "ipv4 format", "schema": { "format": "ipv4" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid ipv4 string is only an annotation by default", "data": "127.0.0.0.1", "valid": true } ] }, { "description": "ipv6 format", "schema": { "format": "ipv6" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid ipv6 string is only an annotation by default", "data": "12345::", "valid": true } ] }, { "description": "idn-hostname format", "schema": { "format": "idn-hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid idn-hostname string is only an annotation by default", "data": "〮실례.테스트", "valid": true } ] }, { "description": "hostname format", "schema": { "format": "hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid hostname string is only an annotation by default", "data": "-a-host-name-that-starts-with--", "valid": true } ] }, { "description": "date format", "schema": { "format": "date" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid date string is only an annotation by default", "data": "06/19/1963", "valid": true } ] }, { "description": "date-time format", "schema": { "format": "date-time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid date-time string is only an annotation by default", "data": "1990-02-31T15:59:60.123-08:00", "valid": true } ] }, { "description": "time format", "schema": { "format": "time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid time string is only an annotation by default", "data": "08:30:06 PST", "valid": true } ] }, { "description": "json-pointer format", "schema": { "format": "json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid json-pointer string is only an annotation by default", "data": "/foo/bar~", "valid": true } ] }, { "description": "relative-json-pointer format", "schema": { "format": "relative-json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid relative-json-pointer string is only an annotation by default", "data": "/foo/bar", "valid": true } ] }, { "description": "iri format", "schema": { "format": "iri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid iri string is only an annotation by default", "data": "http://2001:0db8:85a3:0000:0000:8a2e:0370:7334", "valid": true } ] }, { "description": "iri-reference format", "schema": { "format": "iri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid iri-reference string is only an annotation by default", "data": "\\\\WINDOWS\\filëßåré", "valid": true } ] }, { "description": "uri format", "schema": { "format": "uri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uri string is only an annotation by default", "data": "//foo.bar/?baz=qux#quux", "valid": true } ] }, { "description": "uri-reference format", "schema": { "format": "uri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uri-reference string is only an annotation by default", "data": "\\\\WINDOWS\\fileshare", "valid": true } ] }, { "description": "uri-template format", "schema": { "format": "uri-template" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uri-template string is only an annotation by default", "data": "http://example.com/dictionary/{term:1}/{term", "valid": true } ] }, { "description": "uuid format", "schema": { "format": "uuid" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid uuid string is only an annotation by default", "data": "2eb8aa08-aa98-11ea-b4aa-73b441d1638", "valid": true } ] }, { "description": "duration format", "schema": { "format": "duration" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true }, { "description": "invalid duration string is only an annotation by default", "data": "PT1D", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/id.json000066400000000000000000000211051426774651400257320ustar00rootroot00000000000000[ { "description": "Invalid use of fragments in location-independent $id", "schema": { "$ref": "https://json-schema.org/draft/2020-12/schema" }, "tests": [ { "description": "Identifier name", "data": { "$ref": "#foo", "$defs": { "A": { "$id": "#foo", "type": "integer" } } }, "valid": false }, { "description": "Identifier name and no ref", "data": { "$defs": { "A": { "$id": "#foo" } } }, "valid": false }, { "description": "Identifier path", "data": { "$ref": "#/a/b", "$defs": { "A": { "$id": "#/a/b", "type": "integer" } } }, "valid": false }, { "description": "Identifier name with absolute URI", "data": { "$ref": "http://localhost:1234/bar#foo", "$defs": { "A": { "$id": "http://localhost:1234/bar#foo", "type": "integer" } } }, "valid": false }, { "description": "Identifier path with absolute URI", "data": { "$ref": "http://localhost:1234/bar#/a/b", "$defs": { "A": { "$id": "http://localhost:1234/bar#/a/b", "type": "integer" } } }, "valid": false }, { "description": "Identifier name with base URI change in subschema", "data": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#foo", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$id": "#foo", "type": "integer" } } } } }, "valid": false }, { "description": "Identifier path with base URI change in subschema", "data": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#/a/b", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$id": "#/a/b", "type": "integer" } } } } }, "valid": false } ] }, { "description": "Valid use of empty fragments in location-independent $id", "comment": "These are allowed but discouraged", "schema": { "$ref": "https://json-schema.org/draft/2020-12/schema" }, "tests": [ { "description": "Identifier name with absolute URI", "data": { "$ref": "http://localhost:1234/bar", "$defs": { "A": { "$id": "http://localhost:1234/bar#", "type": "integer" } } }, "valid": true }, { "description": "Identifier name with base URI change in subschema", "data": { "$id": "http://localhost:1234/root", "$ref": "http://localhost:1234/nested.json#/$defs/B", "$defs": { "A": { "$id": "nested.json", "$defs": { "B": { "$id": "#", "type": "integer" } } } } }, "valid": true } ] }, { "description": "Unnormalized $ids are allowed but discouraged", "schema": { "$ref": "https://json-schema.org/draft/2020-12/schema" }, "tests": [ { "description": "Unnormalized identifier", "data": { "$ref": "http://localhost:1234/foo/baz", "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz", "type": "integer" } } }, "valid": true }, { "description": "Unnormalized identifier and no ref", "data": { "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz", "type": "integer" } } }, "valid": true }, { "description": "Unnormalized identifier with empty fragment", "data": { "$ref": "http://localhost:1234/foo/baz", "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz#", "type": "integer" } } }, "valid": true }, { "description": "Unnormalized identifier with empty fragment and no ref", "data": { "$defs": { "A": { "$id": "http://localhost:1234/foo/bar/../baz#", "type": "integer" } } }, "valid": true } ] }, { "description": "$id inside an enum is not a real identifier", "comment": "the implementation must not be confused by an $id buried in the enum", "schema": { "$defs": { "id_in_enum": { "enum": [ { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } ] }, "real_id_in_schema": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "string" }, "zzz_id_in_const": { "const": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } } }, "anyOf": [ { "$ref": "#/$defs/id_in_enum" }, { "$ref": "https://localhost:1234/id/my_identifier.json" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" }, "valid": true }, { "description": "match $ref to $id", "data": "a string to match #/$defs/id_in_enum", "valid": true }, { "description": "no match on enum or $ref to $id", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/if-then-else.json000066400000000000000000000153221426774651400276220ustar00rootroot00000000000000[ { "description": "ignore if without then or else", "schema": { "if": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone if", "data": 0, "valid": true }, { "description": "valid when invalid against lone if", "data": "hello", "valid": true } ] }, { "description": "ignore then without if", "schema": { "then": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone then", "data": 0, "valid": true }, { "description": "valid when invalid against lone then", "data": "hello", "valid": true } ] }, { "description": "ignore else without if", "schema": { "else": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone else", "data": 0, "valid": true }, { "description": "valid when invalid against lone else", "data": "hello", "valid": true } ] }, { "description": "if and then without else", "schema": { "if": { "exclusiveMaximum": 0 }, "then": { "minimum": -10 } }, "tests": [ { "description": "valid through then", "data": -1, "valid": true }, { "description": "invalid through then", "data": -100, "valid": false }, { "description": "valid when if test fails", "data": 3, "valid": true } ] }, { "description": "if and else without then", "schema": { "if": { "exclusiveMaximum": 0 }, "else": { "multipleOf": 2 } }, "tests": [ { "description": "valid when if test passes", "data": -1, "valid": true }, { "description": "valid through else", "data": 4, "valid": true }, { "description": "invalid through else", "data": 3, "valid": false } ] }, { "description": "validate against correct branch, then vs else", "schema": { "if": { "exclusiveMaximum": 0 }, "then": { "minimum": -10 }, "else": { "multipleOf": 2 } }, "tests": [ { "description": "valid through then", "data": -1, "valid": true }, { "description": "invalid through then", "data": -100, "valid": false }, { "description": "valid through else", "data": 4, "valid": true }, { "description": "invalid through else", "data": 3, "valid": false } ] }, { "description": "non-interference across combined schemas", "schema": { "allOf": [ { "if": { "exclusiveMaximum": 0 } }, { "then": { "minimum": -10 } }, { "else": { "multipleOf": 2 } } ] }, "tests": [ { "description": "valid, but would have been invalid through then", "data": -100, "valid": true }, { "description": "valid, but would have been invalid through else", "data": 3, "valid": true } ] }, { "description": "if with boolean schema true", "schema": { "if": true, "then": { "const": "then" }, "else": { "const": "else" } }, "tests": [ { "description": "boolean schema true in if always chooses the then path (valid)", "data": "then", "valid": true }, { "description": "boolean schema true in if always chooses the then path (invalid)", "data": "else", "valid": false } ] }, { "description": "if with boolean schema false", "schema": { "if": false, "then": { "const": "then" }, "else": { "const": "else" } }, "tests": [ { "description": "boolean schema false in if always chooses the else path (invalid)", "data": "then", "valid": false }, { "description": "boolean schema false in if always chooses the else path (valid)", "data": "else", "valid": true } ] }, { "description": "if appears at the end when serialized (keyword processing sequence)", "schema": { "then": { "const": "yes" }, "else": { "const": "other" }, "if": { "maxLength": 4 } }, "tests": [ { "description": "yes redirects to then and passes", "data": "yes", "valid": true }, { "description": "other redirects to else and passes", "data": "other", "valid": true }, { "description": "no redirects to then and fails", "data": "no", "valid": false }, { "description": "invalid redirects to else and fails", "data": "invalid", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/infinite-loop-detection.json000066400000000000000000000017241426774651400320730ustar00rootroot00000000000000[ { "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", "schema": { "$defs": { "int": { "type": "integer" } }, "allOf": [ { "properties": { "foo": { "$ref": "#/$defs/int" } } }, { "additionalProperties": { "$ref": "#/$defs/int" } } ] }, "tests": [ { "description": "passing case", "data": { "foo": 1 }, "valid": true }, { "description": "failing case", "data": { "foo": "a string" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/items.json000066400000000000000000000166731426774651400264750ustar00rootroot00000000000000[ { "description": "a schema given for items", "schema": { "items": {"type": "integer"} }, "tests": [ { "description": "valid items", "data": [ 1, 2, 3 ], "valid": true }, { "description": "wrong type of items", "data": [1, "x"], "valid": false }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "length": 1 }, "valid": true } ] }, { "description": "items with boolean schema (true)", "schema": {"items": true}, "tests": [ { "description": "any array is valid", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schema (false)", "schema": {"items": false}, "tests": [ { "description": "any non-empty array is invalid", "data": [ 1, "foo", true ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items and subitems", "schema": { "$defs": { "item": { "type": "array", "items": false, "prefixItems": [ { "$ref": "#/$defs/sub-item" }, { "$ref": "#/$defs/sub-item" } ] }, "sub-item": { "type": "object", "required": ["foo"] } }, "type": "array", "items": false, "prefixItems": [ { "$ref": "#/$defs/item" }, { "$ref": "#/$defs/item" }, { "$ref": "#/$defs/item" } ] }, "tests": [ { "description": "valid items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": true }, { "description": "too many items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "too many sub-items", "data": [ [ {"foo": null}, {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong item", "data": [ {"foo": null}, [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong sub-item", "data": [ [ {}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "fewer items is valid", "data": [ [ {"foo": null} ], [ {"foo": null} ] ], "valid": true } ] }, { "description": "nested items", "schema": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "number" } } } } }, "tests": [ { "description": "valid nested array", "data": [[[[1]], [[2],[3]]], [[[4], [5], [6]]]], "valid": true }, { "description": "nested array with invalid type", "data": [[[["1"]], [[2],[3]]], [[[4], [5], [6]]]], "valid": false }, { "description": "not deep enough", "data": [[[1], [2],[3]], [[4], [5], [6]]], "valid": false } ] }, { "description": "prefixItems with no additional items allowed", "schema": { "prefixItems": [{}, {}, {}], "items": false }, "tests": [ { "description": "empty array", "data": [ ], "valid": true }, { "description": "fewer number of items present (1)", "data": [ 1 ], "valid": true }, { "description": "fewer number of items present (2)", "data": [ 1, 2 ], "valid": true }, { "description": "equal number of items present", "data": [ 1, 2, 3 ], "valid": true }, { "description": "additional items are not permitted", "data": [ 1, 2, 3, 4 ], "valid": false } ] }, { "description": "items should not look in applicators, valid case", "schema": { "allOf": [ { "prefixItems": [ { "minimum": 3 } ] } ], "items": { "minimum": 5 } }, "tests": [ { "description": "prefixItems in allOf should not constrain items, invalid case", "data": [ 3, 5 ], "valid": false }, { "description": "prefixItems in allOf should not constrain items, valid case", "data": [ 5, 5 ], "valid": true } ] }, { "description": "prefixItems validation adjusts the starting index for items", "schema": { "prefixItems": [ { "type": "string" } ], "items": { "type": "integer" } }, "tests": [ { "description": "valid items", "data": [ "x", 2, 3 ], "valid": true }, { "description": "wrong type of second item", "data": [ "x", "y" ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/maxContains.json000066400000000000000000000042431426774651400276260ustar00rootroot00000000000000[ { "description": "maxContains without contains is ignored", "schema": { "maxContains": 1 }, "tests": [ { "description": "one item valid against lone maxContains", "data": [ 1 ], "valid": true }, { "description": "two items still valid against lone maxContains", "data": [ 1, 2 ], "valid": true } ] }, { "description": "maxContains with contains", "schema": { "contains": {"const": 1}, "maxContains": 1 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "all elements match, valid maxContains", "data": [ 1 ], "valid": true }, { "description": "all elements match, invalid maxContains", "data": [ 1, 1 ], "valid": false }, { "description": "some elements match, valid maxContains", "data": [ 1, 2 ], "valid": true }, { "description": "some elements match, invalid maxContains", "data": [ 1, 2, 1 ], "valid": false } ] }, { "description": "minContains < maxContains", "schema": { "contains": {"const": 1}, "minContains": 1, "maxContains": 3 }, "tests": [ { "description": "actual < minContains < maxContains", "data": [ ], "valid": false }, { "description": "minContains < actual < maxContains", "data": [ 1, 1 ], "valid": true }, { "description": "minContains < maxContains < actual", "data": [ 1, 1, 1, 1 ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/maxItems.json000066400000000000000000000013021426774651400271220ustar00rootroot00000000000000[ { "description": "maxItems validation", "schema": {"maxItems": 2}, "tests": [ { "description": "shorter is valid", "data": [1], "valid": true }, { "description": "exact length is valid", "data": [1, 2], "valid": true }, { "description": "too long is invalid", "data": [1, 2, 3], "valid": false }, { "description": "ignores non-arrays", "data": "foobar", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/maxLength.json000066400000000000000000000016001426774651400272630ustar00rootroot00000000000000[ { "description": "maxLength validation", "schema": {"maxLength": 2}, "tests": [ { "description": "shorter is valid", "data": "f", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too long is invalid", "data": "foo", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true }, { "description": "two supplementary Unicode code points is long enough", "data": "\uD83D\uDCA9\uD83D\uDCA9", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/maxProperties.json000066400000000000000000000027321426774651400302050ustar00rootroot00000000000000[ { "description": "maxProperties validation", "schema": {"maxProperties": 2}, "tests": [ { "description": "shorter is valid", "data": {"foo": 1}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "too long is invalid", "data": {"foo": 1, "bar": 2, "baz": 3}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "maxProperties = 0 means the object is empty", "schema": { "maxProperties": 0 }, "tests": [ { "description": "no properties is valid", "data": {}, "valid": true }, { "description": "one property is invalid", "data": { "foo": 1 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/maximum.json000066400000000000000000000027041426774651400270170ustar00rootroot00000000000000[ { "description": "maximum validation", "schema": {"maximum": 3.0}, "tests": [ { "description": "below the maximum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 3.0, "valid": true }, { "description": "above the maximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "maximum validation with unsigned integer", "schema": {"maximum": 300}, "tests": [ { "description": "below the maximum is invalid", "data": 299.97, "valid": true }, { "description": "boundary point integer is valid", "data": 300, "valid": true }, { "description": "boundary point float is valid", "data": 300.00, "valid": true }, { "description": "above the maximum is invalid", "data": 300.5, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/minContains.json000066400000000000000000000113501426774651400276210ustar00rootroot00000000000000[ { "description": "minContains without contains is ignored", "schema": { "minContains": 1 }, "tests": [ { "description": "one item valid against lone minContains", "data": [ 1 ], "valid": true }, { "description": "zero items still valid against lone minContains", "data": [], "valid": true } ] }, { "description": "minContains=1 with contains", "schema": { "contains": {"const": 1}, "minContains": 1 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "no elements match", "data": [ 2 ], "valid": false }, { "description": "single element matches, valid minContains", "data": [ 1 ], "valid": true }, { "description": "some elements match, valid minContains", "data": [ 1, 2 ], "valid": true }, { "description": "all elements match, valid minContains", "data": [ 1, 1 ], "valid": true } ] }, { "description": "minContains=2 with contains", "schema": { "contains": {"const": 1}, "minContains": 2 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "all elements match, invalid minContains", "data": [ 1 ], "valid": false }, { "description": "some elements match, invalid minContains", "data": [ 1, 2 ], "valid": false }, { "description": "all elements match, valid minContains (exactly as needed)", "data": [ 1, 1 ], "valid": true }, { "description": "all elements match, valid minContains (more than needed)", "data": [ 1, 1, 1 ], "valid": true }, { "description": "some elements match, valid minContains", "data": [ 1, 2, 1 ], "valid": true } ] }, { "description": "maxContains = minContains", "schema": { "contains": {"const": 1}, "maxContains": 2, "minContains": 2 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "all elements match, invalid minContains", "data": [ 1 ], "valid": false }, { "description": "all elements match, invalid maxContains", "data": [ 1, 1, 1 ], "valid": false }, { "description": "all elements match, valid maxContains and minContains", "data": [ 1, 1 ], "valid": true } ] }, { "description": "maxContains < minContains", "schema": { "contains": {"const": 1}, "maxContains": 1, "minContains": 3 }, "tests": [ { "description": "empty data", "data": [ ], "valid": false }, { "description": "invalid minContains", "data": [ 1 ], "valid": false }, { "description": "invalid maxContains", "data": [ 1, 1, 1 ], "valid": false }, { "description": "invalid maxContains and minContains", "data": [ 1, 1 ], "valid": false } ] }, { "description": "minContains = 0", "schema": { "contains": {"const": 1}, "minContains": 0 }, "tests": [ { "description": "empty data", "data": [ ], "valid": true }, { "description": "minContains = 0 makes contains always pass", "data": [ 2 ], "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/minItems.json000066400000000000000000000012651426774651400271300ustar00rootroot00000000000000[ { "description": "minItems validation", "schema": {"minItems": 1}, "tests": [ { "description": "longer is valid", "data": [1, 2], "valid": true }, { "description": "exact length is valid", "data": [1], "valid": true }, { "description": "too short is invalid", "data": [], "valid": false }, { "description": "ignores non-arrays", "data": "", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/minLength.json000066400000000000000000000015661426774651400272740ustar00rootroot00000000000000[ { "description": "minLength validation", "schema": {"minLength": 2}, "tests": [ { "description": "longer is valid", "data": "foo", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too short is invalid", "data": "f", "valid": false }, { "description": "ignores non-strings", "data": 1, "valid": true }, { "description": "one supplementary Unicode code point is not long enough", "data": "\uD83D\uDCA9", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/minProperties.json000066400000000000000000000017541426774651400302060ustar00rootroot00000000000000[ { "description": "minProperties validation", "schema": {"minProperties": 1}, "tests": [ { "description": "longer is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1}, "valid": true }, { "description": "too short is invalid", "data": {}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/minimum.json000066400000000000000000000036121426774651400270140ustar00rootroot00000000000000[ { "description": "minimum validation", "schema": {"minimum": 1.1}, "tests": [ { "description": "above the minimum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 1.1, "valid": true }, { "description": "below the minimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "minimum validation with signed integer", "schema": {"minimum": -2}, "tests": [ { "description": "negative above the minimum is valid", "data": -1, "valid": true }, { "description": "positive above the minimum is valid", "data": 0, "valid": true }, { "description": "boundary point is valid", "data": -2, "valid": true }, { "description": "boundary point with float is valid", "data": -2.0, "valid": true }, { "description": "float below the minimum is invalid", "data": -2.0001, "valid": false }, { "description": "int below the minimum is invalid", "data": -3, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/multipleOf.json000066400000000000000000000035771426774651400274730ustar00rootroot00000000000000[ { "description": "by int", "schema": {"multipleOf": 2}, "tests": [ { "description": "int by int", "data": 10, "valid": true }, { "description": "int by int fail", "data": 7, "valid": false }, { "description": "ignores non-numbers", "data": "foo", "valid": true } ] }, { "description": "by number", "schema": {"multipleOf": 1.5}, "tests": [ { "description": "zero is multiple of anything", "data": 0, "valid": true }, { "description": "4.5 is multiple of 1.5", "data": 4.5, "valid": true }, { "description": "35 is not multiple of 1.5", "data": 35, "valid": false } ] }, { "description": "by small number", "schema": {"multipleOf": 0.0001}, "tests": [ { "description": "0.0075 is multiple of 0.0001", "data": 0.0075, "valid": true }, { "description": "0.00751 is not multiple of 0.0001", "data": 0.00751, "valid": false } ] }, { "description": "invalid instance should not raise error when float division = inf", "schema": {"type": "integer", "multipleOf": 0.123456789}, "tests": [ { "description": "always invalid, but naive implementations may raise an overflow error", "data": 1e308, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/not.json000066400000000000000000000053761426774651400261520ustar00rootroot00000000000000[ { "description": "not", "schema": { "not": {"type": "integer"} }, "tests": [ { "description": "allowed", "data": "foo", "valid": true }, { "description": "disallowed", "data": 1, "valid": false } ] }, { "description": "not multiple types", "schema": { "not": {"type": ["integer", "boolean"]} }, "tests": [ { "description": "valid", "data": "foo", "valid": true }, { "description": "mismatch", "data": 1, "valid": false }, { "description": "other mismatch", "data": true, "valid": false } ] }, { "description": "not more complex schema", "schema": { "not": { "type": "object", "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "match", "data": 1, "valid": true }, { "description": "other match", "data": {"foo": 1}, "valid": true }, { "description": "mismatch", "data": {"foo": "bar"}, "valid": false } ] }, { "description": "forbidden property", "schema": { "properties": { "foo": { "not": {} } } }, "tests": [ { "description": "property present", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "property absent", "data": {"bar": 1, "baz": 2}, "valid": true } ] }, { "description": "not with boolean schema true", "schema": {"not": true}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "not with boolean schema false", "schema": {"not": false}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/oneOf.json000066400000000000000000000161231426774651400264100ustar00rootroot00000000000000[ { "description": "oneOf", "schema": { "oneOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first oneOf valid", "data": 1, "valid": true }, { "description": "second oneOf valid", "data": 2.5, "valid": true }, { "description": "both oneOf valid", "data": 3, "valid": false }, { "description": "neither oneOf valid", "data": 1.5, "valid": false } ] }, { "description": "oneOf with base schema", "schema": { "type": "string", "oneOf" : [ { "minLength": 2 }, { "maxLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one oneOf valid", "data": "foobar", "valid": true }, { "description": "both oneOf valid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all true", "schema": {"oneOf": [true, true, true]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, one true", "schema": {"oneOf": [true, false, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "oneOf with boolean schemas, more than one true", "schema": {"oneOf": [true, true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all false", "schema": {"oneOf": [false, false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf complex types", "schema": { "oneOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second oneOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both oneOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": false }, { "description": "neither oneOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "oneOf with empty schema", "schema": { "oneOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "one valid - valid", "data": "foo", "valid": true }, { "description": "both valid - invalid", "data": 123, "valid": false } ] }, { "description": "oneOf with required", "schema": { "type": "object", "oneOf": [ { "required": ["foo", "bar"] }, { "required": ["foo", "baz"] } ] }, "tests": [ { "description": "both invalid - invalid", "data": {"bar": 2}, "valid": false }, { "description": "first valid - valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "second valid - valid", "data": {"foo": 1, "baz": 3}, "valid": true }, { "description": "both valid - invalid", "data": {"foo": 1, "bar": 2, "baz" : 3}, "valid": false } ] }, { "description": "oneOf with missing optional property", "schema": { "oneOf": [ { "properties": { "bar": true, "baz": true }, "required": ["bar"] }, { "properties": { "foo": true }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid", "data": {"bar": 8}, "valid": true }, { "description": "second oneOf valid", "data": {"foo": "foo"}, "valid": true }, { "description": "both oneOf valid", "data": {"foo": "foo", "bar": 8}, "valid": false }, { "description": "neither oneOf valid", "data": {"baz": "quux"}, "valid": false } ] }, { "description": "nested oneOf, to check validation semantics", "schema": { "oneOf": [ { "oneOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/000077500000000000000000000000001426774651400262715ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/bignum.json000066400000000000000000000057111426774651400304510ustar00rootroot00000000000000[ { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a bignum is an integer", "data": 12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a bignum is a number", "data": 98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a negative bignum is an integer", "data": -12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a negative bignum is a number", "data": -98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "string", "schema": {"type": "string"}, "tests": [ { "description": "a bignum is not a string", "data": 98249283749234923498293171823948729348710298301928331, "valid": false } ] }, { "description": "integer comparison", "schema": {"maximum": 18446744073709551615}, "tests": [ { "description": "comparison works for high numbers", "data": 18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision", "schema": { "exclusiveMaximum": 972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for high numbers", "data": 972783798187987123879878123.188781371, "valid": false } ] }, { "description": "integer comparison", "schema": {"minimum": -18446744073709551615}, "tests": [ { "description": "comparison works for very negative numbers", "data": -18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision on negative numbers", "schema": { "exclusiveMinimum": -972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for very negative numbers", "data": -972783798187987123879878123.188781371, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/ecmascript-regex.json000066400000000000000000000202161426774651400324270ustar00rootroot00000000000000[ { "description": "ECMA 262 regex $ does not match trailing newline", "schema": { "type": "string", "pattern": "^abc$" }, "tests": [ { "description": "matches in Python, but should not in jsonschema", "data": "abc\n", "valid": false }, { "description": "should match", "data": "abc", "valid": true } ] }, { "description": "ECMA 262 regex converts \\t to horizontal tab", "schema": { "type": "string", "pattern": "^\\t$" }, "tests": [ { "description": "does not match", "data": "\\t", "valid": false }, { "description": "matches", "data": "\u0009", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and upper letter", "schema": { "type": "string", "pattern": "^\\cC$" }, "tests": [ { "description": "does not match", "data": "\\cC", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and lower letter", "schema": { "type": "string", "pattern": "^\\cc$" }, "tests": [ { "description": "does not match", "data": "\\cc", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 \\d matches ascii digits only", "schema": { "type": "string", "pattern": "^\\d$" }, "tests": [ { "description": "ASCII zero matches", "data": "0", "valid": true }, { "description": "NKO DIGIT ZERO does not match (unlike e.g. Python)", "data": "߀", "valid": false }, { "description": "NKO DIGIT ZERO (as \\u escape) does not match", "data": "\u07c0", "valid": false } ] }, { "description": "ECMA 262 \\D matches everything but ascii digits", "schema": { "type": "string", "pattern": "^\\D$" }, "tests": [ { "description": "ASCII zero does not match", "data": "0", "valid": false }, { "description": "NKO DIGIT ZERO matches (unlike e.g. Python)", "data": "߀", "valid": true }, { "description": "NKO DIGIT ZERO (as \\u escape) matches", "data": "\u07c0", "valid": true } ] }, { "description": "ECMA 262 \\w matches ascii letters only", "schema": { "type": "string", "pattern": "^\\w$" }, "tests": [ { "description": "ASCII 'a' matches", "data": "a", "valid": true }, { "description": "latin-1 e-acute does not match (unlike e.g. Python)", "data": "é", "valid": false } ] }, { "description": "ECMA 262 \\W matches everything but ascii letters", "schema": { "type": "string", "pattern": "^\\W$" }, "tests": [ { "description": "ASCII 'a' does not match", "data": "a", "valid": false }, { "description": "latin-1 e-acute matches (unlike e.g. Python)", "data": "é", "valid": true } ] }, { "description": "ECMA 262 \\s matches whitespace", "schema": { "type": "string", "pattern": "^\\s$" }, "tests": [ { "description": "ASCII space matches", "data": " ", "valid": true }, { "description": "Character tabulation matches", "data": "\t", "valid": true }, { "description": "Line tabulation matches", "data": "\u000b", "valid": true }, { "description": "Form feed matches", "data": "\u000c", "valid": true }, { "description": "latin-1 non-breaking-space matches", "data": "\u00a0", "valid": true }, { "description": "zero-width whitespace matches", "data": "\ufeff", "valid": true }, { "description": "line feed matches (line terminator)", "data": "\u000a", "valid": true }, { "description": "paragraph separator matches (line terminator)", "data": "\u2029", "valid": true }, { "description": "EM SPACE matches (Space_Separator)", "data": "\u2003", "valid": true }, { "description": "Non-whitespace control does not match", "data": "\u0001", "valid": false }, { "description": "Non-whitespace does not match", "data": "\u2013", "valid": false } ] }, { "description": "ECMA 262 \\S matches everything but whitespace", "schema": { "type": "string", "pattern": "^\\S$" }, "tests": [ { "description": "ASCII space does not match", "data": " ", "valid": false }, { "description": "Character tabulation does not match", "data": "\t", "valid": false }, { "description": "Line tabulation does not match", "data": "\u000b", "valid": false }, { "description": "Form feed does not match", "data": "\u000c", "valid": false }, { "description": "latin-1 non-breaking-space does not match", "data": "\u00a0", "valid": false }, { "description": "zero-width whitespace does not match", "data": "\ufeff", "valid": false }, { "description": "line feed does not match (line terminator)", "data": "\u000a", "valid": false }, { "description": "paragraph separator does not match (line terminator)", "data": "\u2029", "valid": false }, { "description": "EM SPACE does not match (Space_Separator)", "data": "\u2003", "valid": false }, { "description": "Non-whitespace control matches", "data": "\u0001", "valid": true }, { "description": "Non-whitespace matches", "data": "\u2013", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/float-overflow.json000066400000000000000000000005511426774651400321330ustar00rootroot00000000000000[ { "description": "all integers are multiples of 0.5, if overflow is handled", "schema": {"type": "integer", "multipleOf": 0.5}, "tests": [ { "description": "valid if optional overflow handling is implemented", "data": 1e308, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/000077500000000000000000000000001426774651400275615ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/date-time.json000066400000000000000000000041421426774651400323260ustar00rootroot00000000000000[ { "description": "validation of date-time strings", "schema": {"format": "date-time"}, "tests": [ { "description": "a valid date-time string", "data": "1963-06-19T08:30:06.283185Z", "valid": true }, { "description": "a valid date-time string without second fraction", "data": "1963-06-19T08:30:06Z", "valid": true }, { "description": "a valid date-time string with plus offset", "data": "1937-01-01T12:00:27.87+00:20", "valid": true }, { "description": "a valid date-time string with minus offset", "data": "1990-12-31T15:59:50.123-08:00", "valid": true }, { "description": "a invalid day in date-time string", "data": "1990-02-31T15:59:60.123-08:00", "valid": false }, { "description": "an invalid offset in date-time string", "data": "1990-12-31T15:59:60-24:00", "valid": false }, { "description": "an invalid date-time string", "data": "06/19/1963 08:30:06 PST", "valid": false }, { "description": "case-insensitive T and Z", "data": "1963-06-19t08:30:06.283185z", "valid": true }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350T01:01:01", "valid": false }, { "description": "invalid non-padded month dates", "data": "1963-6-19T08:30:06.283185Z", "valid": false }, { "description": "invalid non-padded day dates", "data": "1963-06-1T08:30:06.283185Z", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/date.json000066400000000000000000000131301426774651400313670ustar00rootroot00000000000000[ { "description": "validation of date strings", "schema": {"format": "date"}, "tests": [ { "description": "a valid date string", "data": "1963-06-19", "valid": true }, { "description": "a valid date string with 31 days in January", "data": "2020-01-31", "valid": true }, { "description": "a invalid date string with 32 days in January", "data": "2020-01-32", "valid": false }, { "description": "a valid date string with 28 days in February (normal)", "data": "2021-02-28", "valid": true }, { "description": "a invalid date string with 29 days in February (normal)", "data": "2021-02-29", "valid": false }, { "description": "a valid date string with 29 days in February (leap)", "data": "2020-02-29", "valid": true }, { "description": "a invalid date string with 30 days in February (leap)", "data": "2020-02-30", "valid": false }, { "description": "a valid date string with 31 days in March", "data": "2020-03-31", "valid": true }, { "description": "a invalid date string with 32 days in March", "data": "2020-03-32", "valid": false }, { "description": "a valid date string with 30 days in April", "data": "2020-04-30", "valid": true }, { "description": "a invalid date string with 31 days in April", "data": "2020-04-31", "valid": false }, { "description": "a valid date string with 31 days in May", "data": "2020-05-31", "valid": true }, { "description": "a invalid date string with 32 days in May", "data": "2020-05-32", "valid": false }, { "description": "a valid date string with 30 days in June", "data": "2020-06-30", "valid": true }, { "description": "a invalid date string with 31 days in June", "data": "2020-06-31", "valid": false }, { "description": "a valid date string with 31 days in July", "data": "2020-07-31", "valid": true }, { "description": "a invalid date string with 32 days in July", "data": "2020-07-32", "valid": false }, { "description": "a valid date string with 31 days in August", "data": "2020-08-31", "valid": true }, { "description": "a invalid date string with 32 days in August", "data": "2020-08-32", "valid": false }, { "description": "a valid date string with 30 days in September", "data": "2020-09-30", "valid": true }, { "description": "a invalid date string with 31 days in September", "data": "2020-09-31", "valid": false }, { "description": "a valid date string with 31 days in October", "data": "2020-10-31", "valid": true }, { "description": "a invalid date string with 32 days in October", "data": "2020-10-32", "valid": false }, { "description": "a valid date string with 30 days in November", "data": "2020-11-30", "valid": true }, { "description": "a invalid date string with 31 days in November", "data": "2020-11-31", "valid": false }, { "description": "a valid date string with 31 days in December", "data": "2020-12-31", "valid": true }, { "description": "a invalid date string with 32 days in December", "data": "2020-12-32", "valid": false }, { "description": "a invalid date string with invalid month", "data": "2020-13-01", "valid": false }, { "description": "an invalid date string", "data": "06/19/1963", "valid": false }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350", "valid": false }, { "description": "invalidates non-padded month dates", "data": "1998-1-20", "valid": false }, { "description": "invalidates non-padded day dates", "data": "1998-01-1", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/duration.json000066400000000000000000000047401426774651400323060ustar00rootroot00000000000000[ { "description": "validation of duration strings", "schema": {"format": "duration"}, "tests": [ { "description": "a valid duration string", "data": "P4DT12H30M5S", "valid": true }, { "description": "an invalid duration string", "data": "PT1D", "valid": false }, { "description": "no elements present", "data": "P", "valid": false }, { "description": "no time elements present", "data": "P1YT", "valid": false }, { "description": "no date or time elements present", "data": "PT", "valid": false }, { "description": "elements out of order", "data": "P2D1Y", "valid": false }, { "description": "missing time separator", "data": "P1D2H", "valid": false }, { "description": "time element in the date position", "data": "P2S", "valid": false }, { "description": "four years duration", "data": "P4Y", "valid": true }, { "description": "zero time, in seconds", "data": "PT0S", "valid": true }, { "description": "zero time, in days", "data": "P0D", "valid": true }, { "description": "one month duration", "data": "P1M", "valid": true }, { "description": "one minute duration", "data": "PT1M", "valid": true }, { "description": "one and a half days, in hours", "data": "PT36H", "valid": true }, { "description": "one and a half days, in days and hours", "data": "P1DT12H", "valid": true }, { "description": "two weeks", "data": "P2W", "valid": true }, { "description": "weeks cannot be combined with other units", "data": "P1Y2W", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/email.json000066400000000000000000000032331426774651400315440ustar00rootroot00000000000000[ { "description": "validation of e-mail addresses", "schema": {"format": "email"}, "tests": [ { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false }, { "description": "tilde in local part is valid", "data": "te~st@example.com", "valid": true }, { "description": "tilde before local part is valid", "data": "~test@example.com", "valid": true }, { "description": "tilde after local part is valid", "data": "test~@example.com", "valid": true }, { "description": "dot before local part is not valid", "data": ".test@example.com", "valid": false }, { "description": "dot after local part is not valid", "data": "test.@example.com", "valid": false }, { "description": "two separated dots inside local part are valid", "data": "te.s.t@example.com", "valid": true }, { "description": "two subsequent dots inside local part are not valid", "data": "te..st@example.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/hostname.json000066400000000000000000000043531426774651400322770ustar00rootroot00000000000000[ { "description": "validation of host names", "schema": {"format": "hostname"}, "tests": [ { "description": "a valid host name", "data": "www.example.com", "valid": true }, { "description": "a valid punycoded IDN hostname", "data": "xn--4gbwdl.xn--wgbh1c", "valid": true }, { "description": "a host name starting with an illegal character", "data": "-a-host-name-that-starts-with--", "valid": false }, { "description": "a host name containing illegal characters", "data": "not_a_valid_host_name", "valid": false }, { "description": "a host name with a component too long", "data": "a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component", "valid": false }, { "description": "starts with hyphen", "data": "-hostname", "valid": false }, { "description": "ends with hyphen", "data": "hostname-", "valid": false }, { "description": "starts with underscore", "data": "_hostname", "valid": false }, { "description": "ends with underscore", "data": "hostname_", "valid": false }, { "description": "contains underscore", "data": "host_name", "valid": false }, { "description": "maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com", "valid": true }, { "description": "exceeds maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/idn-email.json000066400000000000000000000015031426774651400323120ustar00rootroot00000000000000[ { "description": "validation of an internationalized e-mail addresses", "schema": {"format": "idn-email"}, "tests": [ { "description": "a valid idn e-mail (example@example.test in Hangul)", "data": "실례@실례.테스트", "valid": true }, { "description": "an invalid idn e-mail address", "data": "2962", "valid": false }, { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/idn-hostname.json000066400000000000000000000327721426774651400330550ustar00rootroot00000000000000[ { "description": "validation of internationalized host names", "schema": { "format": "idn-hostname" }, "tests": [ { "description": "a valid host name (example.test in Hangul)", "data": "실례.테스트", "valid": true }, { "description": "illegal first char U+302E Hangul single dot tone mark", "data": "〮실례.테스트", "valid": false }, { "description": "contains illegal char U+302E Hangul single dot tone mark", "data": "실〮례.테스트", "valid": false }, { "description": "a host name with a component too long", "data": "실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실례례테스트례례례례례례례례례례례례례례례례례테스트례례례례례례례례례례례례례례례례례례례테스트례례례례례례례례례례례례테스트례례실례.테스트", "valid": false }, { "description": "invalid label, correct Punycode", "comment": "https://tools.ietf.org/html/rfc5890#section-2.3.2.1 https://tools.ietf.org/html/rfc5891#section-4.4 https://tools.ietf.org/html/rfc3492#section-7.1", "data": "-> $1.00 <--", "valid": false }, { "description": "valid Chinese Punycode", "comment": "https://tools.ietf.org/html/rfc5890#section-2.3.2.1 https://tools.ietf.org/html/rfc5891#section-4.4", "data": "xn--ihqwcrb4cv8a8dqg056pqjye", "valid": true }, { "description": "invalid Punycode", "comment": "https://tools.ietf.org/html/rfc5891#section-4.4 https://tools.ietf.org/html/rfc5890#section-2.3.2.1", "data": "xn--X", "valid": false }, { "description": "U-label contains \"--\" in the 3rd and 4th position", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1 https://tools.ietf.org/html/rfc5890#section-2.3.2.1", "data": "XN--aa---o47jg78q", "valid": false }, { "description": "U-label starts with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "-hello", "valid": false }, { "description": "U-label ends with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "hello-", "valid": false }, { "description": "U-label starts and ends with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "-hello-", "valid": false }, { "description": "Begins with a Spacing Combining Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0903hello", "valid": false }, { "description": "Begins with a Nonspacing Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0300hello", "valid": false }, { "description": "Begins with an Enclosing Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0488hello", "valid": false }, { "description": "Exceptions that are PVALID, left-to-right chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u00df\u03c2\u0f0b\u3007", "valid": true }, { "description": "Exceptions that are PVALID, right-to-left chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u06fd\u06fe", "valid": true }, { "description": "Exceptions that are DISALLOWED, right-to-left chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u0640\u07fa", "valid": false }, { "description": "Exceptions that are DISALLOWED, left-to-right chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6 Note: The two combining marks (U+302E and U+302F) are in the middle and not at the start", "data": "\u3031\u3032\u3033\u3034\u3035\u302e\u302f\u303b", "valid": false }, { "description": "MIDDLE DOT with no preceding 'l'", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "a\u00b7l", "valid": false }, { "description": "MIDDLE DOT with nothing preceding", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "\u00b7l", "valid": false }, { "description": "MIDDLE DOT with no following 'l'", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7a", "valid": false }, { "description": "MIDDLE DOT with nothing following", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7", "valid": false }, { "description": "MIDDLE DOT with surrounding 'l's", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7l", "valid": true }, { "description": "Greek KERAIA not followed by Greek", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375S", "valid": false }, { "description": "Greek KERAIA not followed by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375", "valid": false }, { "description": "Greek KERAIA followed by Greek", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375\u03b2", "valid": true }, { "description": "Hebrew GERESH not preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "A\u05f3\u05d1", "valid": false }, { "description": "Hebrew GERESH not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "\u05f3\u05d1", "valid": false }, { "description": "Hebrew GERESH preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "\u05d0\u05f3\u05d1", "valid": true }, { "description": "Hebrew GERSHAYIM not preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "A\u05f4\u05d1", "valid": false }, { "description": "Hebrew GERSHAYIM not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "\u05f4\u05d1", "valid": false }, { "description": "Hebrew GERSHAYIM preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "\u05d0\u05f4\u05d1", "valid": true }, { "description": "KATAKANA MIDDLE DOT with no Hiragana, Katakana, or Han", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "def\u30fbabc", "valid": false }, { "description": "KATAKANA MIDDLE DOT with no other characters", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb", "valid": false }, { "description": "KATAKANA MIDDLE DOT with Hiragana", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u3041", "valid": true }, { "description": "KATAKANA MIDDLE DOT with Katakana", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u30a1", "valid": true }, { "description": "KATAKANA MIDDLE DOT with Han", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u4e08", "valid": true }, { "description": "Arabic-Indic digits mixed with Extended Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.8", "data": "\u0660\u06f0", "valid": false }, { "description": "Arabic-Indic digits not mixed with Extended Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.8", "data": "\u0628\u0660\u0628", "valid": true }, { "description": "Extended Arabic-Indic digits not mixed with Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.9", "data": "\u06f00", "valid": true }, { "description": "ZERO WIDTH JOINER not preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u0915\u200d\u0937", "valid": false }, { "description": "ZERO WIDTH JOINER not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u200d\u0937", "valid": false }, { "description": "ZERO WIDTH JOINER preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u0915\u094d\u200d\u0937", "valid": true }, { "description": "ZERO WIDTH NON-JOINER preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.1", "data": "\u0915\u094d\u200c\u0937", "valid": true }, { "description": "ZERO WIDTH NON-JOINER not preceded by Virama but matches regexp", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.1 https://www.w3.org/TR/alreq/#h_disjoining_enforcement", "data": "\u0628\u064a\u200c\u0628\u064a", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/ipv4.json000066400000000000000000000032731426774651400313430ustar00rootroot00000000000000[ { "description": "validation of IP addresses", "schema": {"format": "ipv4"}, "tests": [ { "description": "a valid IP address", "data": "192.168.0.1", "valid": true }, { "description": "an IP address with too many components", "data": "127.0.0.0.1", "valid": false }, { "description": "an IP address with out-of-range values", "data": "256.256.256.256", "valid": false }, { "description": "an IP address without 4 components", "data": "127.0", "valid": false }, { "description": "an IP address as an integer", "data": "0x7f000001", "valid": false }, { "description": "an IP address as an integer (decimal)", "data": "2130706433", "valid": false }, { "description": "leading zeroes should be rejected, as they are treated as octals", "comment": "see https://sick.codes/universal-netmask-npm-package-used-by-270000-projects-vulnerable-to-octal-input-data-server-side-request-forgery-remote-file-inclusion-local-file-inclusion-and-more-cve-2021-28918/", "data": "087.10.0.1", "valid": false }, { "description": "value without leading zero is valid", "data": "87.10.0.1", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/ipv6.json000066400000000000000000000120111426774651400313330ustar00rootroot00000000000000[ { "description": "validation of IPv6 addresses", "schema": {"format": "ipv6"}, "tests": [ { "description": "a valid IPv6 address", "data": "::1", "valid": true }, { "description": "an IPv6 address with out-of-range values", "data": "12345::", "valid": false }, { "description": "an IPv6 address with too many components", "data": "1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1", "valid": false }, { "description": "an IPv6 address containing illegal characters", "data": "::laptop", "valid": false }, { "description": "no digits is valid", "data": "::", "valid": true }, { "description": "leading colons is valid", "data": "::42:ff:1", "valid": true }, { "description": "trailing colons is valid", "data": "d6::", "valid": true }, { "description": "missing leading octet is invalid", "data": ":2:3:4:5:6:7:8", "valid": false }, { "description": "missing trailing octet is invalid", "data": "1:2:3:4:5:6:7:", "valid": false }, { "description": "missing leading octet with omitted octets later", "data": ":2:3:4::8", "valid": false }, { "description": "two sets of double colons is invalid", "data": "1::d6::42", "valid": false }, { "description": "mixed format with the ipv4 section as decimal octets", "data": "1::d6:192.168.0.1", "valid": true }, { "description": "mixed format with double colons between the sections", "data": "1:2::192.168.0.1", "valid": true }, { "description": "mixed format with ipv4 section with octet out of range", "data": "1::2:192.168.256.1", "valid": false }, { "description": "mixed format with ipv4 section with a hex octet", "data": "1::2:192.168.ff.1", "valid": false }, { "description": "mixed format with leading double colons (ipv4-mapped ipv6 address)", "data": "::ffff:192.168.0.1", "valid": true }, { "description": "triple colons is invalid", "data": "1:2:3:4:5:::8", "valid": false }, { "description": "8 octets", "data": "1:2:3:4:5:6:7:8", "valid": true }, { "description": "insufficient octets without double colons", "data": "1:2:3:4:5:6:7", "valid": false }, { "description": "no colons is invalid", "data": "1", "valid": false }, { "description": "ipv4 is not ipv6", "data": "127.0.0.1", "valid": false }, { "description": "ipv4 segment must have 4 octets", "data": "1:2:3:4:1.2.3", "valid": false }, { "description": "leading whitespace is invalid", "data": " ::1", "valid": false }, { "description": "trailing whitespace is invalid", "data": "::1 ", "valid": false }, { "description": "netmask is not a part of ipv6 address", "data": "fe80::/64", "valid": false }, { "description": "zone id is not a part of ipv6 address", "data": "fe80::a%eth1", "valid": false }, { "description": "a long valid ipv6", "data": "1000:1000:1000:1000:1000:1000:255.255.255.255", "valid": true }, { "description": "a long invalid ipv6, below length limit, first", "data": "100:100:100:100:100:100:255.255.255.255.255", "valid": false }, { "description": "a long invalid ipv6, below length limit, second", "data": "100:100:100:100:100:100:100:255.255.255.255", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/iri-reference.json000066400000000000000000000024411426774651400331740ustar00rootroot00000000000000[ { "description": "validation of IRI References", "schema": {"format": "iri-reference"}, "tests": [ { "description": "a valid IRI", "data": "http://ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid protocol-relative IRI Reference", "data": "//ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid relative IRI Reference", "data": "/âππ", "valid": true }, { "description": "an invalid IRI Reference", "data": "\\\\WINDOWS\\filëßåré", "valid": false }, { "description": "a valid IRI Reference", "data": "âππ", "valid": true }, { "description": "a valid IRI fragment", "data": "#ƒrägmênt", "valid": true }, { "description": "an invalid IRI fragment", "data": "#ƒräg\\mênt", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/iri.json000066400000000000000000000034531426774651400312440ustar00rootroot00000000000000[ { "description": "validation of IRIs", "schema": {"format": "iri"}, "tests": [ { "description": "a valid IRI with anchor tag", "data": "http://ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid IRI with anchor tag and parentheses", "data": "http://ƒøø.com/blah_(wîkïpédiå)_blah#ßité-1", "valid": true }, { "description": "a valid IRI with URL-encoded stuff", "data": "http://ƒøø.ßår/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid IRI with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid IRI based on IPv6", "data": "http://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", "valid": true }, { "description": "an invalid IRI based on IPv6", "data": "http://2001:0db8:85a3:0000:0000:8a2e:0370:7334", "valid": false }, { "description": "an invalid relative IRI Reference", "data": "/abc", "valid": false }, { "description": "an invalid IRI", "data": "\\\\WINDOWS\\filëßåré", "valid": false }, { "description": "an invalid IRI though valid IRI reference", "data": "âππ", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/json-pointer.json000066400000000000000000000132121426774651400331020ustar00rootroot00000000000000[ { "description": "validation of JSON-pointers (JSON String Representation)", "schema": {"format": "json-pointer"}, "tests": [ { "description": "a valid JSON-pointer", "data": "/foo/bar~0/baz~1/%a", "valid": true }, { "description": "not a valid JSON-pointer (~ not escaped)", "data": "/foo/bar~", "valid": false }, { "description": "valid JSON-pointer with empty segment", "data": "/foo//bar", "valid": true }, { "description": "valid JSON-pointer with the last empty segment", "data": "/foo/bar/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #1", "data": "", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #2", "data": "/foo", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #3", "data": "/foo/0", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #4", "data": "/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #5", "data": "/a~1b", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #6", "data": "/c%d", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #7", "data": "/e^f", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #8", "data": "/g|h", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #9", "data": "/i\\j", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #10", "data": "/k\"l", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #11", "data": "/ ", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #12", "data": "/m~0n", "valid": true }, { "description": "valid JSON-pointer used adding to the last array position", "data": "/foo/-", "valid": true }, { "description": "valid JSON-pointer (- used as object member name)", "data": "/foo/-/bar", "valid": true }, { "description": "valid JSON-pointer (multiple escaped characters)", "data": "/~1~0~0~1~1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #1", "data": "/~1.1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #2", "data": "/~0.1", "valid": true }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #1", "data": "#", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #2", "data": "#/", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #3", "data": "#a", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #1", "data": "/~0~", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #2", "data": "/~0/~", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #1", "data": "/~2", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #2", "data": "/~-1", "valid": false }, { "description": "not a valid JSON-pointer (multiple characters not escaped)", "data": "/~~", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #1", "data": "a", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #2", "data": "0", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #3", "data": "a/a", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/regex.json000066400000000000000000000007451426774651400315740ustar00rootroot00000000000000[ { "description": "validation of regular expressions", "schema": {"format": "regex"}, "tests": [ { "description": "a valid regular expression", "data": "([abc])+\\s+$", "valid": true }, { "description": "a regular expression with unclosed parens is invalid", "data": "^(abc]", "valid": false } ] } ] relative-json-pointer.json000066400000000000000000000031671426774651400346440ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format[ { "description": "validation of Relative JSON Pointers (RJP)", "schema": {"format": "relative-json-pointer"}, "tests": [ { "description": "a valid upwards RJP", "data": "1", "valid": true }, { "description": "a valid downwards RJP", "data": "0/foo/bar", "valid": true }, { "description": "a valid up and then down RJP, with array index", "data": "2/0/baz/1/zip", "valid": true }, { "description": "a valid RJP taking the member or index name", "data": "0#", "valid": true }, { "description": "an invalid RJP that is a valid JSON Pointer", "data": "/foo/bar", "valid": false }, { "description": "negative prefix", "data": "-1/foo/bar", "valid": false }, { "description": "## is not a valid json-pointer", "data": "0##", "valid": false }, { "description": "zero cannot be followed by other digits, plus json-pointer", "data": "01/a", "valid": false }, { "description": "zero cannot be followed by other digits, plus octothorpe", "data": "01#", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/time.json000066400000000000000000000064221426774651400314160ustar00rootroot00000000000000[ { "description": "validation of time strings", "schema": {"format": "time"}, "tests": [ { "description": "a valid time string", "data": "08:30:06Z", "valid": true }, { "description": "a valid time string with leap second", "data": "23:59:60Z", "valid": true }, { "description": "a valid time string with leap second with offset", "data": "15:59:60-08:00", "valid": true }, { "description": "a valid time string with second fraction", "data": "23:20:50.52Z", "valid": true }, { "description": "a valid time string with precise second fraction", "data": "08:30:06.283185Z", "valid": true }, { "description": "a valid time string with plus offset", "data": "08:30:06+00:20", "valid": true }, { "description": "a valid time string with minus offset", "data": "08:30:06-08:00", "valid": true }, { "description": "a valid time string with case-insensitive Z", "data": "08:30:06z", "valid": true }, { "description": "an invalid time string with invalid hour", "data": "24:00:00Z", "valid": false }, { "description": "an invalid time string with invalid minute", "data": "00:60:00Z", "valid": false }, { "description": "an invalid time string with invalid second", "data": "00:00:61Z", "valid": false }, { "description": "an invalid time string with invalid leap second (wrong hour)", "data": "22:59:60Z", "valid": false }, { "description": "an invalid time string with invalid leap second (wrong minute)", "data": "23:58:60Z", "valid": false }, { "description": "an invalid time string with invalid time numoffset hour", "data": "01:02:03+24:00", "valid": false }, { "description": "an invalid time string with invalid time numoffset minute", "data": "01:02:03+00:60", "valid": false }, { "description": "an invalid time string with invalid time with both Z and numoffset", "data": "01:02:03Z+00:30", "valid": false }, { "description": "an invalid time string", "data": "08:30:06 PST", "valid": false }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "01:01:01,1111", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/uri-reference.json000066400000000000000000000023661426774651400332160ustar00rootroot00000000000000[ { "description": "validation of URI References", "schema": {"format": "uri-reference"}, "tests": [ { "description": "a valid URI", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid relative URI Reference", "data": "/abc", "valid": true }, { "description": "an invalid URI Reference", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "a valid URI Reference", "data": "abc", "valid": true }, { "description": "a valid URI fragment", "data": "#fragment", "valid": true }, { "description": "an invalid URI fragment", "data": "#frag\\ment", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/uri-template.json000066400000000000000000000015601426774651400330660ustar00rootroot00000000000000[ { "description": "format: uri-template", "schema": {"format": "uri-template"}, "tests": [ { "description": "a valid uri-template", "data": "http://example.com/dictionary/{term:1}/{term}", "valid": true }, { "description": "an invalid uri-template", "data": "http://example.com/dictionary/{term:1}/{term", "valid": false }, { "description": "a valid uri-template without variables", "data": "http://example.com/dictionary", "valid": true }, { "description": "a valid relative uri-template", "data": "dictionary/{term:1}/{term}", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/uri.json000066400000000000000000000071631426774651400312620ustar00rootroot00000000000000[ { "description": "validation of URIs", "schema": {"format": "uri"}, "tests": [ { "description": "a valid URL with anchor tag", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid URL with anchor tag and parentheses", "data": "http://foo.com/blah_(wikipedia)_blah#cite-1", "valid": true }, { "description": "a valid URL with URL-encoded stuff", "data": "http://foo.bar/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid puny-coded URL ", "data": "http://xn--nw2a.xn--j6w193g/", "valid": true }, { "description": "a valid URL with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid URL based on IPv4", "data": "http://223.255.255.254", "valid": true }, { "description": "a valid URL with ftp scheme", "data": "ftp://ftp.is.co.za/rfc/rfc1808.txt", "valid": true }, { "description": "a valid URL for a simple text file", "data": "http://www.ietf.org/rfc/rfc2396.txt", "valid": true }, { "description": "a valid URL ", "data": "ldap://[2001:db8::7]/c=GB?objectClass?one", "valid": true }, { "description": "a valid mailto URI", "data": "mailto:John.Doe@example.com", "valid": true }, { "description": "a valid newsgroup URI", "data": "news:comp.infosystems.www.servers.unix", "valid": true }, { "description": "a valid tel URI", "data": "tel:+1-816-555-1212", "valid": true }, { "description": "a valid URN", "data": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", "valid": true }, { "description": "an invalid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": false }, { "description": "an invalid relative URI Reference", "data": "/abc", "valid": false }, { "description": "an invalid URI", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "an invalid URI though valid URI reference", "data": "abc", "valid": false }, { "description": "an invalid URI with spaces", "data": "http:// shouldfail.com", "valid": false }, { "description": "an invalid URI with spaces and missing scheme", "data": ":// should fail", "valid": false }, { "description": "an invalid URI with comma in scheme", "data": "bar,baz:foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/format/uuid.json000066400000000000000000000042601426774651400314240ustar00rootroot00000000000000[ { "description": "uuid format", "schema": { "format": "uuid" }, "tests": [ { "description": "all upper-case", "data": "2EB8AA08-AA98-11EA-B4AA-73B441D16380", "valid": true }, { "description": "all lower-case", "data": "2eb8aa08-aa98-11ea-b4aa-73b441d16380", "valid": true }, { "description": "mixed case", "data": "2eb8aa08-AA98-11ea-B4Aa-73B441D16380", "valid": true }, { "description": "all zeroes is valid", "data": "00000000-0000-0000-0000-000000000000", "valid": true }, { "description": "wrong length", "data": "2eb8aa08-aa98-11ea-b4aa-73b441d1638", "valid": false }, { "description": "missing section", "data": "2eb8aa08-aa98-11ea-73b441d16380", "valid": false }, { "description": "bad characters (not hex)", "data": "2eb8aa08-aa98-11ea-b4ga-73b441d16380", "valid": false }, { "description": "no dashes", "data": "2eb8aa08aa9811eab4aa73b441d16380", "valid": false }, { "description": "valid version 4", "data": "98d80576-482e-427f-8434-7f86890ab222", "valid": true }, { "description": "valid version 5", "data": "99c17cbb-656f-564a-940f-1a4568f03487", "valid": true }, { "description": "hypothetical version 6", "data": "99c17cbb-656f-664a-940f-1a4568f03487", "valid": true }, { "description": "hypothetical version 15", "data": "99c17cbb-656f-f64a-940f-1a4568f03487", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/non-bmp-regex.json000066400000000000000000000045361426774651400316520ustar00rootroot00000000000000[ { "description": "Proper UTF-16 surrogate pair handling: pattern", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "pattern": "^🐲*$" }, "tests": [ { "description": "matches empty", "data": "", "valid": true }, { "description": "matches single", "data": "🐲", "valid": true }, { "description": "matches two", "data": "🐲🐲", "valid": true }, { "description": "doesn't match one", "data": "🐉", "valid": false }, { "description": "doesn't match two", "data": "🐉🐉", "valid": false }, { "description": "doesn't match one ASCII", "data": "D", "valid": false }, { "description": "doesn't match two ASCII", "data": "DD", "valid": false } ] }, { "description": "Proper UTF-16 surrogate pair handling: patternProperties", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "patternProperties": { "^🐲*$": { "type": "integer" } } }, "tests": [ { "description": "matches empty", "data": { "": 1 }, "valid": true }, { "description": "matches single", "data": { "🐲": 1 }, "valid": true }, { "description": "matches two", "data": { "🐲🐲": 1 }, "valid": true }, { "description": "doesn't match one", "data": { "🐲": "hello" }, "valid": false }, { "description": "doesn't match two", "data": { "🐲🐲": "hello" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/refOfUnknownKeyword.json000066400000000000000000000022141426774651400331510ustar00rootroot00000000000000[ { "description": "reference of a root arbitrary keyword ", "schema": { "unknown-keyword": {"type": "integer"}, "properties": { "bar": {"$ref": "#/unknown-keyword"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "reference of an arbitrary keyword of a sub-schema", "schema": { "properties": { "foo": {"unknown-keyword": {"type": "integer"}}, "bar": {"$ref": "#/properties/foo/unknown-keyword"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/optional/unicode.json000066400000000000000000000127301426774651400306150ustar00rootroot00000000000000[ { "description": "unicode semantics should be used for all pattern matching", "schema": { "pattern": "\\wcole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode matching is case-sensitive", "data": "LES HIVERS DE MON ENFANCE ÉTAIENT DES SAISONS LONGUES, LONGUES. NOUS VIVIONS EN TROIS LIEUX: L'ÉCOLE, L'ÉGLISE ET LA PATINOIRE; MAIS LA VRAIE VIE ÉTAIT SUR LA PATINOIRE.", "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "pattern": "[a-z]cole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "ascii characters match", "data": "Les hivers de mon enfance etaient des saisons longues, longues. Nous vivions en trois lieux: l'ecole, l'eglise et la patinoire; mais la vraie vie etait sur la patinoire.", "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "pattern": "^\\d+$" }, "tests": [ { "description": "ascii digits", "data": "42", "valid": true }, { "description": "ascii non-digits", "data": "-%#", "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": "৪২", "valid": true } ] }, { "description": "unicode semantics should be used for all patternProperties matching", "schema": { "type": "object", "patternProperties": { "\\wcole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": true }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": true }, { "description": "unicode matching is case-sensitive", "data": { "L'ÉCOLE": "PAS DE VRAIE VIE" }, "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "type": "object", "patternProperties": { "[a-z]cole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": false }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": false }, { "description": "ascii characters match", "data": { "l'ecole": "pas de vraie vie" }, "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "type": "object", "patternProperties": { "^\\d+$": true }, "additionalProperties": false }, "tests": [ { "description": "ascii digits", "data": { "42": "life, the universe, and everything" }, "valid": true }, { "description": "ascii non-digits", "data": { "-%#": "spending the year dead for tax reasons" }, "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": { "৪২": "khajit has wares if you have coin" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/pattern.json000066400000000000000000000030031426774651400270100ustar00rootroot00000000000000[ { "description": "pattern validation", "schema": {"pattern": "^a*$"}, "tests": [ { "description": "a matching pattern is valid", "data": "aaa", "valid": true }, { "description": "a non-matching pattern is invalid", "data": "abc", "valid": false }, { "description": "ignores booleans", "data": true, "valid": true }, { "description": "ignores integers", "data": 123, "valid": true }, { "description": "ignores floats", "data": 1.0, "valid": true }, { "description": "ignores objects", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores null", "data": null, "valid": true } ] }, { "description": "pattern is not anchored", "schema": {"pattern": "a+"}, "tests": [ { "description": "matches a substring", "data": "xxaayy", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/patternProperties.json000066400000000000000000000112511426774651400310710ustar00rootroot00000000000000[ { "description": "patternProperties validates properties matching a regex", "schema": { "patternProperties": { "f.*o": {"type": "integer"} } }, "tests": [ { "description": "a single valid match is valid", "data": {"foo": 1}, "valid": true }, { "description": "multiple valid matches is valid", "data": {"foo": 1, "foooooo" : 2}, "valid": true }, { "description": "a single invalid match is invalid", "data": {"foo": "bar", "fooooo": 2}, "valid": false }, { "description": "multiple invalid matches is invalid", "data": {"foo": "bar", "foooooo" : "baz"}, "valid": false }, { "description": "ignores arrays", "data": ["foo"], "valid": true }, { "description": "ignores strings", "data": "foo", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "multiple simultaneous patternProperties are validated", "schema": { "patternProperties": { "a*": {"type": "integer"}, "aaa*": {"maximum": 20} } }, "tests": [ { "description": "a single valid match is valid", "data": {"a": 21}, "valid": true }, { "description": "a simultaneous match is valid", "data": {"aaaa": 18}, "valid": true }, { "description": "multiple matches is valid", "data": {"a": 21, "aaaa": 18}, "valid": true }, { "description": "an invalid due to one is invalid", "data": {"a": "bar"}, "valid": false }, { "description": "an invalid due to the other is invalid", "data": {"aaaa": 31}, "valid": false }, { "description": "an invalid due to both is invalid", "data": {"aaa": "foo", "aaaa": 31}, "valid": false } ] }, { "description": "regexes are not anchored by default and are case sensitive", "schema": { "patternProperties": { "[0-9]{2,}": { "type": "boolean" }, "X_": { "type": "string" } } }, "tests": [ { "description": "non recognized members are ignored", "data": { "answer 1": "42" }, "valid": true }, { "description": "recognized members are accounted for", "data": { "a31b": null }, "valid": false }, { "description": "regexes are case sensitive", "data": { "a_x_3": 3 }, "valid": true }, { "description": "regexes are case sensitive, 2", "data": { "a_X_3": 3 }, "valid": false } ] }, { "description": "patternProperties with boolean schemas", "schema": { "patternProperties": { "f.*": true, "b.*": false } }, "tests": [ { "description": "object with property matching schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property matching schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "object with a property matching both true and false is invalid", "data": {"foobar":1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/prefixItems.json000066400000000000000000000042571426774651400276460ustar00rootroot00000000000000[ { "description": "a schema given for prefixItems", "schema": { "prefixItems": [ {"type": "integer"}, {"type": "string"} ] }, "tests": [ { "description": "correct types", "data": [ 1, "foo" ], "valid": true }, { "description": "wrong types", "data": [ "foo", 1 ], "valid": false }, { "description": "incomplete array of items", "data": [ 1 ], "valid": true }, { "description": "array with additional items", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array", "data": [ ], "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "1": "valid", "length": 2 }, "valid": true } ] }, { "description": "prefixItems with boolean schemas", "schema": { "prefixItems": [true, false] }, "tests": [ { "description": "array with one item is valid", "data": [ 1 ], "valid": true }, { "description": "array with two items is invalid", "data": [ 1, "foo" ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "additional items are allowed by default", "schema": {"prefixItems": [{"type": "integer"}]}, "tests": [ { "description": "only the first item is validated", "data": [1, "foo", false], "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/properties.json000066400000000000000000000120341426774651400275330ustar00rootroot00000000000000[ { "description": "object properties validation", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "string"} } }, "tests": [ { "description": "both properties present and valid is valid", "data": {"foo": 1, "bar": "baz"}, "valid": true }, { "description": "one property invalid is invalid", "data": {"foo": 1, "bar": {}}, "valid": false }, { "description": "both properties invalid is invalid", "data": {"foo": [], "bar": {}}, "valid": false }, { "description": "doesn't invalidate other properties", "data": {"quux": []}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "properties, patternProperties, additionalProperties interaction", "schema": { "properties": { "foo": {"type": "array", "maxItems": 3}, "bar": {"type": "array"} }, "patternProperties": {"f.o": {"minItems": 2}}, "additionalProperties": {"type": "integer"} }, "tests": [ { "description": "property validates property", "data": {"foo": [1, 2]}, "valid": true }, { "description": "property invalidates property", "data": {"foo": [1, 2, 3, 4]}, "valid": false }, { "description": "patternProperty invalidates property", "data": {"foo": []}, "valid": false }, { "description": "patternProperty validates nonproperty", "data": {"fxo": [1, 2]}, "valid": true }, { "description": "patternProperty invalidates nonproperty", "data": {"fxo": []}, "valid": false }, { "description": "additionalProperty ignores property", "data": {"bar": []}, "valid": true }, { "description": "additionalProperty validates others", "data": {"quux": 3}, "valid": true }, { "description": "additionalProperty invalidates others", "data": {"quux": "foo"}, "valid": false } ] }, { "description": "properties with boolean schema", "schema": { "properties": { "foo": true, "bar": false } }, "tests": [ { "description": "no property present is valid", "data": {}, "valid": true }, { "description": "only 'true' property present is valid", "data": {"foo": 1}, "valid": true }, { "description": "only 'false' property present is invalid", "data": {"bar": 2}, "valid": false }, { "description": "both properties present is invalid", "data": {"foo": 1, "bar": 2}, "valid": false } ] }, { "description": "properties with escaped characters", "schema": { "properties": { "foo\nbar": {"type": "number"}, "foo\"bar": {"type": "number"}, "foo\\bar": {"type": "number"}, "foo\rbar": {"type": "number"}, "foo\tbar": {"type": "number"}, "foo\fbar": {"type": "number"} } }, "tests": [ { "description": "object with all numbers is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1", "foo\\bar": "1", "foo\rbar": "1", "foo\tbar": "1", "foo\fbar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/propertyNames.json000066400000000000000000000041301426774651400302050ustar00rootroot00000000000000[ { "description": "propertyNames validation", "schema": { "propertyNames": {"maxLength": 3} }, "tests": [ { "description": "all property names valid", "data": { "f": {}, "foo": {} }, "valid": true }, { "description": "some property names invalid", "data": { "foo": {}, "foobar": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [1, 2, 3, 4], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "propertyNames with boolean schema true", "schema": {"propertyNames": true}, "tests": [ { "description": "object with any properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema false", "schema": {"propertyNames": false}, "tests": [ { "description": "object with any properties is invalid", "data": {"foo": 1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/ref.json000066400000000000000000000365411426774651400261240ustar00rootroot00000000000000[ { "description": "root pointer ref", "schema": { "properties": { "foo": {"$ref": "#"} }, "additionalProperties": false }, "tests": [ { "description": "match", "data": {"foo": false}, "valid": true }, { "description": "recursive match", "data": {"foo": {"foo": false}}, "valid": true }, { "description": "mismatch", "data": {"bar": false}, "valid": false }, { "description": "recursive mismatch", "data": {"foo": {"bar": false}}, "valid": false } ] }, { "description": "relative pointer ref to object", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "relative pointer ref to array", "schema": { "prefixItems": [ {"type": "integer"}, {"$ref": "#/prefixItems/0"} ] }, "tests": [ { "description": "match array", "data": [1, 2], "valid": true }, { "description": "mismatch array", "data": [1, "foo"], "valid": false } ] }, { "description": "escaped pointer ref", "schema": { "$defs": { "tilde~field": {"type": "integer"}, "slash/field": {"type": "integer"}, "percent%field": {"type": "integer"} }, "properties": { "tilde": {"$ref": "#/$defs/tilde~0field"}, "slash": {"$ref": "#/$defs/slash~1field"}, "percent": {"$ref": "#/$defs/percent%25field"} } }, "tests": [ { "description": "slash invalid", "data": {"slash": "aoeu"}, "valid": false }, { "description": "tilde invalid", "data": {"tilde": "aoeu"}, "valid": false }, { "description": "percent invalid", "data": {"percent": "aoeu"}, "valid": false }, { "description": "slash valid", "data": {"slash": 123}, "valid": true }, { "description": "tilde valid", "data": {"tilde": 123}, "valid": true }, { "description": "percent valid", "data": {"percent": 123}, "valid": true } ] }, { "description": "nested refs", "schema": { "$defs": { "a": {"type": "integer"}, "b": {"$ref": "#/$defs/a"}, "c": {"$ref": "#/$defs/b"} }, "$ref": "#/$defs/c" }, "tests": [ { "description": "nested ref valid", "data": 5, "valid": true }, { "description": "nested ref invalid", "data": "a", "valid": false } ] }, { "description": "ref applies alongside sibling keywords", "schema": { "$defs": { "reffed": { "type": "array" } }, "properties": { "foo": { "$ref": "#/$defs/reffed", "maxItems": 2 } } }, "tests": [ { "description": "ref valid, maxItems valid", "data": { "foo": [] }, "valid": true }, { "description": "ref valid, maxItems invalid", "data": { "foo": [1, 2, 3] }, "valid": false }, { "description": "ref invalid", "data": { "foo": "string" }, "valid": false } ] }, { "description": "remote ref, containing refs itself", "schema": { "$ref": "https://json-schema.org/draft/2020-12/schema" }, "tests": [ { "description": "remote ref valid", "data": {"minLength": 1}, "valid": true }, { "description": "remote ref invalid", "data": {"minLength": -1}, "valid": false } ] }, { "description": "property named $ref that is not a reference", "schema": { "properties": { "$ref": {"type": "string"} } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "property named $ref, containing an actual $ref", "schema": { "properties": { "$ref": {"$ref": "#/$defs/is-string"} }, "$defs": { "is-string": { "type": "string" } } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "$ref to boolean schema true", "schema": { "$ref": "#/$defs/bool", "$defs": { "bool": true } }, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "$ref to boolean schema false", "schema": { "$ref": "#/$defs/bool", "$defs": { "bool": false } }, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "Recursive references between schemas", "schema": { "$id": "http://localhost:1234/tree", "description": "tree of nodes", "type": "object", "properties": { "meta": {"type": "string"}, "nodes": { "type": "array", "items": {"$ref": "node"} } }, "required": ["meta", "nodes"], "$defs": { "node": { "$id": "http://localhost:1234/node", "description": "node", "type": "object", "properties": { "value": {"type": "number"}, "subtree": {"$ref": "tree"} }, "required": ["value"] } } }, "tests": [ { "description": "valid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": 1.1}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": true }, { "description": "invalid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": "string is invalid"}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": false } ] }, { "description": "refs with quote", "schema": { "properties": { "foo\"bar": {"$ref": "#/$defs/foo%22bar"} }, "$defs": { "foo\"bar": {"type": "number"} } }, "tests": [ { "description": "object with numbers is valid", "data": { "foo\"bar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\"bar": "1" }, "valid": false } ] }, { "description": "ref creates new scope when adjacent to keywords", "schema": { "$defs": { "A": { "unevaluatedProperties": false } }, "properties": { "prop1": { "type": "string" } }, "$ref": "#/$defs/A" }, "tests": [ { "description": "referenced subschema doesn't see annotations from properties", "data": { "prop1": "match" }, "valid": false } ] }, { "description": "naive replacement of $ref with its destination is not correct", "schema": { "$defs": { "a_string": { "type": "string" } }, "enum": [ { "$ref": "#/$defs/a_string" } ] }, "tests": [ { "description": "do not evaluate the $ref inside the enum, matching any string", "data": "this is a string", "valid": false }, { "description": "do not evaluate the $ref inside the enum, definition exact match", "data": { "type": "string" }, "valid": false }, { "description": "match the enum exactly", "data": { "$ref": "#/$defs/a_string" }, "valid": true } ] }, { "description": "refs with relative uris and defs", "schema": { "$id": "http://example.com/schema-relative-uri-defs1.json", "properties": { "foo": { "$id": "schema-relative-uri-defs2.json", "$defs": { "inner": { "properties": { "bar": { "type": "string" } } } }, "$ref": "#/$defs/inner" } }, "$ref": "schema-relative-uri-defs2.json" }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] }, { "description": "relative refs with absolute uris and defs", "schema": { "$id": "http://example.com/schema-refs-absolute-uris-defs1.json", "properties": { "foo": { "$id": "http://example.com/schema-refs-absolute-uris-defs2.json", "$defs": { "inner": { "properties": { "bar": { "type": "string" } } } }, "$ref": "#/$defs/inner" } }, "$ref": "schema-refs-absolute-uris-defs2.json" }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/refRemote.json000066400000000000000000000123341426774651400272720ustar00rootroot00000000000000[ { "description": "remote ref", "schema": {"$ref": "http://localhost:1234/integer.json"}, "tests": [ { "description": "remote ref valid", "data": 1, "valid": true }, { "description": "remote ref invalid", "data": "a", "valid": false } ] }, { "description": "fragment within remote ref", "schema": {"$ref": "http://localhost:1234/subSchemas-defs.json#/$defs/integer"}, "tests": [ { "description": "remote fragment valid", "data": 1, "valid": true }, { "description": "remote fragment invalid", "data": "a", "valid": false } ] }, { "description": "ref within remote ref", "schema": { "$ref": "http://localhost:1234/subSchemas-defs.json#/$defs/refToInteger" }, "tests": [ { "description": "ref within ref valid", "data": 1, "valid": true }, { "description": "ref within ref invalid", "data": "a", "valid": false } ] }, { "description": "base URI change", "schema": { "$id": "http://localhost:1234/", "items": { "$id": "baseUriChange/", "items": {"$ref": "folderInteger.json"} } }, "tests": [ { "description": "base URI change ref valid", "data": [[1]], "valid": true }, { "description": "base URI change ref invalid", "data": [["a"]], "valid": false } ] }, { "description": "base URI change - change folder", "schema": { "$id": "http://localhost:1234/scope_change_defs1.json", "type" : "object", "properties": {"list": {"$ref": "baseUriChangeFolder/"}}, "$defs": { "baz": { "$id": "baseUriChangeFolder/", "type": "array", "items": {"$ref": "folderInteger.json"} } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "base URI change - change folder in subschema", "schema": { "$id": "http://localhost:1234/scope_change_defs2.json", "type" : "object", "properties": {"list": {"$ref": "baseUriChangeFolderInSubschema/#/$defs/bar"}}, "$defs": { "baz": { "$id": "baseUriChangeFolderInSubschema/", "$defs": { "bar": { "type": "array", "items": {"$ref": "folderInteger.json"} } } } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "root ref in remote ref", "schema": { "$id": "http://localhost:1234/object", "type": "object", "properties": { "name": {"$ref": "name-defs.json#/$defs/orNull"} } }, "tests": [ { "description": "string is valid", "data": { "name": "foo" }, "valid": true }, { "description": "null is valid", "data": { "name": null }, "valid": true }, { "description": "object is invalid", "data": { "name": { "name": null } }, "valid": false } ] }, { "description": "remote ref with ref to defs", "schema": { "$id": "http://localhost:1234/schema-remote-ref-ref-defs1.json", "$ref": "ref-and-defs.json" }, "tests": [ { "description": "invalid", "data": { "bar": 1 }, "valid": false }, { "description": "valid", "data": { "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/required.json000066400000000000000000000052061426774651400271620ustar00rootroot00000000000000[ { "description": "required validation", "schema": { "properties": { "foo": {}, "bar": {} }, "required": ["foo"] }, "tests": [ { "description": "present required property is valid", "data": {"foo": 1}, "valid": true }, { "description": "non-present required property is invalid", "data": {"bar": 1}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "required default validation", "schema": { "properties": { "foo": {} } }, "tests": [ { "description": "not required by default", "data": {}, "valid": true } ] }, { "description": "required with empty array", "schema": { "properties": { "foo": {} }, "required": [] }, "tests": [ { "description": "property not required", "data": {}, "valid": true } ] }, { "description": "required with escaped characters", "schema": { "required": [ "foo\nbar", "foo\"bar", "foo\\bar", "foo\rbar", "foo\tbar", "foo\fbar" ] }, "tests": [ { "description": "object with all properties present is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with some properties missing is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/type.json000066400000000000000000000321401426774651400263200ustar00rootroot00000000000000[ { "description": "integer type matches integers", "schema": {"type": "integer"}, "tests": [ { "description": "an integer is an integer", "data": 1, "valid": true }, { "description": "a float with zero fractional part is an integer", "data": 1.0, "valid": true }, { "description": "a float is not an integer", "data": 1.1, "valid": false }, { "description": "a string is not an integer", "data": "foo", "valid": false }, { "description": "a string is still not an integer, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not an integer", "data": {}, "valid": false }, { "description": "an array is not an integer", "data": [], "valid": false }, { "description": "a boolean is not an integer", "data": true, "valid": false }, { "description": "null is not an integer", "data": null, "valid": false } ] }, { "description": "number type matches numbers", "schema": {"type": "number"}, "tests": [ { "description": "an integer is a number", "data": 1, "valid": true }, { "description": "a float with zero fractional part is a number (and an integer)", "data": 1.0, "valid": true }, { "description": "a float is a number", "data": 1.1, "valid": true }, { "description": "a string is not a number", "data": "foo", "valid": false }, { "description": "a string is still not a number, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not a number", "data": {}, "valid": false }, { "description": "an array is not a number", "data": [], "valid": false }, { "description": "a boolean is not a number", "data": true, "valid": false }, { "description": "null is not a number", "data": null, "valid": false } ] }, { "description": "string type matches strings", "schema": {"type": "string"}, "tests": [ { "description": "1 is not a string", "data": 1, "valid": false }, { "description": "a float is not a string", "data": 1.1, "valid": false }, { "description": "a string is a string", "data": "foo", "valid": true }, { "description": "a string is still a string, even if it looks like a number", "data": "1", "valid": true }, { "description": "an empty string is still a string", "data": "", "valid": true }, { "description": "an object is not a string", "data": {}, "valid": false }, { "description": "an array is not a string", "data": [], "valid": false }, { "description": "a boolean is not a string", "data": true, "valid": false }, { "description": "null is not a string", "data": null, "valid": false } ] }, { "description": "object type matches objects", "schema": {"type": "object"}, "tests": [ { "description": "an integer is not an object", "data": 1, "valid": false }, { "description": "a float is not an object", "data": 1.1, "valid": false }, { "description": "a string is not an object", "data": "foo", "valid": false }, { "description": "an object is an object", "data": {}, "valid": true }, { "description": "an array is not an object", "data": [], "valid": false }, { "description": "a boolean is not an object", "data": true, "valid": false }, { "description": "null is not an object", "data": null, "valid": false } ] }, { "description": "array type matches arrays", "schema": {"type": "array"}, "tests": [ { "description": "an integer is not an array", "data": 1, "valid": false }, { "description": "a float is not an array", "data": 1.1, "valid": false }, { "description": "a string is not an array", "data": "foo", "valid": false }, { "description": "an object is not an array", "data": {}, "valid": false }, { "description": "an array is an array", "data": [], "valid": true }, { "description": "a boolean is not an array", "data": true, "valid": false }, { "description": "null is not an array", "data": null, "valid": false } ] }, { "description": "boolean type matches booleans", "schema": {"type": "boolean"}, "tests": [ { "description": "an integer is not a boolean", "data": 1, "valid": false }, { "description": "zero is not a boolean", "data": 0, "valid": false }, { "description": "a float is not a boolean", "data": 1.1, "valid": false }, { "description": "a string is not a boolean", "data": "foo", "valid": false }, { "description": "an empty string is not a boolean", "data": "", "valid": false }, { "description": "an object is not a boolean", "data": {}, "valid": false }, { "description": "an array is not a boolean", "data": [], "valid": false }, { "description": "true is a boolean", "data": true, "valid": true }, { "description": "false is a boolean", "data": false, "valid": true }, { "description": "null is not a boolean", "data": null, "valid": false } ] }, { "description": "null type matches only the null object", "schema": {"type": "null"}, "tests": [ { "description": "an integer is not null", "data": 1, "valid": false }, { "description": "a float is not null", "data": 1.1, "valid": false }, { "description": "zero is not null", "data": 0, "valid": false }, { "description": "a string is not null", "data": "foo", "valid": false }, { "description": "an empty string is not null", "data": "", "valid": false }, { "description": "an object is not null", "data": {}, "valid": false }, { "description": "an array is not null", "data": [], "valid": false }, { "description": "true is not null", "data": true, "valid": false }, { "description": "false is not null", "data": false, "valid": false }, { "description": "null is null", "data": null, "valid": true } ] }, { "description": "multiple types can be specified in an array", "schema": {"type": ["integer", "string"]}, "tests": [ { "description": "an integer is valid", "data": 1, "valid": true }, { "description": "a string is valid", "data": "foo", "valid": true }, { "description": "a float is invalid", "data": 1.1, "valid": false }, { "description": "an object is invalid", "data": {}, "valid": false }, { "description": "an array is invalid", "data": [], "valid": false }, { "description": "a boolean is invalid", "data": true, "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type as array with one item", "schema": { "type": ["string"] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is invalid", "data": 123, "valid": false } ] }, { "description": "type: array or object", "schema": { "type": ["array", "object"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type: array, object or null", "schema": { "type": ["array", "object", "null"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/unevaluatedItems.json000066400000000000000000000404541426774651400306650ustar00rootroot00000000000000[ { "description": "unevaluatedItems true", "schema": { "type": "array", "unevaluatedItems": true }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with unevaluated items", "data": ["foo"], "valid": true } ] }, { "description": "unevaluatedItems false", "schema": { "type": "array", "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with unevaluated items", "data": ["foo"], "valid": false } ] }, { "description": "unevaluatedItems as schema", "schema": { "type": "array", "unevaluatedItems": { "type": "string" } }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with valid unevaluated items", "data": ["foo"], "valid": true }, { "description": "with invalid unevaluated items", "data": [42], "valid": false } ] }, { "description": "unevaluatedItems with uniform items", "schema": { "type": "array", "items": { "type": "string" }, "unevaluatedItems": false }, "tests": [ { "description": "unevaluatedItems doesn't apply", "data": ["foo", "bar"], "valid": true } ] }, { "description": "unevaluatedItems with tuple", "schema": { "type": "array", "prefixItems": [ { "type": "string" } ], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": ["foo"], "valid": true }, { "description": "with unevaluated items", "data": ["foo", "bar"], "valid": false } ] }, { "description": "unevaluatedItems with items", "schema": { "type": "array", "prefixItems": [ { "type": "string" } ], "items": true, "unevaluatedItems": false }, "tests": [ { "description": "unevaluatedItems doesn't apply", "data": ["foo", 42], "valid": true } ] }, { "description": "unevaluatedItems with nested tuple", "schema": { "type": "array", "prefixItems": [ { "type": "string" } ], "allOf": [ { "prefixItems": [ true, { "type": "number" } ] } ], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": ["foo", 42], "valid": true }, { "description": "with unevaluated items", "data": ["foo", 42, true], "valid": false } ] }, { "description": "unevaluatedItems with nested items", "schema": { "type": "array", "allOf": [ { "prefixItems": [ { "type": "string" } ], "items": true } ], "unevaluatedItems": false }, "tests": [ { "description": "with no additional items", "data": ["foo"], "valid": true }, { "description": "with additional items", "data": ["foo", 42, true], "valid": true } ] }, { "description": "unevaluatedItems with nested unevaluatedItems", "schema": { "type": "array", "allOf": [ { "prefixItems": [ { "type": "string" } ] }, { "unevaluatedItems": true } ], "unevaluatedItems": false }, "tests": [ { "description": "with no additional items", "data": ["foo"], "valid": true }, { "description": "with additional items", "data": ["foo", 42, true], "valid": true } ] }, { "description": "unevaluatedItems with anyOf", "schema": { "type": "array", "prefixItems": [ { "const": "foo" } ], "anyOf": [ { "prefixItems": [ true, { "const": "bar" } ] }, { "prefixItems": [ true, true, { "const": "baz" } ] } ], "unevaluatedItems": false }, "tests": [ { "description": "when one schema matches and has no unevaluated items", "data": ["foo", "bar"], "valid": true }, { "description": "when one schema matches and has unevaluated items", "data": ["foo", "bar", 42], "valid": false }, { "description": "when two schemas match and has no unevaluated items", "data": ["foo", "bar", "baz"], "valid": true }, { "description": "when two schemas match and has unevaluated items", "data": ["foo", "bar", "baz", 42], "valid": false } ] }, { "description": "unevaluatedItems with oneOf", "schema": { "type": "array", "prefixItems": [ { "const": "foo" } ], "oneOf": [ { "prefixItems": [ true, { "const": "bar" } ] }, { "prefixItems": [ true, { "const": "baz" } ] } ], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": ["foo", "bar"], "valid": true }, { "description": "with unevaluated items", "data": ["foo", "bar", 42], "valid": false } ] }, { "description": "unevaluatedItems with not", "schema": { "type": "array", "prefixItems": [ { "const": "foo" } ], "not": { "not": { "prefixItems": [ true, { "const": "bar" } ] } }, "unevaluatedItems": false }, "tests": [ { "description": "with unevaluated items", "data": ["foo", "bar"], "valid": false } ] }, { "description": "unevaluatedItems with if/then/else", "schema": { "type": "array", "prefixItems": [ { "const": "foo" } ], "if": { "prefixItems": [ true, { "const": "bar" } ] }, "then": { "prefixItems": [ true, true, { "const": "then" } ] }, "else": { "prefixItems": [ true, true, true, { "const": "else" } ] }, "unevaluatedItems": false }, "tests": [ { "description": "when if matches and it has no unevaluated items", "data": ["foo", "bar", "then"], "valid": true }, { "description": "when if matches and it has unevaluated items", "data": ["foo", "bar", "then", "else"], "valid": false }, { "description": "when if doesn't match and it has no unevaluated items", "data": ["foo", 42, 42, "else"], "valid": true }, { "description": "when if doesn't match and it has unevaluated items", "data": ["foo", 42, 42, "else", 42], "valid": false } ] }, { "description": "unevaluatedItems with boolean schemas", "schema": { "type": "array", "allOf": [true], "unevaluatedItems": false }, "tests": [ { "description": "with no unevaluated items", "data": [], "valid": true }, { "description": "with unevaluated items", "data": ["foo"], "valid": false } ] }, { "description": "unevaluatedItems with $ref", "schema": { "type": "array", "$ref": "#/$defs/bar", "prefixItems": [ { "type": "string" } ], "unevaluatedItems": false, "$defs": { "bar": { "prefixItems": [ true, { "type": "string" } ] } } }, "tests": [ { "description": "with no unevaluated items", "data": ["foo", "bar"], "valid": true }, { "description": "with unevaluated items", "data": ["foo", "bar", "baz"], "valid": false } ] }, { "description": "unevaluatedItems can't see inside cousins", "schema": { "allOf": [ { "prefixItems": [ true ] }, { "unevaluatedItems": false } ] }, "tests": [ { "description": "always fails", "data": [ 1 ], "valid": false } ] }, { "description": "item is evaluated in an uncle schema to unevaluatedItems", "schema": { "type": "object", "properties": { "foo": { "type": "array", "prefixItems": [ { "type": "string" } ], "unevaluatedItems": false } }, "anyOf": [ { "properties": { "foo": { "prefixItems": [ true, { "type": "string" } ] } } } ] }, "tests": [ { "description": "no extra items", "data": { "foo": [ "test" ] }, "valid": true }, { "description": "uncle keyword evaluation is not significant", "data": { "foo": [ "test", "test" ] }, "valid": false } ] }, { "description": "unevaluatedItems depends on adjacent contains", "schema": { "prefixItems": [true], "contains": {"type": "string"}, "unevaluatedItems": false }, "tests": [ { "description": "second item is evaluated by contains", "data": [ 1, "foo" ], "valid": true }, { "description": "contains fails, second item is not evaluated", "data": [ 1, 2 ], "valid": false }, { "description": "contains passes, second item is not evaluated", "data": [ 1, 2, "foo" ], "valid": false } ] }, { "description": "unevaluatedItems depends on multiple nested contains", "schema": { "allOf": [ { "contains": { "multipleOf": 2 } }, { "contains": { "multipleOf": 3 } } ], "unevaluatedItems": { "multipleOf": 5 } }, "tests": [ { "description": "5 not evaluated, passes unevaluatedItems", "data": [ 2, 3, 4, 5, 6 ], "valid": true }, { "description": "7 not evaluated, fails unevaluatedItems", "data": [ 2, 3, 4, 7, 8 ], "valid": false } ] }, { "description": "unevaluatedItems and contains interact to control item dependency relationship", "schema": { "if": { "contains": {"const": "a"} }, "then": { "if": { "contains": {"const": "b"} }, "then": { "if": { "contains": {"const": "c"} } } }, "unevaluatedItems": false }, "tests": [ { "description": "empty array is valid", "data": [], "valid": true }, { "description": "only a's are valid", "data": [ "a", "a" ], "valid": true }, { "description": "a's and b's are valid", "data": [ "a", "b", "a", "b", "a" ], "valid": true }, { "description": "a's, b's and c's are valid", "data": [ "c", "a", "c", "c", "b", "a" ], "valid": true }, { "description": "only b's are invalid", "data": [ "b", "b" ], "valid": false }, { "description": "only c's are invalid", "data": [ "c", "c" ], "valid": false }, { "description": "only b's and c's are invalid", "data": [ "c", "b", "c", "b", "c" ], "valid": false }, { "description": "only a's and c's are invalid", "data": [ "c", "a", "c", "a", "c" ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/unevaluatedProperties.json000066400000000000000000000724101426774651400317350ustar00rootroot00000000000000[ { "description": "unevaluatedProperties true", "schema": { "type": "object", "unevaluatedProperties": true }, "tests": [ { "description": "with no unevaluated properties", "data": {}, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo" }, "valid": true } ] }, { "description": "unevaluatedProperties schema", "schema": { "type": "object", "unevaluatedProperties": { "type": "string", "minLength": 3 } }, "tests": [ { "description": "with no unevaluated properties", "data": {}, "valid": true }, { "description": "with valid unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with invalid unevaluated properties", "data": { "foo": "fo" }, "valid": false } ] }, { "description": "unevaluatedProperties false", "schema": { "type": "object", "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": {}, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo" }, "valid": false } ] }, { "description": "unevaluatedProperties with adjacent properties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with adjacent patternProperties", "schema": { "type": "object", "patternProperties": { "^foo": { "type": "string" } }, "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with adjacent additionalProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "additionalProperties": true, "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "unevaluatedProperties with nested properties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "properties": { "bar": { "type": "string" } } } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with nested patternProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "patternProperties": { "^bar": { "type": "string" } } } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with nested additionalProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "additionalProperties": true } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no additional properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with additional properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "unevaluatedProperties with nested unevaluatedProperties", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "unevaluatedProperties": true } ], "unevaluatedProperties": { "type": "string", "maxLength": 2 } }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "unevaluatedProperties with anyOf", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "anyOf": [ { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] }, { "properties": { "baz": { "const": "baz" } }, "required": ["baz"] }, { "properties": { "quux": { "const": "quux" } }, "required": ["quux"] } ], "unevaluatedProperties": false }, "tests": [ { "description": "when one matches and has no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "when one matches and has unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "not-baz" }, "valid": false }, { "description": "when two match and has no unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": true }, { "description": "when two match and has unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz", "quux": "not-quux" }, "valid": false } ] }, { "description": "unevaluatedProperties with oneOf", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "oneOf": [ { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] }, { "properties": { "baz": { "const": "baz" } }, "required": ["baz"] } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar", "quux": "quux" }, "valid": false } ] }, { "description": "unevaluatedProperties with not", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "not": { "not": { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] } }, "unevaluatedProperties": false }, "tests": [ { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with if/then/else", "schema": { "type": "object", "if": { "properties": { "foo": { "const": "then" } }, "required": ["foo"] }, "then": { "properties": { "bar": { "type": "string" } }, "required": ["bar"] }, "else": { "properties": { "baz": { "type": "string" } }, "required": ["baz"] }, "unevaluatedProperties": false }, "tests": [ { "description": "when if is true and has no unevaluated properties", "data": { "foo": "then", "bar": "bar" }, "valid": true }, { "description": "when if is true and has unevaluated properties", "data": { "foo": "then", "bar": "bar", "baz": "baz" }, "valid": false }, { "description": "when if is false and has no unevaluated properties", "data": { "baz": "baz" }, "valid": true }, { "description": "when if is false and has unevaluated properties", "data": { "foo": "else", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with if/then/else, then not defined", "schema": { "type": "object", "if": { "properties": { "foo": { "const": "then" } }, "required": ["foo"] }, "else": { "properties": { "baz": { "type": "string" } }, "required": ["baz"] }, "unevaluatedProperties": false }, "tests": [ { "description": "when if is true and has no unevaluated properties", "data": { "foo": "then", "bar": "bar" }, "valid": false }, { "description": "when if is true and has unevaluated properties", "data": { "foo": "then", "bar": "bar", "baz": "baz" }, "valid": false }, { "description": "when if is false and has no unevaluated properties", "data": { "baz": "baz" }, "valid": true }, { "description": "when if is false and has unevaluated properties", "data": { "foo": "else", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with if/then/else, else not defined", "schema": { "type": "object", "if": { "properties": { "foo": { "const": "then" } }, "required": ["foo"] }, "then": { "properties": { "bar": { "type": "string" } }, "required": ["bar"] }, "unevaluatedProperties": false }, "tests": [ { "description": "when if is true and has no unevaluated properties", "data": { "foo": "then", "bar": "bar" }, "valid": true }, { "description": "when if is true and has unevaluated properties", "data": { "foo": "then", "bar": "bar", "baz": "baz" }, "valid": false }, { "description": "when if is false and has no unevaluated properties", "data": { "baz": "baz" }, "valid": false }, { "description": "when if is false and has unevaluated properties", "data": { "foo": "else", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties with dependentSchemas", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "dependentSchemas": { "foo": { "properties": { "bar": { "const": "bar" } }, "required": ["bar"] } }, "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with unevaluated properties", "data": { "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with boolean schemas", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [true], "unevaluatedProperties": false }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with unevaluated properties", "data": { "bar": "bar" }, "valid": false } ] }, { "description": "unevaluatedProperties with $ref", "schema": { "type": "object", "$ref": "#/$defs/bar", "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false, "$defs": { "bar": { "properties": { "bar": { "type": "string" } } } } }, "tests": [ { "description": "with no unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true }, { "description": "with unevaluated properties", "data": { "foo": "foo", "bar": "bar", "baz": "baz" }, "valid": false } ] }, { "description": "unevaluatedProperties can't see inside cousins", "schema": { "allOf": [ { "properties": { "foo": true } }, { "unevaluatedProperties": false } ] }, "tests": [ { "description": "always fails", "data": { "foo": 1 }, "valid": false } ] }, { "description": "nested unevaluatedProperties, outer false, inner true, properties outside", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "unevaluatedProperties": true } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "nested unevaluatedProperties, outer false, inner true, properties inside", "schema": { "type": "object", "allOf": [ { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": true } ], "unevaluatedProperties": false }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": true } ] }, { "description": "nested unevaluatedProperties, outer true, inner false, properties outside", "schema": { "type": "object", "properties": { "foo": { "type": "string" } }, "allOf": [ { "unevaluatedProperties": false } ], "unevaluatedProperties": true }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": false }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "nested unevaluatedProperties, outer true, inner false, properties inside", "schema": { "type": "object", "allOf": [ { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false } ], "unevaluatedProperties": true }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "cousin unevaluatedProperties, true and false, true with properties", "schema": { "type": "object", "allOf": [ { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": true }, { "unevaluatedProperties": false } ] }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": false }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "cousin unevaluatedProperties, true and false, false with properties", "schema": { "type": "object", "allOf": [ { "unevaluatedProperties": true }, { "properties": { "foo": { "type": "string" } }, "unevaluatedProperties": false } ] }, "tests": [ { "description": "with no nested unevaluated properties", "data": { "foo": "foo" }, "valid": true }, { "description": "with nested unevaluated properties", "data": { "foo": "foo", "bar": "bar" }, "valid": false } ] }, { "description": "property is evaluated in an uncle schema to unevaluatedProperties", "comment": "see https://stackoverflow.com/questions/66936884/deeply-nested-unevaluatedproperties-and-their-expectations", "schema": { "type": "object", "properties": { "foo": { "type": "object", "properties": { "bar": { "type": "string" } }, "unevaluatedProperties": false } }, "anyOf": [ { "properties": { "foo": { "properties": { "faz": { "type": "string" } } } } } ] }, "tests": [ { "description": "no extra properties", "data": { "foo": { "bar": "test" } }, "valid": true }, { "description": "uncle keyword evaluation is not significant", "data": { "foo": { "bar": "test", "faz": "test" } }, "valid": false } ] }, { "description": "in-place applicator siblings, allOf has unevaluated", "schema": { "type": "object", "allOf": [ { "properties": { "foo": true }, "unevaluatedProperties": false } ], "anyOf": [ { "properties": { "bar": true } } ] }, "tests": [ { "description": "base case: both properties present", "data": { "foo": 1, "bar": 1 }, "valid": false }, { "description": "in place applicator siblings, bar is missing", "data": { "foo": 1 }, "valid": true }, { "description": "in place applicator siblings, foo is missing", "data": { "bar": 1 }, "valid": false } ] }, { "description": "in-place applicator siblings, anyOf has unevaluated", "schema": { "type": "object", "allOf": [ { "properties": { "foo": true } } ], "anyOf": [ { "properties": { "bar": true }, "unevaluatedProperties": false } ] }, "tests": [ { "description": "base case: both properties present", "data": { "foo": 1, "bar": 1 }, "valid": false }, { "description": "in place applicator siblings, bar is missing", "data": { "foo": 1 }, "valid": false }, { "description": "in place applicator siblings, foo is missing", "data": { "bar": 1 }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/uniqueItems.json000066400000000000000000000314051426774651400276520ustar00rootroot00000000000000[ { "description": "uniqueItems validation", "schema": {"uniqueItems": true}, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is invalid", "data": [1, 1], "valid": false }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": false }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is invalid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": false }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is invalid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": false }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is invalid", "data": [["foo"], ["foo"]], "valid": false }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "[1] and [true] are unique", "data": [[1], [true]], "valid": true }, { "description": "[0] and [false] are unique", "data": [[0], [false]], "valid": true }, { "description": "nested [1] and [true] are unique", "data": [[[1], "foo"], [[true], "foo"]], "valid": true }, { "description": "nested [0] and [false] are unique", "data": [[[0], "foo"], [[false], "foo"]], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1, "{}"], "valid": true }, { "description": "non-unique heterogeneous types are invalid", "data": [{}, [1], true, null, {}, 1], "valid": false }, { "description": "different objects are unique", "data": [{"a": 1, "b": 2}, {"a": 2, "b": 1}], "valid": true }, { "description": "objects are non-unique despite key order", "data": [{"a": 1, "b": 2}, {"b": 2, "a": 1}], "valid": false }, { "description": "{\"a\": false} and {\"a\": 0} are unique", "data": [{"a": false}, {"a": 0}], "valid": true }, { "description": "{\"a\": true} and {\"a\": 1} are unique", "data": [{"a": true}, {"a": 1}], "valid": true } ] }, { "description": "uniqueItems with an array of items", "schema": { "prefixItems": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is not valid", "data": [false, true, "foo", "foo"], "valid": false }, { "description": "non-unique array extended from [true, false] is not valid", "data": [true, false, "foo", "foo"], "valid": false } ] }, { "description": "uniqueItems with an array of items and additionalItems=false", "schema": { "prefixItems": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true, "items": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] }, { "description": "uniqueItems=false validation", "schema": { "uniqueItems": false }, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is valid", "data": [1, 1], "valid": true }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": true }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": true }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": true }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is valid", "data": [["foo"], ["foo"]], "valid": true }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1], "valid": true }, { "description": "non-unique heterogeneous types are valid", "data": [{}, [1], true, null, {}, 1], "valid": true } ] }, { "description": "uniqueItems=false with an array of items", "schema": { "prefixItems": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is valid", "data": [false, true, "foo", "foo"], "valid": true }, { "description": "non-unique array extended from [true, false] is valid", "data": [true, false, "foo", "foo"], "valid": true } ] }, { "description": "uniqueItems=false with an array of items and additionalItems=false", "schema": { "prefixItems": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false, "items": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft2020-12/unknownKeyword.json000066400000000000000000000037201426774651400304050ustar00rootroot00000000000000[ { "description": "$id inside an unknown keyword is not a real identifier", "comment": "the implementation must not be confused by an $id in locations we do not know how to parse", "schema": { "$defs": { "id_in_unknown0": { "not": { "array_of_schemas": [ { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "null" } ] } }, "real_id_in_schema": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "string" }, "id_in_unknown1": { "not": { "object_of_schemas": { "foo": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "integer" } } } } }, "anyOf": [ { "$ref": "#/$defs/id_in_unknown0" }, { "$ref": "#/$defs/id_in_unknown1" }, { "$ref": "https://localhost:1234/unknownKeyword/my_identifier.json" } ] }, "tests": [ { "description": "type matches second anyOf, which has a real schema in it", "data": "a string", "valid": true }, { "description": "type matches non-schema in first anyOf", "data": null, "valid": false }, { "description": "type matches non-schema in third anyOf", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/000077500000000000000000000000001426774651400240045ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/additionalItems.json000066400000000000000000000103731426774651400300150ustar00rootroot00000000000000[ { "description": "additionalItems as schema", "schema": { "items": [{}], "additionalItems": {"type": "integer"} }, "tests": [ { "description": "additional items match schema", "data": [ null, 2, 3, 4 ], "valid": true }, { "description": "additional items do not match schema", "data": [ null, 2, 3, "foo" ], "valid": false } ] }, { "description": "when items is schema, additionalItems does nothing", "schema": { "items": {}, "additionalItems": false }, "tests": [ { "description": "all items match schema", "data": [ 1, 2, 3, 4, 5 ], "valid": true } ] }, { "description": "array of items with no additionalItems permitted", "schema": { "items": [{}, {}, {}], "additionalItems": false }, "tests": [ { "description": "empty array", "data": [ ], "valid": true }, { "description": "fewer number of items present (1)", "data": [ 1 ], "valid": true }, { "description": "fewer number of items present (2)", "data": [ 1, 2 ], "valid": true }, { "description": "equal number of items present", "data": [ 1, 2, 3 ], "valid": true }, { "description": "additional items are not permitted", "data": [ 1, 2, 3, 4 ], "valid": false } ] }, { "description": "additionalItems as false without items", "schema": {"additionalItems": false}, "tests": [ { "description": "items defaults to empty schema so everything is valid", "data": [ 1, 2, 3, 4, 5 ], "valid": true }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true } ] }, { "description": "additionalItems are allowed by default", "schema": {"items": [{"type": "integer"}]}, "tests": [ { "description": "only the first item is validated", "data": [1, "foo", false], "valid": true } ] }, { "description": "additionalItems should not look in applicators, valid case", "schema": { "allOf": [ { "items": [ { "type": "integer" } ] } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, null ], "valid": true } ] }, { "description": "additionalItems should not look in applicators, invalid case", "schema": { "allOf": [ { "items": [ { "type": "integer" }, { "type": "string" } ] } ], "items": [ {"type": "integer" } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, "hello" ], "valid": false } ] }, { "description": "items validation adjusts the starting index for additionalItems", "schema": { "items": [ { "type": "string" } ], "additionalItems": { "type": "integer" } }, "tests": [ { "description": "valid items", "data": [ "x", 2, 3 ], "valid": true }, { "description": "wrong type of second item", "data": [ "x", "y" ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/additionalProperties.json000066400000000000000000000077541426774651400311010ustar00rootroot00000000000000[ { "description": "additionalProperties being false does not allow other properties", "schema": { "properties": {"foo": {}, "bar": {}}, "patternProperties": { "^v": {} }, "additionalProperties": false }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : "boom"}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobarbaz", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true }, { "description": "patternProperties are not additional properties", "data": {"foo":1, "vroom": 2}, "valid": true } ] }, { "description": "non-ASCII pattern with additionalProperties", "schema": { "patternProperties": {"^á": {}}, "additionalProperties": false }, "tests": [ { "description": "matching the pattern is valid", "data": {"ármányos": 2}, "valid": true }, { "description": "not matching the pattern is invalid", "data": {"élmény": 2}, "valid": false } ] }, { "description": "additionalProperties allows a schema which should validate", "schema": { "properties": {"foo": {}, "bar": {}}, "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional valid property is valid", "data": {"foo" : 1, "bar" : 2, "quux" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : 12}, "valid": false } ] }, { "description": "additionalProperties can exist by itself", "schema": { "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "an additional valid property is valid", "data": {"foo" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1}, "valid": false } ] }, { "description": "additionalProperties are allowed by default", "schema": {"properties": {"foo": {}, "bar": {}}}, "tests": [ { "description": "additional properties are allowed", "data": {"foo": 1, "bar": 2, "quux": true}, "valid": true } ] }, { "description": "additionalProperties should not look in applicators", "schema": { "allOf": [ {"properties": {"foo": {}}} ], "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "properties defined in allOf are not examined", "data": {"foo": 1, "bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/allOf.json000066400000000000000000000153651426774651400257460ustar00rootroot00000000000000[ { "description": "allOf", "schema": { "allOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "allOf", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "mismatch second", "data": {"foo": "baz"}, "valid": false }, { "description": "mismatch first", "data": {"bar": 2}, "valid": false }, { "description": "wrong type", "data": {"foo": "baz", "bar": "quux"}, "valid": false } ] }, { "description": "allOf with base schema", "schema": { "properties": {"bar": {"type": "integer"}}, "required": ["bar"], "allOf" : [ { "properties": { "foo": {"type": "string"} }, "required": ["foo"] }, { "properties": { "baz": {"type": "null"} }, "required": ["baz"] } ] }, "tests": [ { "description": "valid", "data": {"foo": "quux", "bar": 2, "baz": null}, "valid": true }, { "description": "mismatch base schema", "data": {"foo": "quux", "baz": null}, "valid": false }, { "description": "mismatch first allOf", "data": {"bar": 2, "baz": null}, "valid": false }, { "description": "mismatch second allOf", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "mismatch both", "data": {"bar": 2}, "valid": false } ] }, { "description": "allOf simple types", "schema": { "allOf": [ {"maximum": 30}, {"minimum": 20} ] }, "tests": [ { "description": "valid", "data": 25, "valid": true }, { "description": "mismatch one", "data": 35, "valid": false } ] }, { "description": "allOf with one empty schema", "schema": { "allOf": [ {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with two empty schemas", "schema": { "allOf": [ {}, {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with the first empty schema", "schema": { "allOf": [ {}, { "type": "number" } ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with the last empty schema", "schema": { "allOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "nested allOf, to check validation semantics", "schema": { "allOf": [ { "allOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "allOf combined with anyOf, oneOf", "schema": { "allOf": [ { "multipleOf": 2 } ], "anyOf": [ { "multipleOf": 3 } ], "oneOf": [ { "multipleOf": 5 } ] }, "tests": [ { "description": "allOf: false, anyOf: false, oneOf: false", "data": 1, "valid": false }, { "description": "allOf: false, anyOf: false, oneOf: true", "data": 5, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: false", "data": 3, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: true", "data": 15, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: false", "data": 2, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: true", "data": 10, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: false", "data": 6, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: true", "data": 30, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/anyOf.json000066400000000000000000000107711426774651400257610ustar00rootroot00000000000000[ { "description": "anyOf", "schema": { "anyOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first anyOf valid", "data": 1, "valid": true }, { "description": "second anyOf valid", "data": 2.5, "valid": true }, { "description": "both anyOf valid", "data": 3, "valid": true }, { "description": "neither anyOf valid", "data": 1.5, "valid": false } ] }, { "description": "anyOf with base schema", "schema": { "type": "string", "anyOf" : [ { "maxLength": 2 }, { "minLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one anyOf valid", "data": "foobar", "valid": true }, { "description": "both anyOf invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf complex types", "schema": { "anyOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first anyOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second anyOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both anyOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "neither anyOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "anyOf with one empty schema", "schema": { "anyOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is valid", "data": 123, "valid": true } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/default.json000066400000000000000000000042671426774651400263340ustar00rootroot00000000000000[ { "description": "invalid type for default", "schema": { "properties": { "foo": { "type": "integer", "default": [] } } }, "tests": [ { "description": "valid when property is specified", "data": {"foo": 13}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "invalid string value for default", "schema": { "properties": { "bar": { "type": "string", "minLength": 4, "default": "bad" } } }, "tests": [ { "description": "valid when property is specified", "data": {"bar": "good"}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "the default keyword does not do anything if the property is missing", "schema": { "type": "object", "properties": { "alpha": { "type": "number", "maximum": 3, "default": 5 } } }, "tests": [ { "description": "an explicit property value is checked against maximum (passing)", "data": { "alpha": 1 }, "valid": true }, { "description": "an explicit property value is checked against maximum (failing)", "data": { "alpha": 5 }, "valid": false }, { "description": "missing properties are not filled in with the default", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/definitions.json000066400000000000000000000013171426774651400272140ustar00rootroot00000000000000[ { "description": "validate definition against metaschema", "schema": {"$ref": "http://json-schema.org/draft-04/schema#"}, "tests": [ { "description": "valid definition schema", "data": { "definitions": { "foo": {"type": "integer"} } }, "valid": true }, { "description": "invalid definition schema", "data": { "definitions": { "foo": {"type": 1} } }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/dependencies.json000066400000000000000000000123611426774651400273300ustar00rootroot00000000000000[ { "description": "dependencies", "schema": { "dependencies": {"bar": ["foo"]} }, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependant", "data": {"foo": 1}, "valid": true }, { "description": "with dependency", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "missing dependency", "data": {"bar": 2}, "valid": false }, { "description": "ignores arrays", "data": ["bar"], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "multiple dependencies", "schema": { "dependencies": {"quux": ["foo", "bar"]} }, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependants", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "with dependencies", "data": {"foo": 1, "bar": 2, "quux": 3}, "valid": true }, { "description": "missing dependency", "data": {"foo": 1, "quux": 2}, "valid": false }, { "description": "missing other dependency", "data": {"bar": 1, "quux": 2}, "valid": false }, { "description": "missing both dependencies", "data": {"quux": 1}, "valid": false } ] }, { "description": "multiple dependencies subschema", "schema": { "dependencies": { "bar": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "integer"} } } } }, "tests": [ { "description": "valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "no dependency", "data": {"foo": "quux"}, "valid": true }, { "description": "wrong type", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "wrong type other", "data": {"foo": 2, "bar": "quux"}, "valid": false }, { "description": "wrong type both", "data": {"foo": "quux", "bar": "quux"}, "valid": false } ] }, { "description": "dependencies with escaped characters", "schema": { "dependencies": { "foo\nbar": ["foo\rbar"], "foo\tbar": { "minProperties": 4 }, "foo'bar": {"required": ["foo\"bar"]}, "foo\"bar": ["foo'bar"] } }, "tests": [ { "description": "valid object 1", "data": { "foo\nbar": 1, "foo\rbar": 2 }, "valid": true }, { "description": "valid object 2", "data": { "foo\tbar": 1, "a": 2, "b": 3, "c": 4 }, "valid": true }, { "description": "valid object 3", "data": { "foo'bar": 1, "foo\"bar": 2 }, "valid": true }, { "description": "invalid object 1", "data": { "foo\nbar": 1, "foo": 2 }, "valid": false }, { "description": "invalid object 2", "data": { "foo\tbar": 1, "a": 2 }, "valid": false }, { "description": "invalid object 3", "data": { "foo'bar": 1 }, "valid": false }, { "description": "invalid object 4", "data": { "foo\"bar": 2 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/enum.json000066400000000000000000000146431426774651400256530ustar00rootroot00000000000000[ { "description": "simple enum validation", "schema": {"enum": [1, 2, 3]}, "tests": [ { "description": "one of the enum is valid", "data": 1, "valid": true }, { "description": "something else is invalid", "data": 4, "valid": false } ] }, { "description": "heterogeneous enum validation", "schema": {"enum": [6, "foo", [], true, {"foo": 12}]}, "tests": [ { "description": "one of the enum is valid", "data": [], "valid": true }, { "description": "something else is invalid", "data": null, "valid": false }, { "description": "objects are deep compared", "data": {"foo": false}, "valid": false }, { "description": "valid object matches", "data": {"foo": 12}, "valid": true }, { "description": "extra properties in object is invalid", "data": {"foo": 12, "boo": 42}, "valid": false } ] }, { "description": "heterogeneous enum-with-null validation", "schema": { "enum": [6, null] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "number is valid", "data": 6, "valid": true }, { "description": "something else is invalid", "data": "test", "valid": false } ] }, { "description": "enums in properties", "schema": { "type":"object", "properties": { "foo": {"enum":["foo"]}, "bar": {"enum":["bar"]} }, "required": ["bar"] }, "tests": [ { "description": "both properties are valid", "data": {"foo":"foo", "bar":"bar"}, "valid": true }, { "description": "wrong foo value", "data": {"foo":"foot", "bar":"bar"}, "valid": false }, { "description": "wrong bar value", "data": {"foo":"foo", "bar":"bart"}, "valid": false }, { "description": "missing optional property is valid", "data": {"bar":"bar"}, "valid": true }, { "description": "missing required property is invalid", "data": {"foo":"foo"}, "valid": false }, { "description": "missing all properties is invalid", "data": {}, "valid": false } ] }, { "description": "enum with escaped characters", "schema": { "enum": ["foo\nbar", "foo\rbar"] }, "tests": [ { "description": "member 1 is valid", "data": "foo\nbar", "valid": true }, { "description": "member 2 is valid", "data": "foo\rbar", "valid": true }, { "description": "another string is invalid", "data": "abc", "valid": false } ] }, { "description": "enum with false does not match 0", "schema": {"enum": [false]}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "enum with true does not match 1", "schema": {"enum": [true]}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "enum with 0 does not match false", "schema": {"enum": [0]}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true } ] }, { "description": "enum with 1 does not match true", "schema": {"enum": [1]}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "nul characters in strings", "schema": { "enum": [ "hello\u0000there" ] }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/format.json000066400000000000000000000143111426774651400261670ustar00rootroot00000000000000[ { "description": "email format", "schema": { "format": "email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "ipv4 format", "schema": { "format": "ipv4" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "ipv6 format", "schema": { "format": "ipv6" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "hostname format", "schema": { "format": "hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "date-time format", "schema": { "format": "date-time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri format", "schema": { "format": "uri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/id.json000066400000000000000000000032671426774651400253030ustar00rootroot00000000000000[ { "description": "id inside an enum is not a real identifier", "comment": "the implementation must not be confused by an id buried in the enum", "schema": { "definitions": { "id_in_enum": { "enum": [ { "id": "https://localhost:1234/my_identifier.json", "type": "null" } ] }, "real_id_in_schema": { "id": "https://localhost:1234/my_identifier.json", "type": "string" }, "zzz_id_in_const": { "const": { "id": "https://localhost:1234/my_identifier.json", "type": "null" } } }, "anyOf": [ { "$ref": "#/definitions/id_in_enum" }, { "$ref": "https://localhost:1234/my_identifier.json" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "id": "https://localhost:1234/my_identifier.json", "type": "null" }, "valid": true }, { "description": "match $ref to id", "data": "a string to match #/definitions/id_in_enum", "valid": true }, { "description": "no match on enum or $ref to id", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/infinite-loop-detection.json000066400000000000000000000017461426774651400314370ustar00rootroot00000000000000[ { "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", "schema": { "definitions": { "int": { "type": "integer" } }, "allOf": [ { "properties": { "foo": { "$ref": "#/definitions/int" } } }, { "additionalProperties": { "$ref": "#/definitions/int" } } ] }, "tests": [ { "description": "passing case", "data": { "foo": 1 }, "valid": true }, { "description": "failing case", "data": { "foo": "a string" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/items.json000066400000000000000000000132711426774651400260240ustar00rootroot00000000000000[ { "description": "a schema given for items", "schema": { "items": {"type": "integer"} }, "tests": [ { "description": "valid items", "data": [ 1, 2, 3 ], "valid": true }, { "description": "wrong type of items", "data": [1, "x"], "valid": false }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "length": 1 }, "valid": true } ] }, { "description": "an array of schemas for items", "schema": { "items": [ {"type": "integer"}, {"type": "string"} ] }, "tests": [ { "description": "correct types", "data": [ 1, "foo" ], "valid": true }, { "description": "wrong types", "data": [ "foo", 1 ], "valid": false }, { "description": "incomplete array of items", "data": [ 1 ], "valid": true }, { "description": "array with additional items", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array", "data": [ ], "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "1": "valid", "length": 2 }, "valid": true } ] }, { "description": "items and subitems", "schema": { "definitions": { "item": { "type": "array", "additionalItems": false, "items": [ { "$ref": "#/definitions/sub-item" }, { "$ref": "#/definitions/sub-item" } ] }, "sub-item": { "type": "object", "required": ["foo"] } }, "type": "array", "additionalItems": false, "items": [ { "$ref": "#/definitions/item" }, { "$ref": "#/definitions/item" }, { "$ref": "#/definitions/item" } ] }, "tests": [ { "description": "valid items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": true }, { "description": "too many items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "too many sub-items", "data": [ [ {"foo": null}, {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong item", "data": [ {"foo": null}, [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong sub-item", "data": [ [ {}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "fewer items is valid", "data": [ [ {"foo": null} ], [ {"foo": null} ] ], "valid": true } ] }, { "description": "nested items", "schema": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "number" } } } } }, "tests": [ { "description": "valid nested array", "data": [[[[1]], [[2],[3]]], [[[4], [5], [6]]]], "valid": true }, { "description": "nested array with invalid type", "data": [[[["1"]], [[2],[3]]], [[[4], [5], [6]]]], "valid": false }, { "description": "not deep enough", "data": [[[1], [2],[3]], [[4], [5], [6]]], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/maxItems.json000066400000000000000000000013021426774651400264620ustar00rootroot00000000000000[ { "description": "maxItems validation", "schema": {"maxItems": 2}, "tests": [ { "description": "shorter is valid", "data": [1], "valid": true }, { "description": "exact length is valid", "data": [1, 2], "valid": true }, { "description": "too long is invalid", "data": [1, 2, 3], "valid": false }, { "description": "ignores non-arrays", "data": "foobar", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/maxLength.json000066400000000000000000000016001426774651400266230ustar00rootroot00000000000000[ { "description": "maxLength validation", "schema": {"maxLength": 2}, "tests": [ { "description": "shorter is valid", "data": "f", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too long is invalid", "data": "foo", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true }, { "description": "two supplementary Unicode code points is long enough", "data": "\uD83D\uDCA9\uD83D\uDCA9", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/maxProperties.json000066400000000000000000000027321426774651400275450ustar00rootroot00000000000000[ { "description": "maxProperties validation", "schema": {"maxProperties": 2}, "tests": [ { "description": "shorter is valid", "data": {"foo": 1}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "too long is invalid", "data": {"foo": 1, "bar": 2, "baz": 3}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "maxProperties = 0 means the object is empty", "schema": { "maxProperties": 0 }, "tests": [ { "description": "no properties is valid", "data": {}, "valid": true }, { "description": "one property is invalid", "data": { "foo": 1 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/maximum.json000066400000000000000000000052621426774651400263610ustar00rootroot00000000000000[ { "description": "maximum validation", "schema": {"maximum": 3.0}, "tests": [ { "description": "below the maximum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 3.0, "valid": true }, { "description": "above the maximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "maximum validation with unsigned integer", "schema": {"maximum": 300}, "tests": [ { "description": "below the maximum is invalid", "data": 299.97, "valid": true }, { "description": "boundary point integer is valid", "data": 300, "valid": true }, { "description": "boundary point float is valid", "data": 300.00, "valid": true }, { "description": "above the maximum is invalid", "data": 300.5, "valid": false } ] }, { "description": "maximum validation (explicit false exclusivity)", "schema": {"maximum": 3.0, "exclusiveMaximum": false}, "tests": [ { "description": "below the maximum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 3.0, "valid": true }, { "description": "above the maximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "exclusiveMaximum validation", "schema": { "maximum": 3.0, "exclusiveMaximum": true }, "tests": [ { "description": "below the maximum is still valid", "data": 2.2, "valid": true }, { "description": "boundary point is invalid", "data": 3.0, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/minItems.json000066400000000000000000000012651426774651400264700ustar00rootroot00000000000000[ { "description": "minItems validation", "schema": {"minItems": 1}, "tests": [ { "description": "longer is valid", "data": [1, 2], "valid": true }, { "description": "exact length is valid", "data": [1], "valid": true }, { "description": "too short is invalid", "data": [], "valid": false }, { "description": "ignores non-arrays", "data": "", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/minLength.json000066400000000000000000000015661426774651400266340ustar00rootroot00000000000000[ { "description": "minLength validation", "schema": {"minLength": 2}, "tests": [ { "description": "longer is valid", "data": "foo", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too short is invalid", "data": "f", "valid": false }, { "description": "ignores non-strings", "data": 1, "valid": true }, { "description": "one supplementary Unicode code point is not long enough", "data": "\uD83D\uDCA9", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/minProperties.json000066400000000000000000000017541426774651400275460ustar00rootroot00000000000000[ { "description": "minProperties validation", "schema": {"minProperties": 1}, "tests": [ { "description": "longer is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1}, "valid": true }, { "description": "too short is invalid", "data": {}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/minimum.json000066400000000000000000000061701426774651400263560ustar00rootroot00000000000000[ { "description": "minimum validation", "schema": {"minimum": 1.1}, "tests": [ { "description": "above the minimum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 1.1, "valid": true }, { "description": "below the minimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "minimum validation (explicit false exclusivity)", "schema": {"minimum": 1.1, "exclusiveMinimum": false}, "tests": [ { "description": "above the minimum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 1.1, "valid": true }, { "description": "below the minimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "exclusiveMinimum validation", "schema": { "minimum": 1.1, "exclusiveMinimum": true }, "tests": [ { "description": "above the minimum is still valid", "data": 1.2, "valid": true }, { "description": "boundary point is invalid", "data": 1.1, "valid": false } ] }, { "description": "minimum validation with signed integer", "schema": {"minimum": -2}, "tests": [ { "description": "negative above the minimum is valid", "data": -1, "valid": true }, { "description": "positive above the minimum is valid", "data": 0, "valid": true }, { "description": "boundary point is valid", "data": -2, "valid": true }, { "description": "boundary point with float is valid", "data": -2.0, "valid": true }, { "description": "float below the minimum is invalid", "data": -2.0001, "valid": false }, { "description": "int below the minimum is invalid", "data": -3, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/multipleOf.json000066400000000000000000000035771426774651400270330ustar00rootroot00000000000000[ { "description": "by int", "schema": {"multipleOf": 2}, "tests": [ { "description": "int by int", "data": 10, "valid": true }, { "description": "int by int fail", "data": 7, "valid": false }, { "description": "ignores non-numbers", "data": "foo", "valid": true } ] }, { "description": "by number", "schema": {"multipleOf": 1.5}, "tests": [ { "description": "zero is multiple of anything", "data": 0, "valid": true }, { "description": "4.5 is multiple of 1.5", "data": 4.5, "valid": true }, { "description": "35 is not multiple of 1.5", "data": 35, "valid": false } ] }, { "description": "by small number", "schema": {"multipleOf": 0.0001}, "tests": [ { "description": "0.0075 is multiple of 0.0001", "data": 0.0075, "valid": true }, { "description": "0.00751 is not multiple of 0.0001", "data": 0.00751, "valid": false } ] }, { "description": "invalid instance should not raise error when float division = inf", "schema": {"type": "integer", "multipleOf": 0.123456789}, "tests": [ { "description": "always invalid, but naive implementations may raise an overflow error", "data": 1e308, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/not.json000066400000000000000000000043321426774651400255010ustar00rootroot00000000000000[ { "description": "not", "schema": { "not": {"type": "integer"} }, "tests": [ { "description": "allowed", "data": "foo", "valid": true }, { "description": "disallowed", "data": 1, "valid": false } ] }, { "description": "not multiple types", "schema": { "not": {"type": ["integer", "boolean"]} }, "tests": [ { "description": "valid", "data": "foo", "valid": true }, { "description": "mismatch", "data": 1, "valid": false }, { "description": "other mismatch", "data": true, "valid": false } ] }, { "description": "not more complex schema", "schema": { "not": { "type": "object", "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "match", "data": 1, "valid": true }, { "description": "other match", "data": {"foo": 1}, "valid": true }, { "description": "mismatch", "data": {"foo": "bar"}, "valid": false } ] }, { "description": "forbidden property", "schema": { "properties": { "foo": { "not": {} } } }, "tests": [ { "description": "property present", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "property absent", "data": {"bar": 1, "baz": 2}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/oneOf.json000066400000000000000000000136231426774651400257520ustar00rootroot00000000000000[ { "description": "oneOf", "schema": { "oneOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first oneOf valid", "data": 1, "valid": true }, { "description": "second oneOf valid", "data": 2.5, "valid": true }, { "description": "both oneOf valid", "data": 3, "valid": false }, { "description": "neither oneOf valid", "data": 1.5, "valid": false } ] }, { "description": "oneOf with base schema", "schema": { "type": "string", "oneOf" : [ { "minLength": 2 }, { "maxLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one oneOf valid", "data": "foobar", "valid": true }, { "description": "both oneOf valid", "data": "foo", "valid": false } ] }, { "description": "oneOf complex types", "schema": { "oneOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second oneOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both oneOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": false }, { "description": "neither oneOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "oneOf with empty schema", "schema": { "oneOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "one valid - valid", "data": "foo", "valid": true }, { "description": "both valid - invalid", "data": 123, "valid": false } ] }, { "description": "oneOf with required", "schema": { "type": "object", "oneOf": [ { "required": ["foo", "bar"] }, { "required": ["foo", "baz"] } ] }, "tests": [ { "description": "both invalid - invalid", "data": {"bar": 2}, "valid": false }, { "description": "first valid - valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "second valid - valid", "data": {"foo": 1, "baz": 3}, "valid": true }, { "description": "both valid - invalid", "data": {"foo": 1, "bar": 2, "baz" : 3}, "valid": false } ] }, { "description": "oneOf with missing optional property", "schema": { "oneOf": [ { "properties": { "bar": {}, "baz": {} }, "required": ["bar"] }, { "properties": { "foo": {} }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid", "data": {"bar": 8}, "valid": true }, { "description": "second oneOf valid", "data": {"foo": "foo"}, "valid": true }, { "description": "both oneOf valid", "data": {"foo": "foo", "bar": 8}, "valid": false }, { "description": "neither oneOf valid", "data": {"baz": "quux"}, "valid": false } ] }, { "description": "nested oneOf, to check validation semantics", "schema": { "oneOf": [ { "oneOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/000077500000000000000000000000001426774651400256315ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/bignum.json000066400000000000000000000060031426774651400300040ustar00rootroot00000000000000[ { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a bignum is an integer", "data": 12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a bignum is a number", "data": 98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a negative bignum is an integer", "data": -12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a negative bignum is a number", "data": -98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "string", "schema": {"type": "string"}, "tests": [ { "description": "a bignum is not a string", "data": 98249283749234923498293171823948729348710298301928331, "valid": false } ] }, { "description": "integer comparison", "schema": {"maximum": 18446744073709551615}, "tests": [ { "description": "comparison works for high numbers", "data": 18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision", "schema": { "maximum": 972783798187987123879878123.18878137, "exclusiveMaximum": true }, "tests": [ { "description": "comparison works for high numbers", "data": 972783798187987123879878123.188781371, "valid": false } ] }, { "description": "integer comparison", "schema": {"minimum": -18446744073709551615}, "tests": [ { "description": "comparison works for very negative numbers", "data": -18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision on negative numbers", "schema": { "minimum": -972783798187987123879878123.18878137, "exclusiveMinimum": true }, "tests": [ { "description": "comparison works for very negative numbers", "data": -972783798187987123879878123.188781371, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/ecmascript-regex.json000066400000000000000000000202161426774651400317670ustar00rootroot00000000000000[ { "description": "ECMA 262 regex $ does not match trailing newline", "schema": { "type": "string", "pattern": "^abc$" }, "tests": [ { "description": "matches in Python, but should not in jsonschema", "data": "abc\n", "valid": false }, { "description": "should match", "data": "abc", "valid": true } ] }, { "description": "ECMA 262 regex converts \\t to horizontal tab", "schema": { "type": "string", "pattern": "^\\t$" }, "tests": [ { "description": "does not match", "data": "\\t", "valid": false }, { "description": "matches", "data": "\u0009", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and upper letter", "schema": { "type": "string", "pattern": "^\\cC$" }, "tests": [ { "description": "does not match", "data": "\\cC", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and lower letter", "schema": { "type": "string", "pattern": "^\\cc$" }, "tests": [ { "description": "does not match", "data": "\\cc", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 \\d matches ascii digits only", "schema": { "type": "string", "pattern": "^\\d$" }, "tests": [ { "description": "ASCII zero matches", "data": "0", "valid": true }, { "description": "NKO DIGIT ZERO does not match (unlike e.g. Python)", "data": "߀", "valid": false }, { "description": "NKO DIGIT ZERO (as \\u escape) does not match", "data": "\u07c0", "valid": false } ] }, { "description": "ECMA 262 \\D matches everything but ascii digits", "schema": { "type": "string", "pattern": "^\\D$" }, "tests": [ { "description": "ASCII zero does not match", "data": "0", "valid": false }, { "description": "NKO DIGIT ZERO matches (unlike e.g. Python)", "data": "߀", "valid": true }, { "description": "NKO DIGIT ZERO (as \\u escape) matches", "data": "\u07c0", "valid": true } ] }, { "description": "ECMA 262 \\w matches ascii letters only", "schema": { "type": "string", "pattern": "^\\w$" }, "tests": [ { "description": "ASCII 'a' matches", "data": "a", "valid": true }, { "description": "latin-1 e-acute does not match (unlike e.g. Python)", "data": "é", "valid": false } ] }, { "description": "ECMA 262 \\W matches everything but ascii letters", "schema": { "type": "string", "pattern": "^\\W$" }, "tests": [ { "description": "ASCII 'a' does not match", "data": "a", "valid": false }, { "description": "latin-1 e-acute matches (unlike e.g. Python)", "data": "é", "valid": true } ] }, { "description": "ECMA 262 \\s matches whitespace", "schema": { "type": "string", "pattern": "^\\s$" }, "tests": [ { "description": "ASCII space matches", "data": " ", "valid": true }, { "description": "Character tabulation matches", "data": "\t", "valid": true }, { "description": "Line tabulation matches", "data": "\u000b", "valid": true }, { "description": "Form feed matches", "data": "\u000c", "valid": true }, { "description": "latin-1 non-breaking-space matches", "data": "\u00a0", "valid": true }, { "description": "zero-width whitespace matches", "data": "\ufeff", "valid": true }, { "description": "line feed matches (line terminator)", "data": "\u000a", "valid": true }, { "description": "paragraph separator matches (line terminator)", "data": "\u2029", "valid": true }, { "description": "EM SPACE matches (Space_Separator)", "data": "\u2003", "valid": true }, { "description": "Non-whitespace control does not match", "data": "\u0001", "valid": false }, { "description": "Non-whitespace does not match", "data": "\u2013", "valid": false } ] }, { "description": "ECMA 262 \\S matches everything but whitespace", "schema": { "type": "string", "pattern": "^\\S$" }, "tests": [ { "description": "ASCII space does not match", "data": " ", "valid": false }, { "description": "Character tabulation does not match", "data": "\t", "valid": false }, { "description": "Line tabulation does not match", "data": "\u000b", "valid": false }, { "description": "Form feed does not match", "data": "\u000c", "valid": false }, { "description": "latin-1 non-breaking-space does not match", "data": "\u00a0", "valid": false }, { "description": "zero-width whitespace does not match", "data": "\ufeff", "valid": false }, { "description": "line feed does not match (line terminator)", "data": "\u000a", "valid": false }, { "description": "paragraph separator does not match (line terminator)", "data": "\u2029", "valid": false }, { "description": "EM SPACE does not match (Space_Separator)", "data": "\u2003", "valid": false }, { "description": "Non-whitespace control matches", "data": "\u0001", "valid": true }, { "description": "Non-whitespace matches", "data": "\u2013", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/float-overflow.json000066400000000000000000000005501426774651400314720ustar00rootroot00000000000000[ { "description": "all integers are multiples of 0.5, if overflow is handled", "schema": {"type": "number", "multipleOf": 0.5}, "tests": [ { "description": "valid if optional overflow handling is implemented", "data": 1e308, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/000077500000000000000000000000001426774651400271215ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/date-time.json000066400000000000000000000041421426774651400316660ustar00rootroot00000000000000[ { "description": "validation of date-time strings", "schema": {"format": "date-time"}, "tests": [ { "description": "a valid date-time string", "data": "1963-06-19T08:30:06.283185Z", "valid": true }, { "description": "a valid date-time string without second fraction", "data": "1963-06-19T08:30:06Z", "valid": true }, { "description": "a valid date-time string with plus offset", "data": "1937-01-01T12:00:27.87+00:20", "valid": true }, { "description": "a valid date-time string with minus offset", "data": "1990-12-31T15:59:50.123-08:00", "valid": true }, { "description": "a invalid day in date-time string", "data": "1990-02-31T15:59:60.123-08:00", "valid": false }, { "description": "an invalid offset in date-time string", "data": "1990-12-31T15:59:60-24:00", "valid": false }, { "description": "an invalid date-time string", "data": "06/19/1963 08:30:06 PST", "valid": false }, { "description": "case-insensitive T and Z", "data": "1963-06-19t08:30:06.283185z", "valid": true }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350T01:01:01", "valid": false }, { "description": "invalid non-padded month dates", "data": "1963-6-19T08:30:06.283185Z", "valid": false }, { "description": "invalid non-padded day dates", "data": "1963-06-1T08:30:06.283185Z", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/email.json000066400000000000000000000032331426774651400311040ustar00rootroot00000000000000[ { "description": "validation of e-mail addresses", "schema": {"format": "email"}, "tests": [ { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false }, { "description": "tilde in local part is valid", "data": "te~st@example.com", "valid": true }, { "description": "tilde before local part is valid", "data": "~test@example.com", "valid": true }, { "description": "tilde after local part is valid", "data": "test~@example.com", "valid": true }, { "description": "dot before local part is not valid", "data": ".test@example.com", "valid": false }, { "description": "dot after local part is not valid", "data": "test.@example.com", "valid": false }, { "description": "two separated dots inside local part are valid", "data": "te.s.t@example.com", "valid": true }, { "description": "two subsequent dots inside local part are not valid", "data": "te..st@example.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/hostname.json000066400000000000000000000040771426774651400316420ustar00rootroot00000000000000[ { "description": "validation of host names", "schema": {"format": "hostname"}, "tests": [ { "description": "a valid host name", "data": "www.example.com", "valid": true }, { "description": "a host name starting with an illegal character", "data": "-a-host-name-that-starts-with--", "valid": false }, { "description": "a host name containing illegal characters", "data": "not_a_valid_host_name", "valid": false }, { "description": "a host name with a component too long", "data": "a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component", "valid": false }, { "description": "starts with hyphen", "data": "-hostname", "valid": false }, { "description": "ends with hyphen", "data": "hostname-", "valid": false }, { "description": "starts with underscore", "data": "_hostname", "valid": false }, { "description": "ends with underscore", "data": "hostname_", "valid": false }, { "description": "contains underscore", "data": "host_name", "valid": false }, { "description": "maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com", "valid": true }, { "description": "exceeds maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/ipv4.json000066400000000000000000000032731426774651400307030ustar00rootroot00000000000000[ { "description": "validation of IP addresses", "schema": {"format": "ipv4"}, "tests": [ { "description": "a valid IP address", "data": "192.168.0.1", "valid": true }, { "description": "an IP address with too many components", "data": "127.0.0.0.1", "valid": false }, { "description": "an IP address with out-of-range values", "data": "256.256.256.256", "valid": false }, { "description": "an IP address without 4 components", "data": "127.0", "valid": false }, { "description": "an IP address as an integer", "data": "0x7f000001", "valid": false }, { "description": "an IP address as an integer (decimal)", "data": "2130706433", "valid": false }, { "description": "leading zeroes should be rejected, as they are treated as octals", "comment": "see https://sick.codes/universal-netmask-npm-package-used-by-270000-projects-vulnerable-to-octal-input-data-server-side-request-forgery-remote-file-inclusion-local-file-inclusion-and-more-cve-2021-28918/", "data": "087.10.0.1", "valid": false }, { "description": "value without leading zero is valid", "data": "87.10.0.1", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/ipv6.json000066400000000000000000000120111426774651400306730ustar00rootroot00000000000000[ { "description": "validation of IPv6 addresses", "schema": {"format": "ipv6"}, "tests": [ { "description": "a valid IPv6 address", "data": "::1", "valid": true }, { "description": "an IPv6 address with out-of-range values", "data": "12345::", "valid": false }, { "description": "an IPv6 address with too many components", "data": "1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1", "valid": false }, { "description": "an IPv6 address containing illegal characters", "data": "::laptop", "valid": false }, { "description": "no digits is valid", "data": "::", "valid": true }, { "description": "leading colons is valid", "data": "::42:ff:1", "valid": true }, { "description": "trailing colons is valid", "data": "d6::", "valid": true }, { "description": "missing leading octet is invalid", "data": ":2:3:4:5:6:7:8", "valid": false }, { "description": "missing trailing octet is invalid", "data": "1:2:3:4:5:6:7:", "valid": false }, { "description": "missing leading octet with omitted octets later", "data": ":2:3:4::8", "valid": false }, { "description": "two sets of double colons is invalid", "data": "1::d6::42", "valid": false }, { "description": "mixed format with the ipv4 section as decimal octets", "data": "1::d6:192.168.0.1", "valid": true }, { "description": "mixed format with double colons between the sections", "data": "1:2::192.168.0.1", "valid": true }, { "description": "mixed format with ipv4 section with octet out of range", "data": "1::2:192.168.256.1", "valid": false }, { "description": "mixed format with ipv4 section with a hex octet", "data": "1::2:192.168.ff.1", "valid": false }, { "description": "mixed format with leading double colons (ipv4-mapped ipv6 address)", "data": "::ffff:192.168.0.1", "valid": true }, { "description": "triple colons is invalid", "data": "1:2:3:4:5:::8", "valid": false }, { "description": "8 octets", "data": "1:2:3:4:5:6:7:8", "valid": true }, { "description": "insufficient octets without double colons", "data": "1:2:3:4:5:6:7", "valid": false }, { "description": "no colons is invalid", "data": "1", "valid": false }, { "description": "ipv4 is not ipv6", "data": "127.0.0.1", "valid": false }, { "description": "ipv4 segment must have 4 octets", "data": "1:2:3:4:1.2.3", "valid": false }, { "description": "leading whitespace is invalid", "data": " ::1", "valid": false }, { "description": "trailing whitespace is invalid", "data": "::1 ", "valid": false }, { "description": "netmask is not a part of ipv6 address", "data": "fe80::/64", "valid": false }, { "description": "zone id is not a part of ipv6 address", "data": "fe80::a%eth1", "valid": false }, { "description": "a long valid ipv6", "data": "1000:1000:1000:1000:1000:1000:255.255.255.255", "valid": true }, { "description": "a long invalid ipv6, below length limit, first", "data": "100:100:100:100:100:100:255.255.255.255.255", "valid": false }, { "description": "a long invalid ipv6, below length limit, second", "data": "100:100:100:100:100:100:100:255.255.255.255", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/format/uri.json000066400000000000000000000071631426774651400306220ustar00rootroot00000000000000[ { "description": "validation of URIs", "schema": {"format": "uri"}, "tests": [ { "description": "a valid URL with anchor tag", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid URL with anchor tag and parentheses", "data": "http://foo.com/blah_(wikipedia)_blah#cite-1", "valid": true }, { "description": "a valid URL with URL-encoded stuff", "data": "http://foo.bar/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid puny-coded URL ", "data": "http://xn--nw2a.xn--j6w193g/", "valid": true }, { "description": "a valid URL with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid URL based on IPv4", "data": "http://223.255.255.254", "valid": true }, { "description": "a valid URL with ftp scheme", "data": "ftp://ftp.is.co.za/rfc/rfc1808.txt", "valid": true }, { "description": "a valid URL for a simple text file", "data": "http://www.ietf.org/rfc/rfc2396.txt", "valid": true }, { "description": "a valid URL ", "data": "ldap://[2001:db8::7]/c=GB?objectClass?one", "valid": true }, { "description": "a valid mailto URI", "data": "mailto:John.Doe@example.com", "valid": true }, { "description": "a valid newsgroup URI", "data": "news:comp.infosystems.www.servers.unix", "valid": true }, { "description": "a valid tel URI", "data": "tel:+1-816-555-1212", "valid": true }, { "description": "a valid URN", "data": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", "valid": true }, { "description": "an invalid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": false }, { "description": "an invalid relative URI Reference", "data": "/abc", "valid": false }, { "description": "an invalid URI", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "an invalid URI though valid URI reference", "data": "abc", "valid": false }, { "description": "an invalid URI with spaces", "data": "http:// shouldfail.com", "valid": false }, { "description": "an invalid URI with spaces and missing scheme", "data": ":// should fail", "valid": false }, { "description": "an invalid URI with comma in scheme", "data": "bar,baz:foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/non-bmp-regex.json000066400000000000000000000045361426774651400312120ustar00rootroot00000000000000[ { "description": "Proper UTF-16 surrogate pair handling: pattern", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "pattern": "^🐲*$" }, "tests": [ { "description": "matches empty", "data": "", "valid": true }, { "description": "matches single", "data": "🐲", "valid": true }, { "description": "matches two", "data": "🐲🐲", "valid": true }, { "description": "doesn't match one", "data": "🐉", "valid": false }, { "description": "doesn't match two", "data": "🐉🐉", "valid": false }, { "description": "doesn't match one ASCII", "data": "D", "valid": false }, { "description": "doesn't match two ASCII", "data": "DD", "valid": false } ] }, { "description": "Proper UTF-16 surrogate pair handling: patternProperties", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "patternProperties": { "^🐲*$": { "type": "integer" } } }, "tests": [ { "description": "matches empty", "data": { "": 1 }, "valid": true }, { "description": "matches single", "data": { "🐲": 1 }, "valid": true }, { "description": "matches two", "data": { "🐲🐲": 1 }, "valid": true }, { "description": "doesn't match one", "data": { "🐲": "hello" }, "valid": false }, { "description": "doesn't match two", "data": { "🐲🐲": "hello" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/unicode.json000066400000000000000000000127221426774651400301560ustar00rootroot00000000000000[ { "description": "unicode semantics should be used for all pattern matching", "schema": { "pattern": "\\wcole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode matching is case-sensitive", "data": "LES HIVERS DE MON ENFANCE ÉTAIENT DES SAISONS LONGUES, LONGUES. NOUS VIVIONS EN TROIS LIEUX: L'ÉCOLE, L'ÉGLISE ET LA PATINOIRE; MAIS LA VRAIE VIE ÉTAIT SUR LA PATINOIRE.", "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "pattern": "[a-z]cole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "ascii characters match", "data": "Les hivers de mon enfance etaient des saisons longues, longues. Nous vivions en trois lieux: l'ecole, l'eglise et la patinoire; mais la vraie vie etait sur la patinoire.", "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "pattern": "^\\d+$" }, "tests": [ { "description": "ascii digits", "data": "42", "valid": true }, { "description": "ascii non-digits", "data": "-%#", "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": "৪২", "valid": true } ] }, { "description": "unicode semantics should be used for all patternProperties matching", "schema": { "type": "object", "patternProperties": { "\\wcole": {} }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": true }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": true }, { "description": "unicode matching is case-sensitive", "data": { "L'ÉCOLE": "PAS DE VRAIE VIE" }, "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "type": "object", "patternProperties": { "[a-z]cole": {} }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": false }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": false }, { "description": "ascii characters match", "data": { "l'ecole": "pas de vraie vie" }, "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "type": "object", "patternProperties": { "^\\d+$": {} }, "additionalProperties": false }, "tests": [ { "description": "ascii digits", "data": { "42": "life, the universe, and everything" }, "valid": true }, { "description": "ascii non-digits", "data": { "-%#": "spending the year dead for tax reasons" }, "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": { "৪২": "khajit has wares if you have coin" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/optional/zeroTerminatedFloats.json000066400000000000000000000006001426774651400326650ustar00rootroot00000000000000[ { "description": "some languages do not distinguish between different types of numeric value", "schema": { "type": "integer" }, "tests": [ { "description": "a float is not an integer even without fractional part", "data": 1.0, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/pattern.json000066400000000000000000000030031426774651400263500ustar00rootroot00000000000000[ { "description": "pattern validation", "schema": {"pattern": "^a*$"}, "tests": [ { "description": "a matching pattern is valid", "data": "aaa", "valid": true }, { "description": "a non-matching pattern is invalid", "data": "abc", "valid": false }, { "description": "ignores booleans", "data": true, "valid": true }, { "description": "ignores integers", "data": 123, "valid": true }, { "description": "ignores floats", "data": 1.0, "valid": true }, { "description": "ignores objects", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores null", "data": null, "valid": true } ] }, { "description": "pattern is not anchored", "schema": {"pattern": "a+"}, "tests": [ { "description": "matches a substring", "data": "xxaayy", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/patternProperties.json000066400000000000000000000070741426774651400304410ustar00rootroot00000000000000[ { "description": "patternProperties validates properties matching a regex", "schema": { "patternProperties": { "f.*o": {"type": "integer"} } }, "tests": [ { "description": "a single valid match is valid", "data": {"foo": 1}, "valid": true }, { "description": "multiple valid matches is valid", "data": {"foo": 1, "foooooo" : 2}, "valid": true }, { "description": "a single invalid match is invalid", "data": {"foo": "bar", "fooooo": 2}, "valid": false }, { "description": "multiple invalid matches is invalid", "data": {"foo": "bar", "foooooo" : "baz"}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "multiple simultaneous patternProperties are validated", "schema": { "patternProperties": { "a*": {"type": "integer"}, "aaa*": {"maximum": 20} } }, "tests": [ { "description": "a single valid match is valid", "data": {"a": 21}, "valid": true }, { "description": "a simultaneous match is valid", "data": {"aaaa": 18}, "valid": true }, { "description": "multiple matches is valid", "data": {"a": 21, "aaaa": 18}, "valid": true }, { "description": "an invalid due to one is invalid", "data": {"a": "bar"}, "valid": false }, { "description": "an invalid due to the other is invalid", "data": {"aaaa": 31}, "valid": false }, { "description": "an invalid due to both is invalid", "data": {"aaa": "foo", "aaaa": 31}, "valid": false } ] }, { "description": "regexes are not anchored by default and are case sensitive", "schema": { "patternProperties": { "[0-9]{2,}": { "type": "boolean" }, "X_": { "type": "string" } } }, "tests": [ { "description": "non recognized members are ignored", "data": { "answer 1": "42" }, "valid": true }, { "description": "recognized members are accounted for", "data": { "a31b": null }, "valid": false }, { "description": "regexes are case sensitive", "data": { "a_x_3": 3 }, "valid": true }, { "description": "regexes are case sensitive, 2", "data": { "a_X_3": 3 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/properties.json000066400000000000000000000102401426774651400270700ustar00rootroot00000000000000[ { "description": "object properties validation", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "string"} } }, "tests": [ { "description": "both properties present and valid is valid", "data": {"foo": 1, "bar": "baz"}, "valid": true }, { "description": "one property invalid is invalid", "data": {"foo": 1, "bar": {}}, "valid": false }, { "description": "both properties invalid is invalid", "data": {"foo": [], "bar": {}}, "valid": false }, { "description": "doesn't invalidate other properties", "data": {"quux": []}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "properties, patternProperties, additionalProperties interaction", "schema": { "properties": { "foo": {"type": "array", "maxItems": 3}, "bar": {"type": "array"} }, "patternProperties": {"f.o": {"minItems": 2}}, "additionalProperties": {"type": "integer"} }, "tests": [ { "description": "property validates property", "data": {"foo": [1, 2]}, "valid": true }, { "description": "property invalidates property", "data": {"foo": [1, 2, 3, 4]}, "valid": false }, { "description": "patternProperty invalidates property", "data": {"foo": []}, "valid": false }, { "description": "patternProperty validates nonproperty", "data": {"fxo": [1, 2]}, "valid": true }, { "description": "patternProperty invalidates nonproperty", "data": {"fxo": []}, "valid": false }, { "description": "additionalProperty ignores property", "data": {"bar": []}, "valid": true }, { "description": "additionalProperty validates others", "data": {"quux": 3}, "valid": true }, { "description": "additionalProperty invalidates others", "data": {"quux": "foo"}, "valid": false } ] }, { "description": "properties with escaped characters", "schema": { "properties": { "foo\nbar": {"type": "number"}, "foo\"bar": {"type": "number"}, "foo\\bar": {"type": "number"}, "foo\rbar": {"type": "number"}, "foo\tbar": {"type": "number"}, "foo\fbar": {"type": "number"} } }, "tests": [ { "description": "object with all numbers is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1", "foo\\bar": "1", "foo\rbar": "1", "foo\tbar": "1", "foo\fbar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/ref.json000066400000000000000000000330521426774651400254560ustar00rootroot00000000000000[ { "description": "root pointer ref", "schema": { "properties": { "foo": {"$ref": "#"} }, "additionalProperties": false }, "tests": [ { "description": "match", "data": {"foo": false}, "valid": true }, { "description": "recursive match", "data": {"foo": {"foo": false}}, "valid": true }, { "description": "mismatch", "data": {"bar": false}, "valid": false }, { "description": "recursive mismatch", "data": {"foo": {"bar": false}}, "valid": false } ] }, { "description": "relative pointer ref to object", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "relative pointer ref to array", "schema": { "items": [ {"type": "integer"}, {"$ref": "#/items/0"} ] }, "tests": [ { "description": "match array", "data": [1, 2], "valid": true }, { "description": "mismatch array", "data": [1, "foo"], "valid": false } ] }, { "description": "escaped pointer ref", "schema": { "definitions": { "tilde~field": {"type": "integer"}, "slash/field": {"type": "integer"}, "percent%field": {"type": "integer"} }, "properties": { "tilde": {"$ref": "#/definitions/tilde~0field"}, "slash": {"$ref": "#/definitions/slash~1field"}, "percent": {"$ref": "#/definitions/percent%25field"} } }, "tests": [ { "description": "slash invalid", "data": {"slash": "aoeu"}, "valid": false }, { "description": "tilde invalid", "data": {"tilde": "aoeu"}, "valid": false }, { "description": "percent invalid", "data": {"percent": "aoeu"}, "valid": false }, { "description": "slash valid", "data": {"slash": 123}, "valid": true }, { "description": "tilde valid", "data": {"tilde": 123}, "valid": true }, { "description": "percent valid", "data": {"percent": 123}, "valid": true } ] }, { "description": "nested refs", "schema": { "definitions": { "a": {"type": "integer"}, "b": {"$ref": "#/definitions/a"}, "c": {"$ref": "#/definitions/b"} }, "allOf": [{ "$ref": "#/definitions/c" }] }, "tests": [ { "description": "nested ref valid", "data": 5, "valid": true }, { "description": "nested ref invalid", "data": "a", "valid": false } ] }, { "description": "ref overrides any sibling keywords", "schema": { "definitions": { "reffed": { "type": "array" } }, "properties": { "foo": { "$ref": "#/definitions/reffed", "maxItems": 2 } } }, "tests": [ { "description": "ref valid", "data": { "foo": [] }, "valid": true }, { "description": "ref valid, maxItems ignored", "data": { "foo": [ 1, 2, 3] }, "valid": true }, { "description": "ref invalid", "data": { "foo": "string" }, "valid": false } ] }, { "description": "$ref prevents a sibling id from changing the base uri", "schema": { "id": "http://localhost:1234/sibling_id/base/", "definitions": { "foo": { "id": "http://localhost:1234/sibling_id/foo.json", "minimum": 2 }, "base_foo": { "$comment": "this canonical uri is http://localhost:1234/sibling_id/base/foo.json", "id": "foo.json", "minimum": 5 } }, "allOf": [ { "$comment": "$ref resolves to http://localhost:1234/sibling_id/base/foo.json, not ttp://localhost:1234/sibling_id/foo.json", "id": "http://localhost:1234/sibling_id/", "$ref": "foo.json" } ] }, "tests": [ { "description": "$ref resolves to /definitions/foo, data validates", "data": 10, "valid": true }, { "description": "$ref resolves to /definitions/foo, data does not validate", "data": 1, "valid": false } ] }, { "description": "remote ref, containing refs itself", "schema": {"$ref": "http://json-schema.org/draft-04/schema#"}, "tests": [ { "description": "remote ref valid", "data": {"minLength": 1}, "valid": true }, { "description": "remote ref invalid", "data": {"minLength": -1}, "valid": false } ] }, { "description": "property named $ref that is not a reference", "schema": { "properties": { "$ref": {"type": "string"} } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "property named $ref, containing an actual $ref", "schema": { "properties": { "$ref": {"$ref": "#/definitions/is-string"} }, "definitions": { "is-string": { "type": "string" } } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "Recursive references between schemas", "schema": { "id": "http://localhost:1234/tree", "description": "tree of nodes", "type": "object", "properties": { "meta": {"type": "string"}, "nodes": { "type": "array", "items": {"$ref": "node"} } }, "required": ["meta", "nodes"], "definitions": { "node": { "id": "http://localhost:1234/node", "description": "node", "type": "object", "properties": { "value": {"type": "number"}, "subtree": {"$ref": "tree"} }, "required": ["value"] } } }, "tests": [ { "description": "valid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": 1.1}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": true }, { "description": "invalid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": "string is invalid"}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": false } ] }, { "description": "refs with quote", "schema": { "properties": { "foo\"bar": {"$ref": "#/definitions/foo%22bar"} }, "definitions": { "foo\"bar": {"type": "number"} } }, "tests": [ { "description": "object with numbers is valid", "data": { "foo\"bar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\"bar": "1" }, "valid": false } ] }, { "description": "Location-independent identifier", "schema": { "allOf": [{ "$ref": "#foo" }], "definitions": { "A": { "id": "#foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with base URI change in subschema", "schema": { "id": "http://localhost:1234/root", "allOf": [{ "$ref": "http://localhost:1234/nested.json#foo" }], "definitions": { "A": { "id": "nested.json", "definitions": { "B": { "id": "#foo", "type": "integer" } } } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "naive replacement of $ref with its destination is not correct", "schema": { "definitions": { "a_string": { "type": "string" } }, "enum": [ { "$ref": "#/definitions/a_string" } ] }, "tests": [ { "description": "do not evaluate the $ref inside the enum, matching any string", "data": "this is a string", "valid": false }, { "description": "match the enum exactly", "data": { "$ref": "#/definitions/a_string" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/refRemote.json000066400000000000000000000112601426774651400266270ustar00rootroot00000000000000[ { "description": "remote ref", "schema": {"$ref": "http://localhost:1234/integer.json"}, "tests": [ { "description": "remote ref valid", "data": 1, "valid": true }, { "description": "remote ref invalid", "data": "a", "valid": false } ] }, { "description": "fragment within remote ref", "schema": {"$ref": "http://localhost:1234/subSchemas.json#/integer"}, "tests": [ { "description": "remote fragment valid", "data": 1, "valid": true }, { "description": "remote fragment invalid", "data": "a", "valid": false } ] }, { "description": "ref within remote ref", "schema": { "$ref": "http://localhost:1234/subSchemas.json#/refToInteger" }, "tests": [ { "description": "ref within ref valid", "data": 1, "valid": true }, { "description": "ref within ref invalid", "data": "a", "valid": false } ] }, { "description": "base URI change", "schema": { "id": "http://localhost:1234/", "items": { "id": "baseUriChange/", "items": {"$ref": "folderInteger.json"} } }, "tests": [ { "description": "base URI change ref valid", "data": [[1]], "valid": true }, { "description": "base URI change ref invalid", "data": [["a"]], "valid": false } ] }, { "description": "base URI change - change folder", "schema": { "id": "http://localhost:1234/scope_change_defs1.json", "type" : "object", "properties": { "list": {"$ref": "#/definitions/baz"} }, "definitions": { "baz": { "id": "baseUriChangeFolder/", "type": "array", "items": {"$ref": "folderInteger.json"} } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "base URI change - change folder in subschema", "schema": { "id": "http://localhost:1234/scope_change_defs2.json", "type" : "object", "properties": { "list": {"$ref": "#/definitions/baz/definitions/bar"} }, "definitions": { "baz": { "id": "baseUriChangeFolderInSubschema/", "definitions": { "bar": { "type": "array", "items": {"$ref": "folderInteger.json"} } } } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "root ref in remote ref", "schema": { "id": "http://localhost:1234/object", "type": "object", "properties": { "name": {"$ref": "name.json#/definitions/orNull"} } }, "tests": [ { "description": "string is valid", "data": { "name": "foo" }, "valid": true }, { "description": "null is valid", "data": { "name": null }, "valid": true }, { "description": "object is invalid", "data": { "name": { "name": null } }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/required.json000066400000000000000000000044331426774651400265230ustar00rootroot00000000000000[ { "description": "required validation", "schema": { "properties": { "foo": {}, "bar": {} }, "required": ["foo"] }, "tests": [ { "description": "present required property is valid", "data": {"foo": 1}, "valid": true }, { "description": "non-present required property is invalid", "data": {"bar": 1}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "required default validation", "schema": { "properties": { "foo": {} } }, "tests": [ { "description": "not required by default", "data": {}, "valid": true } ] }, { "description": "required with escaped characters", "schema": { "required": [ "foo\nbar", "foo\"bar", "foo\\bar", "foo\rbar", "foo\tbar", "foo\fbar" ] }, "tests": [ { "description": "object with all properties present is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with some properties missing is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/type.json000066400000000000000000000316451426774651400256710ustar00rootroot00000000000000[ { "description": "integer type matches integers", "schema": {"type": "integer"}, "tests": [ { "description": "an integer is an integer", "data": 1, "valid": true }, { "description": "a float is not an integer", "data": 1.1, "valid": false }, { "description": "a string is not an integer", "data": "foo", "valid": false }, { "description": "a string is still not an integer, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not an integer", "data": {}, "valid": false }, { "description": "an array is not an integer", "data": [], "valid": false }, { "description": "a boolean is not an integer", "data": true, "valid": false }, { "description": "null is not an integer", "data": null, "valid": false } ] }, { "description": "number type matches numbers", "schema": {"type": "number"}, "tests": [ { "description": "an integer is a number", "data": 1, "valid": true }, { "description": "a float with zero fractional part is a number", "data": 1.0, "valid": true }, { "description": "a float is a number", "data": 1.1, "valid": true }, { "description": "a string is not a number", "data": "foo", "valid": false }, { "description": "a string is still not a number, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not a number", "data": {}, "valid": false }, { "description": "an array is not a number", "data": [], "valid": false }, { "description": "a boolean is not a number", "data": true, "valid": false }, { "description": "null is not a number", "data": null, "valid": false } ] }, { "description": "string type matches strings", "schema": {"type": "string"}, "tests": [ { "description": "1 is not a string", "data": 1, "valid": false }, { "description": "a float is not a string", "data": 1.1, "valid": false }, { "description": "a string is a string", "data": "foo", "valid": true }, { "description": "a string is still a string, even if it looks like a number", "data": "1", "valid": true }, { "description": "an empty string is still a string", "data": "", "valid": true }, { "description": "an object is not a string", "data": {}, "valid": false }, { "description": "an array is not a string", "data": [], "valid": false }, { "description": "a boolean is not a string", "data": true, "valid": false }, { "description": "null is not a string", "data": null, "valid": false } ] }, { "description": "object type matches objects", "schema": {"type": "object"}, "tests": [ { "description": "an integer is not an object", "data": 1, "valid": false }, { "description": "a float is not an object", "data": 1.1, "valid": false }, { "description": "a string is not an object", "data": "foo", "valid": false }, { "description": "an object is an object", "data": {}, "valid": true }, { "description": "an array is not an object", "data": [], "valid": false }, { "description": "a boolean is not an object", "data": true, "valid": false }, { "description": "null is not an object", "data": null, "valid": false } ] }, { "description": "array type matches arrays", "schema": {"type": "array"}, "tests": [ { "description": "an integer is not an array", "data": 1, "valid": false }, { "description": "a float is not an array", "data": 1.1, "valid": false }, { "description": "a string is not an array", "data": "foo", "valid": false }, { "description": "an object is not an array", "data": {}, "valid": false }, { "description": "an array is an array", "data": [], "valid": true }, { "description": "a boolean is not an array", "data": true, "valid": false }, { "description": "null is not an array", "data": null, "valid": false } ] }, { "description": "boolean type matches booleans", "schema": {"type": "boolean"}, "tests": [ { "description": "an integer is not a boolean", "data": 1, "valid": false }, { "description": "zero is not a boolean", "data": 0, "valid": false }, { "description": "a float is not a boolean", "data": 1.1, "valid": false }, { "description": "a string is not a boolean", "data": "foo", "valid": false }, { "description": "an empty string is not a boolean", "data": "", "valid": false }, { "description": "an object is not a boolean", "data": {}, "valid": false }, { "description": "an array is not a boolean", "data": [], "valid": false }, { "description": "true is a boolean", "data": true, "valid": true }, { "description": "false is a boolean", "data": false, "valid": true }, { "description": "null is not a boolean", "data": null, "valid": false } ] }, { "description": "null type matches only the null object", "schema": {"type": "null"}, "tests": [ { "description": "an integer is not null", "data": 1, "valid": false }, { "description": "a float is not null", "data": 1.1, "valid": false }, { "description": "zero is not null", "data": 0, "valid": false }, { "description": "a string is not null", "data": "foo", "valid": false }, { "description": "an empty string is not null", "data": "", "valid": false }, { "description": "an object is not null", "data": {}, "valid": false }, { "description": "an array is not null", "data": [], "valid": false }, { "description": "true is not null", "data": true, "valid": false }, { "description": "false is not null", "data": false, "valid": false }, { "description": "null is null", "data": null, "valid": true } ] }, { "description": "multiple types can be specified in an array", "schema": {"type": ["integer", "string"]}, "tests": [ { "description": "an integer is valid", "data": 1, "valid": true }, { "description": "a string is valid", "data": "foo", "valid": true }, { "description": "a float is invalid", "data": 1.1, "valid": false }, { "description": "an object is invalid", "data": {}, "valid": false }, { "description": "an array is invalid", "data": [], "valid": false }, { "description": "a boolean is invalid", "data": true, "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type as array with one item", "schema": { "type": ["string"] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is invalid", "data": 123, "valid": false } ] }, { "description": "type: array or object", "schema": { "type": ["array", "object"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type: array, object or null", "schema": { "type": ["array", "object", "null"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft4/uniqueItems.json000066400000000000000000000314011426774651400272060ustar00rootroot00000000000000[ { "description": "uniqueItems validation", "schema": {"uniqueItems": true}, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is invalid", "data": [1, 1], "valid": false }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": false }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is invalid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": false }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is invalid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": false }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is invalid", "data": [["foo"], ["foo"]], "valid": false }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "[1] and [true] are unique", "data": [[1], [true]], "valid": true }, { "description": "[0] and [false] are unique", "data": [[0], [false]], "valid": true }, { "description": "nested [1] and [true] are unique", "data": [[[1], "foo"], [[true], "foo"]], "valid": true }, { "description": "nested [0] and [false] are unique", "data": [[[0], "foo"], [[false], "foo"]], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1, "{}"], "valid": true }, { "description": "non-unique heterogeneous types are invalid", "data": [{}, [1], true, null, {}, 1], "valid": false }, { "description": "different objects are unique", "data": [{"a": 1, "b": 2}, {"a": 2, "b": 1}], "valid": true }, { "description": "objects are non-unique despite key order", "data": [{"a": 1, "b": 2}, {"b": 2, "a": 1}], "valid": false }, { "description": "{\"a\": false} and {\"a\": 0} are unique", "data": [{"a": false}, {"a": 0}], "valid": true }, { "description": "{\"a\": true} and {\"a\": 1} are unique", "data": [{"a": true}, {"a": 1}], "valid": true } ] }, { "description": "uniqueItems with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is not valid", "data": [false, true, "foo", "foo"], "valid": false }, { "description": "non-unique array extended from [true, false] is not valid", "data": [true, false, "foo", "foo"], "valid": false } ] }, { "description": "uniqueItems with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] }, { "description": "uniqueItems=false validation", "schema": { "uniqueItems": false }, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is valid", "data": [1, 1], "valid": true }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": true }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": true }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": true }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is valid", "data": [["foo"], ["foo"]], "valid": true }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1], "valid": true }, { "description": "non-unique heterogeneous types are valid", "data": [{}, [1], true, null, {}, 1], "valid": true } ] }, { "description": "uniqueItems=false with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is valid", "data": [false, true, "foo", "foo"], "valid": true }, { "description": "non-unique array extended from [true, false] is valid", "data": [true, false, "foo", "foo"], "valid": true } ] }, { "description": "uniqueItems=false with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/000077500000000000000000000000001426774651400240065ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/additionalItems.json000066400000000000000000000103731426774651400300170ustar00rootroot00000000000000[ { "description": "additionalItems as schema", "schema": { "items": [{}], "additionalItems": {"type": "integer"} }, "tests": [ { "description": "additional items match schema", "data": [ null, 2, 3, 4 ], "valid": true }, { "description": "additional items do not match schema", "data": [ null, 2, 3, "foo" ], "valid": false } ] }, { "description": "when items is schema, additionalItems does nothing", "schema": { "items": {}, "additionalItems": false }, "tests": [ { "description": "all items match schema", "data": [ 1, 2, 3, 4, 5 ], "valid": true } ] }, { "description": "array of items with no additionalItems permitted", "schema": { "items": [{}, {}, {}], "additionalItems": false }, "tests": [ { "description": "empty array", "data": [ ], "valid": true }, { "description": "fewer number of items present (1)", "data": [ 1 ], "valid": true }, { "description": "fewer number of items present (2)", "data": [ 1, 2 ], "valid": true }, { "description": "equal number of items present", "data": [ 1, 2, 3 ], "valid": true }, { "description": "additional items are not permitted", "data": [ 1, 2, 3, 4 ], "valid": false } ] }, { "description": "additionalItems as false without items", "schema": {"additionalItems": false}, "tests": [ { "description": "items defaults to empty schema so everything is valid", "data": [ 1, 2, 3, 4, 5 ], "valid": true }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true } ] }, { "description": "additionalItems are allowed by default", "schema": {"items": [{"type": "integer"}]}, "tests": [ { "description": "only the first item is validated", "data": [1, "foo", false], "valid": true } ] }, { "description": "additionalItems should not look in applicators, valid case", "schema": { "allOf": [ { "items": [ { "type": "integer" } ] } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, null ], "valid": true } ] }, { "description": "additionalItems should not look in applicators, invalid case", "schema": { "allOf": [ { "items": [ { "type": "integer" }, { "type": "string" } ] } ], "items": [ {"type": "integer" } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, "hello" ], "valid": false } ] }, { "description": "items validation adjusts the starting index for additionalItems", "schema": { "items": [ { "type": "string" } ], "additionalItems": { "type": "integer" } }, "tests": [ { "description": "valid items", "data": [ "x", 2, 3 ], "valid": true }, { "description": "wrong type of second item", "data": [ "x", "y" ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/additionalProperties.json000066400000000000000000000077541426774651400311030ustar00rootroot00000000000000[ { "description": "additionalProperties being false does not allow other properties", "schema": { "properties": {"foo": {}, "bar": {}}, "patternProperties": { "^v": {} }, "additionalProperties": false }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : "boom"}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobarbaz", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true }, { "description": "patternProperties are not additional properties", "data": {"foo":1, "vroom": 2}, "valid": true } ] }, { "description": "non-ASCII pattern with additionalProperties", "schema": { "patternProperties": {"^á": {}}, "additionalProperties": false }, "tests": [ { "description": "matching the pattern is valid", "data": {"ármányos": 2}, "valid": true }, { "description": "not matching the pattern is invalid", "data": {"élmény": 2}, "valid": false } ] }, { "description": "additionalProperties allows a schema which should validate", "schema": { "properties": {"foo": {}, "bar": {}}, "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional valid property is valid", "data": {"foo" : 1, "bar" : 2, "quux" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : 12}, "valid": false } ] }, { "description": "additionalProperties can exist by itself", "schema": { "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "an additional valid property is valid", "data": {"foo" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1}, "valid": false } ] }, { "description": "additionalProperties are allowed by default", "schema": {"properties": {"foo": {}, "bar": {}}}, "tests": [ { "description": "additional properties are allowed", "data": {"foo": 1, "bar": 2, "quux": true}, "valid": true } ] }, { "description": "additionalProperties should not look in applicators", "schema": { "allOf": [ {"properties": {"foo": {}}} ], "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "properties defined in allOf are not examined", "data": {"foo": 1, "bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/allOf.json000066400000000000000000000171471426774651400257500ustar00rootroot00000000000000[ { "description": "allOf", "schema": { "allOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "allOf", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "mismatch second", "data": {"foo": "baz"}, "valid": false }, { "description": "mismatch first", "data": {"bar": 2}, "valid": false }, { "description": "wrong type", "data": {"foo": "baz", "bar": "quux"}, "valid": false } ] }, { "description": "allOf with base schema", "schema": { "properties": {"bar": {"type": "integer"}}, "required": ["bar"], "allOf" : [ { "properties": { "foo": {"type": "string"} }, "required": ["foo"] }, { "properties": { "baz": {"type": "null"} }, "required": ["baz"] } ] }, "tests": [ { "description": "valid", "data": {"foo": "quux", "bar": 2, "baz": null}, "valid": true }, { "description": "mismatch base schema", "data": {"foo": "quux", "baz": null}, "valid": false }, { "description": "mismatch first allOf", "data": {"bar": 2, "baz": null}, "valid": false }, { "description": "mismatch second allOf", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "mismatch both", "data": {"bar": 2}, "valid": false } ] }, { "description": "allOf simple types", "schema": { "allOf": [ {"maximum": 30}, {"minimum": 20} ] }, "tests": [ { "description": "valid", "data": 25, "valid": true }, { "description": "mismatch one", "data": 35, "valid": false } ] }, { "description": "allOf with boolean schemas, all true", "schema": {"allOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "allOf with boolean schemas, some false", "schema": {"allOf": [true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with boolean schemas, all false", "schema": {"allOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with one empty schema", "schema": { "allOf": [ {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with two empty schemas", "schema": { "allOf": [ {}, {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with the first empty schema", "schema": { "allOf": [ {}, { "type": "number" } ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with the last empty schema", "schema": { "allOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "nested allOf, to check validation semantics", "schema": { "allOf": [ { "allOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "allOf combined with anyOf, oneOf", "schema": { "allOf": [ { "multipleOf": 2 } ], "anyOf": [ { "multipleOf": 3 } ], "oneOf": [ { "multipleOf": 5 } ] }, "tests": [ { "description": "allOf: false, anyOf: false, oneOf: false", "data": 1, "valid": false }, { "description": "allOf: false, anyOf: false, oneOf: true", "data": 5, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: false", "data": 3, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: true", "data": 15, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: false", "data": 2, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: true", "data": 10, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: false", "data": 6, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: true", "data": 30, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/anyOf.json000066400000000000000000000125471426774651400257660ustar00rootroot00000000000000[ { "description": "anyOf", "schema": { "anyOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first anyOf valid", "data": 1, "valid": true }, { "description": "second anyOf valid", "data": 2.5, "valid": true }, { "description": "both anyOf valid", "data": 3, "valid": true }, { "description": "neither anyOf valid", "data": 1.5, "valid": false } ] }, { "description": "anyOf with base schema", "schema": { "type": "string", "anyOf" : [ { "maxLength": 2 }, { "minLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one anyOf valid", "data": "foobar", "valid": true }, { "description": "both anyOf invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf with boolean schemas, all true", "schema": {"anyOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, some true", "schema": {"anyOf": [true, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, all false", "schema": {"anyOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf complex types", "schema": { "anyOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first anyOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second anyOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both anyOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "neither anyOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "anyOf with one empty schema", "schema": { "anyOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is valid", "data": 123, "valid": true } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/boolean_schema.json000066400000000000000000000054021426774651400276410ustar00rootroot00000000000000[ { "description": "boolean schema 'true'", "schema": true, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is valid", "data": "foo", "valid": true }, { "description": "boolean true is valid", "data": true, "valid": true }, { "description": "boolean false is valid", "data": false, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "object is valid", "data": {"foo": "bar"}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true }, { "description": "array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "boolean schema 'false'", "schema": false, "tests": [ { "description": "number is invalid", "data": 1, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "boolean true is invalid", "data": true, "valid": false }, { "description": "boolean false is invalid", "data": false, "valid": false }, { "description": "null is invalid", "data": null, "valid": false }, { "description": "object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/const.json000066400000000000000000000225641426774651400260400ustar00rootroot00000000000000[ { "description": "const validation", "schema": {"const": 2}, "tests": [ { "description": "same value is valid", "data": 2, "valid": true }, { "description": "another value is invalid", "data": 5, "valid": false }, { "description": "another type is invalid", "data": "a", "valid": false } ] }, { "description": "const with object", "schema": {"const": {"foo": "bar", "baz": "bax"}}, "tests": [ { "description": "same object is valid", "data": {"foo": "bar", "baz": "bax"}, "valid": true }, { "description": "same object with different property order is valid", "data": {"baz": "bax", "foo": "bar"}, "valid": true }, { "description": "another object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "another type is invalid", "data": [1, 2], "valid": false } ] }, { "description": "const with array", "schema": {"const": [{ "foo": "bar" }]}, "tests": [ { "description": "same array is valid", "data": [{"foo": "bar"}], "valid": true }, { "description": "another array item is invalid", "data": [2], "valid": false }, { "description": "array with additional items is invalid", "data": [1, 2, 3], "valid": false } ] }, { "description": "const with null", "schema": {"const": null}, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "not null is invalid", "data": 0, "valid": false } ] }, { "description": "const with false does not match 0", "schema": {"const": false}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "const with true does not match 1", "schema": {"const": true}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "const with [false] does not match [0]", "schema": {"const": [false]}, "tests": [ { "description": "[false] is valid", "data": [false], "valid": true }, { "description": "[0] is invalid", "data": [0], "valid": false }, { "description": "[0.0] is invalid", "data": [0.0], "valid": false } ] }, { "description": "const with [true] does not match [1]", "schema": {"const": [true]}, "tests": [ { "description": "[true] is valid", "data": [true], "valid": true }, { "description": "[1] is invalid", "data": [1], "valid": false }, { "description": "[1.0] is invalid", "data": [1.0], "valid": false } ] }, { "description": "const with {\"a\": false} does not match {\"a\": 0}", "schema": {"const": {"a": false}}, "tests": [ { "description": "{\"a\": false} is valid", "data": {"a": false}, "valid": true }, { "description": "{\"a\": 0} is invalid", "data": {"a": 0}, "valid": false }, { "description": "{\"a\": 0.0} is invalid", "data": {"a": 0.0}, "valid": false } ] }, { "description": "const with {\"a\": true} does not match {\"a\": 1}", "schema": {"const": {"a": true}}, "tests": [ { "description": "{\"a\": true} is valid", "data": {"a": true}, "valid": true }, { "description": "{\"a\": 1} is invalid", "data": {"a": 1}, "valid": false }, { "description": "{\"a\": 1.0} is invalid", "data": {"a": 1.0}, "valid": false } ] }, { "description": "const with 0 does not match other zero-like types", "schema": {"const": 0}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "empty string is invalid", "data": "", "valid": false } ] }, { "description": "const with 1 does not match true", "schema": {"const": 1}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "const with -2.0 matches integer and float types", "schema": {"const": -2.0}, "tests": [ { "description": "integer -2 is valid", "data": -2, "valid": true }, { "description": "integer 2 is invalid", "data": 2, "valid": false }, { "description": "float -2.0 is valid", "data": -2.0, "valid": true }, { "description": "float 2.0 is invalid", "data": 2.0, "valid": false }, { "description": "float -2.00001 is invalid", "data": -2.00001, "valid": false } ] }, { "description": "float and integers are equal up to 64-bit representation limits", "schema": {"const": 9007199254740992}, "tests": [ { "description": "integer is valid", "data": 9007199254740992, "valid": true }, { "description": "integer minus one is invalid", "data": 9007199254740991, "valid": false }, { "description": "float is valid", "data": 9007199254740992.0, "valid": true }, { "description": "float minus one is invalid", "data": 9007199254740991.0, "valid": false } ] }, { "description": "nul characters in strings", "schema": { "const": "hello\u0000there" }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/contains.json000066400000000000000000000102721426774651400265210ustar00rootroot00000000000000[ { "description": "contains keyword validation", "schema": { "contains": {"minimum": 5} }, "tests": [ { "description": "array with item matching schema (5) is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with item matching schema (6) is valid", "data": [3, 4, 6], "valid": true }, { "description": "array with two items matching schema (5, 6) is valid", "data": [3, 4, 5, 6], "valid": true }, { "description": "array without items matching schema is invalid", "data": [2, 3, 4], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "not array is valid", "data": {}, "valid": true } ] }, { "description": "contains keyword with const keyword", "schema": { "contains": { "const": 5 } }, "tests": [ { "description": "array with item 5 is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with two items 5 is valid", "data": [3, 4, 5, 5], "valid": true }, { "description": "array without item 5 is invalid", "data": [1, 2, 3, 4], "valid": false } ] }, { "description": "contains keyword with boolean schema true", "schema": {"contains": true}, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] }, { "description": "contains keyword with boolean schema false", "schema": {"contains": false}, "tests": [ { "description": "any non-empty array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "non-arrays are valid", "data": "contains does not apply to strings", "valid": true } ] }, { "description": "items + contains", "schema": { "items": { "multipleOf": 2 }, "contains": { "multipleOf": 3 } }, "tests": [ { "description": "matches items, does not match contains", "data": [ 2, 4, 8 ], "valid": false }, { "description": "does not match items, matches contains", "data": [ 3, 6, 9 ], "valid": false }, { "description": "matches both items and contains", "data": [ 6, 12 ], "valid": true }, { "description": "matches neither items nor contains", "data": [ 1, 5 ], "valid": false } ] }, { "description": "contains with false if subschema", "schema": { "contains": { "if": false, "else": true } }, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/default.json000066400000000000000000000042671426774651400263360ustar00rootroot00000000000000[ { "description": "invalid type for default", "schema": { "properties": { "foo": { "type": "integer", "default": [] } } }, "tests": [ { "description": "valid when property is specified", "data": {"foo": 13}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "invalid string value for default", "schema": { "properties": { "bar": { "type": "string", "minLength": 4, "default": "bad" } } }, "tests": [ { "description": "valid when property is specified", "data": {"bar": "good"}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "the default keyword does not do anything if the property is missing", "schema": { "type": "object", "properties": { "alpha": { "type": "number", "maximum": 3, "default": 5 } } }, "tests": [ { "description": "an explicit property value is checked against maximum (passing)", "data": { "alpha": 1 }, "valid": true }, { "description": "an explicit property value is checked against maximum (failing)", "data": { "alpha": 5 }, "valid": false }, { "description": "missing properties are not filled in with the default", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/definitions.json000066400000000000000000000013171426774651400272160ustar00rootroot00000000000000[ { "description": "validate definition against metaschema", "schema": {"$ref": "http://json-schema.org/draft-06/schema#"}, "tests": [ { "description": "valid definition schema", "data": { "definitions": { "foo": {"type": "integer"} } }, "valid": true }, { "description": "invalid definition schema", "data": { "definitions": { "foo": {"type": 1} } }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/dependencies.json000066400000000000000000000153341426774651400273350ustar00rootroot00000000000000[ { "description": "dependencies", "schema": { "dependencies": {"bar": ["foo"]} }, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependant", "data": {"foo": 1}, "valid": true }, { "description": "with dependency", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "missing dependency", "data": {"bar": 2}, "valid": false }, { "description": "ignores arrays", "data": ["bar"], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "dependencies with empty array", "schema": { "dependencies": {"bar": []} }, "tests": [ { "description": "empty object", "data": {}, "valid": true }, { "description": "object with one property", "data": {"bar": 2}, "valid": true }, { "description": "non-object is valid", "data": 1, "valid": true } ] }, { "description": "multiple dependencies", "schema": { "dependencies": {"quux": ["foo", "bar"]} }, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependants", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "with dependencies", "data": {"foo": 1, "bar": 2, "quux": 3}, "valid": true }, { "description": "missing dependency", "data": {"foo": 1, "quux": 2}, "valid": false }, { "description": "missing other dependency", "data": {"bar": 1, "quux": 2}, "valid": false }, { "description": "missing both dependencies", "data": {"quux": 1}, "valid": false } ] }, { "description": "multiple dependencies subschema", "schema": { "dependencies": { "bar": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "integer"} } } } }, "tests": [ { "description": "valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "no dependency", "data": {"foo": "quux"}, "valid": true }, { "description": "wrong type", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "wrong type other", "data": {"foo": 2, "bar": "quux"}, "valid": false }, { "description": "wrong type both", "data": {"foo": "quux", "bar": "quux"}, "valid": false } ] }, { "description": "dependencies with boolean subschemas", "schema": { "dependencies": { "foo": true, "bar": false } }, "tests": [ { "description": "object with property having schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property having schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "dependencies with escaped characters", "schema": { "dependencies": { "foo\nbar": ["foo\rbar"], "foo\tbar": { "minProperties": 4 }, "foo'bar": {"required": ["foo\"bar"]}, "foo\"bar": ["foo'bar"] } }, "tests": [ { "description": "valid object 1", "data": { "foo\nbar": 1, "foo\rbar": 2 }, "valid": true }, { "description": "valid object 2", "data": { "foo\tbar": 1, "a": 2, "b": 3, "c": 4 }, "valid": true }, { "description": "valid object 3", "data": { "foo'bar": 1, "foo\"bar": 2 }, "valid": true }, { "description": "invalid object 1", "data": { "foo\nbar": 1, "foo": 2 }, "valid": false }, { "description": "invalid object 2", "data": { "foo\tbar": 1, "a": 2 }, "valid": false }, { "description": "invalid object 3", "data": { "foo'bar": 1 }, "valid": false }, { "description": "invalid object 4", "data": { "foo\"bar": 2 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/enum.json000066400000000000000000000146431426774651400256550ustar00rootroot00000000000000[ { "description": "simple enum validation", "schema": {"enum": [1, 2, 3]}, "tests": [ { "description": "one of the enum is valid", "data": 1, "valid": true }, { "description": "something else is invalid", "data": 4, "valid": false } ] }, { "description": "heterogeneous enum validation", "schema": {"enum": [6, "foo", [], true, {"foo": 12}]}, "tests": [ { "description": "one of the enum is valid", "data": [], "valid": true }, { "description": "something else is invalid", "data": null, "valid": false }, { "description": "objects are deep compared", "data": {"foo": false}, "valid": false }, { "description": "valid object matches", "data": {"foo": 12}, "valid": true }, { "description": "extra properties in object is invalid", "data": {"foo": 12, "boo": 42}, "valid": false } ] }, { "description": "heterogeneous enum-with-null validation", "schema": { "enum": [6, null] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "number is valid", "data": 6, "valid": true }, { "description": "something else is invalid", "data": "test", "valid": false } ] }, { "description": "enums in properties", "schema": { "type":"object", "properties": { "foo": {"enum":["foo"]}, "bar": {"enum":["bar"]} }, "required": ["bar"] }, "tests": [ { "description": "both properties are valid", "data": {"foo":"foo", "bar":"bar"}, "valid": true }, { "description": "wrong foo value", "data": {"foo":"foot", "bar":"bar"}, "valid": false }, { "description": "wrong bar value", "data": {"foo":"foo", "bar":"bart"}, "valid": false }, { "description": "missing optional property is valid", "data": {"bar":"bar"}, "valid": true }, { "description": "missing required property is invalid", "data": {"foo":"foo"}, "valid": false }, { "description": "missing all properties is invalid", "data": {}, "valid": false } ] }, { "description": "enum with escaped characters", "schema": { "enum": ["foo\nbar", "foo\rbar"] }, "tests": [ { "description": "member 1 is valid", "data": "foo\nbar", "valid": true }, { "description": "member 2 is valid", "data": "foo\rbar", "valid": true }, { "description": "another string is invalid", "data": "abc", "valid": false } ] }, { "description": "enum with false does not match 0", "schema": {"enum": [false]}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "enum with true does not match 1", "schema": {"enum": [true]}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "enum with 0 does not match false", "schema": {"enum": [0]}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true } ] }, { "description": "enum with 1 does not match true", "schema": {"enum": [1]}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "nul characters in strings", "schema": { "enum": [ "hello\u0000there" ] }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/exclusiveMaximum.json000066400000000000000000000014071426774651400302500ustar00rootroot00000000000000[ { "description": "exclusiveMaximum validation", "schema": { "exclusiveMaximum": 3.0 }, "tests": [ { "description": "below the exclusiveMaximum is valid", "data": 2.2, "valid": true }, { "description": "boundary point is invalid", "data": 3.0, "valid": false }, { "description": "above the exclusiveMaximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/exclusiveMinimum.json000066400000000000000000000014071426774651400302460ustar00rootroot00000000000000[ { "description": "exclusiveMinimum validation", "schema": { "exclusiveMinimum": 1.1 }, "tests": [ { "description": "above the exclusiveMinimum is valid", "data": 1.2, "valid": true }, { "description": "boundary point is invalid", "data": 1.1, "valid": false }, { "description": "below the exclusiveMinimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/format.json000066400000000000000000000225251426774651400261770ustar00rootroot00000000000000[ { "description": "email format", "schema": { "format": "email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "ipv4 format", "schema": { "format": "ipv4" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "ipv6 format", "schema": { "format": "ipv6" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "hostname format", "schema": { "format": "hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "date-time format", "schema": { "format": "date-time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "json-pointer format", "schema": { "format": "json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri format", "schema": { "format": "uri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri-reference format", "schema": { "format": "uri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri-template format", "schema": { "format": "uri-template" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/id.json000066400000000000000000000033121426774651400252740ustar00rootroot00000000000000[ { "description": "id inside an enum is not a real identifier", "comment": "the implementation must not be confused by an id buried in the enum", "schema": { "definitions": { "id_in_enum": { "enum": [ { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } ] }, "real_id_in_schema": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "string" }, "zzz_id_in_const": { "const": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } } }, "anyOf": [ { "$ref": "#/definitions/id_in_enum" }, { "$ref": "https://localhost:1234/id/my_identifier.json" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" }, "valid": true }, { "description": "match $ref to id", "data": "a string to match #/definitions/id_in_enum", "valid": true }, { "description": "no match on enum or $ref to id", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/infinite-loop-detection.json000066400000000000000000000017461426774651400314410ustar00rootroot00000000000000[ { "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", "schema": { "definitions": { "int": { "type": "integer" } }, "allOf": [ { "properties": { "foo": { "$ref": "#/definitions/int" } } }, { "additionalProperties": { "$ref": "#/definitions/int" } } ] }, "tests": [ { "description": "passing case", "data": { "foo": 1 }, "valid": true }, { "description": "failing case", "data": { "foo": "a string" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/items.json000066400000000000000000000162251426774651400260300ustar00rootroot00000000000000[ { "description": "a schema given for items", "schema": { "items": {"type": "integer"} }, "tests": [ { "description": "valid items", "data": [ 1, 2, 3 ], "valid": true }, { "description": "wrong type of items", "data": [1, "x"], "valid": false }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "length": 1 }, "valid": true } ] }, { "description": "an array of schemas for items", "schema": { "items": [ {"type": "integer"}, {"type": "string"} ] }, "tests": [ { "description": "correct types", "data": [ 1, "foo" ], "valid": true }, { "description": "wrong types", "data": [ "foo", 1 ], "valid": false }, { "description": "incomplete array of items", "data": [ 1 ], "valid": true }, { "description": "array with additional items", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array", "data": [ ], "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "1": "valid", "length": 2 }, "valid": true } ] }, { "description": "items with boolean schema (true)", "schema": {"items": true}, "tests": [ { "description": "any array is valid", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schema (false)", "schema": {"items": false}, "tests": [ { "description": "any non-empty array is invalid", "data": [ 1, "foo", true ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schemas", "schema": { "items": [true, false] }, "tests": [ { "description": "array with one item is valid", "data": [ 1 ], "valid": true }, { "description": "array with two items is invalid", "data": [ 1, "foo" ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items and subitems", "schema": { "definitions": { "item": { "type": "array", "additionalItems": false, "items": [ { "$ref": "#/definitions/sub-item" }, { "$ref": "#/definitions/sub-item" } ] }, "sub-item": { "type": "object", "required": ["foo"] } }, "type": "array", "additionalItems": false, "items": [ { "$ref": "#/definitions/item" }, { "$ref": "#/definitions/item" }, { "$ref": "#/definitions/item" } ] }, "tests": [ { "description": "valid items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": true }, { "description": "too many items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "too many sub-items", "data": [ [ {"foo": null}, {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong item", "data": [ {"foo": null}, [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong sub-item", "data": [ [ {}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "fewer items is valid", "data": [ [ {"foo": null} ], [ {"foo": null} ] ], "valid": true } ] }, { "description": "nested items", "schema": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "number" } } } } }, "tests": [ { "description": "valid nested array", "data": [[[[1]], [[2],[3]]], [[[4], [5], [6]]]], "valid": true }, { "description": "nested array with invalid type", "data": [[[["1"]], [[2],[3]]], [[[4], [5], [6]]]], "valid": false }, { "description": "not deep enough", "data": [[[1], [2],[3]], [[4], [5], [6]]], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/maxItems.json000066400000000000000000000013021426774651400264640ustar00rootroot00000000000000[ { "description": "maxItems validation", "schema": {"maxItems": 2}, "tests": [ { "description": "shorter is valid", "data": [1], "valid": true }, { "description": "exact length is valid", "data": [1, 2], "valid": true }, { "description": "too long is invalid", "data": [1, 2, 3], "valid": false }, { "description": "ignores non-arrays", "data": "foobar", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/maxLength.json000066400000000000000000000016001426774651400266250ustar00rootroot00000000000000[ { "description": "maxLength validation", "schema": {"maxLength": 2}, "tests": [ { "description": "shorter is valid", "data": "f", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too long is invalid", "data": "foo", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true }, { "description": "two supplementary Unicode code points is long enough", "data": "\uD83D\uDCA9\uD83D\uDCA9", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/maxProperties.json000066400000000000000000000027321426774651400275470ustar00rootroot00000000000000[ { "description": "maxProperties validation", "schema": {"maxProperties": 2}, "tests": [ { "description": "shorter is valid", "data": {"foo": 1}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "too long is invalid", "data": {"foo": 1, "bar": 2, "baz": 3}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "maxProperties = 0 means the object is empty", "schema": { "maxProperties": 0 }, "tests": [ { "description": "no properties is valid", "data": {}, "valid": true }, { "description": "one property is invalid", "data": { "foo": 1 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/maximum.json000066400000000000000000000027041426774651400263610ustar00rootroot00000000000000[ { "description": "maximum validation", "schema": {"maximum": 3.0}, "tests": [ { "description": "below the maximum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 3.0, "valid": true }, { "description": "above the maximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "maximum validation with unsigned integer", "schema": {"maximum": 300}, "tests": [ { "description": "below the maximum is invalid", "data": 299.97, "valid": true }, { "description": "boundary point integer is valid", "data": 300, "valid": true }, { "description": "boundary point float is valid", "data": 300.00, "valid": true }, { "description": "above the maximum is invalid", "data": 300.5, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/minItems.json000066400000000000000000000012651426774651400264720ustar00rootroot00000000000000[ { "description": "minItems validation", "schema": {"minItems": 1}, "tests": [ { "description": "longer is valid", "data": [1, 2], "valid": true }, { "description": "exact length is valid", "data": [1], "valid": true }, { "description": "too short is invalid", "data": [], "valid": false }, { "description": "ignores non-arrays", "data": "", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/minLength.json000066400000000000000000000015661426774651400266360ustar00rootroot00000000000000[ { "description": "minLength validation", "schema": {"minLength": 2}, "tests": [ { "description": "longer is valid", "data": "foo", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too short is invalid", "data": "f", "valid": false }, { "description": "ignores non-strings", "data": 1, "valid": true }, { "description": "one supplementary Unicode code point is not long enough", "data": "\uD83D\uDCA9", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/minProperties.json000066400000000000000000000017541426774651400275500ustar00rootroot00000000000000[ { "description": "minProperties validation", "schema": {"minProperties": 1}, "tests": [ { "description": "longer is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1}, "valid": true }, { "description": "too short is invalid", "data": {}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/minimum.json000066400000000000000000000036121426774651400263560ustar00rootroot00000000000000[ { "description": "minimum validation", "schema": {"minimum": 1.1}, "tests": [ { "description": "above the minimum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 1.1, "valid": true }, { "description": "below the minimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "minimum validation with signed integer", "schema": {"minimum": -2}, "tests": [ { "description": "negative above the minimum is valid", "data": -1, "valid": true }, { "description": "positive above the minimum is valid", "data": 0, "valid": true }, { "description": "boundary point is valid", "data": -2, "valid": true }, { "description": "boundary point with float is valid", "data": -2.0, "valid": true }, { "description": "float below the minimum is invalid", "data": -2.0001, "valid": false }, { "description": "int below the minimum is invalid", "data": -3, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/multipleOf.json000066400000000000000000000035771426774651400270350ustar00rootroot00000000000000[ { "description": "by int", "schema": {"multipleOf": 2}, "tests": [ { "description": "int by int", "data": 10, "valid": true }, { "description": "int by int fail", "data": 7, "valid": false }, { "description": "ignores non-numbers", "data": "foo", "valid": true } ] }, { "description": "by number", "schema": {"multipleOf": 1.5}, "tests": [ { "description": "zero is multiple of anything", "data": 0, "valid": true }, { "description": "4.5 is multiple of 1.5", "data": 4.5, "valid": true }, { "description": "35 is not multiple of 1.5", "data": 35, "valid": false } ] }, { "description": "by small number", "schema": {"multipleOf": 0.0001}, "tests": [ { "description": "0.0075 is multiple of 0.0001", "data": 0.0075, "valid": true }, { "description": "0.00751 is not multiple of 0.0001", "data": 0.00751, "valid": false } ] }, { "description": "invalid instance should not raise error when float division = inf", "schema": {"type": "integer", "multipleOf": 0.123456789}, "tests": [ { "description": "always invalid, but naive implementations may raise an overflow error", "data": 1e308, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/not.json000066400000000000000000000053761426774651400255140ustar00rootroot00000000000000[ { "description": "not", "schema": { "not": {"type": "integer"} }, "tests": [ { "description": "allowed", "data": "foo", "valid": true }, { "description": "disallowed", "data": 1, "valid": false } ] }, { "description": "not multiple types", "schema": { "not": {"type": ["integer", "boolean"]} }, "tests": [ { "description": "valid", "data": "foo", "valid": true }, { "description": "mismatch", "data": 1, "valid": false }, { "description": "other mismatch", "data": true, "valid": false } ] }, { "description": "not more complex schema", "schema": { "not": { "type": "object", "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "match", "data": 1, "valid": true }, { "description": "other match", "data": {"foo": 1}, "valid": true }, { "description": "mismatch", "data": {"foo": "bar"}, "valid": false } ] }, { "description": "forbidden property", "schema": { "properties": { "foo": { "not": {} } } }, "tests": [ { "description": "property present", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "property absent", "data": {"bar": 1, "baz": 2}, "valid": true } ] }, { "description": "not with boolean schema true", "schema": {"not": true}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "not with boolean schema false", "schema": {"not": false}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/oneOf.json000066400000000000000000000161231426774651400257520ustar00rootroot00000000000000[ { "description": "oneOf", "schema": { "oneOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first oneOf valid", "data": 1, "valid": true }, { "description": "second oneOf valid", "data": 2.5, "valid": true }, { "description": "both oneOf valid", "data": 3, "valid": false }, { "description": "neither oneOf valid", "data": 1.5, "valid": false } ] }, { "description": "oneOf with base schema", "schema": { "type": "string", "oneOf" : [ { "minLength": 2 }, { "maxLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one oneOf valid", "data": "foobar", "valid": true }, { "description": "both oneOf valid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all true", "schema": {"oneOf": [true, true, true]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, one true", "schema": {"oneOf": [true, false, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "oneOf with boolean schemas, more than one true", "schema": {"oneOf": [true, true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all false", "schema": {"oneOf": [false, false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf complex types", "schema": { "oneOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second oneOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both oneOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": false }, { "description": "neither oneOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "oneOf with empty schema", "schema": { "oneOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "one valid - valid", "data": "foo", "valid": true }, { "description": "both valid - invalid", "data": 123, "valid": false } ] }, { "description": "oneOf with required", "schema": { "type": "object", "oneOf": [ { "required": ["foo", "bar"] }, { "required": ["foo", "baz"] } ] }, "tests": [ { "description": "both invalid - invalid", "data": {"bar": 2}, "valid": false }, { "description": "first valid - valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "second valid - valid", "data": {"foo": 1, "baz": 3}, "valid": true }, { "description": "both valid - invalid", "data": {"foo": 1, "bar": 2, "baz" : 3}, "valid": false } ] }, { "description": "oneOf with missing optional property", "schema": { "oneOf": [ { "properties": { "bar": true, "baz": true }, "required": ["bar"] }, { "properties": { "foo": true }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid", "data": {"bar": 8}, "valid": true }, { "description": "second oneOf valid", "data": {"foo": "foo"}, "valid": true }, { "description": "both oneOf valid", "data": {"foo": "foo", "bar": 8}, "valid": false }, { "description": "neither oneOf valid", "data": {"baz": "quux"}, "valid": false } ] }, { "description": "nested oneOf, to check validation semantics", "schema": { "oneOf": [ { "oneOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/000077500000000000000000000000001426774651400256335ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/bignum.json000066400000000000000000000057111426774651400300130ustar00rootroot00000000000000[ { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a bignum is an integer", "data": 12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a bignum is a number", "data": 98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a negative bignum is an integer", "data": -12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a negative bignum is a number", "data": -98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "string", "schema": {"type": "string"}, "tests": [ { "description": "a bignum is not a string", "data": 98249283749234923498293171823948729348710298301928331, "valid": false } ] }, { "description": "integer comparison", "schema": {"maximum": 18446744073709551615}, "tests": [ { "description": "comparison works for high numbers", "data": 18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision", "schema": { "exclusiveMaximum": 972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for high numbers", "data": 972783798187987123879878123.188781371, "valid": false } ] }, { "description": "integer comparison", "schema": {"minimum": -18446744073709551615}, "tests": [ { "description": "comparison works for very negative numbers", "data": -18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision on negative numbers", "schema": { "exclusiveMinimum": -972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for very negative numbers", "data": -972783798187987123879878123.188781371, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/ecmascript-regex.json000066400000000000000000000202161426774651400317710ustar00rootroot00000000000000[ { "description": "ECMA 262 regex $ does not match trailing newline", "schema": { "type": "string", "pattern": "^abc$" }, "tests": [ { "description": "matches in Python, but should not in jsonschema", "data": "abc\n", "valid": false }, { "description": "should match", "data": "abc", "valid": true } ] }, { "description": "ECMA 262 regex converts \\t to horizontal tab", "schema": { "type": "string", "pattern": "^\\t$" }, "tests": [ { "description": "does not match", "data": "\\t", "valid": false }, { "description": "matches", "data": "\u0009", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and upper letter", "schema": { "type": "string", "pattern": "^\\cC$" }, "tests": [ { "description": "does not match", "data": "\\cC", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and lower letter", "schema": { "type": "string", "pattern": "^\\cc$" }, "tests": [ { "description": "does not match", "data": "\\cc", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 \\d matches ascii digits only", "schema": { "type": "string", "pattern": "^\\d$" }, "tests": [ { "description": "ASCII zero matches", "data": "0", "valid": true }, { "description": "NKO DIGIT ZERO does not match (unlike e.g. Python)", "data": "߀", "valid": false }, { "description": "NKO DIGIT ZERO (as \\u escape) does not match", "data": "\u07c0", "valid": false } ] }, { "description": "ECMA 262 \\D matches everything but ascii digits", "schema": { "type": "string", "pattern": "^\\D$" }, "tests": [ { "description": "ASCII zero does not match", "data": "0", "valid": false }, { "description": "NKO DIGIT ZERO matches (unlike e.g. Python)", "data": "߀", "valid": true }, { "description": "NKO DIGIT ZERO (as \\u escape) matches", "data": "\u07c0", "valid": true } ] }, { "description": "ECMA 262 \\w matches ascii letters only", "schema": { "type": "string", "pattern": "^\\w$" }, "tests": [ { "description": "ASCII 'a' matches", "data": "a", "valid": true }, { "description": "latin-1 e-acute does not match (unlike e.g. Python)", "data": "é", "valid": false } ] }, { "description": "ECMA 262 \\W matches everything but ascii letters", "schema": { "type": "string", "pattern": "^\\W$" }, "tests": [ { "description": "ASCII 'a' does not match", "data": "a", "valid": false }, { "description": "latin-1 e-acute matches (unlike e.g. Python)", "data": "é", "valid": true } ] }, { "description": "ECMA 262 \\s matches whitespace", "schema": { "type": "string", "pattern": "^\\s$" }, "tests": [ { "description": "ASCII space matches", "data": " ", "valid": true }, { "description": "Character tabulation matches", "data": "\t", "valid": true }, { "description": "Line tabulation matches", "data": "\u000b", "valid": true }, { "description": "Form feed matches", "data": "\u000c", "valid": true }, { "description": "latin-1 non-breaking-space matches", "data": "\u00a0", "valid": true }, { "description": "zero-width whitespace matches", "data": "\ufeff", "valid": true }, { "description": "line feed matches (line terminator)", "data": "\u000a", "valid": true }, { "description": "paragraph separator matches (line terminator)", "data": "\u2029", "valid": true }, { "description": "EM SPACE matches (Space_Separator)", "data": "\u2003", "valid": true }, { "description": "Non-whitespace control does not match", "data": "\u0001", "valid": false }, { "description": "Non-whitespace does not match", "data": "\u2013", "valid": false } ] }, { "description": "ECMA 262 \\S matches everything but whitespace", "schema": { "type": "string", "pattern": "^\\S$" }, "tests": [ { "description": "ASCII space does not match", "data": " ", "valid": false }, { "description": "Character tabulation does not match", "data": "\t", "valid": false }, { "description": "Line tabulation does not match", "data": "\u000b", "valid": false }, { "description": "Form feed does not match", "data": "\u000c", "valid": false }, { "description": "latin-1 non-breaking-space does not match", "data": "\u00a0", "valid": false }, { "description": "zero-width whitespace does not match", "data": "\ufeff", "valid": false }, { "description": "line feed does not match (line terminator)", "data": "\u000a", "valid": false }, { "description": "paragraph separator does not match (line terminator)", "data": "\u2029", "valid": false }, { "description": "EM SPACE does not match (Space_Separator)", "data": "\u2003", "valid": false }, { "description": "Non-whitespace control matches", "data": "\u0001", "valid": true }, { "description": "Non-whitespace matches", "data": "\u2013", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/float-overflow.json000066400000000000000000000005511426774651400314750ustar00rootroot00000000000000[ { "description": "all integers are multiples of 0.5, if overflow is handled", "schema": {"type": "integer", "multipleOf": 0.5}, "tests": [ { "description": "valid if optional overflow handling is implemented", "data": 1e308, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/000077500000000000000000000000001426774651400271235ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/date-time.json000066400000000000000000000044501426774651400316720ustar00rootroot00000000000000[ { "description": "validation of date-time strings", "schema": {"format": "date-time"}, "tests": [ { "description": "a valid date-time string", "data": "1963-06-19T08:30:06.283185Z", "valid": true }, { "description": "a valid date-time string without second fraction", "data": "1963-06-19T08:30:06Z", "valid": true }, { "description": "a valid date-time string with plus offset", "data": "1937-01-01T12:00:27.87+00:20", "valid": true }, { "description": "a valid date-time string with minus offset", "data": "1990-12-31T15:59:50.123-08:00", "valid": true }, { "description": "a invalid day in date-time string", "data": "1990-02-31T15:59:60.123-08:00", "valid": false }, { "description": "an invalid offset in date-time string", "data": "1990-12-31T15:59:60-24:00", "valid": false }, { "description": "an invalid closing Z after time-zone offset", "data": "1963-06-19T08:30:06.28123+01:00Z", "valid": false }, { "description": "an invalid date-time string", "data": "06/19/1963 08:30:06 PST", "valid": false }, { "description": "case-insensitive T and Z", "data": "1963-06-19t08:30:06.283185z", "valid": true }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350T01:01:01", "valid": false }, { "description": "invalid non-padded month dates", "data": "1963-6-19T08:30:06.283185Z", "valid": false }, { "description": "invalid non-padded day dates", "data": "1963-06-1T08:30:06.283185Z", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/email.json000066400000000000000000000032331426774651400311060ustar00rootroot00000000000000[ { "description": "validation of e-mail addresses", "schema": {"format": "email"}, "tests": [ { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false }, { "description": "tilde in local part is valid", "data": "te~st@example.com", "valid": true }, { "description": "tilde before local part is valid", "data": "~test@example.com", "valid": true }, { "description": "tilde after local part is valid", "data": "test~@example.com", "valid": true }, { "description": "dot before local part is not valid", "data": ".test@example.com", "valid": false }, { "description": "dot after local part is not valid", "data": "test.@example.com", "valid": false }, { "description": "two separated dots inside local part are valid", "data": "te.s.t@example.com", "valid": true }, { "description": "two subsequent dots inside local part are not valid", "data": "te..st@example.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/hostname.json000066400000000000000000000040761426774651400316430ustar00rootroot00000000000000[ { "description": "validation of host names", "schema": {"format": "hostname"}, "tests": [ { "description": "a valid host name", "data": "www.example.com", "valid": true }, { "description": "a host name starting with an illegal character", "data": "-a-host-name-that-starts-with--", "valid": false }, { "description": "a host name containing illegal characters", "data": "not_a_valid_host_name", "valid": false }, { "description": "a host name with a component too long", "data": "a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component", "valid": false }, { "description": "starts with hyphen", "data": "-hostname", "valid": false }, { "description": "ends with hyphen", "data": "hostname-", "valid": false }, { "description": "starts with underscore", "data": "_hostname", "valid": false }, { "description": "ends with underscore", "data": "hostname_", "valid": false }, { "description": "contains underscore", "data": "host_name", "valid": false }, { "description": "maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com", "valid": true }, { "description": "exceeds maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/ipv4.json000066400000000000000000000032731426774651400307050ustar00rootroot00000000000000[ { "description": "validation of IP addresses", "schema": {"format": "ipv4"}, "tests": [ { "description": "a valid IP address", "data": "192.168.0.1", "valid": true }, { "description": "an IP address with too many components", "data": "127.0.0.0.1", "valid": false }, { "description": "an IP address with out-of-range values", "data": "256.256.256.256", "valid": false }, { "description": "an IP address without 4 components", "data": "127.0", "valid": false }, { "description": "an IP address as an integer", "data": "0x7f000001", "valid": false }, { "description": "an IP address as an integer (decimal)", "data": "2130706433", "valid": false }, { "description": "leading zeroes should be rejected, as they are treated as octals", "comment": "see https://sick.codes/universal-netmask-npm-package-used-by-270000-projects-vulnerable-to-octal-input-data-server-side-request-forgery-remote-file-inclusion-local-file-inclusion-and-more-cve-2021-28918/", "data": "087.10.0.1", "valid": false }, { "description": "value without leading zero is valid", "data": "87.10.0.1", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/ipv6.json000066400000000000000000000120111426774651400306750ustar00rootroot00000000000000[ { "description": "validation of IPv6 addresses", "schema": {"format": "ipv6"}, "tests": [ { "description": "a valid IPv6 address", "data": "::1", "valid": true }, { "description": "an IPv6 address with out-of-range values", "data": "12345::", "valid": false }, { "description": "an IPv6 address with too many components", "data": "1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1", "valid": false }, { "description": "an IPv6 address containing illegal characters", "data": "::laptop", "valid": false }, { "description": "no digits is valid", "data": "::", "valid": true }, { "description": "leading colons is valid", "data": "::42:ff:1", "valid": true }, { "description": "trailing colons is valid", "data": "d6::", "valid": true }, { "description": "missing leading octet is invalid", "data": ":2:3:4:5:6:7:8", "valid": false }, { "description": "missing trailing octet is invalid", "data": "1:2:3:4:5:6:7:", "valid": false }, { "description": "missing leading octet with omitted octets later", "data": ":2:3:4::8", "valid": false }, { "description": "two sets of double colons is invalid", "data": "1::d6::42", "valid": false }, { "description": "mixed format with the ipv4 section as decimal octets", "data": "1::d6:192.168.0.1", "valid": true }, { "description": "mixed format with double colons between the sections", "data": "1:2::192.168.0.1", "valid": true }, { "description": "mixed format with ipv4 section with octet out of range", "data": "1::2:192.168.256.1", "valid": false }, { "description": "mixed format with ipv4 section with a hex octet", "data": "1::2:192.168.ff.1", "valid": false }, { "description": "mixed format with leading double colons (ipv4-mapped ipv6 address)", "data": "::ffff:192.168.0.1", "valid": true }, { "description": "triple colons is invalid", "data": "1:2:3:4:5:::8", "valid": false }, { "description": "8 octets", "data": "1:2:3:4:5:6:7:8", "valid": true }, { "description": "insufficient octets without double colons", "data": "1:2:3:4:5:6:7", "valid": false }, { "description": "no colons is invalid", "data": "1", "valid": false }, { "description": "ipv4 is not ipv6", "data": "127.0.0.1", "valid": false }, { "description": "ipv4 segment must have 4 octets", "data": "1:2:3:4:1.2.3", "valid": false }, { "description": "leading whitespace is invalid", "data": " ::1", "valid": false }, { "description": "trailing whitespace is invalid", "data": "::1 ", "valid": false }, { "description": "netmask is not a part of ipv6 address", "data": "fe80::/64", "valid": false }, { "description": "zone id is not a part of ipv6 address", "data": "fe80::a%eth1", "valid": false }, { "description": "a long valid ipv6", "data": "1000:1000:1000:1000:1000:1000:255.255.255.255", "valid": true }, { "description": "a long invalid ipv6, below length limit, first", "data": "100:100:100:100:100:100:255.255.255.255.255", "valid": false }, { "description": "a long invalid ipv6, below length limit, second", "data": "100:100:100:100:100:100:100:255.255.255.255", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/json-pointer.json000066400000000000000000000132121426774651400324440ustar00rootroot00000000000000[ { "description": "validation of JSON-pointers (JSON String Representation)", "schema": {"format": "json-pointer"}, "tests": [ { "description": "a valid JSON-pointer", "data": "/foo/bar~0/baz~1/%a", "valid": true }, { "description": "not a valid JSON-pointer (~ not escaped)", "data": "/foo/bar~", "valid": false }, { "description": "valid JSON-pointer with empty segment", "data": "/foo//bar", "valid": true }, { "description": "valid JSON-pointer with the last empty segment", "data": "/foo/bar/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #1", "data": "", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #2", "data": "/foo", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #3", "data": "/foo/0", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #4", "data": "/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #5", "data": "/a~1b", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #6", "data": "/c%d", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #7", "data": "/e^f", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #8", "data": "/g|h", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #9", "data": "/i\\j", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #10", "data": "/k\"l", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #11", "data": "/ ", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #12", "data": "/m~0n", "valid": true }, { "description": "valid JSON-pointer used adding to the last array position", "data": "/foo/-", "valid": true }, { "description": "valid JSON-pointer (- used as object member name)", "data": "/foo/-/bar", "valid": true }, { "description": "valid JSON-pointer (multiple escaped characters)", "data": "/~1~0~0~1~1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #1", "data": "/~1.1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #2", "data": "/~0.1", "valid": true }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #1", "data": "#", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #2", "data": "#/", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #3", "data": "#a", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #1", "data": "/~0~", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #2", "data": "/~0/~", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #1", "data": "/~2", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #2", "data": "/~-1", "valid": false }, { "description": "not a valid JSON-pointer (multiple characters not escaped)", "data": "/~~", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #1", "data": "a", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #2", "data": "0", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #3", "data": "a/a", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/uri-reference.json000066400000000000000000000023661426774651400325600ustar00rootroot00000000000000[ { "description": "validation of URI References", "schema": {"format": "uri-reference"}, "tests": [ { "description": "a valid URI", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid relative URI Reference", "data": "/abc", "valid": true }, { "description": "an invalid URI Reference", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "a valid URI Reference", "data": "abc", "valid": true }, { "description": "a valid URI fragment", "data": "#fragment", "valid": true }, { "description": "an invalid URI fragment", "data": "#frag\\ment", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/uri-template.json000066400000000000000000000015601426774651400324300ustar00rootroot00000000000000[ { "description": "format: uri-template", "schema": {"format": "uri-template"}, "tests": [ { "description": "a valid uri-template", "data": "http://example.com/dictionary/{term:1}/{term}", "valid": true }, { "description": "an invalid uri-template", "data": "http://example.com/dictionary/{term:1}/{term", "valid": false }, { "description": "a valid uri-template without variables", "data": "http://example.com/dictionary", "valid": true }, { "description": "a valid relative uri-template", "data": "dictionary/{term:1}/{term}", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/format/uri.json000066400000000000000000000071631426774651400306240ustar00rootroot00000000000000[ { "description": "validation of URIs", "schema": {"format": "uri"}, "tests": [ { "description": "a valid URL with anchor tag", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid URL with anchor tag and parentheses", "data": "http://foo.com/blah_(wikipedia)_blah#cite-1", "valid": true }, { "description": "a valid URL with URL-encoded stuff", "data": "http://foo.bar/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid puny-coded URL ", "data": "http://xn--nw2a.xn--j6w193g/", "valid": true }, { "description": "a valid URL with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid URL based on IPv4", "data": "http://223.255.255.254", "valid": true }, { "description": "a valid URL with ftp scheme", "data": "ftp://ftp.is.co.za/rfc/rfc1808.txt", "valid": true }, { "description": "a valid URL for a simple text file", "data": "http://www.ietf.org/rfc/rfc2396.txt", "valid": true }, { "description": "a valid URL ", "data": "ldap://[2001:db8::7]/c=GB?objectClass?one", "valid": true }, { "description": "a valid mailto URI", "data": "mailto:John.Doe@example.com", "valid": true }, { "description": "a valid newsgroup URI", "data": "news:comp.infosystems.www.servers.unix", "valid": true }, { "description": "a valid tel URI", "data": "tel:+1-816-555-1212", "valid": true }, { "description": "a valid URN", "data": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", "valid": true }, { "description": "an invalid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": false }, { "description": "an invalid relative URI Reference", "data": "/abc", "valid": false }, { "description": "an invalid URI", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "an invalid URI though valid URI reference", "data": "abc", "valid": false }, { "description": "an invalid URI with spaces", "data": "http:// shouldfail.com", "valid": false }, { "description": "an invalid URI with spaces and missing scheme", "data": ":// should fail", "valid": false }, { "description": "an invalid URI with comma in scheme", "data": "bar,baz:foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/non-bmp-regex.json000066400000000000000000000045361426774651400312140ustar00rootroot00000000000000[ { "description": "Proper UTF-16 surrogate pair handling: pattern", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "pattern": "^🐲*$" }, "tests": [ { "description": "matches empty", "data": "", "valid": true }, { "description": "matches single", "data": "🐲", "valid": true }, { "description": "matches two", "data": "🐲🐲", "valid": true }, { "description": "doesn't match one", "data": "🐉", "valid": false }, { "description": "doesn't match two", "data": "🐉🐉", "valid": false }, { "description": "doesn't match one ASCII", "data": "D", "valid": false }, { "description": "doesn't match two ASCII", "data": "DD", "valid": false } ] }, { "description": "Proper UTF-16 surrogate pair handling: patternProperties", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "patternProperties": { "^🐲*$": { "type": "integer" } } }, "tests": [ { "description": "matches empty", "data": { "": 1 }, "valid": true }, { "description": "matches single", "data": { "🐲": 1 }, "valid": true }, { "description": "matches two", "data": { "🐲🐲": 1 }, "valid": true }, { "description": "doesn't match one", "data": { "🐲": "hello" }, "valid": false }, { "description": "doesn't match two", "data": { "🐲🐲": "hello" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/optional/unicode.json000066400000000000000000000127301426774651400301570ustar00rootroot00000000000000[ { "description": "unicode semantics should be used for all pattern matching", "schema": { "pattern": "\\wcole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode matching is case-sensitive", "data": "LES HIVERS DE MON ENFANCE ÉTAIENT DES SAISONS LONGUES, LONGUES. NOUS VIVIONS EN TROIS LIEUX: L'ÉCOLE, L'ÉGLISE ET LA PATINOIRE; MAIS LA VRAIE VIE ÉTAIT SUR LA PATINOIRE.", "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "pattern": "[a-z]cole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "ascii characters match", "data": "Les hivers de mon enfance etaient des saisons longues, longues. Nous vivions en trois lieux: l'ecole, l'eglise et la patinoire; mais la vraie vie etait sur la patinoire.", "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "pattern": "^\\d+$" }, "tests": [ { "description": "ascii digits", "data": "42", "valid": true }, { "description": "ascii non-digits", "data": "-%#", "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": "৪২", "valid": true } ] }, { "description": "unicode semantics should be used for all patternProperties matching", "schema": { "type": "object", "patternProperties": { "\\wcole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": true }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": true }, { "description": "unicode matching is case-sensitive", "data": { "L'ÉCOLE": "PAS DE VRAIE VIE" }, "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "type": "object", "patternProperties": { "[a-z]cole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": false }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": false }, { "description": "ascii characters match", "data": { "l'ecole": "pas de vraie vie" }, "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "type": "object", "patternProperties": { "^\\d+$": true }, "additionalProperties": false }, "tests": [ { "description": "ascii digits", "data": { "42": "life, the universe, and everything" }, "valid": true }, { "description": "ascii non-digits", "data": { "-%#": "spending the year dead for tax reasons" }, "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": { "৪২": "khajit has wares if you have coin" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/pattern.json000066400000000000000000000030031426774651400263520ustar00rootroot00000000000000[ { "description": "pattern validation", "schema": {"pattern": "^a*$"}, "tests": [ { "description": "a matching pattern is valid", "data": "aaa", "valid": true }, { "description": "a non-matching pattern is invalid", "data": "abc", "valid": false }, { "description": "ignores booleans", "data": true, "valid": true }, { "description": "ignores integers", "data": 123, "valid": true }, { "description": "ignores floats", "data": 1.0, "valid": true }, { "description": "ignores objects", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores null", "data": null, "valid": true } ] }, { "description": "pattern is not anchored", "schema": {"pattern": "a+"}, "tests": [ { "description": "matches a substring", "data": "xxaayy", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/patternProperties.json000066400000000000000000000112511426774651400304330ustar00rootroot00000000000000[ { "description": "patternProperties validates properties matching a regex", "schema": { "patternProperties": { "f.*o": {"type": "integer"} } }, "tests": [ { "description": "a single valid match is valid", "data": {"foo": 1}, "valid": true }, { "description": "multiple valid matches is valid", "data": {"foo": 1, "foooooo" : 2}, "valid": true }, { "description": "a single invalid match is invalid", "data": {"foo": "bar", "fooooo": 2}, "valid": false }, { "description": "multiple invalid matches is invalid", "data": {"foo": "bar", "foooooo" : "baz"}, "valid": false }, { "description": "ignores arrays", "data": ["foo"], "valid": true }, { "description": "ignores strings", "data": "foo", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "multiple simultaneous patternProperties are validated", "schema": { "patternProperties": { "a*": {"type": "integer"}, "aaa*": {"maximum": 20} } }, "tests": [ { "description": "a single valid match is valid", "data": {"a": 21}, "valid": true }, { "description": "a simultaneous match is valid", "data": {"aaaa": 18}, "valid": true }, { "description": "multiple matches is valid", "data": {"a": 21, "aaaa": 18}, "valid": true }, { "description": "an invalid due to one is invalid", "data": {"a": "bar"}, "valid": false }, { "description": "an invalid due to the other is invalid", "data": {"aaaa": 31}, "valid": false }, { "description": "an invalid due to both is invalid", "data": {"aaa": "foo", "aaaa": 31}, "valid": false } ] }, { "description": "regexes are not anchored by default and are case sensitive", "schema": { "patternProperties": { "[0-9]{2,}": { "type": "boolean" }, "X_": { "type": "string" } } }, "tests": [ { "description": "non recognized members are ignored", "data": { "answer 1": "42" }, "valid": true }, { "description": "recognized members are accounted for", "data": { "a31b": null }, "valid": false }, { "description": "regexes are case sensitive", "data": { "a_x_3": 3 }, "valid": true }, { "description": "regexes are case sensitive, 2", "data": { "a_X_3": 3 }, "valid": false } ] }, { "description": "patternProperties with boolean schemas", "schema": { "patternProperties": { "f.*": true, "b.*": false } }, "tests": [ { "description": "object with property matching schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property matching schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "object with a property matching both true and false is invalid", "data": {"foobar":1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/properties.json000066400000000000000000000120341426774651400270750ustar00rootroot00000000000000[ { "description": "object properties validation", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "string"} } }, "tests": [ { "description": "both properties present and valid is valid", "data": {"foo": 1, "bar": "baz"}, "valid": true }, { "description": "one property invalid is invalid", "data": {"foo": 1, "bar": {}}, "valid": false }, { "description": "both properties invalid is invalid", "data": {"foo": [], "bar": {}}, "valid": false }, { "description": "doesn't invalidate other properties", "data": {"quux": []}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "properties, patternProperties, additionalProperties interaction", "schema": { "properties": { "foo": {"type": "array", "maxItems": 3}, "bar": {"type": "array"} }, "patternProperties": {"f.o": {"minItems": 2}}, "additionalProperties": {"type": "integer"} }, "tests": [ { "description": "property validates property", "data": {"foo": [1, 2]}, "valid": true }, { "description": "property invalidates property", "data": {"foo": [1, 2, 3, 4]}, "valid": false }, { "description": "patternProperty invalidates property", "data": {"foo": []}, "valid": false }, { "description": "patternProperty validates nonproperty", "data": {"fxo": [1, 2]}, "valid": true }, { "description": "patternProperty invalidates nonproperty", "data": {"fxo": []}, "valid": false }, { "description": "additionalProperty ignores property", "data": {"bar": []}, "valid": true }, { "description": "additionalProperty validates others", "data": {"quux": 3}, "valid": true }, { "description": "additionalProperty invalidates others", "data": {"quux": "foo"}, "valid": false } ] }, { "description": "properties with boolean schema", "schema": { "properties": { "foo": true, "bar": false } }, "tests": [ { "description": "no property present is valid", "data": {}, "valid": true }, { "description": "only 'true' property present is valid", "data": {"foo": 1}, "valid": true }, { "description": "only 'false' property present is invalid", "data": {"bar": 2}, "valid": false }, { "description": "both properties present is invalid", "data": {"foo": 1, "bar": 2}, "valid": false } ] }, { "description": "properties with escaped characters", "schema": { "properties": { "foo\nbar": {"type": "number"}, "foo\"bar": {"type": "number"}, "foo\\bar": {"type": "number"}, "foo\rbar": {"type": "number"}, "foo\tbar": {"type": "number"}, "foo\fbar": {"type": "number"} } }, "tests": [ { "description": "object with all numbers is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1", "foo\\bar": "1", "foo\rbar": "1", "foo\tbar": "1", "foo\fbar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/propertyNames.json000066400000000000000000000055771426774651400275670ustar00rootroot00000000000000[ { "description": "propertyNames validation", "schema": { "propertyNames": {"maxLength": 3} }, "tests": [ { "description": "all property names valid", "data": { "f": {}, "foo": {} }, "valid": true }, { "description": "some property names invalid", "data": { "foo": {}, "foobar": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [1, 2, 3, 4], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "propertyNames validation with pattern", "schema": { "propertyNames": { "pattern": "^a+$" } }, "tests": [ { "description": "matching property names valid", "data": { "a": {}, "aa": {}, "aaa": {} }, "valid": true }, { "description": "non-matching property name is invalid", "data": { "aaA": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema true", "schema": {"propertyNames": true}, "tests": [ { "description": "object with any properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema false", "schema": {"propertyNames": false}, "tests": [ { "description": "object with any properties is invalid", "data": {"foo": 1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/ref.json000066400000000000000000000432371426774651400254660ustar00rootroot00000000000000[ { "description": "root pointer ref", "schema": { "properties": { "foo": {"$ref": "#"} }, "additionalProperties": false }, "tests": [ { "description": "match", "data": {"foo": false}, "valid": true }, { "description": "recursive match", "data": {"foo": {"foo": false}}, "valid": true }, { "description": "mismatch", "data": {"bar": false}, "valid": false }, { "description": "recursive mismatch", "data": {"foo": {"bar": false}}, "valid": false } ] }, { "description": "relative pointer ref to object", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "relative pointer ref to array", "schema": { "items": [ {"type": "integer"}, {"$ref": "#/items/0"} ] }, "tests": [ { "description": "match array", "data": [1, 2], "valid": true }, { "description": "mismatch array", "data": [1, "foo"], "valid": false } ] }, { "description": "escaped pointer ref", "schema": { "definitions": { "tilde~field": {"type": "integer"}, "slash/field": {"type": "integer"}, "percent%field": {"type": "integer"} }, "properties": { "tilde": {"$ref": "#/definitions/tilde~0field"}, "slash": {"$ref": "#/definitions/slash~1field"}, "percent": {"$ref": "#/definitions/percent%25field"} } }, "tests": [ { "description": "slash invalid", "data": {"slash": "aoeu"}, "valid": false }, { "description": "tilde invalid", "data": {"tilde": "aoeu"}, "valid": false }, { "description": "percent invalid", "data": {"percent": "aoeu"}, "valid": false }, { "description": "slash valid", "data": {"slash": 123}, "valid": true }, { "description": "tilde valid", "data": {"tilde": 123}, "valid": true }, { "description": "percent valid", "data": {"percent": 123}, "valid": true } ] }, { "description": "nested refs", "schema": { "definitions": { "a": {"type": "integer"}, "b": {"$ref": "#/definitions/a"}, "c": {"$ref": "#/definitions/b"} }, "allOf": [{ "$ref": "#/definitions/c" }] }, "tests": [ { "description": "nested ref valid", "data": 5, "valid": true }, { "description": "nested ref invalid", "data": "a", "valid": false } ] }, { "description": "ref overrides any sibling keywords", "schema": { "definitions": { "reffed": { "type": "array" } }, "properties": { "foo": { "$ref": "#/definitions/reffed", "maxItems": 2 } } }, "tests": [ { "description": "ref valid", "data": { "foo": [] }, "valid": true }, { "description": "ref valid, maxItems ignored", "data": { "foo": [ 1, 2, 3] }, "valid": true }, { "description": "ref invalid", "data": { "foo": "string" }, "valid": false } ] }, { "description": "$ref prevents a sibling $id from changing the base uri", "schema": { "$id": "http://localhost:1234/sibling_id/base/", "definitions": { "foo": { "$id": "http://localhost:1234/sibling_id/foo.json", "minimum": 2 }, "base_foo": { "$comment": "this canonical uri is http://localhost:1234/sibling_id/base/foo.json", "$id": "foo.json", "minimum": 5 } }, "allOf": [ { "$comment": "$ref resolves to http://localhost:1234/sibling_id/base/foo.json, not ttp://localhost:1234/sibling_id/foo.json", "$id": "http://localhost:1234/sibling_id/", "$ref": "foo.json" } ] }, "tests": [ { "description": "$ref resolves to /definitions/foo, data validates", "data": 10, "valid": true }, { "description": "$ref resolves to /definitions/foo, data does not validate", "data": 1, "valid": false } ] }, { "description": "remote ref, containing refs itself", "schema": {"$ref": "http://json-schema.org/draft-06/schema#"}, "tests": [ { "description": "remote ref valid", "data": {"minLength": 1}, "valid": true }, { "description": "remote ref invalid", "data": {"minLength": -1}, "valid": false } ] }, { "description": "property named $ref that is not a reference", "schema": { "properties": { "$ref": {"type": "string"} } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "property named $ref, containing an actual $ref", "schema": { "properties": { "$ref": {"$ref": "#/definitions/is-string"} }, "definitions": { "is-string": { "type": "string" } } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "$ref to boolean schema true", "schema": { "allOf": [{ "$ref": "#/definitions/bool" }], "definitions": { "bool": true } }, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "$ref to boolean schema false", "schema": { "allOf": [{ "$ref": "#/definitions/bool" }], "definitions": { "bool": false } }, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "Recursive references between schemas", "schema": { "$id": "http://localhost:1234/tree", "description": "tree of nodes", "type": "object", "properties": { "meta": {"type": "string"}, "nodes": { "type": "array", "items": {"$ref": "node"} } }, "required": ["meta", "nodes"], "definitions": { "node": { "$id": "http://localhost:1234/node", "description": "node", "type": "object", "properties": { "value": {"type": "number"}, "subtree": {"$ref": "tree"} }, "required": ["value"] } } }, "tests": [ { "description": "valid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": 1.1}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": true }, { "description": "invalid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": "string is invalid"}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": false } ] }, { "description": "refs with quote", "schema": { "properties": { "foo\"bar": {"$ref": "#/definitions/foo%22bar"} }, "definitions": { "foo\"bar": {"type": "number"} } }, "tests": [ { "description": "object with numbers is valid", "data": { "foo\"bar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\"bar": "1" }, "valid": false } ] }, { "description": "Location-independent identifier", "schema": { "allOf": [{ "$ref": "#foo" }], "definitions": { "A": { "$id": "#foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with base URI change in subschema", "schema": { "$id": "http://localhost:1234/root", "allOf": [{ "$ref": "http://localhost:1234/nested.json#foo" }], "definitions": { "A": { "$id": "nested.json", "definitions": { "B": { "$id": "#foo", "type": "integer" } } } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "naive replacement of $ref with its destination is not correct", "schema": { "definitions": { "a_string": { "type": "string" } }, "enum": [ { "$ref": "#/definitions/a_string" } ] }, "tests": [ { "description": "do not evaluate the $ref inside the enum, matching any string", "data": "this is a string", "valid": false }, { "description": "do not evaluate the $ref inside the enum, definition exact match", "data": { "type": "string" }, "valid": false }, { "description": "match the enum exactly", "data": { "$ref": "#/definitions/a_string" }, "valid": true } ] }, { "description": "refs with relative uris and defs", "schema": { "$id": "http://example.com/schema-relative-uri-defs1.json", "properties": { "foo": { "$id": "schema-relative-uri-defs2.json", "definitions": { "inner": { "properties": { "bar": { "type": "string" } } } }, "allOf": [ { "$ref": "#/definitions/inner" } ] } }, "allOf": [ { "$ref": "schema-relative-uri-defs2.json" } ] }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] }, { "description": "relative refs with absolute uris and defs", "schema": { "$id": "http://example.com/schema-refs-absolute-uris-defs1.json", "properties": { "foo": { "$id": "http://example.com/schema-refs-absolute-uris-defs2.json", "definitions": { "inner": { "properties": { "bar": { "type": "string" } } } }, "allOf": [ { "$ref": "#/definitions/inner" } ] } }, "allOf": [ { "$ref": "schema-refs-absolute-uris-defs2.json" } ] }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/refRemote.json000066400000000000000000000125041426774651400266330ustar00rootroot00000000000000[ { "description": "remote ref", "schema": {"$ref": "http://localhost:1234/integer.json"}, "tests": [ { "description": "remote ref valid", "data": 1, "valid": true }, { "description": "remote ref invalid", "data": "a", "valid": false } ] }, { "description": "fragment within remote ref", "schema": {"$ref": "http://localhost:1234/subSchemas.json#/integer"}, "tests": [ { "description": "remote fragment valid", "data": 1, "valid": true }, { "description": "remote fragment invalid", "data": "a", "valid": false } ] }, { "description": "ref within remote ref", "schema": { "$ref": "http://localhost:1234/subSchemas.json#/refToInteger" }, "tests": [ { "description": "ref within ref valid", "data": 1, "valid": true }, { "description": "ref within ref invalid", "data": "a", "valid": false } ] }, { "description": "base URI change", "schema": { "$id": "http://localhost:1234/", "items": { "$id": "baseUriChange/", "items": {"$ref": "folderInteger.json"} } }, "tests": [ { "description": "base URI change ref valid", "data": [[1]], "valid": true }, { "description": "base URI change ref invalid", "data": [["a"]], "valid": false } ] }, { "description": "base URI change - change folder", "schema": { "$id": "http://localhost:1234/scope_change_defs1.json", "type" : "object", "properties": { "list": {"$ref": "#/definitions/baz"} }, "definitions": { "baz": { "$id": "baseUriChangeFolder/", "type": "array", "items": {"$ref": "folderInteger.json"} } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "base URI change - change folder in subschema", "schema": { "$id": "http://localhost:1234/scope_change_defs2.json", "type" : "object", "properties": { "list": {"$ref": "#/definitions/baz/definitions/bar"} }, "definitions": { "baz": { "$id": "baseUriChangeFolderInSubschema/", "definitions": { "bar": { "type": "array", "items": {"$ref": "folderInteger.json"} } } } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "root ref in remote ref", "schema": { "$id": "http://localhost:1234/object", "type": "object", "properties": { "name": {"$ref": "name.json#/definitions/orNull"} } }, "tests": [ { "description": "string is valid", "data": { "name": "foo" }, "valid": true }, { "description": "null is valid", "data": { "name": null }, "valid": true }, { "description": "object is invalid", "data": { "name": { "name": null } }, "valid": false } ] }, { "description": "remote ref with ref to definitions", "schema": { "$id": "http://localhost:1234/schema-remote-ref-ref-defs1.json", "allOf": [ { "$ref": "ref-and-definitions.json" } ] }, "tests": [ { "description": "invalid", "data": { "bar": 1 }, "valid": false }, { "description": "valid", "data": { "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/required.json000066400000000000000000000052061426774651400265240ustar00rootroot00000000000000[ { "description": "required validation", "schema": { "properties": { "foo": {}, "bar": {} }, "required": ["foo"] }, "tests": [ { "description": "present required property is valid", "data": {"foo": 1}, "valid": true }, { "description": "non-present required property is invalid", "data": {"bar": 1}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "required default validation", "schema": { "properties": { "foo": {} } }, "tests": [ { "description": "not required by default", "data": {}, "valid": true } ] }, { "description": "required with empty array", "schema": { "properties": { "foo": {} }, "required": [] }, "tests": [ { "description": "property not required", "data": {}, "valid": true } ] }, { "description": "required with escaped characters", "schema": { "required": [ "foo\nbar", "foo\"bar", "foo\\bar", "foo\rbar", "foo\tbar", "foo\fbar" ] }, "tests": [ { "description": "object with all properties present is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with some properties missing is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/type.json000066400000000000000000000321401426774651400256620ustar00rootroot00000000000000[ { "description": "integer type matches integers", "schema": {"type": "integer"}, "tests": [ { "description": "an integer is an integer", "data": 1, "valid": true }, { "description": "a float with zero fractional part is an integer", "data": 1.0, "valid": true }, { "description": "a float is not an integer", "data": 1.1, "valid": false }, { "description": "a string is not an integer", "data": "foo", "valid": false }, { "description": "a string is still not an integer, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not an integer", "data": {}, "valid": false }, { "description": "an array is not an integer", "data": [], "valid": false }, { "description": "a boolean is not an integer", "data": true, "valid": false }, { "description": "null is not an integer", "data": null, "valid": false } ] }, { "description": "number type matches numbers", "schema": {"type": "number"}, "tests": [ { "description": "an integer is a number", "data": 1, "valid": true }, { "description": "a float with zero fractional part is a number (and an integer)", "data": 1.0, "valid": true }, { "description": "a float is a number", "data": 1.1, "valid": true }, { "description": "a string is not a number", "data": "foo", "valid": false }, { "description": "a string is still not a number, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not a number", "data": {}, "valid": false }, { "description": "an array is not a number", "data": [], "valid": false }, { "description": "a boolean is not a number", "data": true, "valid": false }, { "description": "null is not a number", "data": null, "valid": false } ] }, { "description": "string type matches strings", "schema": {"type": "string"}, "tests": [ { "description": "1 is not a string", "data": 1, "valid": false }, { "description": "a float is not a string", "data": 1.1, "valid": false }, { "description": "a string is a string", "data": "foo", "valid": true }, { "description": "a string is still a string, even if it looks like a number", "data": "1", "valid": true }, { "description": "an empty string is still a string", "data": "", "valid": true }, { "description": "an object is not a string", "data": {}, "valid": false }, { "description": "an array is not a string", "data": [], "valid": false }, { "description": "a boolean is not a string", "data": true, "valid": false }, { "description": "null is not a string", "data": null, "valid": false } ] }, { "description": "object type matches objects", "schema": {"type": "object"}, "tests": [ { "description": "an integer is not an object", "data": 1, "valid": false }, { "description": "a float is not an object", "data": 1.1, "valid": false }, { "description": "a string is not an object", "data": "foo", "valid": false }, { "description": "an object is an object", "data": {}, "valid": true }, { "description": "an array is not an object", "data": [], "valid": false }, { "description": "a boolean is not an object", "data": true, "valid": false }, { "description": "null is not an object", "data": null, "valid": false } ] }, { "description": "array type matches arrays", "schema": {"type": "array"}, "tests": [ { "description": "an integer is not an array", "data": 1, "valid": false }, { "description": "a float is not an array", "data": 1.1, "valid": false }, { "description": "a string is not an array", "data": "foo", "valid": false }, { "description": "an object is not an array", "data": {}, "valid": false }, { "description": "an array is an array", "data": [], "valid": true }, { "description": "a boolean is not an array", "data": true, "valid": false }, { "description": "null is not an array", "data": null, "valid": false } ] }, { "description": "boolean type matches booleans", "schema": {"type": "boolean"}, "tests": [ { "description": "an integer is not a boolean", "data": 1, "valid": false }, { "description": "zero is not a boolean", "data": 0, "valid": false }, { "description": "a float is not a boolean", "data": 1.1, "valid": false }, { "description": "a string is not a boolean", "data": "foo", "valid": false }, { "description": "an empty string is not a boolean", "data": "", "valid": false }, { "description": "an object is not a boolean", "data": {}, "valid": false }, { "description": "an array is not a boolean", "data": [], "valid": false }, { "description": "true is a boolean", "data": true, "valid": true }, { "description": "false is a boolean", "data": false, "valid": true }, { "description": "null is not a boolean", "data": null, "valid": false } ] }, { "description": "null type matches only the null object", "schema": {"type": "null"}, "tests": [ { "description": "an integer is not null", "data": 1, "valid": false }, { "description": "a float is not null", "data": 1.1, "valid": false }, { "description": "zero is not null", "data": 0, "valid": false }, { "description": "a string is not null", "data": "foo", "valid": false }, { "description": "an empty string is not null", "data": "", "valid": false }, { "description": "an object is not null", "data": {}, "valid": false }, { "description": "an array is not null", "data": [], "valid": false }, { "description": "true is not null", "data": true, "valid": false }, { "description": "false is not null", "data": false, "valid": false }, { "description": "null is null", "data": null, "valid": true } ] }, { "description": "multiple types can be specified in an array", "schema": {"type": ["integer", "string"]}, "tests": [ { "description": "an integer is valid", "data": 1, "valid": true }, { "description": "a string is valid", "data": "foo", "valid": true }, { "description": "a float is invalid", "data": 1.1, "valid": false }, { "description": "an object is invalid", "data": {}, "valid": false }, { "description": "an array is invalid", "data": [], "valid": false }, { "description": "a boolean is invalid", "data": true, "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type as array with one item", "schema": { "type": ["string"] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is invalid", "data": 123, "valid": false } ] }, { "description": "type: array or object", "schema": { "type": ["array", "object"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type: array, object or null", "schema": { "type": ["array", "object", "null"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/uniqueItems.json000066400000000000000000000314011426774651400272100ustar00rootroot00000000000000[ { "description": "uniqueItems validation", "schema": {"uniqueItems": true}, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is invalid", "data": [1, 1], "valid": false }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": false }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is invalid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": false }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is invalid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": false }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is invalid", "data": [["foo"], ["foo"]], "valid": false }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "[1] and [true] are unique", "data": [[1], [true]], "valid": true }, { "description": "[0] and [false] are unique", "data": [[0], [false]], "valid": true }, { "description": "nested [1] and [true] are unique", "data": [[[1], "foo"], [[true], "foo"]], "valid": true }, { "description": "nested [0] and [false] are unique", "data": [[[0], "foo"], [[false], "foo"]], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1, "{}"], "valid": true }, { "description": "non-unique heterogeneous types are invalid", "data": [{}, [1], true, null, {}, 1], "valid": false }, { "description": "different objects are unique", "data": [{"a": 1, "b": 2}, {"a": 2, "b": 1}], "valid": true }, { "description": "objects are non-unique despite key order", "data": [{"a": 1, "b": 2}, {"b": 2, "a": 1}], "valid": false }, { "description": "{\"a\": false} and {\"a\": 0} are unique", "data": [{"a": false}, {"a": 0}], "valid": true }, { "description": "{\"a\": true} and {\"a\": 1} are unique", "data": [{"a": true}, {"a": 1}], "valid": true } ] }, { "description": "uniqueItems with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is not valid", "data": [false, true, "foo", "foo"], "valid": false }, { "description": "non-unique array extended from [true, false] is not valid", "data": [true, false, "foo", "foo"], "valid": false } ] }, { "description": "uniqueItems with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] }, { "description": "uniqueItems=false validation", "schema": { "uniqueItems": false }, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is valid", "data": [1, 1], "valid": true }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": true }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": true }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": true }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is valid", "data": [["foo"], ["foo"]], "valid": true }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1], "valid": true }, { "description": "non-unique heterogeneous types are valid", "data": [{}, [1], true, null, {}, 1], "valid": true } ] }, { "description": "uniqueItems=false with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is valid", "data": [false, true, "foo", "foo"], "valid": true }, { "description": "non-unique array extended from [true, false] is valid", "data": [true, false, "foo", "foo"], "valid": true } ] }, { "description": "uniqueItems=false with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft6/unknownKeyword.json000066400000000000000000000037421426774651400277530ustar00rootroot00000000000000[ { "description": "$id inside an unknown keyword is not a real identifier", "comment": "the implementation must not be confused by an $id in locations we do not know how to parse", "schema": { "definitions": { "id_in_unknown0": { "not": { "array_of_schemas": [ { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "null" } ] } }, "real_id_in_schema": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "string" }, "id_in_unknown1": { "not": { "object_of_schemas": { "foo": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "integer" } } } } }, "anyOf": [ { "$ref": "#/definitions/id_in_unknown0" }, { "$ref": "#/definitions/id_in_unknown1" }, { "$ref": "https://localhost:1234/unknownKeyword/my_identifier.json" } ] }, "tests": [ { "description": "type matches second anyOf, which has a real schema in it", "data": "a string", "valid": true }, { "description": "type matches non-schema in first anyOf", "data": null, "valid": false }, { "description": "type matches non-schema in third anyOf", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/000077500000000000000000000000001426774651400240075ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/additionalItems.json000066400000000000000000000103731426774651400300200ustar00rootroot00000000000000[ { "description": "additionalItems as schema", "schema": { "items": [{}], "additionalItems": {"type": "integer"} }, "tests": [ { "description": "additional items match schema", "data": [ null, 2, 3, 4 ], "valid": true }, { "description": "additional items do not match schema", "data": [ null, 2, 3, "foo" ], "valid": false } ] }, { "description": "when items is schema, additionalItems does nothing", "schema": { "items": {}, "additionalItems": false }, "tests": [ { "description": "all items match schema", "data": [ 1, 2, 3, 4, 5 ], "valid": true } ] }, { "description": "array of items with no additionalItems permitted", "schema": { "items": [{}, {}, {}], "additionalItems": false }, "tests": [ { "description": "empty array", "data": [ ], "valid": true }, { "description": "fewer number of items present (1)", "data": [ 1 ], "valid": true }, { "description": "fewer number of items present (2)", "data": [ 1, 2 ], "valid": true }, { "description": "equal number of items present", "data": [ 1, 2, 3 ], "valid": true }, { "description": "additional items are not permitted", "data": [ 1, 2, 3, 4 ], "valid": false } ] }, { "description": "additionalItems as false without items", "schema": {"additionalItems": false}, "tests": [ { "description": "items defaults to empty schema so everything is valid", "data": [ 1, 2, 3, 4, 5 ], "valid": true }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true } ] }, { "description": "additionalItems are allowed by default", "schema": {"items": [{"type": "integer"}]}, "tests": [ { "description": "only the first item is validated", "data": [1, "foo", false], "valid": true } ] }, { "description": "additionalItems should not look in applicators, valid case", "schema": { "allOf": [ { "items": [ { "type": "integer" } ] } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, null ], "valid": true } ] }, { "description": "additionalItems should not look in applicators, invalid case", "schema": { "allOf": [ { "items": [ { "type": "integer" }, { "type": "string" } ] } ], "items": [ {"type": "integer" } ], "additionalItems": { "type": "boolean" } }, "tests": [ { "description": "items defined in allOf are not examined", "data": [ 1, "hello" ], "valid": false } ] }, { "description": "items validation adjusts the starting index for additionalItems", "schema": { "items": [ { "type": "string" } ], "additionalItems": { "type": "integer" } }, "tests": [ { "description": "valid items", "data": [ "x", 2, 3 ], "valid": true }, { "description": "wrong type of second item", "data": [ "x", "y" ], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/additionalProperties.json000066400000000000000000000077541426774651400311040ustar00rootroot00000000000000[ { "description": "additionalProperties being false does not allow other properties", "schema": { "properties": {"foo": {}, "bar": {}}, "patternProperties": { "^v": {} }, "additionalProperties": false }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : "boom"}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobarbaz", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true }, { "description": "patternProperties are not additional properties", "data": {"foo":1, "vroom": 2}, "valid": true } ] }, { "description": "non-ASCII pattern with additionalProperties", "schema": { "patternProperties": {"^á": {}}, "additionalProperties": false }, "tests": [ { "description": "matching the pattern is valid", "data": {"ármányos": 2}, "valid": true }, { "description": "not matching the pattern is invalid", "data": {"élmény": 2}, "valid": false } ] }, { "description": "additionalProperties allows a schema which should validate", "schema": { "properties": {"foo": {}, "bar": {}}, "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "no additional properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "an additional valid property is valid", "data": {"foo" : 1, "bar" : 2, "quux" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1, "bar" : 2, "quux" : 12}, "valid": false } ] }, { "description": "additionalProperties can exist by itself", "schema": { "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "an additional valid property is valid", "data": {"foo" : true}, "valid": true }, { "description": "an additional invalid property is invalid", "data": {"foo" : 1}, "valid": false } ] }, { "description": "additionalProperties are allowed by default", "schema": {"properties": {"foo": {}, "bar": {}}}, "tests": [ { "description": "additional properties are allowed", "data": {"foo": 1, "bar": 2, "quux": true}, "valid": true } ] }, { "description": "additionalProperties should not look in applicators", "schema": { "allOf": [ {"properties": {"foo": {}}} ], "additionalProperties": {"type": "boolean"} }, "tests": [ { "description": "properties defined in allOf are not examined", "data": {"foo": 1, "bar": true}, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/allOf.json000066400000000000000000000171471426774651400257510ustar00rootroot00000000000000[ { "description": "allOf", "schema": { "allOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "allOf", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "mismatch second", "data": {"foo": "baz"}, "valid": false }, { "description": "mismatch first", "data": {"bar": 2}, "valid": false }, { "description": "wrong type", "data": {"foo": "baz", "bar": "quux"}, "valid": false } ] }, { "description": "allOf with base schema", "schema": { "properties": {"bar": {"type": "integer"}}, "required": ["bar"], "allOf" : [ { "properties": { "foo": {"type": "string"} }, "required": ["foo"] }, { "properties": { "baz": {"type": "null"} }, "required": ["baz"] } ] }, "tests": [ { "description": "valid", "data": {"foo": "quux", "bar": 2, "baz": null}, "valid": true }, { "description": "mismatch base schema", "data": {"foo": "quux", "baz": null}, "valid": false }, { "description": "mismatch first allOf", "data": {"bar": 2, "baz": null}, "valid": false }, { "description": "mismatch second allOf", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "mismatch both", "data": {"bar": 2}, "valid": false } ] }, { "description": "allOf simple types", "schema": { "allOf": [ {"maximum": 30}, {"minimum": 20} ] }, "tests": [ { "description": "valid", "data": 25, "valid": true }, { "description": "mismatch one", "data": 35, "valid": false } ] }, { "description": "allOf with boolean schemas, all true", "schema": {"allOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "allOf with boolean schemas, some false", "schema": {"allOf": [true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with boolean schemas, all false", "schema": {"allOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with one empty schema", "schema": { "allOf": [ {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with two empty schemas", "schema": { "allOf": [ {}, {} ] }, "tests": [ { "description": "any data is valid", "data": 1, "valid": true } ] }, { "description": "allOf with the first empty schema", "schema": { "allOf": [ {}, { "type": "number" } ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "allOf with the last empty schema", "schema": { "allOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is invalid", "data": "foo", "valid": false } ] }, { "description": "nested allOf, to check validation semantics", "schema": { "allOf": [ { "allOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "allOf combined with anyOf, oneOf", "schema": { "allOf": [ { "multipleOf": 2 } ], "anyOf": [ { "multipleOf": 3 } ], "oneOf": [ { "multipleOf": 5 } ] }, "tests": [ { "description": "allOf: false, anyOf: false, oneOf: false", "data": 1, "valid": false }, { "description": "allOf: false, anyOf: false, oneOf: true", "data": 5, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: false", "data": 3, "valid": false }, { "description": "allOf: false, anyOf: true, oneOf: true", "data": 15, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: false", "data": 2, "valid": false }, { "description": "allOf: true, anyOf: false, oneOf: true", "data": 10, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: false", "data": 6, "valid": false }, { "description": "allOf: true, anyOf: true, oneOf: true", "data": 30, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/anyOf.json000066400000000000000000000125471426774651400257670ustar00rootroot00000000000000[ { "description": "anyOf", "schema": { "anyOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first anyOf valid", "data": 1, "valid": true }, { "description": "second anyOf valid", "data": 2.5, "valid": true }, { "description": "both anyOf valid", "data": 3, "valid": true }, { "description": "neither anyOf valid", "data": 1.5, "valid": false } ] }, { "description": "anyOf with base schema", "schema": { "type": "string", "anyOf" : [ { "maxLength": 2 }, { "minLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one anyOf valid", "data": "foobar", "valid": true }, { "description": "both anyOf invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf with boolean schemas, all true", "schema": {"anyOf": [true, true]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, some true", "schema": {"anyOf": [true, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "anyOf with boolean schemas, all false", "schema": {"anyOf": [false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "anyOf complex types", "schema": { "anyOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first anyOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second anyOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both anyOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": true }, { "description": "neither anyOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "anyOf with one empty schema", "schema": { "anyOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is valid", "data": 123, "valid": true } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] }, { "description": "nested anyOf, to check validation semantics", "schema": { "anyOf": [ { "anyOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/boolean_schema.json000066400000000000000000000054021426774651400276420ustar00rootroot00000000000000[ { "description": "boolean schema 'true'", "schema": true, "tests": [ { "description": "number is valid", "data": 1, "valid": true }, { "description": "string is valid", "data": "foo", "valid": true }, { "description": "boolean true is valid", "data": true, "valid": true }, { "description": "boolean false is valid", "data": false, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "object is valid", "data": {"foo": "bar"}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true }, { "description": "array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "boolean schema 'false'", "schema": false, "tests": [ { "description": "number is invalid", "data": 1, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "boolean true is invalid", "data": true, "valid": false }, { "description": "boolean false is invalid", "data": false, "valid": false }, { "description": "null is invalid", "data": null, "valid": false }, { "description": "object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/const.json000066400000000000000000000225641426774651400260410ustar00rootroot00000000000000[ { "description": "const validation", "schema": {"const": 2}, "tests": [ { "description": "same value is valid", "data": 2, "valid": true }, { "description": "another value is invalid", "data": 5, "valid": false }, { "description": "another type is invalid", "data": "a", "valid": false } ] }, { "description": "const with object", "schema": {"const": {"foo": "bar", "baz": "bax"}}, "tests": [ { "description": "same object is valid", "data": {"foo": "bar", "baz": "bax"}, "valid": true }, { "description": "same object with different property order is valid", "data": {"baz": "bax", "foo": "bar"}, "valid": true }, { "description": "another object is invalid", "data": {"foo": "bar"}, "valid": false }, { "description": "another type is invalid", "data": [1, 2], "valid": false } ] }, { "description": "const with array", "schema": {"const": [{ "foo": "bar" }]}, "tests": [ { "description": "same array is valid", "data": [{"foo": "bar"}], "valid": true }, { "description": "another array item is invalid", "data": [2], "valid": false }, { "description": "array with additional items is invalid", "data": [1, 2, 3], "valid": false } ] }, { "description": "const with null", "schema": {"const": null}, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "not null is invalid", "data": 0, "valid": false } ] }, { "description": "const with false does not match 0", "schema": {"const": false}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "const with true does not match 1", "schema": {"const": true}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "const with [false] does not match [0]", "schema": {"const": [false]}, "tests": [ { "description": "[false] is valid", "data": [false], "valid": true }, { "description": "[0] is invalid", "data": [0], "valid": false }, { "description": "[0.0] is invalid", "data": [0.0], "valid": false } ] }, { "description": "const with [true] does not match [1]", "schema": {"const": [true]}, "tests": [ { "description": "[true] is valid", "data": [true], "valid": true }, { "description": "[1] is invalid", "data": [1], "valid": false }, { "description": "[1.0] is invalid", "data": [1.0], "valid": false } ] }, { "description": "const with {\"a\": false} does not match {\"a\": 0}", "schema": {"const": {"a": false}}, "tests": [ { "description": "{\"a\": false} is valid", "data": {"a": false}, "valid": true }, { "description": "{\"a\": 0} is invalid", "data": {"a": 0}, "valid": false }, { "description": "{\"a\": 0.0} is invalid", "data": {"a": 0.0}, "valid": false } ] }, { "description": "const with {\"a\": true} does not match {\"a\": 1}", "schema": {"const": {"a": true}}, "tests": [ { "description": "{\"a\": true} is valid", "data": {"a": true}, "valid": true }, { "description": "{\"a\": 1} is invalid", "data": {"a": 1}, "valid": false }, { "description": "{\"a\": 1.0} is invalid", "data": {"a": 1.0}, "valid": false } ] }, { "description": "const with 0 does not match other zero-like types", "schema": {"const": 0}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true }, { "description": "empty object is invalid", "data": {}, "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "empty string is invalid", "data": "", "valid": false } ] }, { "description": "const with 1 does not match true", "schema": {"const": 1}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "const with -2.0 matches integer and float types", "schema": {"const": -2.0}, "tests": [ { "description": "integer -2 is valid", "data": -2, "valid": true }, { "description": "integer 2 is invalid", "data": 2, "valid": false }, { "description": "float -2.0 is valid", "data": -2.0, "valid": true }, { "description": "float 2.0 is invalid", "data": 2.0, "valid": false }, { "description": "float -2.00001 is invalid", "data": -2.00001, "valid": false } ] }, { "description": "float and integers are equal up to 64-bit representation limits", "schema": {"const": 9007199254740992}, "tests": [ { "description": "integer is valid", "data": 9007199254740992, "valid": true }, { "description": "integer minus one is invalid", "data": 9007199254740991, "valid": false }, { "description": "float is valid", "data": 9007199254740992.0, "valid": true }, { "description": "float minus one is invalid", "data": 9007199254740991.0, "valid": false } ] }, { "description": "nul characters in strings", "schema": { "const": "hello\u0000there" }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/contains.json000066400000000000000000000102721426774651400265220ustar00rootroot00000000000000[ { "description": "contains keyword validation", "schema": { "contains": {"minimum": 5} }, "tests": [ { "description": "array with item matching schema (5) is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with item matching schema (6) is valid", "data": [3, 4, 6], "valid": true }, { "description": "array with two items matching schema (5, 6) is valid", "data": [3, 4, 5, 6], "valid": true }, { "description": "array without items matching schema is invalid", "data": [2, 3, 4], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "not array is valid", "data": {}, "valid": true } ] }, { "description": "contains keyword with const keyword", "schema": { "contains": { "const": 5 } }, "tests": [ { "description": "array with item 5 is valid", "data": [3, 4, 5], "valid": true }, { "description": "array with two items 5 is valid", "data": [3, 4, 5, 5], "valid": true }, { "description": "array without item 5 is invalid", "data": [1, 2, 3, 4], "valid": false } ] }, { "description": "contains keyword with boolean schema true", "schema": {"contains": true}, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] }, { "description": "contains keyword with boolean schema false", "schema": {"contains": false}, "tests": [ { "description": "any non-empty array is invalid", "data": ["foo"], "valid": false }, { "description": "empty array is invalid", "data": [], "valid": false }, { "description": "non-arrays are valid", "data": "contains does not apply to strings", "valid": true } ] }, { "description": "items + contains", "schema": { "items": { "multipleOf": 2 }, "contains": { "multipleOf": 3 } }, "tests": [ { "description": "matches items, does not match contains", "data": [ 2, 4, 8 ], "valid": false }, { "description": "does not match items, matches contains", "data": [ 3, 6, 9 ], "valid": false }, { "description": "matches both items and contains", "data": [ 6, 12 ], "valid": true }, { "description": "matches neither items nor contains", "data": [ 1, 5 ], "valid": false } ] }, { "description": "contains with false if subschema", "schema": { "contains": { "if": false, "else": true } }, "tests": [ { "description": "any non-empty array is valid", "data": ["foo"], "valid": true }, { "description": "empty array is invalid", "data": [], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/default.json000066400000000000000000000042671426774651400263370ustar00rootroot00000000000000[ { "description": "invalid type for default", "schema": { "properties": { "foo": { "type": "integer", "default": [] } } }, "tests": [ { "description": "valid when property is specified", "data": {"foo": 13}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "invalid string value for default", "schema": { "properties": { "bar": { "type": "string", "minLength": 4, "default": "bad" } } }, "tests": [ { "description": "valid when property is specified", "data": {"bar": "good"}, "valid": true }, { "description": "still valid when the invalid default is used", "data": {}, "valid": true } ] }, { "description": "the default keyword does not do anything if the property is missing", "schema": { "type": "object", "properties": { "alpha": { "type": "number", "maximum": 3, "default": 5 } } }, "tests": [ { "description": "an explicit property value is checked against maximum (passing)", "data": { "alpha": 1 }, "valid": true }, { "description": "an explicit property value is checked against maximum (failing)", "data": { "alpha": 5 }, "valid": false }, { "description": "missing properties are not filled in with the default", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/definitions.json000066400000000000000000000013171426774651400272170ustar00rootroot00000000000000[ { "description": "validate definition against metaschema", "schema": {"$ref": "http://json-schema.org/draft-07/schema#"}, "tests": [ { "description": "valid definition schema", "data": { "definitions": { "foo": {"type": "integer"} } }, "valid": true }, { "description": "invalid definition schema", "data": { "definitions": { "foo": {"type": 1} } }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/dependencies.json000066400000000000000000000153341426774651400273360ustar00rootroot00000000000000[ { "description": "dependencies", "schema": { "dependencies": {"bar": ["foo"]} }, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependant", "data": {"foo": 1}, "valid": true }, { "description": "with dependency", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "missing dependency", "data": {"bar": 2}, "valid": false }, { "description": "ignores arrays", "data": ["bar"], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "dependencies with empty array", "schema": { "dependencies": {"bar": []} }, "tests": [ { "description": "empty object", "data": {}, "valid": true }, { "description": "object with one property", "data": {"bar": 2}, "valid": true }, { "description": "non-object is valid", "data": 1, "valid": true } ] }, { "description": "multiple dependencies", "schema": { "dependencies": {"quux": ["foo", "bar"]} }, "tests": [ { "description": "neither", "data": {}, "valid": true }, { "description": "nondependants", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "with dependencies", "data": {"foo": 1, "bar": 2, "quux": 3}, "valid": true }, { "description": "missing dependency", "data": {"foo": 1, "quux": 2}, "valid": false }, { "description": "missing other dependency", "data": {"bar": 1, "quux": 2}, "valid": false }, { "description": "missing both dependencies", "data": {"quux": 1}, "valid": false } ] }, { "description": "multiple dependencies subschema", "schema": { "dependencies": { "bar": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "integer"} } } } }, "tests": [ { "description": "valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "no dependency", "data": {"foo": "quux"}, "valid": true }, { "description": "wrong type", "data": {"foo": "quux", "bar": 2}, "valid": false }, { "description": "wrong type other", "data": {"foo": 2, "bar": "quux"}, "valid": false }, { "description": "wrong type both", "data": {"foo": "quux", "bar": "quux"}, "valid": false } ] }, { "description": "dependencies with boolean subschemas", "schema": { "dependencies": { "foo": true, "bar": false } }, "tests": [ { "description": "object with property having schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property having schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "dependencies with escaped characters", "schema": { "dependencies": { "foo\nbar": ["foo\rbar"], "foo\tbar": { "minProperties": 4 }, "foo'bar": {"required": ["foo\"bar"]}, "foo\"bar": ["foo'bar"] } }, "tests": [ { "description": "valid object 1", "data": { "foo\nbar": 1, "foo\rbar": 2 }, "valid": true }, { "description": "valid object 2", "data": { "foo\tbar": 1, "a": 2, "b": 3, "c": 4 }, "valid": true }, { "description": "valid object 3", "data": { "foo'bar": 1, "foo\"bar": 2 }, "valid": true }, { "description": "invalid object 1", "data": { "foo\nbar": 1, "foo": 2 }, "valid": false }, { "description": "invalid object 2", "data": { "foo\tbar": 1, "a": 2 }, "valid": false }, { "description": "invalid object 3", "data": { "foo'bar": 1 }, "valid": false }, { "description": "invalid object 4", "data": { "foo\"bar": 2 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/enum.json000066400000000000000000000146431426774651400256560ustar00rootroot00000000000000[ { "description": "simple enum validation", "schema": {"enum": [1, 2, 3]}, "tests": [ { "description": "one of the enum is valid", "data": 1, "valid": true }, { "description": "something else is invalid", "data": 4, "valid": false } ] }, { "description": "heterogeneous enum validation", "schema": {"enum": [6, "foo", [], true, {"foo": 12}]}, "tests": [ { "description": "one of the enum is valid", "data": [], "valid": true }, { "description": "something else is invalid", "data": null, "valid": false }, { "description": "objects are deep compared", "data": {"foo": false}, "valid": false }, { "description": "valid object matches", "data": {"foo": 12}, "valid": true }, { "description": "extra properties in object is invalid", "data": {"foo": 12, "boo": 42}, "valid": false } ] }, { "description": "heterogeneous enum-with-null validation", "schema": { "enum": [6, null] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "number is valid", "data": 6, "valid": true }, { "description": "something else is invalid", "data": "test", "valid": false } ] }, { "description": "enums in properties", "schema": { "type":"object", "properties": { "foo": {"enum":["foo"]}, "bar": {"enum":["bar"]} }, "required": ["bar"] }, "tests": [ { "description": "both properties are valid", "data": {"foo":"foo", "bar":"bar"}, "valid": true }, { "description": "wrong foo value", "data": {"foo":"foot", "bar":"bar"}, "valid": false }, { "description": "wrong bar value", "data": {"foo":"foo", "bar":"bart"}, "valid": false }, { "description": "missing optional property is valid", "data": {"bar":"bar"}, "valid": true }, { "description": "missing required property is invalid", "data": {"foo":"foo"}, "valid": false }, { "description": "missing all properties is invalid", "data": {}, "valid": false } ] }, { "description": "enum with escaped characters", "schema": { "enum": ["foo\nbar", "foo\rbar"] }, "tests": [ { "description": "member 1 is valid", "data": "foo\nbar", "valid": true }, { "description": "member 2 is valid", "data": "foo\rbar", "valid": true }, { "description": "another string is invalid", "data": "abc", "valid": false } ] }, { "description": "enum with false does not match 0", "schema": {"enum": [false]}, "tests": [ { "description": "false is valid", "data": false, "valid": true }, { "description": "integer zero is invalid", "data": 0, "valid": false }, { "description": "float zero is invalid", "data": 0.0, "valid": false } ] }, { "description": "enum with true does not match 1", "schema": {"enum": [true]}, "tests": [ { "description": "true is valid", "data": true, "valid": true }, { "description": "integer one is invalid", "data": 1, "valid": false }, { "description": "float one is invalid", "data": 1.0, "valid": false } ] }, { "description": "enum with 0 does not match false", "schema": {"enum": [0]}, "tests": [ { "description": "false is invalid", "data": false, "valid": false }, { "description": "integer zero is valid", "data": 0, "valid": true }, { "description": "float zero is valid", "data": 0.0, "valid": true } ] }, { "description": "enum with 1 does not match true", "schema": {"enum": [1]}, "tests": [ { "description": "true is invalid", "data": true, "valid": false }, { "description": "integer one is valid", "data": 1, "valid": true }, { "description": "float one is valid", "data": 1.0, "valid": true } ] }, { "description": "nul characters in strings", "schema": { "enum": [ "hello\u0000there" ] }, "tests": [ { "description": "match string with nul", "data": "hello\u0000there", "valid": true }, { "description": "do not match string lacking nul", "data": "hellothere", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/exclusiveMaximum.json000066400000000000000000000014071426774651400302510ustar00rootroot00000000000000[ { "description": "exclusiveMaximum validation", "schema": { "exclusiveMaximum": 3.0 }, "tests": [ { "description": "below the exclusiveMaximum is valid", "data": 2.2, "valid": true }, { "description": "boundary point is invalid", "data": 3.0, "valid": false }, { "description": "above the exclusiveMaximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/exclusiveMinimum.json000066400000000000000000000014071426774651400302470ustar00rootroot00000000000000[ { "description": "exclusiveMinimum validation", "schema": { "exclusiveMinimum": 1.1 }, "tests": [ { "description": "above the exclusiveMinimum is valid", "data": 1.2, "valid": true }, { "description": "boundary point is invalid", "data": 1.1, "valid": false }, { "description": "below the exclusiveMinimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/format.json000066400000000000000000000432231426774651400261760ustar00rootroot00000000000000[ { "description": "email format", "schema": { "format": "email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "idn-email format", "schema": { "format": "idn-email" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "regex format", "schema": { "format": "regex" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "ipv4 format", "schema": { "format": "ipv4" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "ipv6 format", "schema": { "format": "ipv6" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "idn-hostname format", "schema": { "format": "idn-hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "hostname format", "schema": { "format": "hostname" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "date format", "schema": { "format": "date" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "date-time format", "schema": { "format": "date-time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "time format", "schema": { "format": "time" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "json-pointer format", "schema": { "format": "json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "relative-json-pointer format", "schema": { "format": "relative-json-pointer" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "iri format", "schema": { "format": "iri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "iri-reference format", "schema": { "format": "iri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri format", "schema": { "format": "uri" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri-reference format", "schema": { "format": "uri-reference" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] }, { "description": "uri-template format", "schema": { "format": "uri-template" }, "tests": [ { "description": "all string formats ignore integers", "data": 12, "valid": true }, { "description": "all string formats ignore floats", "data": 13.7, "valid": true }, { "description": "all string formats ignore objects", "data": {}, "valid": true }, { "description": "all string formats ignore arrays", "data": [], "valid": true }, { "description": "all string formats ignore booleans", "data": false, "valid": true }, { "description": "all string formats ignore nulls", "data": null, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/id.json000066400000000000000000000033121426774651400252750ustar00rootroot00000000000000[ { "description": "id inside an enum is not a real identifier", "comment": "the implementation must not be confused by an id buried in the enum", "schema": { "definitions": { "id_in_enum": { "enum": [ { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } ] }, "real_id_in_schema": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "string" }, "zzz_id_in_const": { "const": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" } } }, "anyOf": [ { "$ref": "#/definitions/id_in_enum" }, { "$ref": "https://localhost:1234/id/my_identifier.json" } ] }, "tests": [ { "description": "exact match to enum, and type matches", "data": { "$id": "https://localhost:1234/id/my_identifier.json", "type": "null" }, "valid": true }, { "description": "match $ref to id", "data": "a string to match #/definitions/id_in_enum", "valid": true }, { "description": "no match on enum or $ref to id", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/if-then-else.json000066400000000000000000000153221426774651400271650ustar00rootroot00000000000000[ { "description": "ignore if without then or else", "schema": { "if": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone if", "data": 0, "valid": true }, { "description": "valid when invalid against lone if", "data": "hello", "valid": true } ] }, { "description": "ignore then without if", "schema": { "then": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone then", "data": 0, "valid": true }, { "description": "valid when invalid against lone then", "data": "hello", "valid": true } ] }, { "description": "ignore else without if", "schema": { "else": { "const": 0 } }, "tests": [ { "description": "valid when valid against lone else", "data": 0, "valid": true }, { "description": "valid when invalid against lone else", "data": "hello", "valid": true } ] }, { "description": "if and then without else", "schema": { "if": { "exclusiveMaximum": 0 }, "then": { "minimum": -10 } }, "tests": [ { "description": "valid through then", "data": -1, "valid": true }, { "description": "invalid through then", "data": -100, "valid": false }, { "description": "valid when if test fails", "data": 3, "valid": true } ] }, { "description": "if and else without then", "schema": { "if": { "exclusiveMaximum": 0 }, "else": { "multipleOf": 2 } }, "tests": [ { "description": "valid when if test passes", "data": -1, "valid": true }, { "description": "valid through else", "data": 4, "valid": true }, { "description": "invalid through else", "data": 3, "valid": false } ] }, { "description": "validate against correct branch, then vs else", "schema": { "if": { "exclusiveMaximum": 0 }, "then": { "minimum": -10 }, "else": { "multipleOf": 2 } }, "tests": [ { "description": "valid through then", "data": -1, "valid": true }, { "description": "invalid through then", "data": -100, "valid": false }, { "description": "valid through else", "data": 4, "valid": true }, { "description": "invalid through else", "data": 3, "valid": false } ] }, { "description": "non-interference across combined schemas", "schema": { "allOf": [ { "if": { "exclusiveMaximum": 0 } }, { "then": { "minimum": -10 } }, { "else": { "multipleOf": 2 } } ] }, "tests": [ { "description": "valid, but would have been invalid through then", "data": -100, "valid": true }, { "description": "valid, but would have been invalid through else", "data": 3, "valid": true } ] }, { "description": "if with boolean schema true", "schema": { "if": true, "then": { "const": "then" }, "else": { "const": "else" } }, "tests": [ { "description": "boolean schema true in if always chooses the then path (valid)", "data": "then", "valid": true }, { "description": "boolean schema true in if always chooses the then path (invalid)", "data": "else", "valid": false } ] }, { "description": "if with boolean schema false", "schema": { "if": false, "then": { "const": "then" }, "else": { "const": "else" } }, "tests": [ { "description": "boolean schema false in if always chooses the else path (invalid)", "data": "then", "valid": false }, { "description": "boolean schema false in if always chooses the else path (valid)", "data": "else", "valid": true } ] }, { "description": "if appears at the end when serialized (keyword processing sequence)", "schema": { "then": { "const": "yes" }, "else": { "const": "other" }, "if": { "maxLength": 4 } }, "tests": [ { "description": "yes redirects to then and passes", "data": "yes", "valid": true }, { "description": "other redirects to else and passes", "data": "other", "valid": true }, { "description": "no redirects to then and fails", "data": "no", "valid": false }, { "description": "invalid redirects to else and fails", "data": "invalid", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/infinite-loop-detection.json000066400000000000000000000017461426774651400314420ustar00rootroot00000000000000[ { "description": "evaluating the same schema location against the same data location twice is not a sign of an infinite loop", "schema": { "definitions": { "int": { "type": "integer" } }, "allOf": [ { "properties": { "foo": { "$ref": "#/definitions/int" } } }, { "additionalProperties": { "$ref": "#/definitions/int" } } ] }, "tests": [ { "description": "passing case", "data": { "foo": 1 }, "valid": true }, { "description": "failing case", "data": { "foo": "a string" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/items.json000066400000000000000000000162251426774651400260310ustar00rootroot00000000000000[ { "description": "a schema given for items", "schema": { "items": {"type": "integer"} }, "tests": [ { "description": "valid items", "data": [ 1, 2, 3 ], "valid": true }, { "description": "wrong type of items", "data": [1, "x"], "valid": false }, { "description": "ignores non-arrays", "data": {"foo" : "bar"}, "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "length": 1 }, "valid": true } ] }, { "description": "an array of schemas for items", "schema": { "items": [ {"type": "integer"}, {"type": "string"} ] }, "tests": [ { "description": "correct types", "data": [ 1, "foo" ], "valid": true }, { "description": "wrong types", "data": [ "foo", 1 ], "valid": false }, { "description": "incomplete array of items", "data": [ 1 ], "valid": true }, { "description": "array with additional items", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array", "data": [ ], "valid": true }, { "description": "JavaScript pseudo-array is valid", "data": { "0": "invalid", "1": "valid", "length": 2 }, "valid": true } ] }, { "description": "items with boolean schema (true)", "schema": {"items": true}, "tests": [ { "description": "any array is valid", "data": [ 1, "foo", true ], "valid": true }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schema (false)", "schema": {"items": false}, "tests": [ { "description": "any non-empty array is invalid", "data": [ 1, "foo", true ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items with boolean schemas", "schema": { "items": [true, false] }, "tests": [ { "description": "array with one item is valid", "data": [ 1 ], "valid": true }, { "description": "array with two items is invalid", "data": [ 1, "foo" ], "valid": false }, { "description": "empty array is valid", "data": [], "valid": true } ] }, { "description": "items and subitems", "schema": { "definitions": { "item": { "type": "array", "additionalItems": false, "items": [ { "$ref": "#/definitions/sub-item" }, { "$ref": "#/definitions/sub-item" } ] }, "sub-item": { "type": "object", "required": ["foo"] } }, "type": "array", "additionalItems": false, "items": [ { "$ref": "#/definitions/item" }, { "$ref": "#/definitions/item" }, { "$ref": "#/definitions/item" } ] }, "tests": [ { "description": "valid items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": true }, { "description": "too many items", "data": [ [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "too many sub-items", "data": [ [ {"foo": null}, {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong item", "data": [ {"foo": null}, [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "wrong sub-item", "data": [ [ {}, {"foo": null} ], [ {"foo": null}, {"foo": null} ], [ {"foo": null}, {"foo": null} ] ], "valid": false }, { "description": "fewer items is valid", "data": [ [ {"foo": null} ], [ {"foo": null} ] ], "valid": true } ] }, { "description": "nested items", "schema": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "array", "items": { "type": "number" } } } } }, "tests": [ { "description": "valid nested array", "data": [[[[1]], [[2],[3]]], [[[4], [5], [6]]]], "valid": true }, { "description": "nested array with invalid type", "data": [[[["1"]], [[2],[3]]], [[[4], [5], [6]]]], "valid": false }, { "description": "not deep enough", "data": [[[1], [2],[3]], [[4], [5], [6]]], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/maxItems.json000066400000000000000000000013021426774651400264650ustar00rootroot00000000000000[ { "description": "maxItems validation", "schema": {"maxItems": 2}, "tests": [ { "description": "shorter is valid", "data": [1], "valid": true }, { "description": "exact length is valid", "data": [1, 2], "valid": true }, { "description": "too long is invalid", "data": [1, 2, 3], "valid": false }, { "description": "ignores non-arrays", "data": "foobar", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/maxLength.json000066400000000000000000000016001426774651400266260ustar00rootroot00000000000000[ { "description": "maxLength validation", "schema": {"maxLength": 2}, "tests": [ { "description": "shorter is valid", "data": "f", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too long is invalid", "data": "foo", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true }, { "description": "two supplementary Unicode code points is long enough", "data": "\uD83D\uDCA9\uD83D\uDCA9", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/maxProperties.json000066400000000000000000000027321426774651400275500ustar00rootroot00000000000000[ { "description": "maxProperties validation", "schema": {"maxProperties": 2}, "tests": [ { "description": "shorter is valid", "data": {"foo": 1}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "too long is invalid", "data": {"foo": 1, "bar": 2, "baz": 3}, "valid": false }, { "description": "ignores arrays", "data": [1, 2, 3], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "maxProperties = 0 means the object is empty", "schema": { "maxProperties": 0 }, "tests": [ { "description": "no properties is valid", "data": {}, "valid": true }, { "description": "one property is invalid", "data": { "foo": 1 }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/maximum.json000066400000000000000000000027041426774651400263620ustar00rootroot00000000000000[ { "description": "maximum validation", "schema": {"maximum": 3.0}, "tests": [ { "description": "below the maximum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 3.0, "valid": true }, { "description": "above the maximum is invalid", "data": 3.5, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "maximum validation with unsigned integer", "schema": {"maximum": 300}, "tests": [ { "description": "below the maximum is invalid", "data": 299.97, "valid": true }, { "description": "boundary point integer is valid", "data": 300, "valid": true }, { "description": "boundary point float is valid", "data": 300.00, "valid": true }, { "description": "above the maximum is invalid", "data": 300.5, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/minItems.json000066400000000000000000000012651426774651400264730ustar00rootroot00000000000000[ { "description": "minItems validation", "schema": {"minItems": 1}, "tests": [ { "description": "longer is valid", "data": [1, 2], "valid": true }, { "description": "exact length is valid", "data": [1], "valid": true }, { "description": "too short is invalid", "data": [], "valid": false }, { "description": "ignores non-arrays", "data": "", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/minLength.json000066400000000000000000000015661426774651400266370ustar00rootroot00000000000000[ { "description": "minLength validation", "schema": {"minLength": 2}, "tests": [ { "description": "longer is valid", "data": "foo", "valid": true }, { "description": "exact length is valid", "data": "fo", "valid": true }, { "description": "too short is invalid", "data": "f", "valid": false }, { "description": "ignores non-strings", "data": 1, "valid": true }, { "description": "one supplementary Unicode code point is not long enough", "data": "\uD83D\uDCA9", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/minProperties.json000066400000000000000000000017541426774651400275510ustar00rootroot00000000000000[ { "description": "minProperties validation", "schema": {"minProperties": 1}, "tests": [ { "description": "longer is valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "exact length is valid", "data": {"foo": 1}, "valid": true }, { "description": "too short is invalid", "data": {}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/minimum.json000066400000000000000000000036121426774651400263570ustar00rootroot00000000000000[ { "description": "minimum validation", "schema": {"minimum": 1.1}, "tests": [ { "description": "above the minimum is valid", "data": 2.6, "valid": true }, { "description": "boundary point is valid", "data": 1.1, "valid": true }, { "description": "below the minimum is invalid", "data": 0.6, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] }, { "description": "minimum validation with signed integer", "schema": {"minimum": -2}, "tests": [ { "description": "negative above the minimum is valid", "data": -1, "valid": true }, { "description": "positive above the minimum is valid", "data": 0, "valid": true }, { "description": "boundary point is valid", "data": -2, "valid": true }, { "description": "boundary point with float is valid", "data": -2.0, "valid": true }, { "description": "float below the minimum is invalid", "data": -2.0001, "valid": false }, { "description": "int below the minimum is invalid", "data": -3, "valid": false }, { "description": "ignores non-numbers", "data": "x", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/multipleOf.json000066400000000000000000000035771426774651400270360ustar00rootroot00000000000000[ { "description": "by int", "schema": {"multipleOf": 2}, "tests": [ { "description": "int by int", "data": 10, "valid": true }, { "description": "int by int fail", "data": 7, "valid": false }, { "description": "ignores non-numbers", "data": "foo", "valid": true } ] }, { "description": "by number", "schema": {"multipleOf": 1.5}, "tests": [ { "description": "zero is multiple of anything", "data": 0, "valid": true }, { "description": "4.5 is multiple of 1.5", "data": 4.5, "valid": true }, { "description": "35 is not multiple of 1.5", "data": 35, "valid": false } ] }, { "description": "by small number", "schema": {"multipleOf": 0.0001}, "tests": [ { "description": "0.0075 is multiple of 0.0001", "data": 0.0075, "valid": true }, { "description": "0.00751 is not multiple of 0.0001", "data": 0.00751, "valid": false } ] }, { "description": "invalid instance should not raise error when float division = inf", "schema": {"type": "integer", "multipleOf": 0.123456789}, "tests": [ { "description": "always invalid, but naive implementations may raise an overflow error", "data": 1e308, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/not.json000066400000000000000000000053761426774651400255150ustar00rootroot00000000000000[ { "description": "not", "schema": { "not": {"type": "integer"} }, "tests": [ { "description": "allowed", "data": "foo", "valid": true }, { "description": "disallowed", "data": 1, "valid": false } ] }, { "description": "not multiple types", "schema": { "not": {"type": ["integer", "boolean"]} }, "tests": [ { "description": "valid", "data": "foo", "valid": true }, { "description": "mismatch", "data": 1, "valid": false }, { "description": "other mismatch", "data": true, "valid": false } ] }, { "description": "not more complex schema", "schema": { "not": { "type": "object", "properties": { "foo": { "type": "string" } } } }, "tests": [ { "description": "match", "data": 1, "valid": true }, { "description": "other match", "data": {"foo": 1}, "valid": true }, { "description": "mismatch", "data": {"foo": "bar"}, "valid": false } ] }, { "description": "forbidden property", "schema": { "properties": { "foo": { "not": {} } } }, "tests": [ { "description": "property present", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "property absent", "data": {"bar": 1, "baz": 2}, "valid": true } ] }, { "description": "not with boolean schema true", "schema": {"not": true}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "not with boolean schema false", "schema": {"not": false}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/oneOf.json000066400000000000000000000161231426774651400257530ustar00rootroot00000000000000[ { "description": "oneOf", "schema": { "oneOf": [ { "type": "integer" }, { "minimum": 2 } ] }, "tests": [ { "description": "first oneOf valid", "data": 1, "valid": true }, { "description": "second oneOf valid", "data": 2.5, "valid": true }, { "description": "both oneOf valid", "data": 3, "valid": false }, { "description": "neither oneOf valid", "data": 1.5, "valid": false } ] }, { "description": "oneOf with base schema", "schema": { "type": "string", "oneOf" : [ { "minLength": 2 }, { "maxLength": 4 } ] }, "tests": [ { "description": "mismatch base schema", "data": 3, "valid": false }, { "description": "one oneOf valid", "data": "foobar", "valid": true }, { "description": "both oneOf valid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all true", "schema": {"oneOf": [true, true, true]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, one true", "schema": {"oneOf": [true, false, false]}, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "oneOf with boolean schemas, more than one true", "schema": {"oneOf": [true, true, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf with boolean schemas, all false", "schema": {"oneOf": [false, false, false]}, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "oneOf complex types", "schema": { "oneOf": [ { "properties": { "bar": {"type": "integer"} }, "required": ["bar"] }, { "properties": { "foo": {"type": "string"} }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid (complex)", "data": {"bar": 2}, "valid": true }, { "description": "second oneOf valid (complex)", "data": {"foo": "baz"}, "valid": true }, { "description": "both oneOf valid (complex)", "data": {"foo": "baz", "bar": 2}, "valid": false }, { "description": "neither oneOf valid (complex)", "data": {"foo": 2, "bar": "quux"}, "valid": false } ] }, { "description": "oneOf with empty schema", "schema": { "oneOf": [ { "type": "number" }, {} ] }, "tests": [ { "description": "one valid - valid", "data": "foo", "valid": true }, { "description": "both valid - invalid", "data": 123, "valid": false } ] }, { "description": "oneOf with required", "schema": { "type": "object", "oneOf": [ { "required": ["foo", "bar"] }, { "required": ["foo", "baz"] } ] }, "tests": [ { "description": "both invalid - invalid", "data": {"bar": 2}, "valid": false }, { "description": "first valid - valid", "data": {"foo": 1, "bar": 2}, "valid": true }, { "description": "second valid - valid", "data": {"foo": 1, "baz": 3}, "valid": true }, { "description": "both valid - invalid", "data": {"foo": 1, "bar": 2, "baz" : 3}, "valid": false } ] }, { "description": "oneOf with missing optional property", "schema": { "oneOf": [ { "properties": { "bar": true, "baz": true }, "required": ["bar"] }, { "properties": { "foo": true }, "required": ["foo"] } ] }, "tests": [ { "description": "first oneOf valid", "data": {"bar": 8}, "valid": true }, { "description": "second oneOf valid", "data": {"foo": "foo"}, "valid": true }, { "description": "both oneOf valid", "data": {"foo": "foo", "bar": 8}, "valid": false }, { "description": "neither oneOf valid", "data": {"baz": "quux"}, "valid": false } ] }, { "description": "nested oneOf, to check validation semantics", "schema": { "oneOf": [ { "oneOf": [ { "type": "null" } ] } ] }, "tests": [ { "description": "null is valid", "data": null, "valid": true }, { "description": "anything non-null is invalid", "data": 123, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/000077500000000000000000000000001426774651400256345ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/bignum.json000066400000000000000000000057111426774651400300140ustar00rootroot00000000000000[ { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a bignum is an integer", "data": 12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a bignum is a number", "data": 98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "integer", "schema": {"type": "integer"}, "tests": [ { "description": "a negative bignum is an integer", "data": -12345678910111213141516171819202122232425262728293031, "valid": true } ] }, { "description": "number", "schema": {"type": "number"}, "tests": [ { "description": "a negative bignum is a number", "data": -98249283749234923498293171823948729348710298301928331, "valid": true } ] }, { "description": "string", "schema": {"type": "string"}, "tests": [ { "description": "a bignum is not a string", "data": 98249283749234923498293171823948729348710298301928331, "valid": false } ] }, { "description": "integer comparison", "schema": {"maximum": 18446744073709551615}, "tests": [ { "description": "comparison works for high numbers", "data": 18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision", "schema": { "exclusiveMaximum": 972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for high numbers", "data": 972783798187987123879878123.188781371, "valid": false } ] }, { "description": "integer comparison", "schema": {"minimum": -18446744073709551615}, "tests": [ { "description": "comparison works for very negative numbers", "data": -18446744073709551600, "valid": true } ] }, { "description": "float comparison with high precision on negative numbers", "schema": { "exclusiveMinimum": -972783798187987123879878123.18878137 }, "tests": [ { "description": "comparison works for very negative numbers", "data": -972783798187987123879878123.188781371, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/content.json000066400000000000000000000042741426774651400302100ustar00rootroot00000000000000[ { "description": "validation of string-encoded content based on media type", "schema": { "contentMediaType": "application/json" }, "tests": [ { "description": "a valid JSON document", "data": "{\"foo\": \"bar\"}", "valid": true }, { "description": "an invalid JSON document", "data": "{:}", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary string-encoding", "schema": { "contentEncoding": "base64" }, "tests": [ { "description": "a valid base64 string", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "an invalid base64 string (% is not a valid character)", "data": "eyJmb28iOi%iYmFyIn0K", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true } ] }, { "description": "validation of binary-encoded media type documents", "schema": { "contentMediaType": "application/json", "contentEncoding": "base64" }, "tests": [ { "description": "a valid base64-encoded JSON document", "data": "eyJmb28iOiAiYmFyIn0K", "valid": true }, { "description": "a validly-encoded invalid JSON document", "data": "ezp9Cg==", "valid": false }, { "description": "an invalid base64 string that is valid JSON", "data": "{}", "valid": false }, { "description": "ignores non-strings", "data": 100, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/ecmascript-regex.json000066400000000000000000000202161426774651400317720ustar00rootroot00000000000000[ { "description": "ECMA 262 regex $ does not match trailing newline", "schema": { "type": "string", "pattern": "^abc$" }, "tests": [ { "description": "matches in Python, but should not in jsonschema", "data": "abc\n", "valid": false }, { "description": "should match", "data": "abc", "valid": true } ] }, { "description": "ECMA 262 regex converts \\t to horizontal tab", "schema": { "type": "string", "pattern": "^\\t$" }, "tests": [ { "description": "does not match", "data": "\\t", "valid": false }, { "description": "matches", "data": "\u0009", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and upper letter", "schema": { "type": "string", "pattern": "^\\cC$" }, "tests": [ { "description": "does not match", "data": "\\cC", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 regex escapes control codes with \\c and lower letter", "schema": { "type": "string", "pattern": "^\\cc$" }, "tests": [ { "description": "does not match", "data": "\\cc", "valid": false }, { "description": "matches", "data": "\u0003", "valid": true } ] }, { "description": "ECMA 262 \\d matches ascii digits only", "schema": { "type": "string", "pattern": "^\\d$" }, "tests": [ { "description": "ASCII zero matches", "data": "0", "valid": true }, { "description": "NKO DIGIT ZERO does not match (unlike e.g. Python)", "data": "߀", "valid": false }, { "description": "NKO DIGIT ZERO (as \\u escape) does not match", "data": "\u07c0", "valid": false } ] }, { "description": "ECMA 262 \\D matches everything but ascii digits", "schema": { "type": "string", "pattern": "^\\D$" }, "tests": [ { "description": "ASCII zero does not match", "data": "0", "valid": false }, { "description": "NKO DIGIT ZERO matches (unlike e.g. Python)", "data": "߀", "valid": true }, { "description": "NKO DIGIT ZERO (as \\u escape) matches", "data": "\u07c0", "valid": true } ] }, { "description": "ECMA 262 \\w matches ascii letters only", "schema": { "type": "string", "pattern": "^\\w$" }, "tests": [ { "description": "ASCII 'a' matches", "data": "a", "valid": true }, { "description": "latin-1 e-acute does not match (unlike e.g. Python)", "data": "é", "valid": false } ] }, { "description": "ECMA 262 \\W matches everything but ascii letters", "schema": { "type": "string", "pattern": "^\\W$" }, "tests": [ { "description": "ASCII 'a' does not match", "data": "a", "valid": false }, { "description": "latin-1 e-acute matches (unlike e.g. Python)", "data": "é", "valid": true } ] }, { "description": "ECMA 262 \\s matches whitespace", "schema": { "type": "string", "pattern": "^\\s$" }, "tests": [ { "description": "ASCII space matches", "data": " ", "valid": true }, { "description": "Character tabulation matches", "data": "\t", "valid": true }, { "description": "Line tabulation matches", "data": "\u000b", "valid": true }, { "description": "Form feed matches", "data": "\u000c", "valid": true }, { "description": "latin-1 non-breaking-space matches", "data": "\u00a0", "valid": true }, { "description": "zero-width whitespace matches", "data": "\ufeff", "valid": true }, { "description": "line feed matches (line terminator)", "data": "\u000a", "valid": true }, { "description": "paragraph separator matches (line terminator)", "data": "\u2029", "valid": true }, { "description": "EM SPACE matches (Space_Separator)", "data": "\u2003", "valid": true }, { "description": "Non-whitespace control does not match", "data": "\u0001", "valid": false }, { "description": "Non-whitespace does not match", "data": "\u2013", "valid": false } ] }, { "description": "ECMA 262 \\S matches everything but whitespace", "schema": { "type": "string", "pattern": "^\\S$" }, "tests": [ { "description": "ASCII space does not match", "data": " ", "valid": false }, { "description": "Character tabulation does not match", "data": "\t", "valid": false }, { "description": "Line tabulation does not match", "data": "\u000b", "valid": false }, { "description": "Form feed does not match", "data": "\u000c", "valid": false }, { "description": "latin-1 non-breaking-space does not match", "data": "\u00a0", "valid": false }, { "description": "zero-width whitespace does not match", "data": "\ufeff", "valid": false }, { "description": "line feed does not match (line terminator)", "data": "\u000a", "valid": false }, { "description": "paragraph separator does not match (line terminator)", "data": "\u2029", "valid": false }, { "description": "EM SPACE does not match (Space_Separator)", "data": "\u2003", "valid": false }, { "description": "Non-whitespace control matches", "data": "\u0001", "valid": true }, { "description": "Non-whitespace matches", "data": "\u2013", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/float-overflow.json000066400000000000000000000005511426774651400314760ustar00rootroot00000000000000[ { "description": "all integers are multiples of 0.5, if overflow is handled", "schema": {"type": "integer", "multipleOf": 0.5}, "tests": [ { "description": "valid if optional overflow handling is implemented", "data": 1e308, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/000077500000000000000000000000001426774651400271245ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/date-time.json000066400000000000000000000041421426774651400316710ustar00rootroot00000000000000[ { "description": "validation of date-time strings", "schema": {"format": "date-time"}, "tests": [ { "description": "a valid date-time string", "data": "1963-06-19T08:30:06.283185Z", "valid": true }, { "description": "a valid date-time string without second fraction", "data": "1963-06-19T08:30:06Z", "valid": true }, { "description": "a valid date-time string with plus offset", "data": "1937-01-01T12:00:27.87+00:20", "valid": true }, { "description": "a valid date-time string with minus offset", "data": "1990-12-31T15:59:50.123-08:00", "valid": true }, { "description": "a invalid day in date-time string", "data": "1990-02-31T15:59:60.123-08:00", "valid": false }, { "description": "an invalid offset in date-time string", "data": "1990-12-31T15:59:60-24:00", "valid": false }, { "description": "an invalid date-time string", "data": "06/19/1963 08:30:06 PST", "valid": false }, { "description": "case-insensitive T and Z", "data": "1963-06-19t08:30:06.283185z", "valid": true }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350T01:01:01", "valid": false }, { "description": "invalid non-padded month dates", "data": "1963-6-19T08:30:06.283185Z", "valid": false }, { "description": "invalid non-padded day dates", "data": "1963-06-1T08:30:06.283185Z", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/date.json000066400000000000000000000131301426774651400307320ustar00rootroot00000000000000[ { "description": "validation of date strings", "schema": {"format": "date"}, "tests": [ { "description": "a valid date string", "data": "1963-06-19", "valid": true }, { "description": "a valid date string with 31 days in January", "data": "2020-01-31", "valid": true }, { "description": "a invalid date string with 32 days in January", "data": "2020-01-32", "valid": false }, { "description": "a valid date string with 28 days in February (normal)", "data": "2021-02-28", "valid": true }, { "description": "a invalid date string with 29 days in February (normal)", "data": "2021-02-29", "valid": false }, { "description": "a valid date string with 29 days in February (leap)", "data": "2020-02-29", "valid": true }, { "description": "a invalid date string with 30 days in February (leap)", "data": "2020-02-30", "valid": false }, { "description": "a valid date string with 31 days in March", "data": "2020-03-31", "valid": true }, { "description": "a invalid date string with 32 days in March", "data": "2020-03-32", "valid": false }, { "description": "a valid date string with 30 days in April", "data": "2020-04-30", "valid": true }, { "description": "a invalid date string with 31 days in April", "data": "2020-04-31", "valid": false }, { "description": "a valid date string with 31 days in May", "data": "2020-05-31", "valid": true }, { "description": "a invalid date string with 32 days in May", "data": "2020-05-32", "valid": false }, { "description": "a valid date string with 30 days in June", "data": "2020-06-30", "valid": true }, { "description": "a invalid date string with 31 days in June", "data": "2020-06-31", "valid": false }, { "description": "a valid date string with 31 days in July", "data": "2020-07-31", "valid": true }, { "description": "a invalid date string with 32 days in July", "data": "2020-07-32", "valid": false }, { "description": "a valid date string with 31 days in August", "data": "2020-08-31", "valid": true }, { "description": "a invalid date string with 32 days in August", "data": "2020-08-32", "valid": false }, { "description": "a valid date string with 30 days in September", "data": "2020-09-30", "valid": true }, { "description": "a invalid date string with 31 days in September", "data": "2020-09-31", "valid": false }, { "description": "a valid date string with 31 days in October", "data": "2020-10-31", "valid": true }, { "description": "a invalid date string with 32 days in October", "data": "2020-10-32", "valid": false }, { "description": "a valid date string with 30 days in November", "data": "2020-11-30", "valid": true }, { "description": "a invalid date string with 31 days in November", "data": "2020-11-31", "valid": false }, { "description": "a valid date string with 31 days in December", "data": "2020-12-31", "valid": true }, { "description": "a invalid date string with 32 days in December", "data": "2020-12-32", "valid": false }, { "description": "a invalid date string with invalid month", "data": "2020-13-01", "valid": false }, { "description": "an invalid date string", "data": "06/19/1963", "valid": false }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "2013-350", "valid": false }, { "description": "invalidates non-padded month dates", "data": "1998-1-20", "valid": false }, { "description": "invalidates non-padded day dates", "data": "1998-01-1", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/email.json000066400000000000000000000032331426774651400311070ustar00rootroot00000000000000[ { "description": "validation of e-mail addresses", "schema": {"format": "email"}, "tests": [ { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false }, { "description": "tilde in local part is valid", "data": "te~st@example.com", "valid": true }, { "description": "tilde before local part is valid", "data": "~test@example.com", "valid": true }, { "description": "tilde after local part is valid", "data": "test~@example.com", "valid": true }, { "description": "dot before local part is not valid", "data": ".test@example.com", "valid": false }, { "description": "dot after local part is not valid", "data": "test.@example.com", "valid": false }, { "description": "two separated dots inside local part are valid", "data": "te.s.t@example.com", "valid": true }, { "description": "two subsequent dots inside local part are not valid", "data": "te..st@example.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/hostname.json000066400000000000000000000043531426774651400316420ustar00rootroot00000000000000[ { "description": "validation of host names", "schema": {"format": "hostname"}, "tests": [ { "description": "a valid host name", "data": "www.example.com", "valid": true }, { "description": "a valid punycoded IDN hostname", "data": "xn--4gbwdl.xn--wgbh1c", "valid": true }, { "description": "a host name starting with an illegal character", "data": "-a-host-name-that-starts-with--", "valid": false }, { "description": "a host name containing illegal characters", "data": "not_a_valid_host_name", "valid": false }, { "description": "a host name with a component too long", "data": "a-vvvvvvvvvvvvvvvveeeeeeeeeeeeeeeerrrrrrrrrrrrrrrryyyyyyyyyyyyyyyy-long-host-name-component", "valid": false }, { "description": "starts with hyphen", "data": "-hostname", "valid": false }, { "description": "ends with hyphen", "data": "hostname-", "valid": false }, { "description": "starts with underscore", "data": "_hostname", "valid": false }, { "description": "ends with underscore", "data": "hostname_", "valid": false }, { "description": "contains underscore", "data": "host_name", "valid": false }, { "description": "maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijk.com", "valid": true }, { "description": "exceeds maximum label length", "data": "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl.com", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/idn-email.json000066400000000000000000000015031426774651400316550ustar00rootroot00000000000000[ { "description": "validation of an internationalized e-mail addresses", "schema": {"format": "idn-email"}, "tests": [ { "description": "a valid idn e-mail (example@example.test in Hangul)", "data": "실례@실례.테스트", "valid": true }, { "description": "an invalid idn e-mail address", "data": "2962", "valid": false }, { "description": "a valid e-mail address", "data": "joe.bloggs@example.com", "valid": true }, { "description": "an invalid e-mail address", "data": "2962", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/idn-hostname.json000066400000000000000000000327741426774651400324220ustar00rootroot00000000000000[ { "description": "validation of internationalized host names", "schema": {"format": "idn-hostname"}, "tests": [ { "description": "a valid host name (example.test in Hangul)", "data": "실례.테스트", "valid": true }, { "description": "illegal first char U+302E Hangul single dot tone mark", "data": "〮실례.테스트", "valid": false }, { "description": "contains illegal char U+302E Hangul single dot tone mark", "data": "실〮례.테스트", "valid": false }, { "description": "a host name with a component too long", "data": "실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실실례례테스트례례례례례례례례례례례례례례례례례테스트례례례례례례례례례례례례례례례례례례례테스트례례례례례례례례례례례례테스트례례실례.테스트", "valid": false }, { "description": "invalid label, correct Punycode", "comment": "https://tools.ietf.org/html/rfc5890#section-2.3.2.1 https://tools.ietf.org/html/rfc5891#section-4.4 https://tools.ietf.org/html/rfc3492#section-7.1", "data": "-> $1.00 <--", "valid": false }, { "description": "valid Chinese Punycode", "comment": "https://tools.ietf.org/html/rfc5890#section-2.3.2.1 https://tools.ietf.org/html/rfc5891#section-4.4", "data": "xn--ihqwcrb4cv8a8dqg056pqjye", "valid": true }, { "description": "invalid Punycode", "comment": "https://tools.ietf.org/html/rfc5891#section-4.4 https://tools.ietf.org/html/rfc5890#section-2.3.2.1", "data": "xn--X", "valid": false }, { "description": "U-label contains \"--\" in the 3rd and 4th position", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1 https://tools.ietf.org/html/rfc5890#section-2.3.2.1", "data": "XN--aa---o47jg78q", "valid": false }, { "description": "U-label starts with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "-hello", "valid": false }, { "description": "U-label ends with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "hello-", "valid": false }, { "description": "U-label starts and ends with a dash", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.1", "data": "-hello-", "valid": false }, { "description": "Begins with a Spacing Combining Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0903hello", "valid": false }, { "description": "Begins with a Nonspacing Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0300hello", "valid": false }, { "description": "Begins with an Enclosing Mark", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.2", "data": "\u0488hello", "valid": false }, { "description": "Exceptions that are PVALID, left-to-right chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u00df\u03c2\u0f0b\u3007", "valid": true }, { "description": "Exceptions that are PVALID, right-to-left chars", "comment": "https://tools.ietf.org/html/rfc/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u06fd\u06fe", "valid": true }, { "description": "Exceptions that are DISALLOWED, right-to-left chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6", "data": "\u0640\u07fa", "valid": false }, { "description": "Exceptions that are DISALLOWED, left-to-right chars", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.2 https://tools.ietf.org/html/rfc5892#section-2.6 Note: The two combining marks (U+302E and U+302F) are in the middle and not at the start", "data": "\u3031\u3032\u3033\u3034\u3035\u302e\u302f\u303b", "valid": false }, { "description": "MIDDLE DOT with no preceding 'l'", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "a\u00b7l", "valid": false }, { "description": "MIDDLE DOT with nothing preceding", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "\u00b7l", "valid": false }, { "description": "MIDDLE DOT with no following 'l'", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7a", "valid": false }, { "description": "MIDDLE DOT with nothing following", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7", "valid": false }, { "description": "MIDDLE DOT with surrounding 'l's", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.3", "data": "l\u00b7l", "valid": true }, { "description": "Greek KERAIA not followed by Greek", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375S", "valid": false }, { "description": "Greek KERAIA not followed by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375", "valid": false }, { "description": "Greek KERAIA followed by Greek", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.4", "data": "\u03b1\u0375\u03b2", "valid": true }, { "description": "Hebrew GERESH not preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "A\u05f3\u05d1", "valid": false }, { "description": "Hebrew GERESH not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "\u05f3\u05d1", "valid": false }, { "description": "Hebrew GERESH preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.5", "data": "\u05d0\u05f3\u05d1", "valid": true }, { "description": "Hebrew GERSHAYIM not preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "A\u05f4\u05d1", "valid": false }, { "description": "Hebrew GERSHAYIM not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "\u05f4\u05d1", "valid": false }, { "description": "Hebrew GERSHAYIM preceded by Hebrew", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.6", "data": "\u05d0\u05f4\u05d1", "valid": true }, { "description": "KATAKANA MIDDLE DOT with no Hiragana, Katakana, or Han", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "def\u30fbabc", "valid": false }, { "description": "KATAKANA MIDDLE DOT with no other characters", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb", "valid": false }, { "description": "KATAKANA MIDDLE DOT with Hiragana", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u3041", "valid": true }, { "description": "KATAKANA MIDDLE DOT with Katakana", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u30a1", "valid": true }, { "description": "KATAKANA MIDDLE DOT with Han", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.7", "data": "\u30fb\u4e08", "valid": true }, { "description": "Arabic-Indic digits mixed with Extended Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.8", "data": "\u0660\u06f0", "valid": false }, { "description": "Arabic-Indic digits not mixed with Extended Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.8", "data": "\u0628\u0660\u0628", "valid": true }, { "description": "Extended Arabic-Indic digits not mixed with Arabic-Indic digits", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.9", "data": "\u06f00", "valid": true }, { "description": "ZERO WIDTH JOINER not preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u0915\u200d\u0937", "valid": false }, { "description": "ZERO WIDTH JOINER not preceded by anything", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u200d\u0937", "valid": false }, { "description": "ZERO WIDTH JOINER preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.2 https://www.unicode.org/review/pr-37.pdf", "data": "\u0915\u094d\u200d\u0937", "valid": true }, { "description": "ZERO WIDTH NON-JOINER preceded by Virama", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.1", "data": "\u0915\u094d\u200c\u0937", "valid": true }, { "description": "ZERO WIDTH NON-JOINER not preceded by Virama but matches regexp", "comment": "https://tools.ietf.org/html/rfc5891#section-4.2.3.3 https://tools.ietf.org/html/rfc5892#appendix-A.1 https://www.w3.org/TR/alreq/#h_disjoining_enforcement", "data": "\u0628\u064a\u200c\u0628\u064a", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/ipv4.json000066400000000000000000000032731426774651400307060ustar00rootroot00000000000000[ { "description": "validation of IP addresses", "schema": {"format": "ipv4"}, "tests": [ { "description": "a valid IP address", "data": "192.168.0.1", "valid": true }, { "description": "an IP address with too many components", "data": "127.0.0.0.1", "valid": false }, { "description": "an IP address with out-of-range values", "data": "256.256.256.256", "valid": false }, { "description": "an IP address without 4 components", "data": "127.0", "valid": false }, { "description": "an IP address as an integer", "data": "0x7f000001", "valid": false }, { "description": "an IP address as an integer (decimal)", "data": "2130706433", "valid": false }, { "description": "leading zeroes should be rejected, as they are treated as octals", "comment": "see https://sick.codes/universal-netmask-npm-package-used-by-270000-projects-vulnerable-to-octal-input-data-server-side-request-forgery-remote-file-inclusion-local-file-inclusion-and-more-cve-2021-28918/", "data": "087.10.0.1", "valid": false }, { "description": "value without leading zero is valid", "data": "87.10.0.1", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/ipv6.json000066400000000000000000000120111426774651400306760ustar00rootroot00000000000000[ { "description": "validation of IPv6 addresses", "schema": {"format": "ipv6"}, "tests": [ { "description": "a valid IPv6 address", "data": "::1", "valid": true }, { "description": "an IPv6 address with out-of-range values", "data": "12345::", "valid": false }, { "description": "an IPv6 address with too many components", "data": "1:1:1:1:1:1:1:1:1:1:1:1:1:1:1:1", "valid": false }, { "description": "an IPv6 address containing illegal characters", "data": "::laptop", "valid": false }, { "description": "no digits is valid", "data": "::", "valid": true }, { "description": "leading colons is valid", "data": "::42:ff:1", "valid": true }, { "description": "trailing colons is valid", "data": "d6::", "valid": true }, { "description": "missing leading octet is invalid", "data": ":2:3:4:5:6:7:8", "valid": false }, { "description": "missing trailing octet is invalid", "data": "1:2:3:4:5:6:7:", "valid": false }, { "description": "missing leading octet with omitted octets later", "data": ":2:3:4::8", "valid": false }, { "description": "two sets of double colons is invalid", "data": "1::d6::42", "valid": false }, { "description": "mixed format with the ipv4 section as decimal octets", "data": "1::d6:192.168.0.1", "valid": true }, { "description": "mixed format with double colons between the sections", "data": "1:2::192.168.0.1", "valid": true }, { "description": "mixed format with ipv4 section with octet out of range", "data": "1::2:192.168.256.1", "valid": false }, { "description": "mixed format with ipv4 section with a hex octet", "data": "1::2:192.168.ff.1", "valid": false }, { "description": "mixed format with leading double colons (ipv4-mapped ipv6 address)", "data": "::ffff:192.168.0.1", "valid": true }, { "description": "triple colons is invalid", "data": "1:2:3:4:5:::8", "valid": false }, { "description": "8 octets", "data": "1:2:3:4:5:6:7:8", "valid": true }, { "description": "insufficient octets without double colons", "data": "1:2:3:4:5:6:7", "valid": false }, { "description": "no colons is invalid", "data": "1", "valid": false }, { "description": "ipv4 is not ipv6", "data": "127.0.0.1", "valid": false }, { "description": "ipv4 segment must have 4 octets", "data": "1:2:3:4:1.2.3", "valid": false }, { "description": "leading whitespace is invalid", "data": " ::1", "valid": false }, { "description": "trailing whitespace is invalid", "data": "::1 ", "valid": false }, { "description": "netmask is not a part of ipv6 address", "data": "fe80::/64", "valid": false }, { "description": "zone id is not a part of ipv6 address", "data": "fe80::a%eth1", "valid": false }, { "description": "a long valid ipv6", "data": "1000:1000:1000:1000:1000:1000:255.255.255.255", "valid": true }, { "description": "a long invalid ipv6, below length limit, first", "data": "100:100:100:100:100:100:255.255.255.255.255", "valid": false }, { "description": "a long invalid ipv6, below length limit, second", "data": "100:100:100:100:100:100:100:255.255.255.255", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/iri-reference.json000066400000000000000000000024411426774651400325370ustar00rootroot00000000000000[ { "description": "validation of IRI References", "schema": {"format": "iri-reference"}, "tests": [ { "description": "a valid IRI", "data": "http://ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid protocol-relative IRI Reference", "data": "//ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid relative IRI Reference", "data": "/âππ", "valid": true }, { "description": "an invalid IRI Reference", "data": "\\\\WINDOWS\\filëßåré", "valid": false }, { "description": "a valid IRI Reference", "data": "âππ", "valid": true }, { "description": "a valid IRI fragment", "data": "#ƒrägmênt", "valid": true }, { "description": "an invalid IRI fragment", "data": "#ƒräg\\mênt", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/iri.json000066400000000000000000000034531426774651400306070ustar00rootroot00000000000000[ { "description": "validation of IRIs", "schema": {"format": "iri"}, "tests": [ { "description": "a valid IRI with anchor tag", "data": "http://ƒøø.ßår/?∂éœ=πîx#πîüx", "valid": true }, { "description": "a valid IRI with anchor tag and parentheses", "data": "http://ƒøø.com/blah_(wîkïpédiå)_blah#ßité-1", "valid": true }, { "description": "a valid IRI with URL-encoded stuff", "data": "http://ƒøø.ßår/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid IRI with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid IRI based on IPv6", "data": "http://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", "valid": true }, { "description": "an invalid IRI based on IPv6", "data": "http://2001:0db8:85a3:0000:0000:8a2e:0370:7334", "valid": false }, { "description": "an invalid relative IRI Reference", "data": "/abc", "valid": false }, { "description": "an invalid IRI", "data": "\\\\WINDOWS\\filëßåré", "valid": false }, { "description": "an invalid IRI though valid IRI reference", "data": "âππ", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/json-pointer.json000066400000000000000000000132121426774651400324450ustar00rootroot00000000000000[ { "description": "validation of JSON-pointers (JSON String Representation)", "schema": {"format": "json-pointer"}, "tests": [ { "description": "a valid JSON-pointer", "data": "/foo/bar~0/baz~1/%a", "valid": true }, { "description": "not a valid JSON-pointer (~ not escaped)", "data": "/foo/bar~", "valid": false }, { "description": "valid JSON-pointer with empty segment", "data": "/foo//bar", "valid": true }, { "description": "valid JSON-pointer with the last empty segment", "data": "/foo/bar/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #1", "data": "", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #2", "data": "/foo", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #3", "data": "/foo/0", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #4", "data": "/", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #5", "data": "/a~1b", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #6", "data": "/c%d", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #7", "data": "/e^f", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #8", "data": "/g|h", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #9", "data": "/i\\j", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #10", "data": "/k\"l", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #11", "data": "/ ", "valid": true }, { "description": "valid JSON-pointer as stated in RFC 6901 #12", "data": "/m~0n", "valid": true }, { "description": "valid JSON-pointer used adding to the last array position", "data": "/foo/-", "valid": true }, { "description": "valid JSON-pointer (- used as object member name)", "data": "/foo/-/bar", "valid": true }, { "description": "valid JSON-pointer (multiple escaped characters)", "data": "/~1~0~0~1~1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #1", "data": "/~1.1", "valid": true }, { "description": "valid JSON-pointer (escaped with fraction part) #2", "data": "/~0.1", "valid": true }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #1", "data": "#", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #2", "data": "#/", "valid": false }, { "description": "not a valid JSON-pointer (URI Fragment Identifier) #3", "data": "#a", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #1", "data": "/~0~", "valid": false }, { "description": "not a valid JSON-pointer (some escaped, but not all) #2", "data": "/~0/~", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #1", "data": "/~2", "valid": false }, { "description": "not a valid JSON-pointer (wrong escape character) #2", "data": "/~-1", "valid": false }, { "description": "not a valid JSON-pointer (multiple characters not escaped)", "data": "/~~", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #1", "data": "a", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #2", "data": "0", "valid": false }, { "description": "not a valid JSON-pointer (isn't empty nor starts with /) #3", "data": "a/a", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/regex.json000066400000000000000000000007451426774651400311370ustar00rootroot00000000000000[ { "description": "validation of regular expressions", "schema": {"format": "regex"}, "tests": [ { "description": "a valid regular expression", "data": "([abc])+\\s+$", "valid": true }, { "description": "a regular expression with unclosed parens is invalid", "data": "^(abc]", "valid": false } ] } ] relative-json-pointer.json000066400000000000000000000021541426774651400342020ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format[ { "description": "validation of Relative JSON Pointers (RJP)", "schema": {"format": "relative-json-pointer"}, "tests": [ { "description": "a valid upwards RJP", "data": "1", "valid": true }, { "description": "a valid downwards RJP", "data": "0/foo/bar", "valid": true }, { "description": "a valid up and then down RJP, with array index", "data": "2/0/baz/1/zip", "valid": true }, { "description": "a valid RJP taking the member or index name", "data": "0#", "valid": true }, { "description": "an invalid RJP that is a valid JSON Pointer", "data": "/foo/bar", "valid": false }, { "description": "negative prefix", "data": "-1/foo/bar", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/time.json000066400000000000000000000064221426774651400307610ustar00rootroot00000000000000[ { "description": "validation of time strings", "schema": {"format": "time"}, "tests": [ { "description": "a valid time string", "data": "08:30:06Z", "valid": true }, { "description": "a valid time string with leap second", "data": "23:59:60Z", "valid": true }, { "description": "a valid time string with leap second with offset", "data": "15:59:60-08:00", "valid": true }, { "description": "a valid time string with second fraction", "data": "23:20:50.52Z", "valid": true }, { "description": "a valid time string with precise second fraction", "data": "08:30:06.283185Z", "valid": true }, { "description": "a valid time string with plus offset", "data": "08:30:06+00:20", "valid": true }, { "description": "a valid time string with minus offset", "data": "08:30:06-08:00", "valid": true }, { "description": "a valid time string with case-insensitive Z", "data": "08:30:06z", "valid": true }, { "description": "an invalid time string with invalid hour", "data": "24:00:00Z", "valid": false }, { "description": "an invalid time string with invalid minute", "data": "00:60:00Z", "valid": false }, { "description": "an invalid time string with invalid second", "data": "00:00:61Z", "valid": false }, { "description": "an invalid time string with invalid leap second (wrong hour)", "data": "22:59:60Z", "valid": false }, { "description": "an invalid time string with invalid leap second (wrong minute)", "data": "23:58:60Z", "valid": false }, { "description": "an invalid time string with invalid time numoffset hour", "data": "01:02:03+24:00", "valid": false }, { "description": "an invalid time string with invalid time numoffset minute", "data": "01:02:03+00:60", "valid": false }, { "description": "an invalid time string with invalid time with both Z and numoffset", "data": "01:02:03Z+00:30", "valid": false }, { "description": "an invalid time string", "data": "08:30:06 PST", "valid": false }, { "description": "only RFC3339 not all of ISO 8601 are valid", "data": "01:01:01,1111", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/uri-reference.json000066400000000000000000000023661426774651400325610ustar00rootroot00000000000000[ { "description": "validation of URI References", "schema": {"format": "uri-reference"}, "tests": [ { "description": "a valid URI", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid relative URI Reference", "data": "/abc", "valid": true }, { "description": "an invalid URI Reference", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "a valid URI Reference", "data": "abc", "valid": true }, { "description": "a valid URI fragment", "data": "#fragment", "valid": true }, { "description": "an invalid URI fragment", "data": "#frag\\ment", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/uri-template.json000066400000000000000000000015601426774651400324310ustar00rootroot00000000000000[ { "description": "format: uri-template", "schema": {"format": "uri-template"}, "tests": [ { "description": "a valid uri-template", "data": "http://example.com/dictionary/{term:1}/{term}", "valid": true }, { "description": "an invalid uri-template", "data": "http://example.com/dictionary/{term:1}/{term", "valid": false }, { "description": "a valid uri-template without variables", "data": "http://example.com/dictionary", "valid": true }, { "description": "a valid relative uri-template", "data": "dictionary/{term:1}/{term}", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/format/uri.json000066400000000000000000000071631426774651400306250ustar00rootroot00000000000000[ { "description": "validation of URIs", "schema": {"format": "uri"}, "tests": [ { "description": "a valid URL with anchor tag", "data": "http://foo.bar/?baz=qux#quux", "valid": true }, { "description": "a valid URL with anchor tag and parentheses", "data": "http://foo.com/blah_(wikipedia)_blah#cite-1", "valid": true }, { "description": "a valid URL with URL-encoded stuff", "data": "http://foo.bar/?q=Test%20URL-encoded%20stuff", "valid": true }, { "description": "a valid puny-coded URL ", "data": "http://xn--nw2a.xn--j6w193g/", "valid": true }, { "description": "a valid URL with many special characters", "data": "http://-.~_!$&'()*+,;=:%40:80%2f::::::@example.com", "valid": true }, { "description": "a valid URL based on IPv4", "data": "http://223.255.255.254", "valid": true }, { "description": "a valid URL with ftp scheme", "data": "ftp://ftp.is.co.za/rfc/rfc1808.txt", "valid": true }, { "description": "a valid URL for a simple text file", "data": "http://www.ietf.org/rfc/rfc2396.txt", "valid": true }, { "description": "a valid URL ", "data": "ldap://[2001:db8::7]/c=GB?objectClass?one", "valid": true }, { "description": "a valid mailto URI", "data": "mailto:John.Doe@example.com", "valid": true }, { "description": "a valid newsgroup URI", "data": "news:comp.infosystems.www.servers.unix", "valid": true }, { "description": "a valid tel URI", "data": "tel:+1-816-555-1212", "valid": true }, { "description": "a valid URN", "data": "urn:oasis:names:specification:docbook:dtd:xml:4.1.2", "valid": true }, { "description": "an invalid protocol-relative URI Reference", "data": "//foo.bar/?baz=qux#quux", "valid": false }, { "description": "an invalid relative URI Reference", "data": "/abc", "valid": false }, { "description": "an invalid URI", "data": "\\\\WINDOWS\\fileshare", "valid": false }, { "description": "an invalid URI though valid URI reference", "data": "abc", "valid": false }, { "description": "an invalid URI with spaces", "data": "http:// shouldfail.com", "valid": false }, { "description": "an invalid URI with spaces and missing scheme", "data": ":// should fail", "valid": false }, { "description": "an invalid URI with comma in scheme", "data": "bar,baz:foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/non-bmp-regex.json000066400000000000000000000045361426774651400312150ustar00rootroot00000000000000[ { "description": "Proper UTF-16 surrogate pair handling: pattern", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "pattern": "^🐲*$" }, "tests": [ { "description": "matches empty", "data": "", "valid": true }, { "description": "matches single", "data": "🐲", "valid": true }, { "description": "matches two", "data": "🐲🐲", "valid": true }, { "description": "doesn't match one", "data": "🐉", "valid": false }, { "description": "doesn't match two", "data": "🐉🐉", "valid": false }, { "description": "doesn't match one ASCII", "data": "D", "valid": false }, { "description": "doesn't match two ASCII", "data": "DD", "valid": false } ] }, { "description": "Proper UTF-16 surrogate pair handling: patternProperties", "comment": "Optional because .Net doesn't correctly handle 32-bit Unicode characters", "schema": { "patternProperties": { "^🐲*$": { "type": "integer" } } }, "tests": [ { "description": "matches empty", "data": { "": 1 }, "valid": true }, { "description": "matches single", "data": { "🐲": 1 }, "valid": true }, { "description": "matches two", "data": { "🐲🐲": 1 }, "valid": true }, { "description": "doesn't match one", "data": { "🐲": "hello" }, "valid": false }, { "description": "doesn't match two", "data": { "🐲🐲": "hello" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/optional/unicode.json000066400000000000000000000127301426774651400301600ustar00rootroot00000000000000[ { "description": "unicode semantics should be used for all pattern matching", "schema": { "pattern": "\\wcole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": true }, { "description": "unicode matching is case-sensitive", "data": "LES HIVERS DE MON ENFANCE ÉTAIENT DES SAISONS LONGUES, LONGUES. NOUS VIVIONS EN TROIS LIEUX: L'ÉCOLE, L'ÉGLISE ET LA PATINOIRE; MAIS LA VRAIE VIE ÉTAIT SUR LA PATINOIRE.", "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "pattern": "[a-z]cole" }, "tests": [ { "description": "literal unicode character in json string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'école, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "unicode character in hex format in string", "data": "Les hivers de mon enfance étaient des saisons longues, longues. Nous vivions en trois lieux: l'\u00e9cole, l'église et la patinoire; mais la vraie vie était sur la patinoire.", "valid": false }, { "description": "ascii characters match", "data": "Les hivers de mon enfance etaient des saisons longues, longues. Nous vivions en trois lieux: l'ecole, l'eglise et la patinoire; mais la vraie vie etait sur la patinoire.", "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "pattern": "^\\d+$" }, "tests": [ { "description": "ascii digits", "data": "42", "valid": true }, { "description": "ascii non-digits", "data": "-%#", "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": "৪২", "valid": true } ] }, { "description": "unicode semantics should be used for all patternProperties matching", "schema": { "type": "object", "patternProperties": { "\\wcole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": true }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": true }, { "description": "unicode matching is case-sensitive", "data": { "L'ÉCOLE": "PAS DE VRAIE VIE" }, "valid": false } ] }, { "description": "unicode characters do not match ascii ranges", "schema": { "type": "object", "patternProperties": { "[a-z]cole": true }, "additionalProperties": false }, "tests": [ { "description": "literal unicode character in json string", "data": { "l'école": "pas de vraie vie" }, "valid": false }, { "description": "unicode character in hex format in string", "data": { "l'\u00e9cole": "pas de vraie vie" }, "valid": false }, { "description": "ascii characters match", "data": { "l'ecole": "pas de vraie vie" }, "valid": true } ] }, { "description": "unicode digits are more than 0 through 9", "schema": { "type": "object", "patternProperties": { "^\\d+$": true }, "additionalProperties": false }, "tests": [ { "description": "ascii digits", "data": { "42": "life, the universe, and everything" }, "valid": true }, { "description": "ascii non-digits", "data": { "-%#": "spending the year dead for tax reasons" }, "valid": false }, { "description": "non-ascii digits (BENGALI DIGIT FOUR, BENGALI DIGIT TWO)", "data": { "৪২": "khajit has wares if you have coin" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/pattern.json000066400000000000000000000030031426774651400263530ustar00rootroot00000000000000[ { "description": "pattern validation", "schema": {"pattern": "^a*$"}, "tests": [ { "description": "a matching pattern is valid", "data": "aaa", "valid": true }, { "description": "a non-matching pattern is invalid", "data": "abc", "valid": false }, { "description": "ignores booleans", "data": true, "valid": true }, { "description": "ignores integers", "data": 123, "valid": true }, { "description": "ignores floats", "data": 1.0, "valid": true }, { "description": "ignores objects", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores null", "data": null, "valid": true } ] }, { "description": "pattern is not anchored", "schema": {"pattern": "a+"}, "tests": [ { "description": "matches a substring", "data": "xxaayy", "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/patternProperties.json000066400000000000000000000112511426774651400304340ustar00rootroot00000000000000[ { "description": "patternProperties validates properties matching a regex", "schema": { "patternProperties": { "f.*o": {"type": "integer"} } }, "tests": [ { "description": "a single valid match is valid", "data": {"foo": 1}, "valid": true }, { "description": "multiple valid matches is valid", "data": {"foo": 1, "foooooo" : 2}, "valid": true }, { "description": "a single invalid match is invalid", "data": {"foo": "bar", "fooooo": 2}, "valid": false }, { "description": "multiple invalid matches is invalid", "data": {"foo": "bar", "foooooo" : "baz"}, "valid": false }, { "description": "ignores arrays", "data": ["foo"], "valid": true }, { "description": "ignores strings", "data": "foo", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "multiple simultaneous patternProperties are validated", "schema": { "patternProperties": { "a*": {"type": "integer"}, "aaa*": {"maximum": 20} } }, "tests": [ { "description": "a single valid match is valid", "data": {"a": 21}, "valid": true }, { "description": "a simultaneous match is valid", "data": {"aaaa": 18}, "valid": true }, { "description": "multiple matches is valid", "data": {"a": 21, "aaaa": 18}, "valid": true }, { "description": "an invalid due to one is invalid", "data": {"a": "bar"}, "valid": false }, { "description": "an invalid due to the other is invalid", "data": {"aaaa": 31}, "valid": false }, { "description": "an invalid due to both is invalid", "data": {"aaa": "foo", "aaaa": 31}, "valid": false } ] }, { "description": "regexes are not anchored by default and are case sensitive", "schema": { "patternProperties": { "[0-9]{2,}": { "type": "boolean" }, "X_": { "type": "string" } } }, "tests": [ { "description": "non recognized members are ignored", "data": { "answer 1": "42" }, "valid": true }, { "description": "recognized members are accounted for", "data": { "a31b": null }, "valid": false }, { "description": "regexes are case sensitive", "data": { "a_x_3": 3 }, "valid": true }, { "description": "regexes are case sensitive, 2", "data": { "a_X_3": 3 }, "valid": false } ] }, { "description": "patternProperties with boolean schemas", "schema": { "patternProperties": { "f.*": true, "b.*": false } }, "tests": [ { "description": "object with property matching schema true is valid", "data": {"foo": 1}, "valid": true }, { "description": "object with property matching schema false is invalid", "data": {"bar": 2}, "valid": false }, { "description": "object with both properties is invalid", "data": {"foo": 1, "bar": 2}, "valid": false }, { "description": "object with a property matching both true and false is invalid", "data": {"foobar":1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/properties.json000066400000000000000000000120341426774651400270760ustar00rootroot00000000000000[ { "description": "object properties validation", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"type": "string"} } }, "tests": [ { "description": "both properties present and valid is valid", "data": {"foo": 1, "bar": "baz"}, "valid": true }, { "description": "one property invalid is invalid", "data": {"foo": 1, "bar": {}}, "valid": false }, { "description": "both properties invalid is invalid", "data": {"foo": [], "bar": {}}, "valid": false }, { "description": "doesn't invalidate other properties", "data": {"quux": []}, "valid": true }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "properties, patternProperties, additionalProperties interaction", "schema": { "properties": { "foo": {"type": "array", "maxItems": 3}, "bar": {"type": "array"} }, "patternProperties": {"f.o": {"minItems": 2}}, "additionalProperties": {"type": "integer"} }, "tests": [ { "description": "property validates property", "data": {"foo": [1, 2]}, "valid": true }, { "description": "property invalidates property", "data": {"foo": [1, 2, 3, 4]}, "valid": false }, { "description": "patternProperty invalidates property", "data": {"foo": []}, "valid": false }, { "description": "patternProperty validates nonproperty", "data": {"fxo": [1, 2]}, "valid": true }, { "description": "patternProperty invalidates nonproperty", "data": {"fxo": []}, "valid": false }, { "description": "additionalProperty ignores property", "data": {"bar": []}, "valid": true }, { "description": "additionalProperty validates others", "data": {"quux": 3}, "valid": true }, { "description": "additionalProperty invalidates others", "data": {"quux": "foo"}, "valid": false } ] }, { "description": "properties with boolean schema", "schema": { "properties": { "foo": true, "bar": false } }, "tests": [ { "description": "no property present is valid", "data": {}, "valid": true }, { "description": "only 'true' property present is valid", "data": {"foo": 1}, "valid": true }, { "description": "only 'false' property present is invalid", "data": {"bar": 2}, "valid": false }, { "description": "both properties present is invalid", "data": {"foo": 1, "bar": 2}, "valid": false } ] }, { "description": "properties with escaped characters", "schema": { "properties": { "foo\nbar": {"type": "number"}, "foo\"bar": {"type": "number"}, "foo\\bar": {"type": "number"}, "foo\rbar": {"type": "number"}, "foo\tbar": {"type": "number"}, "foo\fbar": {"type": "number"} } }, "tests": [ { "description": "object with all numbers is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1", "foo\\bar": "1", "foo\rbar": "1", "foo\tbar": "1", "foo\fbar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/propertyNames.json000066400000000000000000000055771426774651400275700ustar00rootroot00000000000000[ { "description": "propertyNames validation", "schema": { "propertyNames": {"maxLength": 3} }, "tests": [ { "description": "all property names valid", "data": { "f": {}, "foo": {} }, "valid": true }, { "description": "some property names invalid", "data": { "foo": {}, "foobar": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true }, { "description": "ignores arrays", "data": [1, 2, 3, 4], "valid": true }, { "description": "ignores strings", "data": "foobar", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "propertyNames validation with pattern", "schema": { "propertyNames": { "pattern": "^a+$" } }, "tests": [ { "description": "matching property names valid", "data": { "a": {}, "aa": {}, "aaa": {} }, "valid": true }, { "description": "non-matching property name is invalid", "data": { "aaA": {} }, "valid": false }, { "description": "object without properties is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema true", "schema": {"propertyNames": true}, "tests": [ { "description": "object with any properties is valid", "data": {"foo": 1}, "valid": true }, { "description": "empty object is valid", "data": {}, "valid": true } ] }, { "description": "propertyNames with boolean schema false", "schema": {"propertyNames": false}, "tests": [ { "description": "object with any properties is invalid", "data": {"foo": 1}, "valid": false }, { "description": "empty object is valid", "data": {}, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/ref.json000066400000000000000000000432371426774651400254670ustar00rootroot00000000000000[ { "description": "root pointer ref", "schema": { "properties": { "foo": {"$ref": "#"} }, "additionalProperties": false }, "tests": [ { "description": "match", "data": {"foo": false}, "valid": true }, { "description": "recursive match", "data": {"foo": {"foo": false}}, "valid": true }, { "description": "mismatch", "data": {"bar": false}, "valid": false }, { "description": "recursive mismatch", "data": {"foo": {"bar": false}}, "valid": false } ] }, { "description": "relative pointer ref to object", "schema": { "properties": { "foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"} } }, "tests": [ { "description": "match", "data": {"bar": 3}, "valid": true }, { "description": "mismatch", "data": {"bar": true}, "valid": false } ] }, { "description": "relative pointer ref to array", "schema": { "items": [ {"type": "integer"}, {"$ref": "#/items/0"} ] }, "tests": [ { "description": "match array", "data": [1, 2], "valid": true }, { "description": "mismatch array", "data": [1, "foo"], "valid": false } ] }, { "description": "escaped pointer ref", "schema": { "definitions": { "tilde~field": {"type": "integer"}, "slash/field": {"type": "integer"}, "percent%field": {"type": "integer"} }, "properties": { "tilde": {"$ref": "#/definitions/tilde~0field"}, "slash": {"$ref": "#/definitions/slash~1field"}, "percent": {"$ref": "#/definitions/percent%25field"} } }, "tests": [ { "description": "slash invalid", "data": {"slash": "aoeu"}, "valid": false }, { "description": "tilde invalid", "data": {"tilde": "aoeu"}, "valid": false }, { "description": "percent invalid", "data": {"percent": "aoeu"}, "valid": false }, { "description": "slash valid", "data": {"slash": 123}, "valid": true }, { "description": "tilde valid", "data": {"tilde": 123}, "valid": true }, { "description": "percent valid", "data": {"percent": 123}, "valid": true } ] }, { "description": "nested refs", "schema": { "definitions": { "a": {"type": "integer"}, "b": {"$ref": "#/definitions/a"}, "c": {"$ref": "#/definitions/b"} }, "allOf": [{ "$ref": "#/definitions/c" }] }, "tests": [ { "description": "nested ref valid", "data": 5, "valid": true }, { "description": "nested ref invalid", "data": "a", "valid": false } ] }, { "description": "ref overrides any sibling keywords", "schema": { "definitions": { "reffed": { "type": "array" } }, "properties": { "foo": { "$ref": "#/definitions/reffed", "maxItems": 2 } } }, "tests": [ { "description": "ref valid", "data": { "foo": [] }, "valid": true }, { "description": "ref valid, maxItems ignored", "data": { "foo": [ 1, 2, 3] }, "valid": true }, { "description": "ref invalid", "data": { "foo": "string" }, "valid": false } ] }, { "description": "$ref prevents a sibling $id from changing the base uri", "schema": { "$id": "http://localhost:1234/sibling_id/base/", "definitions": { "foo": { "$id": "http://localhost:1234/sibling_id/foo.json", "minimum": 2 }, "base_foo": { "$comment": "this canonical uri is http://localhost:1234/sibling_id/base/foo.json", "$id": "foo.json", "minimum": 5 } }, "allOf": [ { "$comment": "$ref resolves to http://localhost:1234/sibling_id/base/foo.json, not ttp://localhost:1234/sibling_id/foo.json", "$id": "http://localhost:1234/sibling_id/", "$ref": "foo.json" } ] }, "tests": [ { "description": "$ref resolves to /definitions/foo, data validates", "data": 10, "valid": true }, { "description": "$ref resolves to /definitions/foo, data does not validate", "data": 1, "valid": false } ] }, { "description": "remote ref, containing refs itself", "schema": {"$ref": "http://json-schema.org/draft-07/schema#"}, "tests": [ { "description": "remote ref valid", "data": {"minLength": 1}, "valid": true }, { "description": "remote ref invalid", "data": {"minLength": -1}, "valid": false } ] }, { "description": "property named $ref that is not a reference", "schema": { "properties": { "$ref": {"type": "string"} } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "property named $ref, containing an actual $ref", "schema": { "properties": { "$ref": {"$ref": "#/definitions/is-string"} }, "definitions": { "is-string": { "type": "string" } } }, "tests": [ { "description": "property named $ref valid", "data": {"$ref": "a"}, "valid": true }, { "description": "property named $ref invalid", "data": {"$ref": 2}, "valid": false } ] }, { "description": "$ref to boolean schema true", "schema": { "allOf": [{ "$ref": "#/definitions/bool" }], "definitions": { "bool": true } }, "tests": [ { "description": "any value is valid", "data": "foo", "valid": true } ] }, { "description": "$ref to boolean schema false", "schema": { "allOf": [{ "$ref": "#/definitions/bool" }], "definitions": { "bool": false } }, "tests": [ { "description": "any value is invalid", "data": "foo", "valid": false } ] }, { "description": "Recursive references between schemas", "schema": { "$id": "http://localhost:1234/tree", "description": "tree of nodes", "type": "object", "properties": { "meta": {"type": "string"}, "nodes": { "type": "array", "items": {"$ref": "node"} } }, "required": ["meta", "nodes"], "definitions": { "node": { "$id": "http://localhost:1234/node", "description": "node", "type": "object", "properties": { "value": {"type": "number"}, "subtree": {"$ref": "tree"} }, "required": ["value"] } } }, "tests": [ { "description": "valid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": 1.1}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": true }, { "description": "invalid tree", "data": { "meta": "root", "nodes": [ { "value": 1, "subtree": { "meta": "child", "nodes": [ {"value": "string is invalid"}, {"value": 1.2} ] } }, { "value": 2, "subtree": { "meta": "child", "nodes": [ {"value": 2.1}, {"value": 2.2} ] } } ] }, "valid": false } ] }, { "description": "refs with quote", "schema": { "properties": { "foo\"bar": {"$ref": "#/definitions/foo%22bar"} }, "definitions": { "foo\"bar": {"type": "number"} } }, "tests": [ { "description": "object with numbers is valid", "data": { "foo\"bar": 1 }, "valid": true }, { "description": "object with strings is invalid", "data": { "foo\"bar": "1" }, "valid": false } ] }, { "description": "Location-independent identifier", "schema": { "allOf": [{ "$ref": "#foo" }], "definitions": { "A": { "$id": "#foo", "type": "integer" } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "Location-independent identifier with base URI change in subschema", "schema": { "$id": "http://localhost:1234/root", "allOf": [{ "$ref": "http://localhost:1234/nested.json#foo" }], "definitions": { "A": { "$id": "nested.json", "definitions": { "B": { "$id": "#foo", "type": "integer" } } } } }, "tests": [ { "data": 1, "description": "match", "valid": true }, { "data": "a", "description": "mismatch", "valid": false } ] }, { "description": "naive replacement of $ref with its destination is not correct", "schema": { "definitions": { "a_string": { "type": "string" } }, "enum": [ { "$ref": "#/definitions/a_string" } ] }, "tests": [ { "description": "do not evaluate the $ref inside the enum, matching any string", "data": "this is a string", "valid": false }, { "description": "do not evaluate the $ref inside the enum, definition exact match", "data": { "type": "string" }, "valid": false }, { "description": "match the enum exactly", "data": { "$ref": "#/definitions/a_string" }, "valid": true } ] }, { "description": "refs with relative uris and defs", "schema": { "$id": "http://example.com/schema-relative-uri-defs1.json", "properties": { "foo": { "$id": "schema-relative-uri-defs2.json", "definitions": { "inner": { "properties": { "bar": { "type": "string" } } } }, "allOf": [ { "$ref": "#/definitions/inner" } ] } }, "allOf": [ { "$ref": "schema-relative-uri-defs2.json" } ] }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] }, { "description": "relative refs with absolute uris and defs", "schema": { "$id": "http://example.com/schema-refs-absolute-uris-defs1.json", "properties": { "foo": { "$id": "http://example.com/schema-refs-absolute-uris-defs2.json", "definitions": { "inner": { "properties": { "bar": { "type": "string" } } } }, "allOf": [ { "$ref": "#/definitions/inner" } ] } }, "allOf": [ { "$ref": "schema-refs-absolute-uris-defs2.json" } ] }, "tests": [ { "description": "invalid on inner field", "data": { "foo": { "bar": 1 }, "bar": "a" }, "valid": false }, { "description": "invalid on outer field", "data": { "foo": { "bar": "a" }, "bar": 1 }, "valid": false }, { "description": "valid on both fields", "data": { "foo": { "bar": "a" }, "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/refRemote.json000066400000000000000000000125041426774651400266340ustar00rootroot00000000000000[ { "description": "remote ref", "schema": {"$ref": "http://localhost:1234/integer.json"}, "tests": [ { "description": "remote ref valid", "data": 1, "valid": true }, { "description": "remote ref invalid", "data": "a", "valid": false } ] }, { "description": "fragment within remote ref", "schema": {"$ref": "http://localhost:1234/subSchemas.json#/integer"}, "tests": [ { "description": "remote fragment valid", "data": 1, "valid": true }, { "description": "remote fragment invalid", "data": "a", "valid": false } ] }, { "description": "ref within remote ref", "schema": { "$ref": "http://localhost:1234/subSchemas.json#/refToInteger" }, "tests": [ { "description": "ref within ref valid", "data": 1, "valid": true }, { "description": "ref within ref invalid", "data": "a", "valid": false } ] }, { "description": "base URI change", "schema": { "$id": "http://localhost:1234/", "items": { "$id": "baseUriChange/", "items": {"$ref": "folderInteger.json"} } }, "tests": [ { "description": "base URI change ref valid", "data": [[1]], "valid": true }, { "description": "base URI change ref invalid", "data": [["a"]], "valid": false } ] }, { "description": "base URI change - change folder", "schema": { "$id": "http://localhost:1234/scope_change_defs1.json", "type" : "object", "properties": { "list": {"$ref": "#/definitions/baz"} }, "definitions": { "baz": { "$id": "baseUriChangeFolder/", "type": "array", "items": {"$ref": "folderInteger.json"} } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "base URI change - change folder in subschema", "schema": { "$id": "http://localhost:1234/scope_change_defs2.json", "type" : "object", "properties": { "list": {"$ref": "#/definitions/baz/definitions/bar"} }, "definitions": { "baz": { "$id": "baseUriChangeFolderInSubschema/", "definitions": { "bar": { "type": "array", "items": {"$ref": "folderInteger.json"} } } } } }, "tests": [ { "description": "number is valid", "data": {"list": [1]}, "valid": true }, { "description": "string is invalid", "data": {"list": ["a"]}, "valid": false } ] }, { "description": "root ref in remote ref", "schema": { "$id": "http://localhost:1234/object", "type": "object", "properties": { "name": {"$ref": "name.json#/definitions/orNull"} } }, "tests": [ { "description": "string is valid", "data": { "name": "foo" }, "valid": true }, { "description": "null is valid", "data": { "name": null }, "valid": true }, { "description": "object is invalid", "data": { "name": { "name": null } }, "valid": false } ] }, { "description": "remote ref with ref to definitions", "schema": { "$id": "http://localhost:1234/schema-remote-ref-ref-defs1.json", "allOf": [ { "$ref": "ref-and-definitions.json" } ] }, "tests": [ { "description": "invalid", "data": { "bar": 1 }, "valid": false }, { "description": "valid", "data": { "bar": "a" }, "valid": true } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/required.json000066400000000000000000000052061426774651400265250ustar00rootroot00000000000000[ { "description": "required validation", "schema": { "properties": { "foo": {}, "bar": {} }, "required": ["foo"] }, "tests": [ { "description": "present required property is valid", "data": {"foo": 1}, "valid": true }, { "description": "non-present required property is invalid", "data": {"bar": 1}, "valid": false }, { "description": "ignores arrays", "data": [], "valid": true }, { "description": "ignores strings", "data": "", "valid": true }, { "description": "ignores other non-objects", "data": 12, "valid": true } ] }, { "description": "required default validation", "schema": { "properties": { "foo": {} } }, "tests": [ { "description": "not required by default", "data": {}, "valid": true } ] }, { "description": "required with empty array", "schema": { "properties": { "foo": {} }, "required": [] }, "tests": [ { "description": "property not required", "data": {}, "valid": true } ] }, { "description": "required with escaped characters", "schema": { "required": [ "foo\nbar", "foo\"bar", "foo\\bar", "foo\rbar", "foo\tbar", "foo\fbar" ] }, "tests": [ { "description": "object with all properties present is valid", "data": { "foo\nbar": 1, "foo\"bar": 1, "foo\\bar": 1, "foo\rbar": 1, "foo\tbar": 1, "foo\fbar": 1 }, "valid": true }, { "description": "object with some properties missing is invalid", "data": { "foo\nbar": "1", "foo\"bar": "1" }, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/type.json000066400000000000000000000321401426774651400256630ustar00rootroot00000000000000[ { "description": "integer type matches integers", "schema": {"type": "integer"}, "tests": [ { "description": "an integer is an integer", "data": 1, "valid": true }, { "description": "a float with zero fractional part is an integer", "data": 1.0, "valid": true }, { "description": "a float is not an integer", "data": 1.1, "valid": false }, { "description": "a string is not an integer", "data": "foo", "valid": false }, { "description": "a string is still not an integer, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not an integer", "data": {}, "valid": false }, { "description": "an array is not an integer", "data": [], "valid": false }, { "description": "a boolean is not an integer", "data": true, "valid": false }, { "description": "null is not an integer", "data": null, "valid": false } ] }, { "description": "number type matches numbers", "schema": {"type": "number"}, "tests": [ { "description": "an integer is a number", "data": 1, "valid": true }, { "description": "a float with zero fractional part is a number (and an integer)", "data": 1.0, "valid": true }, { "description": "a float is a number", "data": 1.1, "valid": true }, { "description": "a string is not a number", "data": "foo", "valid": false }, { "description": "a string is still not a number, even if it looks like one", "data": "1", "valid": false }, { "description": "an object is not a number", "data": {}, "valid": false }, { "description": "an array is not a number", "data": [], "valid": false }, { "description": "a boolean is not a number", "data": true, "valid": false }, { "description": "null is not a number", "data": null, "valid": false } ] }, { "description": "string type matches strings", "schema": {"type": "string"}, "tests": [ { "description": "1 is not a string", "data": 1, "valid": false }, { "description": "a float is not a string", "data": 1.1, "valid": false }, { "description": "a string is a string", "data": "foo", "valid": true }, { "description": "a string is still a string, even if it looks like a number", "data": "1", "valid": true }, { "description": "an empty string is still a string", "data": "", "valid": true }, { "description": "an object is not a string", "data": {}, "valid": false }, { "description": "an array is not a string", "data": [], "valid": false }, { "description": "a boolean is not a string", "data": true, "valid": false }, { "description": "null is not a string", "data": null, "valid": false } ] }, { "description": "object type matches objects", "schema": {"type": "object"}, "tests": [ { "description": "an integer is not an object", "data": 1, "valid": false }, { "description": "a float is not an object", "data": 1.1, "valid": false }, { "description": "a string is not an object", "data": "foo", "valid": false }, { "description": "an object is an object", "data": {}, "valid": true }, { "description": "an array is not an object", "data": [], "valid": false }, { "description": "a boolean is not an object", "data": true, "valid": false }, { "description": "null is not an object", "data": null, "valid": false } ] }, { "description": "array type matches arrays", "schema": {"type": "array"}, "tests": [ { "description": "an integer is not an array", "data": 1, "valid": false }, { "description": "a float is not an array", "data": 1.1, "valid": false }, { "description": "a string is not an array", "data": "foo", "valid": false }, { "description": "an object is not an array", "data": {}, "valid": false }, { "description": "an array is an array", "data": [], "valid": true }, { "description": "a boolean is not an array", "data": true, "valid": false }, { "description": "null is not an array", "data": null, "valid": false } ] }, { "description": "boolean type matches booleans", "schema": {"type": "boolean"}, "tests": [ { "description": "an integer is not a boolean", "data": 1, "valid": false }, { "description": "zero is not a boolean", "data": 0, "valid": false }, { "description": "a float is not a boolean", "data": 1.1, "valid": false }, { "description": "a string is not a boolean", "data": "foo", "valid": false }, { "description": "an empty string is not a boolean", "data": "", "valid": false }, { "description": "an object is not a boolean", "data": {}, "valid": false }, { "description": "an array is not a boolean", "data": [], "valid": false }, { "description": "true is a boolean", "data": true, "valid": true }, { "description": "false is a boolean", "data": false, "valid": true }, { "description": "null is not a boolean", "data": null, "valid": false } ] }, { "description": "null type matches only the null object", "schema": {"type": "null"}, "tests": [ { "description": "an integer is not null", "data": 1, "valid": false }, { "description": "a float is not null", "data": 1.1, "valid": false }, { "description": "zero is not null", "data": 0, "valid": false }, { "description": "a string is not null", "data": "foo", "valid": false }, { "description": "an empty string is not null", "data": "", "valid": false }, { "description": "an object is not null", "data": {}, "valid": false }, { "description": "an array is not null", "data": [], "valid": false }, { "description": "true is not null", "data": true, "valid": false }, { "description": "false is not null", "data": false, "valid": false }, { "description": "null is null", "data": null, "valid": true } ] }, { "description": "multiple types can be specified in an array", "schema": {"type": ["integer", "string"]}, "tests": [ { "description": "an integer is valid", "data": 1, "valid": true }, { "description": "a string is valid", "data": "foo", "valid": true }, { "description": "a float is invalid", "data": 1.1, "valid": false }, { "description": "an object is invalid", "data": {}, "valid": false }, { "description": "an array is invalid", "data": [], "valid": false }, { "description": "a boolean is invalid", "data": true, "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type as array with one item", "schema": { "type": ["string"] }, "tests": [ { "description": "string is valid", "data": "foo", "valid": true }, { "description": "number is invalid", "data": 123, "valid": false } ] }, { "description": "type: array or object", "schema": { "type": ["array", "object"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false }, { "description": "null is invalid", "data": null, "valid": false } ] }, { "description": "type: array, object or null", "schema": { "type": ["array", "object", "null"] }, "tests": [ { "description": "array is valid", "data": [1,2,3], "valid": true }, { "description": "object is valid", "data": {"foo": 123}, "valid": true }, { "description": "null is valid", "data": null, "valid": true }, { "description": "number is invalid", "data": 123, "valid": false }, { "description": "string is invalid", "data": "foo", "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/uniqueItems.json000066400000000000000000000314011426774651400272110ustar00rootroot00000000000000[ { "description": "uniqueItems validation", "schema": {"uniqueItems": true}, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is invalid", "data": [1, 1], "valid": false }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": false }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is invalid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": false }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is invalid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": false }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is invalid", "data": [["foo"], ["foo"]], "valid": false }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "[1] and [true] are unique", "data": [[1], [true]], "valid": true }, { "description": "[0] and [false] are unique", "data": [[0], [false]], "valid": true }, { "description": "nested [1] and [true] are unique", "data": [[[1], "foo"], [[true], "foo"]], "valid": true }, { "description": "nested [0] and [false] are unique", "data": [[[0], "foo"], [[false], "foo"]], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1, "{}"], "valid": true }, { "description": "non-unique heterogeneous types are invalid", "data": [{}, [1], true, null, {}, 1], "valid": false }, { "description": "different objects are unique", "data": [{"a": 1, "b": 2}, {"a": 2, "b": 1}], "valid": true }, { "description": "objects are non-unique despite key order", "data": [{"a": 1, "b": 2}, {"b": 2, "a": 1}], "valid": false }, { "description": "{\"a\": false} and {\"a\": 0} are unique", "data": [{"a": false}, {"a": 0}], "valid": true }, { "description": "{\"a\": true} and {\"a\": 1} are unique", "data": [{"a": true}, {"a": 1}], "valid": true } ] }, { "description": "uniqueItems with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is not valid", "data": [false, true, "foo", "foo"], "valid": false }, { "description": "non-unique array extended from [true, false] is not valid", "data": [true, false, "foo", "foo"], "valid": false } ] }, { "description": "uniqueItems with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": true, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is not valid", "data": [false, false], "valid": false }, { "description": "[true, true] from items array is not valid", "data": [true, true], "valid": false }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] }, { "description": "uniqueItems=false validation", "schema": { "uniqueItems": false }, "tests": [ { "description": "unique array of integers is valid", "data": [1, 2], "valid": true }, { "description": "non-unique array of integers is valid", "data": [1, 1], "valid": true }, { "description": "numbers are unique if mathematically unequal", "data": [1.0, 1.00, 1], "valid": true }, { "description": "false is not equal to zero", "data": [0, false], "valid": true }, { "description": "true is not equal to one", "data": [1, true], "valid": true }, { "description": "unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "baz"}], "valid": true }, { "description": "non-unique array of objects is valid", "data": [{"foo": "bar"}, {"foo": "bar"}], "valid": true }, { "description": "unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : false}}} ], "valid": true }, { "description": "non-unique array of nested objects is valid", "data": [ {"foo": {"bar" : {"baz" : true}}}, {"foo": {"bar" : {"baz" : true}}} ], "valid": true }, { "description": "unique array of arrays is valid", "data": [["foo"], ["bar"]], "valid": true }, { "description": "non-unique array of arrays is valid", "data": [["foo"], ["foo"]], "valid": true }, { "description": "1 and true are unique", "data": [1, true], "valid": true }, { "description": "0 and false are unique", "data": [0, false], "valid": true }, { "description": "unique heterogeneous types are valid", "data": [{}, [1], true, null, 1], "valid": true }, { "description": "non-unique heterogeneous types are valid", "data": [{}, [1], true, null, {}, 1], "valid": true } ] }, { "description": "uniqueItems=false with an array of items", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "unique array extended from [false, true] is valid", "data": [false, true, "foo", "bar"], "valid": true }, { "description": "unique array extended from [true, false] is valid", "data": [true, false, "foo", "bar"], "valid": true }, { "description": "non-unique array extended from [false, true] is valid", "data": [false, true, "foo", "foo"], "valid": true }, { "description": "non-unique array extended from [true, false] is valid", "data": [true, false, "foo", "foo"], "valid": true } ] }, { "description": "uniqueItems=false with an array of items and additionalItems=false", "schema": { "items": [{"type": "boolean"}, {"type": "boolean"}], "uniqueItems": false, "additionalItems": false }, "tests": [ { "description": "[false, true] from items array is valid", "data": [false, true], "valid": true }, { "description": "[true, false] from items array is valid", "data": [true, false], "valid": true }, { "description": "[false, false] from items array is valid", "data": [false, false], "valid": true }, { "description": "[true, true] from items array is valid", "data": [true, true], "valid": true }, { "description": "extra items are invalid even if unique", "data": [false, true, null], "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/draft7/unknownKeyword.json000066400000000000000000000037421426774651400277540ustar00rootroot00000000000000[ { "description": "$id inside an unknown keyword is not a real identifier", "comment": "the implementation must not be confused by an $id in locations we do not know how to parse", "schema": { "definitions": { "id_in_unknown0": { "not": { "array_of_schemas": [ { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "null" } ] } }, "real_id_in_schema": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "string" }, "id_in_unknown1": { "not": { "object_of_schemas": { "foo": { "$id": "https://localhost:1234/unknownKeyword/my_identifier.json", "type": "integer" } } } } }, "anyOf": [ { "$ref": "#/definitions/id_in_unknown0" }, { "$ref": "#/definitions/id_in_unknown1" }, { "$ref": "https://localhost:1234/unknownKeyword/my_identifier.json" } ] }, "tests": [ { "description": "type matches second anyOf, which has a real schema in it", "data": "a string", "valid": true }, { "description": "type matches non-schema in first anyOf", "data": null, "valid": false }, { "description": "type matches non-schema in third anyOf", "data": 1, "valid": false } ] } ] golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/000077500000000000000000000000001426774651400242765ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/baseUriChange/000077500000000000000000000000001426774651400267765ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/baseUriChange/folderInteger.json000066400000000000000000000000321426774651400324550ustar00rootroot00000000000000{ "type": "integer" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/baseUriChangeFolder/000077500000000000000000000000001426774651400301325ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/baseUriChangeFolder/folderInteger.json000066400000000000000000000000321426774651400336110ustar00rootroot00000000000000{ "type": "integer" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/baseUriChangeFolderInSubschema/000077500000000000000000000000001426774651400322545ustar00rootroot00000000000000folderInteger.json000066400000000000000000000000321426774651400356540ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/baseUriChangeFolderInSubschema{ "type": "integer" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/integer.json000066400000000000000000000000321426774651400266210ustar00rootroot00000000000000{ "type": "integer" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/name-defs.json000066400000000000000000000003761426774651400270360ustar00rootroot00000000000000{ "$defs": { "orNull": { "anyOf": [ { "type": "null" }, { "$ref": "#" } ] } }, "type": "string" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/name.json000066400000000000000000000004041426774651400261070ustar00rootroot00000000000000{ "definitions": { "orNull": { "anyOf": [ { "type": "null" }, { "$ref": "#" } ] } }, "type": "string" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/ref-and-definitions.json000066400000000000000000000004031426774651400310130ustar00rootroot00000000000000{ "$id": "http://localhost:1234/ref-and-definitions.json", "definitions": { "inner": { "properties": { "bar": { "type": "string" } } } }, "allOf": [ { "$ref": "#/definitions/inner" } ] } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/ref-and-defs.json000066400000000000000000000003371426774651400274270ustar00rootroot00000000000000{ "$id": "http://localhost:1234/ref-and-defs.json", "$defs": { "inner": { "properties": { "bar": { "type": "string" } } } }, "$ref": "#/$defs/inner" } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/subSchemas-defs.json000066400000000000000000000002411426774651400302020ustar00rootroot00000000000000{ "$defs": { "integer": { "type": "integer" }, "refToInteger": { "$ref": "#/$defs/integer" } } } golang-github-flowstack-go-jsonschema-0.1.2/testdata/remotes/subSchemas.json000066400000000000000000000001561426774651400272700ustar00rootroot00000000000000{ "integer": { "type": "integer" }, "refToInteger": { "$ref": "#/integer" } } golang-github-flowstack-go-jsonschema-0.1.2/testtools/000077500000000000000000000000001426774651400230475ustar00rootroot00000000000000golang-github-flowstack-go-jsonschema-0.1.2/testtools/testtools.go000066400000000000000000000013001426774651400254300ustar00rootroot00000000000000package testtools import ( "bytes" "encoding/json" ) func CompareJSON(j1, j2 []byte) (bool, error) { var err error j1, err = SortAndCompactJSON(j1) if err != nil { return false, err } j2, err = SortAndCompactJSON(j2) if err != nil { return false, err } return (string(j1) == string(j2)), nil } func SortAndCompactJSON(j []byte) ([]byte, error) { // Unmarshalling to an interface and marshalling back, will cause the fields to be sorted var err error var tmp interface{} if err = json.Unmarshal(j, &tmp); err != nil { return nil, err } j, err = json.Marshal(tmp) if err != nil { return nil, err } var out bytes.Buffer json.Compact(&out, j) return out.Bytes(), nil } golang-github-flowstack-go-jsonschema-0.1.2/testtools/testtools_test.go000066400000000000000000000004321426774651400264740ustar00rootroot00000000000000package testtools import "testing" func TestCompareJSON(t *testing.T) { j1 := []byte(`{ "a": "a", "b": "b" }`) j2 := []byte(`{ "b": "b", "a": "a" }`) eq, err := CompareJSON(j1, j2) if err != nil { t.Fatal(err) } if !eq { t.Fatal("expected j1 and j2 to be equal") } } golang-github-flowstack-go-jsonschema-0.1.2/validate.go000066400000000000000000000027071426774651400231350ustar00rootroot00000000000000package jsonschema import ( "bytes" "errors" "strings" "github.com/buger/jsonparser" ) // Validate will get $schema if it exists or fall back to latest supported Draft func Validate(jsonDoc []byte) (bool, error) { var err error var schema *Schema val, vt, _, err := jsonparser.Get(jsonDoc, "$schema") if err == nil && vt == jsonparser.String { strVal := string(val) schema, err = schema.ResolveRef(&Ref{String: &strVal}) if err == nil { return false, err } } else { schema = Draft07Schema } return schema.Validate(jsonDoc) } // Validate will return on the first encounter of something invalid func (s *Schema) Validate(jsonDoc []byte) (bool, error) { if s == nil { return false, errors.New("invalid schema") } // Ensure that datectors work (though it slows things down a bit) jsonDoc = bytes.Trim(jsonDoc, " \r\n") // It's valid to have a text string with quotes as document, but the Validate func // expects non-quoted strings and the rest of the validators handles this automatically. // So we'll clean up any docs starting and ending with quotes. var err error typ := DetectJSONType(jsonDoc) if typ == String { jsonDoc = jsonDoc[1 : len(jsonDoc)-1] } // In Draft 4 the value 1.0 can NOT be an integer all other drafts allows this if s.IsDraft4() && typ == Integer && strings.Contains(string(jsonDoc), ".") { typ = Number } err = validate(jsonDoc, typ, s) if err != nil { return false, err } return true, nil } golang-github-flowstack-go-jsonschema-0.1.2/validate_test.go000066400000000000000000000401071426774651400241700ustar00rootroot00000000000000package jsonschema import ( _ "embed" "encoding/json" "fmt" "io/ioutil" "net/http" "os" "path" "testing" "time" "github.com/flowstack/go-jsonschema/testtools" "github.com/xeipuuv/gojsonschema" ) type schemaTest struct { Description string `json:"description"` // valid definition schema Data json.RawMessage `json:"data"` Valid bool `json:"valid"` } type schemaTests struct { Description string `json:"description"` // validate definition against metaschema Schema json.RawMessage `json:"schema"` // {"$ref": "http://json-schema.org/draft-07/schema#"} Tests []schemaTest `json:"tests"` } var testSchemaVersions = []string{"draft4", "draft6", "draft7", "draft2019-09", "draft2020-12"} // var testSchemaVersions = []string{"draft4", "draft6", "draft7", "draft2019-09"} // This is basically to get an idea of how much work is left to support draft2019-09. // Another consideration is how to de-ref $defs, if at all - they're to be treated as self-contained schemas. // TODO: Make the tests pass var ignoreDraft2019_09TestFiles = map[string]struct{}{ "anchor.json": {}, // not implemented "content.json": {}, // not implemented - optional for all earlier draft standards "defs.json": {}, // not implemented "dependentRequired.json": {}, // not implemented, but is basically the dependencies code "dependentSchemas.json": {}, // not implemented, but is basically the dependencies code "format.json": {}, // more checks than for the earlier draft standards "id.json": {}, // seems to be things that should be checked anyway "infinite-loop-detection.json": {}, // $defs not implemented "items.json": {}, // $defs not implemented "maxContains.json": {}, // not implemented "minContains.json": {}, // not implemented "recursiveRef.json": {}, // not implemented "ref.json": {}, // $defs not implemented "refRemote.json": {}, // $defs not implemented "unevaluatedItems.json": {}, // not implemented "unevaluatedProperties.json": {}, // not implemented "unknownKeyword.json": {}, // not implemented "refOfUnknownKeyword.json": {}, // not implemented (optional) } // Same as for draft2019-09. var ignoreDraft2020_12TestFiles = map[string]struct{}{ "anchor.json": {}, // not implemented "content.json": {}, // not implemented - optional for all earlier draft standards "defs.json": {}, // not implemented "dependentRequired.json": {}, // not implemented, but is basically the dependencies code "dependentSchemas.json": {}, // not implemented, but is basically the dependencies code "dynamicRef.json": {}, // not implemented "format.json": {}, // more checks than for the earlier draft standards "id.json": {}, // seems to be things that should be checked anyway "infinite-loop-detection.json": {}, // $defs not implemented "items.json": {}, // $defs not implemented "maxContains.json": {}, // not implemented "minContains.json": {}, // not implemented "prefixItems.json": {}, // not implemented "ref.json": {}, // $defs not implemented "refRemote.json": {}, // $defs not implemented "unevaluatedItems.json": {}, // not implemented "unevaluatedProperties.json": {}, // not implemented "uniqueItems.json": {}, // prefixItems not implemented "unknownKeyword.json": {}, // not implemented "refOfUnknownKeyword.json": {}, // not implemented (optional) } var testDataPath = "testdata" func TestMain(m *testing.M) { // Start a server for the remote test schema remoteSchemasPath := path.Join(testDataPath, "remotes") go func() { err := http.ListenAndServe(":1234", http.FileServer(http.Dir(remoteSchemasPath))) if err != nil { panic(err) } }() // Give the HTTP server a second to get started time.Sleep(time.Second) os.Exit(m.Run()) } func TestValidateEmptyDocWithSchema(t *testing.T) { schema, err := NewFromString("{}") if err != nil { t.Fatal(err) } _, err = schema.Validate([]byte("")) if err == nil { t.Fatal(`expected empty err, expected: empty document does not validate against the schema`) } else if err.Error() != `empty document is not valid against any other schemas than "false"` { t.Fatalf(`expected error to be:\nempty document is not valid against any other schemas than "false"\n, got:\n%s`, err.Error()) } } func TestValidateSchemaWithWrongSchema(t *testing.T) { _, err := Validate([]byte(`{"$schema": "nosuchschema"}`)) if err == nil { t.Fatal(`expected err`) } else if err.Error() != "invalid schema" { t.Fatalf("expected error to be:\ninvalid schema\n, got:\n%s", err.Error()) } } // TODO: verify that this is the wanted outcome func TestValidateEmptyDocWithFalseSchema(t *testing.T) { schema, err := NewFromString("false") if err != nil { t.Fatal(err) } valid, err := schema.Validate([]byte("")) if err != nil { t.Fatalf("expected error to be empty, got:\n%s", err.Error()) } else if !valid { t.Fatal(`expected document to be valid`) } } // TODO: verify that this is the wanted outcome func TestValidateValueWithTrueSchema(t *testing.T) { schema, err := NewFromString("true") if err != nil { t.Fatal(err) } valid, err := schema.Validate([]byte("1")) if err != nil { t.Fatalf(`expected error to be empty, got: %s`, err.Error()) } else if !valid { t.Fatal(`expected document to be valid`) } } func TestValidateValue(t *testing.T) { schema, err := NewFromString("{}") if err != nil { t.Fatal(err) } valid, err := schema.Validate([]byte("1")) if err != nil { t.Fatalf(`expected error to be empty, got: "%s"`, err.Error()) } else if !valid { t.Fatal(`expected validation to be true, got false`) } } func TestValidateSchema(t *testing.T) { var testSchema = `{"$id":"bla","const":null,"properties":{"bla":{"type":["string","null"]},"yadda":{"enum":["abc",123,1.23,null,false]}}}` valid, err := Validate([]byte(testSchema)) if err != nil { t.Fatalf(`expected error to be empty, got: %s`, err.Error()) } else if !valid { t.Fatal(`expected document to be valid`) } } // TestParseAndValidate runs through all of the test suite's tests (including optional) func TestParseAndValidate(t *testing.T) { for _, testSchemaVersions := range testSchemaVersions { dirPath := path.Join("./", testDataPath, testSchemaVersions) parseAndValidateHelper(t, dirPath, testSchemaVersions) } } // These are long running benchmarks, so they won't be included by default // func BenchmarkParse(b *testing.B) { // for _, testSchemaVersions := range testSchemaVersions { // dirPath := path.Join("./", testDataPath, testSchemaVersions) // parseBenchmarkHelper(b, dirPath, testSchemaVersions) // } // } // func BenchmarkValidate(b *testing.B) { // for _, testSchemaVersions := range testSchemaVersions { // dirPath := path.Join("./", testDataPath, testSchemaVersions) // validateBenchmarkHelper(b, dirPath, testSchemaVersions) // } // } // Helper for recursing the testdata dirs func parseAndValidateHelper(t *testing.T, dirPath, schemaVersion string) { t.Helper() files, err := os.ReadDir(dirPath) if err != nil { t.Fatal(err) } for _, file := range files { if file.IsDir() { // Only go through files for now - optionals could / should be included though parseAndValidateHelper(t, path.Join(dirPath, file.Name()), schemaVersion) continue } // Temporarily disable some draft2019-09 tests. if schemaVersion == "draft2019-09" { if _, ok := ignoreDraft2019_09TestFiles[file.Name()]; ok { continue } } // Temporarily disable some draft2020-12 tests. if schemaVersion == "draft2020-12" { if _, ok := ignoreDraft2020_12TestFiles[file.Name()]; ok { continue } } // TODO: Make the failing cases pass... if path.Base(dirPath) == "format" { // The following formats ARE validated, but the validations fails in some rare edge cases, // which in many cases, can be mitigated by formatting the values. // E.g. 087.1.2.3 is invalid due to leading 0, but will be formatted correctly by net.ParseIP. // Formatting of URI/IRI(-reference) is done with Go's buildin url methods. if file.Name() == "idn-hostname.json" { continue } if file.Name() == "ipv4.json" || file.Name() == "ipv6.json" { continue } if file.Name() == "iri.json" || file.Name() == "iri-reference.json" { continue } if file.Name() == "uri.json" || file.Name() == "uri-reference.json" { continue } if file.Name() == "relative-json-pointer.json" { continue } } if path.Base(dirPath) == "optional" { // EcmaScript regex is a different (slower) beast than Go's regex2 engine. // A couple of manipulations are done to the regexes, before they're run, // in order to support some of EcmaScript regex, but not everything is working yet. if file.Name() == "ecmascript-regex.json" { continue } // Content validation (e.g. is this value, valid JSON, JPEG, etc.) could (should?) be done. if file.Name() == "content.json" { continue } } filePath := path.Join(dirPath, file.Name()) t.Run(fmt.Sprintf("%s/%s", path.Base(dirPath), file.Name()), func(t *testing.T) { data, err := ioutil.ReadFile(filePath) if err != nil { t.Fatal(err) } // Extract the tests into structs schemaTests := []schemaTests{} err = json.Unmarshal(data, &schemaTests) if err != nil { t.Fatalf("error while parsing: %s\nerror:%s", filePath, err.Error()) } for i, schemaTest := range schemaTests { // Parse the schema schema, err := New(schemaTest.Schema) if err != nil { t.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } // Verify that we actually have all the information actualSchema, err := json.Marshal(schema) if err != nil { t.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } expectedSchema, err := testtools.SortAndCompactJSON(schemaTest.Schema) if err != nil { t.Fatal(err) } actualSchema, err = testtools.SortAndCompactJSON(actualSchema) if err != nil { t.Fatal(err) } if string(expectedSchema) != string(actualSchema) { // Allow match failure for testdata/draft*/unknownKeyword.json // The schema has errors on purpose, so the parser SHOULD get something different if file.Name() != "unknownKeyword.json" { t.Fatalf( "%s, test #%d\nexpected schemas to be equal, got:\nexpected:\n%s\nactual:\n%s \n", filePath, i+1, string(expectedSchema), string(actualSchema)) } } // Force set the $schema value, to ensure the parser / validators knows which version is expected var schemaStr string switch schemaVersion { case "draft4": schemaStr = "http://json-schema.org/draft-04/schema#" case "draft6": schemaStr = "http://json-schema.org/draft-06/schema#" case "draft7": schemaStr = "http://json-schema.org/draft-07/schema#" } schema.Schema = &schemaStr // Go through the tests and check that the validations matches for n, test := range schemaTest.Tests { actual, err := schema.Validate(test.Data) if actual != test.Valid { errStr := fmt.Sprintf("expected validation to be %t, got: %t\n", test.Valid, actual) if err != nil { errStr += err.Error() + "\n\n" } if errStr != "" { errStr = "errors encountered:\n" + errStr t.Fatalf(`%s, Test #%d.%d: "%s" %sSchema: %s Test document: %s`, filePath, i+1, n+1, test.Description, errStr, string(schemaTest.Schema), string(test.Data)) } } } // Go through the tests again, but this time with de-ref'ed $refs err = schema.DeRef() if err != nil { t.Fatal(err) } for n, test := range schemaTest.Tests { actual, err := schema.Validate(test.Data) if actual != test.Valid { errStr := fmt.Sprintf("expected validation to be %t, got: %t\n", test.Valid, actual) if err != nil { errStr += err.Error() + "\n\n" } if errStr != "" { errStr = "errors encountered:\n" + errStr t.Fatalf(`%s, Test #%d.%d: "%s" %sSchema: %s Test document: %s`, filePath, i+1, n+1, test.Description, errStr, string(schemaTest.Schema), string(test.Data)) } } } } }) } } // Helper for recursing the testdata dirs func parseBenchmarkHelper(b *testing.B, dirPath, schemaVersion string) { b.Helper() files, err := os.ReadDir(dirPath) if err != nil { b.Fatal(err) } for _, file := range files { if file.IsDir() { // Only go through files for now - optionals could / should be included though parseBenchmarkHelper(b, path.Join(dirPath, file.Name()), schemaVersion) continue } filePath := path.Join(dirPath, file.Name()) data, err := ioutil.ReadFile(filePath) if err != nil { b.Fatal(err) } // Extract the tests into structs schemaTests := []schemaTests{} err = json.Unmarshal(data, &schemaTests) if err != nil { b.Fatalf("error while parsing: %s\nerror:%s", filePath, err.Error()) } for _, schemaTest := range schemaTests { // Parse the schema b.Run(filePath, func(b *testing.B) { var err error for i := 0; i < b.N; i++ { var schema *Schema schema, err = New(schemaTest.Schema) if err != nil { b.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } _ = schema } }) b.Run(filePath+"Native", func(b *testing.B) { var err error for i := 0; i < b.N; i++ { var schema interface{} err = json.Unmarshal(schemaTest.Schema, &schema) if err != nil { b.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } _ = schema } }) b.Run(filePath+"GoJSON", func(b *testing.B) { var err error for i := 0; i < b.N; i++ { sl := gojsonschema.NewSchemaLoader() loader1 := gojsonschema.NewBytesLoader(schemaTest.Schema) err = sl.AddSchema("http://some_host.com/string.json", loader1) if err != nil { b.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } _, _ = sl, loader1 } }) } } } // Helper for recursing the testdata dirs func validateBenchmarkHelper(b *testing.B, dirPath, schemaVersion string) { b.Helper() files, err := os.ReadDir(dirPath) if err != nil { b.Fatal(err) } for _, file := range files { if file.IsDir() { // Only go through files for now - optionals could / should be included though parseBenchmarkHelper(b, path.Join(dirPath, file.Name()), schemaVersion) continue } filePath := path.Join(dirPath, file.Name()) data, err := ioutil.ReadFile(filePath) if err != nil { b.Fatal(err) } // Extract the tests into structs schemaTests := []schemaTests{} err = json.Unmarshal(data, &schemaTests) if err != nil { b.Fatalf("error while parsing: %s\nerror:%s", filePath, err.Error()) } for i, schemaTest := range schemaTests { // Parse the schema var jsonSchema *Schema jsonSchema, err = New(schemaTest.Schema) if err != nil { b.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } schemaLoader := gojsonschema.NewBytesLoader(schemaTest.Schema) gojsonSchema, err := gojsonschema.NewSchema(schemaLoader) if err != nil { b.Fatalf("error while parsing: %s, test #%d\nerror: %s", filePath, i+1, err.Error()) } for n, test := range schemaTest.Tests { var res1 bool var err1 error b.Run(fmt.Sprintf("LOCAL: %s #%d.%d", filePath, i, n), func(b *testing.B) { for i := 0; i < b.N; i++ { res1, err1 = jsonSchema.Validate(test.Data) } }) _, _ = res1, err1 var err2 error var res2 *gojsonschema.Result b.Run(fmt.Sprintf("GOJSON: %s #%d.%d", filePath, i, n), func(b *testing.B) { for i := 0; i < b.N; i++ { docLoader := gojsonschema.NewBytesLoader(test.Data) res2, err2 = gojsonSchema.Validate(docLoader) } }) _, _ = res2, err2 } } } } golang-github-flowstack-go-jsonschema-0.1.2/validate_unique.go000066400000000000000000000047741426774651400245310ustar00rootroot00000000000000package jsonschema import ( "errors" "fmt" "sort" "strings" "github.com/buger/jsonparser" ) // uniqueValidator is a bit awkward, but is built this way, // to make the validation fast and relatively simple. type uniqueValidator struct { // For arrays the key is: [index]:[value]:type // For objects the key is: [key]:[value]:jtype // All others have: [value]:[type] cache map[string]struct{} } // This will output object and arrays as a sorted json value func sortObject(data []byte) []byte { vals := map[string][]byte{} err := jsonparser.ObjectEach(data, func(key, value []byte, dataType jsonparser.ValueType, offset int) error { if dataType == jsonparser.String { vals[string(key)] = []byte(fmt.Sprintf(`"%s"`, string(value))) } else { vals[string(key)] = value } return nil }) if err != nil { return data } keys := []string{} for k := range vals { keys = append(keys, k) } sort.Strings(keys) var sortedKVs []string for _, k := range keys { sortedKVs = append(sortedKVs, fmt.Sprintf(`"%s":%s`, k, vals[k])) } sortedData := fmt.Sprintf("{%s}", strings.Join(sortedKVs, ",")) return []byte(sortedData) } func newUniqueValidator() *uniqueValidator { return &uniqueValidator{cache: map[string]struct{}{}} } func (u *uniqueValidator) Exists(data []byte, vt jsonparser.ValueType) bool { var key string switch vt { case jsonparser.Number: key = strings.TrimRight(strings.TrimRight(string(data), "0"), ".") case jsonparser.Array: // Objects must have sorted keys in order for comparison to work (objects can be in arrays) arrVal := newUniqueValidator() var errs error _, err := jsonparser.ArrayEach(data, func(value []byte, dataType jsonparser.ValueType, offset int, err error) { if arrVal.Exists(value, dataType) { errs = addError(errors.New("already exists"), errs) return } }) if err != nil || errs != nil { // errs = addError(err, errs) return true } key = string(data) case jsonparser.Object: // Objects must have sorted keys in order for comparison to work (objects can be in arrays) objVal := newUniqueValidator() err := jsonparser.ObjectEach(data, func(key, value []byte, dataType jsonparser.ValueType, offset int) error { if objVal.Exists(value, dataType) { return errors.New("already exists") } return nil }) if err != nil { return true } key = string(sortObject(data)) default: key = string(data) } if _, ok := u.cache[key+vt.String()]; ok { return true } u.cache[key+vt.String()] = struct{}{} return false } golang-github-flowstack-go-jsonschema-0.1.2/validators.go000066400000000000000000000556461426774651400235260ustar00rootroot00000000000000package jsonschema import ( "bytes" "encoding/json" "errors" "fmt" "log" "math/big" "net" "net/mail" "net/url" "regexp" "strings" "time" "unicode/utf8" "github.com/buger/jsonparser" "golang.org/x/net/idna" ) type validatorFunc func(value []byte, vt ValueType, schema *Schema) error // TODO: Benchmark whether by ref or by pointer is the most performant func validate(value []byte, vt ValueType, schema *Schema) error { var err error if schema == nil { return errors.New("no schema supplied") } if vt == String { value, err = jsonparser.Unescape(value, nil) if err != nil { log.Println(err) return err } } if len(schema.validators) == 0 { return errors.New("no validators found - at least 1 was expected") } for _, validator := range schema.validators { err = validator(value, vt, schema) if err != nil { return err } } return nil } func validateValue(value []byte, vt ValueType, schema *Schema) error { // If the we have an empty value and the schema is not boolean (false), then the doc is invalid // if len(value) == 0 && schema.boolean != nil && !*schema.boolean { if len(value) == 0 && schema.IsEmpty() { return errors.New(`empty document is not valid against any other schemas than "false"`) } return nil } func validateBooleanSchema(value []byte, vt ValueType, schema *Schema) error { // Start by checking for empty JSON value if len(value) == 0 { // If we have an empty value and a boolean false schema then the value is valid if !*schema.boolean { return nil } // If we do not have a boolean false schema, but have an empty value, then the doc is invalid return errors.New("empty document does not validate against the schema") } // If we have a value and a boolean true schema then the value is valid if *schema.boolean { return nil } return errors.New("document does not match the false schema") } func validateRef(value []byte, vt ValueType, schema *Schema) error { refSchema, err := schema.ResolveRef(schema.Ref) if err != nil { log.Println(err) return err } return validate(value, vt, refSchema) } func validateItems(value []byte, vt ValueType, schema *Schema) error { if schema == nil { return errors.New("empty schema") } // Ignore non-arrays if vt != Array { return nil } // Used to ensure uniqueness unique := newUniqueValidator() // Contains validator contains := false // Start by checking if we have boolean schema if schema.Items != nil && schema.Items.Boolean != nil { if *schema.Items.Boolean && len(value) > 0 { return nil } else if !*schema.Items.Boolean && len(value) <= 2 { // empty array matches boolean false schema return nil } return errors.New("items doesn't match schema") } idx := -1 var errs error _, parseErr := jsonparser.ArrayEach(value, func(value []byte, dataType jsonparser.ValueType, offset int, parseErr error) { idx++ // Don't spent time validating, if we already have a parser error if parseErr != nil { errs = addError(parseErr, errs) return } if schema.UniqueItems != nil && *schema.UniqueItems { if unique.Exists(value, dataType) { errs = addError(errors.New("values are not unique"), errs) return } } if schema.Contains != nil { err := validate(value, ValueType(dataType), schema.Contains) if err == nil { contains = true } } if schema.Items == nil { // Items default to empty schema (anything is valid) // So do nothing } else if schema.Items.Schema != nil { err := validate(value, ValueType(dataType), schema.Items.Schema) errs = addError(err, errs) } else if schema.Items.Schemas != nil && idx < len(*schema.Items.Schemas) { err := validate(value, ValueType(dataType), (*schema.Items.Schemas)[idx]) errs = addError(err, errs) } else if schema.AdditionalItems == nil { // It's allowed to have more items than schemas // So do nothing } else if schema.AdditionalItems != nil && (schema.IsDraft4() || len(*schema.Items.Schemas) > 0) { // Only draft 4 allows addtionalItems without items as well err := validate(value, ValueType(dataType), schema.AdditionalItems) errs = addError(err, errs) } else { errs = addError(fmt.Errorf("index %d has no schema to match against", idx), errs) } }) if schema.Contains != nil && !contains { errs = addError(errors.New("no values matched the contains schema"), errs) } count := int64(idx + 1) if schema.MaxItems != nil { if count > *schema.MaxItems { errs = addError(errors.New("too many properties"), errs) } } if schema.MinItems != nil { if count < *schema.MinItems { errs = addError(errors.New("too few properties"), errs) } } if parseErr != nil { errs = addError(parseErr, errs) } return errs } // Unless required, any property can be left out // Properties not defined in the schema are allowed, unless additionProperties == false func validateProperties(value []byte, vt ValueType, schema *Schema) error { // Ignore anything other than Objects (probably an Array) if vt != Object { return nil } // Keep a counter for min and max properties checks var count int64 errs := jsonparser.ObjectEach(value, func(key []byte, value []byte, dataType jsonparser.ValueType, offset int) error { count++ var hasSchema bool var subSchema *Schema if schema.Properties != nil { var subProp *NamedProperty subProp, hasSchema = schema.Properties.GetProperty(string(key)) if hasSchema { subSchema = subProp.Property } } if schema.PatternProperties != nil { subSchemas := schema.findPatternProperties(key) if len(subSchemas) > 0 { hasSchema = true for _, subSchema := range subSchemas { subSchema.name = string(key) if subSchema != nil { err := validate(value, ValueType(dataType), subSchema) if err != nil { return err } } } } } if !hasSchema && schema.AdditionalProperties != nil { subSchema = schema.AdditionalProperties } if subSchema != nil { subSchema.name = string(key) return validate(value, ValueType(dataType), subSchema) } return nil }) if schema.MaxProperties != nil { if count > *schema.MaxProperties { errs = addError(errors.New("too many properties"), errs) } } if schema.MinProperties != nil { if count < *schema.MinProperties { errs = addError(errors.New("too few properties"), errs) } } if schema.Required != nil { err := validateRequired(value, vt, schema) errs = addError(err, errs) } return errs } // Handled in ValidateProperties // func validateMaxProperties(value []byte, vt ValueType, schema *Schema) error { // return errors.New("ValidateMaxProperties is not implemented yet") // } // func validateMinProperties(value []byte, vt ValueType, schema *Schema) error { // return errors.New("ValidateMinProperties is not implemented yet") // } // func validatePatternProperties(value []byte, vt ValueType, schema *Schema) error { // return errors.New("ValidatePatternProperties is not implemented yet") // } // func validateAdditionalProperties(value []byte, vt ValueType, schema *Schema) error { // return errors.New("ValidateAdditionalProperties is not implemented yet") // } func validatePattern(value []byte, vt ValueType, schema *Schema) error { // Ignore anything other than Strings if vt != String { return nil } if !schema.patternRegexp.Match(value) { return errors.New("value did not match pattern") } return nil } // TODO: It might be necessary and / or better to split ValidateProperties into it's // original multiple ValidateXxx methods, so that they do not depend on a // properties object to exist. func validatePropertyNames(value []byte, vt ValueType, schema *Schema) error { // Ignore anything other than Objects (probably an Array) if vt != Object { return nil } return jsonparser.ObjectEach(value, func(key []byte, value []byte, dataType jsonparser.ValueType, offset int) error { return validate(key, String, schema.PropertyNames) }) } func validateType(value []byte, vt ValueType, schema *Schema) error { if vt == Unknown { return errors.New("invalid value") } if schema.Type.String != nil { // A value detected as a number, may still be a valid integer if *schema.Type.String == "integer" && vt == Number && isInteger(value) { // In Draft 4 the value 1.0 can NOT be an integer all other drafts allows this if schema.IsDraft4() && strings.Contains(string(value), ".") { return fmt.Errorf(`value "%s" is of type %s, but should be of type: %s`, value, vt, *schema.Type.String) } return nil } // A detected Integer is also a valid Number if *schema.Type.String == "number" && vt == Integer { return nil } if *schema.Type.String == vt.String() { return nil } return fmt.Errorf(`value "%s" is of type %s, but should be of type: %s`, value, vt, *schema.Type.String) } else if schema.Type.Strings != nil { for _, t := range *schema.Type.Strings { // A value detected as a number, may still be a valid integer if *t == "integer" && vt == Number && isInteger(value) { return nil } // A detected Integer is also a valid Number if *t == "number" && vt == Integer { return nil } if *t == vt.String() { return nil } } return fmt.Errorf(`value "%v" is of type %s, but should be of type: %v`, value, vt, *schema.Type.Strings) } return fmt.Errorf("unknown type") } func validateRequired(value []byte, vt ValueType, schema *Schema) error { // Ignore anything other than Objects if vt != Object { return nil } var errs error paths := [][]string{} for _, str := range *schema.Required { paths = append(paths, []string{*str}) } found := 0 jsonparser.EachKey(value, func(idx int, value []byte, vt jsonparser.ValueType, parseErr error) { // Don't spent time validating, if we already have a parser error if parseErr != nil { errs = addError(parseErr, errs) return } if len(value) == 0 { errs = addError(fmt.Errorf("required value not found"), errs) return } found++ }, paths...) if errs != nil { return errs } if found != len(*schema.Required) { return errors.New("not all required properties were found") } return nil } func validateDependencies(value []byte, vt ValueType, schema *Schema) error { // Ignore anything other than Objects if vt != Object { return nil } paths := [][]string{} for key := range *schema.Dependencies { paths = append(paths, []string{key}) } var errs error jsonparser.EachKey(value, func(idx int, subVal []byte, dataType jsonparser.ValueType, parseErr error) { // Don't spent time validating, if we already have a parser error if parseErr != nil { errs = addError(parseErr, errs) return } if len(paths[idx]) != 1 { errs = addError(errors.New("unexpected path"), errs) return } path := paths[idx][0] dep, ok := (*schema.Dependencies)[path] if !ok { errs = addError(errors.New("path not found in dependencies"), errs) return } if dep.Strings != nil { err := validateRequired(value, vt, &Schema{Required: dep.Strings}) errs = addError(err, errs) } else if dep.Schema != nil { err := validate(value, vt, dep.Schema) errs = addError(err, errs) } }, paths...) return errs } func validateAllOf(value []byte, vt ValueType, schema *Schema) error { for _, subSchema := range *schema.AllOf { err := validate(value, vt, subSchema) if err != nil { return err } } return nil } func validateAnyOf(value []byte, vt ValueType, schema *Schema) error { for _, subSchema := range *schema.AnyOf { err := validate(value, vt, subSchema) if err == nil { return nil } } return errors.New("value does not match any of the schemas") } func validateOneOf(value []byte, vt ValueType, schema *Schema) error { valid := false for _, subSchema := range *schema.OneOf { err := validate(value, vt, subSchema) if err == nil { if !valid { valid = true } else { return errors.New("value matches more than one of the schemas") } } } if valid { return nil } return errors.New("value does not match one of the schemas") } func validateNot(value []byte, vt ValueType, schema *Schema) error { err := validate(value, vt, schema.Not) if err == nil { return errors.New("value should NOT match schema") } return nil } func validateMultipleOf(value []byte, vt ValueType, schema *Schema) error { // Ignore anything but numbers and integers if vt != Number && vt != Integer { return nil } floatVal, _ := new(big.Rat).SetString(string(value)) mul, _ := new(big.Rat).SetString(string(*schema.MultipleOf)) if q := new(big.Rat).Quo(floatVal, mul); !q.IsInt() { return fmt.Errorf("value (%s) is not a multiple of %s", floatVal.String(), mul.String()) } return nil } func validateMaximum(value []byte, vt ValueType, schema *Schema) error { // Ignore anything but numbers and integers if vt != Number && vt != Integer { return nil } floatVal, ok := new(big.Float).SetString(string(value)) if !ok { return errors.New("invalid float value") } if schema.Maximum != nil && schema.Maximum.Number != nil { if schema.ExclusiveMaximum != nil && schema.ExclusiveMaximum.Boolean != nil && *schema.ExclusiveMaximum.Boolean { if floatVal.Cmp(schema.Maximum.Number) < 0 { return nil } } else if floatVal.Cmp(schema.Maximum.Number) <= 0 { return nil } } if schema.ExclusiveMaximum != nil && schema.ExclusiveMaximum.Number != nil { if floatVal.Cmp(schema.ExclusiveMaximum.Number) < 0 { return nil } } return errors.New("value is more than maximum") } func validateMinimum(value []byte, vt ValueType, schema *Schema) error { // Ignore anything but numbers and integers if vt != Number && vt != Integer { return nil } floatVal, ok := new(big.Float).SetString(string(value)) if !ok { return errors.New("invalid float value") } if schema.Minimum != nil && schema.Minimum.Number != nil { if schema.ExclusiveMinimum != nil && schema.ExclusiveMinimum.Boolean != nil && *schema.ExclusiveMinimum.Boolean { if floatVal.Cmp(schema.Minimum.Number) > 0 { return nil } } else if floatVal.Cmp(schema.Minimum.Number) >= 0 { return nil } } if schema.ExclusiveMinimum != nil && schema.ExclusiveMinimum.Number != nil { if floatVal.Cmp(schema.ExclusiveMinimum.Number) > 0 { return nil } } return errors.New("value is more than minimum") } func validateMaxLength(value []byte, vt ValueType, schema *Schema) error { // Ignore anything but strings if vt != String { return nil } if utf8.RuneCount(value) > int(*schema.MaxLength) { return fmt.Errorf("length of value is more than %d", *schema.MaxLength) } return nil } func validateMinLength(value []byte, vt ValueType, schema *Schema) error { // Ignore anything but strings if vt != String { return nil } if utf8.RuneCount(value) < int(*schema.MinLength) { return fmt.Errorf("length of value is less than %d", *schema.MinLength) } return nil } func validateEnum(value []byte, vt ValueType, schema *Schema) error { val, err := NewValue(value, vt.ParserValueType()) if err != nil { return err } for _, e := range *schema.Enum { if e.Equal(val) { return nil } } return errors.New("value is not part of the enum set") } func validateConst(value []byte, vt ValueType, schema *Schema) error { if vt == Integer || vt == Number { if schema.Const.valueType == Integer || schema.Const.valueType == Number { floatVal, _ := new(big.Float).SetString(string(value)) if schema.Const.Number != nil && floatVal.Cmp(schema.Const.Number) == 0 { return nil } } } if vt != schema.Const.valueType { return errors.New("value type doesn't match const value type in schema") } if vt == Object || vt == Array { buf := &bytes.Buffer{} json.Compact(buf, value) value = buf.Bytes() value = sortObject(value) } else if vt == String { if schema.Const.String != nil && *schema.Const.String == string(value) { return nil } } if bytes.Equal(value, schema.Const.raw) { return nil } return errors.New("values does not match const") } func validateIf(value []byte, vt ValueType, schema *Schema) error { err := validate(value, vt, schema.If) if err == nil && schema.Then != nil { return validate(value, vt, schema.Then) } else if err == nil && schema.Then == nil { // Same as Then being true (valid or schema true?) return nil } else if err != nil && schema.Else != nil { return validate(value, vt, schema.Else) } else if err != nil && schema.Else == nil { // Same as Else being true (valid or schema true?) return nil } return errors.New("unable to validate value against if / then / else") } var reHostname = regexp.MustCompile(`^(?:[a-z0-9]{0,63}|[a-z0-9][a-z0-9\-]{0,61}[a-z0-9])(?:\.(?:[\pL\pN\-]{0,63}|[a-z0-9][a-z0-9\-]{0,61}[a-z0-9]))*?$`) var reNonEscapedJSONPointerChars = regexp.MustCompile(`~(?:[^0-1]|$)`) var reCurlyBracketsMatch = regexp.MustCompile(`(?:{\w+.*?})*`) var reDuration = regexp.MustCompile(`^P(?:\d+W|(?:\d+Y){0,1}(?:\d+M){0,1}(?:\d+D){0,1}(?:T(?:\d+H){0,1}(?:\d+M){0,1}(?:\d+S){0,1}){0,1})$`) var reUUID = regexp.MustCompile(`^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$`) func validateFormat(value []byte, vt ValueType, schema *Schema) error { // Ignore anything that is not a string if vt != String { return nil } // Parse takes a layout string, which defines the format by showing how the reference time, // should be interpreted. The reference time is: // Mon Jan 2 15:04:05 -0700 MST 2006 switch *schema.Format { case "date-time": // Date and time together, for example, 2006-01-02T15:04:05-07:00. valueStr := strings.ToUpper(string(value)) valueStr = strings.Replace(valueStr, "15:59:60", "15:59:59", 1) valueStr = strings.Replace(valueStr, "23:59:60", "23:59:59", 1) if _, err := time.Parse(time.RFC3339, valueStr); err != nil { return err } // JSON Schema doesn't allow a couple of weird offset cases for some reason, e.g: // 24:00, -24:00, -00:60 if len(valueStr) >= 5 { if valueStr[len(valueStr)-5:] == "24:00" { return errors.New("invalid offset") } if valueStr[len(valueStr)-5:] == "00:60" { return errors.New("invalid offset") } } return nil case "time": // Time, for example, 15:04:05-07:00 // replace leapseconds valueStr := strings.ToUpper(string(value)) valueStr = strings.Replace(valueStr, "23:59:60", "23:59:59", 1) valueStr = strings.Replace(valueStr, "15:59:60", "15:59:59", 1) t := fmt.Sprintf("1970-01-01T%s", valueStr) if _, err := time.Parse(time.RFC3339, t); err != nil { return err } // JSON Schema doesn't allow a couple of weird offset cases for some reason, e.g: // 24:00, -24:00, -00:60 if len(valueStr) >= 5 { if valueStr[len(valueStr)-5:] == "24:00" { return errors.New("invalid offset") } if valueStr[len(valueStr)-5:] == "00:60" { return errors.New("invalid offset") } } return nil case "date": // Date, for example, 2006-01-02. _, err := time.Parse("2006-01-02", strings.ToUpper(string(value))) return err case "duration": // A duration as defined by the ISO 8601 ABNF for “duration”. For example, P3D expresses a duration of 3 days. str := string(value) if reDuration.MatchString(str) && len(str) > 1 && str[len(str)-1:] != "T" { return nil } return errors.New("value is not a valid duration") case "email": // Internet email address, see RFC 5322, section 3.4.1. fallthrough case "idn-email": // The internationalized form of an Internet email address, see RFC 6531. _, err := mail.ParseAddress(string(value)) return err case "hostname": // Internet host name, see RFC 1123, section 2.1. if reHostname.MatchString(strings.ToLower(string(value))) { return nil } return errors.New("value is not a valid hostname") case "idn-hostname": // An internationalized Internet host name, see RFC5890, section 2.3.2.3. // A domain label must contain a minimum of 1 character and a maximum of 63 characters. i := idna.New( idna.BidiRule(), idna.CheckHyphens(true), idna.CheckJoiners(true), idna.MapForLookup(), idna.RemoveLeadingDots(true), idna.StrictDomainName(true), idna.Transitional(true), idna.ValidateForRegistration(), idna.ValidateLabels(true), idna.VerifyDNSLength(true), ) _, err := i.ToASCII(string(value)) if err == nil { return nil } return err case "ipv4": // IPv4 address, according to dotted-quad ABNF syntax as defined in RFC 2673, section 3.2. ip := net.ParseIP(string(value)) if ip.To4() != nil && strings.Count(string(value), ".") == 3 { return nil } return errors.New("value is not a valid IPv4 address") case "ipv6": // IPv6 address, as defined in RFC 2373, section 2.2. ip := net.ParseIP(string(value)) if ip.To16() != nil && !strings.Contains(string(value), ".") { return nil } return errors.New("value is not a valid IPv6 address") case "uuid": // A Universally Unique Identifier as defined by RFC 4122. Example: 3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a if reUUID.MatchString(strings.ToLower(string(value))) { return nil } return errors.New("value is not a valid UUID") case "uri": // A universal resource identifier (URI), according to RFC3986. u, err := url.Parse(string(value)) if err == nil { if u.Scheme == "" || u.Host == "" { err = errors.New("valus is not a valid IRI") } } return err case "uri-reference": // A URI Reference (either a URI or a relative-reference), according to RFC3986, section 4.1. _, err := url.Parse(string(value)) return err case "iri": // The internationalized equivalent of a “uri”, according to RFC3987. u, err := url.Parse(string(value)) if err == nil { if u.Scheme == "" || u.Host == "" { err = errors.New("valus is not a valid IRI") } } return err case "iri-reference": // The internationalized equivalent of a “uri-reference”, according to RFC3987 _, err := url.Parse(string(value)) return err case "uri-template": // A URI Template (of any level) according to RFC6570. If you don’t already know what a URI Template is, you probably don’t need this value. _, err := url.Parse(string(value)) if err != nil { return err } // Brackets must match if !reCurlyBracketsMatch.MatchString(string(value)) { return errors.New("brackets doesn't match") } if strings.Count(string(value), "{") != strings.Count(string(value), "}") { return errors.New("brackets doesn't match") } return err case "json-pointer": // A JSON Pointer, according to RFC6901. if len(value) > 0 && string(value[:1]) != "/" { return errors.New("value should start with / or be empty") } if reNonEscapedJSONPointerChars.Match(value) { return errors.New("value contains unescaped ~") } pointer := url.QueryEscape(string(value)) _, err := url.Parse(pointer) return err case "relative-json-pointer": // A relative JSON pointer. if len(value) > 0 && string(value[:1]) == "/" { return errors.New("value should not start with /") } pointer := url.QueryEscape(string(value)) _, err := url.Parse(pointer) return err case "regex": // A regular expression, which should be valid according to the ECMA 262 dialect. _, err := regexp.Compile(string(value)) return err default: return fmt.Errorf("unknown format: %s", *schema.Format) } }