JSON-Validator-0.92/0000755000175000017500000000000013037653534013173 5ustar rebusrebusJSON-Validator-0.92/README0000644000175000017500000002412213037653533014053 0ustar rebusrebusNAME JSON::Validator - Validate data against a JSON schema VERSION 0.92 SYNOPSIS use JSON::Validator; my $validator = JSON::Validator->new; # Define a schema - http://json-schema.org/examples.html # You can also load schema from disk or web $validator->schema( { type => "object", required => ["firstName", "lastName"], properties => { firstName => {type => "string"}, lastName => {type => "string"}, age => {type => "integer", minimum => 0, description => "Age in years"} } } ); # Validate your data @errors = $validator->validate({firstName => "Jan Henning", lastName => "Thorsen", age => -42}); # Do something if any errors was found die "@errors" if @errors; DESCRIPTION JSON::Validator is a class for validating data against JSON schemas. You might want to use this instead of JSON::Schema if you need to validate data against draft 4 of the specification. This module can be used standalone, but if you want to define a specification for your webserver's API, then have a look at Mojolicious::Plugin::OpenAPI, which will replace Mojolicious::Plugin::Swagger2. Supported schema formats JSON::Validator can load JSON schemas in multiple formats: Plain perl data structured (as shown in "SYNOPSIS") or files on disk/web in the JSON/YAML format. The JSON parsing is done using Mojo::JSON, while the YAML parsing is done with an optional modules which need to be installed manually. JSON::Validator will look for the YAML modules in this order: YAML::XS, YAML::Syck. The order is set by which module that performs the best, so it might change in the future. Resources Here are some resources that are related to JSON schemas and validation: * * * * Swagger2 Bundled specifications This module comes with some JSON specifications bundled, so your application don't have to fetch those from the web. These specifications should be up to date, but please submit an issue if they are not. Note that the bundled specifications can be ignored, by customizing "cache_paths". * JSON schema, draft 4 Web page: $ref: * JSON schema for JSONPatch files Web page: $ref: * Swagger / OpenAPI specification, version 2 Web page: $ref: * Custom error document There is a custom schema used by Mojolicious::Plugin::OpenAPI as a default error document. This document might be extended later, but it will always be backward compatible. Specification: $ref: . * Swagger Petstore This is used for unit tests, and should probably not be relied on by external users. ERROR OBJECT Overview The method "validate" and the function "validate_json" returns error objects when the input data violates the "schema". Each of the objects looks like this: bless { message => "Some description", path => "/json/path/to/node", }, "JSON::Validator::Error" See also JSON::Validator::Error. Operators The error object overloads the following operators: * bool Returns a true value. * string Returns the "path" and "message" part as a string: "$path: $message". Special cases Have a look at the test suite for documented examples of the error cases. Especially look at "jv-allof.t", "jv-anyof.t" and "jv-oneof.t". The special cases for "allOf", "anyOf" and "oneOf" will contain the error messages from all the failing rules below. It can be a bit hard to read, so if the error message is long, then you might want to run a smaller test with "JSON_VALIDATOR_DEBUG=1". Example error object: bless { message => "(String is too long: 8/5. String is too short: 8/12)", path => "/json/path/to/node", }, "JSON::Validator::Error" Note that these error messages are subject for change. Any suggestions are most welcome! FUNCTIONS validate_json use JSON::Validator "validate_json"; @errors = validate_json $data, $schema; This can be useful in web applications: @errors = validate_json $c->req->json, "data://main/spec.json"; See also "validate" and "ERROR OBJECT" for more details. ATTRIBUTES cache_dir Deprecated in favor of "cache_paths". cache_paths $self = $self->cache_paths(\@paths); $array_ref = $self->cache_paths; Search paths to where cached specifications are stored. Defaults to "JSON_VALIDATOR_CACHE_DIR" and the bundled spec files that are shipped with this distribution. JSON_VALIDATOR_CACHE_DIR=/cache/dir:/some/other/location perl script.pl To download a file and add it to the cache, do this: $ curl http://swagger.io/v2/schema.json > /cache/dir/$(md5 -qs http://swagger.io/v2/schema.json) Files referenced to an URL will automatically be cached if the first path in "cache_paths" is writable. formats $hash_ref = $self->formats; $self = $self->formats(\%hash); Holds a hash-ref, where the keys are supported JSON type "formats", and the values holds a code block which can validate a given format. Note! The modules mentioned below are optional. * date-time An RFC3339 timestamp in UTC time. This is formatted as "YYYY-MM-DDThh:mm:ss.fffZ". The milliseconds portion (".fff") is optional * email Validated against the RFC5322 spec. * hostname Will be validated using Data::Validate::Domain if installed. * ipv4 Will be validated using Data::Validate::IP if installed or fall back to a plain IPv4 IP regex. * ipv6 Will be validated using Data::Validate::IP if installed. * regex EXPERIMENTAL. Will check if the string is a regex, using "qr{...}". * uri Validated against the RFC3986 spec. resolver $code = $self->resolver; $self = $self->resolver(sub { my ($self, $namespace, $refs) = @_; }); Set this to a sub without any logic if you want to skip resolving references, like this: $self->resolver(sub {}); This attribute is EXPERIMENTAL. ua $ua = $self->ua; $self = $self->ua(Mojo::UserAgent->new); Holds a Mojo::UserAgent object, used by "schema" to load a JSON schema from remote location. Note that the default Mojo::UserAgent will detect proxy settings and have "max_redirects" in Mojo::UserAgent set to 3. (These settings are EXPERIMENTAL and might change without a warning) METHODS coerce $self = $self->coerce(booleans => 1, numbers => 1, strings => 1); $self = $self->coerce({booleans => 1, numbers => 1, strings => 1}); $self = $self->coerce(1) # enable all $hash = $self->coerce; Set the given type to coerce. Before enabling coercion this module is very strict when it comes to validating types. Example: The string "1" is not the same as the number 1, unless you have coercion enabled. WARNING! Enabling coercion might hide bugs in your api, which would have been detected if you were strict. For example JavaScript is very picky on a number being an actual number. This module tries it best to convert the data on the fly into the proper value, but this means that you unit tests might be ok, but the client side libraries (that care about types) might break. Loading a YAML document will enable "booleans" automatically. This feature is experimental, but was added since YAML has no real concept of booleans, such as Mojo::JSON or other JSON parsers. The coercion rules are EXPERIMENTAL and will be tighten/loosen if bugs are reported. See for more details. schema $self = $self->schema(\%schema); $self = $self->schema($url); $schema = $self->schema; Used to set a schema from either a data structure or a URL. $schema will be a Mojo::JSON::Pointer object when loaded, and "undef" by default. The $url can take many forms, but needs to point to a text file in the JSON or YAML format. * http://... or https://... A web resource will be fetched using the Mojo::UserAgent, stored in "ua". * data://Some::Module/file.name This version will use "data_section" in Mojo::Loader to load "file.name" from the module "Some::Module". * /path/to/file An URL (without a recognized scheme) will be loaded from disk. singleton $self = $class->singleton; Returns the JSON::Validator object used by "validate_json". validate @errors = $self->validate($data); @errors = $self->validate($data, $schema); Validates $data against a given JSON "schema". @errors will contain validation error objects or be an empty list on success. See "ERROR OBJECT" for details. $schema is optional, but when specified, it will override schema stored in "schema". Example: $self->validate({hero => "superwoman"}, {type => "object"}); COPYRIGHT AND LICENSE Copyright (C) 2014-2015, Jan Henning Thorsen This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0. AUTHOR Jan Henning Thorsen - "jhthorsen@cpan.org" Daniel Böhmer - "post@daniel-boehmer.de" Martin Renvoize - "martin.renvoize@gmail.com" JSON-Validator-0.92/.travis.yml0000644000175000017500000000050212721636157015302 0ustar rebusrebuslanguage: perl perl: - "5.20" - "5.16" - "5.10" env: - "HARNESS_OPTIONS=j6" install: - "cpanm -n Test::Pod Test::Pod::Coverage Test::JSON::Schema::Acceptance" - "cpanm -n Data::Validate::Domain Data::Validate::IP Cpanel::JSON::XS YAML::XS Swagger2" - "cpanm -n --installdeps ." notifications: email: false JSON-Validator-0.92/Changes0000644000175000017500000001374713037653533014501 0ustar rebusrebusRevision history for perl distribution JSON-Validator 0.92 2017-01-18T11:54:03+0000 - Fix infinite recursion when resolving self referencing data structures 0.91 2017-01-10T23:02:36+0100 - Mojo::Util::slurp is DEPRECATED in favor of Mojo::File::slurp 0.90 2016-12-11T11:38:38+0100 - Add support for validating Dancer2 requset/responses #34 - Fix invalidating integer/number path part with letters #37 0.89 2016-11-05T01:36:52+0100 - Fix multipleOf:0.01, closes #35 0.88 2016-11-04T23:18:26+0100 - Fix number coercion #32 Contributor: @melhesedek - Add JSON::Validator::OpenAPI->load_and_validate_spec() 0.87 2016-10-20T22:59:45+0200 - Fix validating data when boolean.pm is loaded 0.86 2016-10-06T18:36:36+0200 - Documented bundled resources 0.85 2016-09-26T22:30:21+0200 - Fix handling of collectionFormat where no input is defined 0.84 2016-08-19T19:11:51+0200 - Removed support for passing $json_path to validate() - Fix guessing type of objects that has TO_JSON() 0.83 2016-08-16T19:37:04+0200 - Fix handling of true/false in schema, when loaded with YAML::Syck #27 - Add EXPERIMENTAL support for passing $json_path to validate() 0.82 2016-08-09T12:45:05+0200 - Fix finding all $ref occurances jhthorsen/swagger2#95 0.81 2016-08-08T10:03:43+0200 - Add support for multiple cache dir search paths - Deperecated cache_dir() - Fix recurring requests with same path part jhthorsen/swagger2#93 - Fix "Use of uninitialized value $schema_type..." warnings 0.80 2016-08-03T19:12:40+0200 - Fix parsing recursive schema 0.79 2016-07-28T21:14:47+0200 - Reverted improved allOf, anyOf and oneOf error messages 0.78 2016-07-28T20:51:31+0200 - Fix recursive dependencies #23 - Add EXPERIMENTAL resolver attribute - Improved allOf, anyOf and oneOf error messages 0.77 2016-07-26T15:03:13+0200 - Avoid duplicate error messages with enum #22 - Fix "false" must be false and not true in OpenAPI 0.76 2016-07-25T14:49:27+0200 - Will write default values into Mojolicious::Controller 0.75 2016-07-02T14:44:31+0200 - Fix uploads must not be slurped - Fix reporting error on missing response status definition - Add warnings on invalid (Perl) regexes 0.74 2016-06-22T19:26:14+0200 - Fix length($data) need be defined in 5.10 0.73 2016-06-22T19:12:10+0200 - Add http://git.io/vcKD4 error schema to cache - Add JSON schema for JSONPatch files - Updated Swagger2 spec to https://github.com/OAI/OpenAPI-Specification/blob/19fed9f0f812ccebe0fc45313fea75bb6656de1c/schemas/v2.0/schema.json 0.72 2016-06-10T19:22:52-0700 - Fix default cache_dir() path - JSON::Validator is no longer EXPERIMENTAL - Move Swagger2::SchemaValidator into JSON::Validator::OpenAPI 0.71 2016-06-07T15:29:35-0500 - Fix setting schema() inside validate() 0.70 2016-05-31T13:38:04+0200 - Fix allowing "id" as property name in objects 0.69 2016-05-26T19:36:53+0200 - Fix failing anyOf logic in t/swagger-validate-response-object.t 0.68 2016-05-25T17:35:26+0100 - Remove _merge_error to clarify anyOf errors #15 0.67 2016-04-11T13:49:55+0200 - Add JSON::Validator::Error class 0.66 2016-02-09T18:32:57+0100 - Fix validating recursive datastructures 0.65 2016-01-07T15:31:37+0100 - Fix t/swagger-validate-response-object.t require Swagger2 0.66 #14 0.64 2015-12-18T16:03:09+0800 - Fix treating JSON::PP::Boolean objects as boolean #13 Contributor: Krasimir Berov - Allow hash reference as arguments to coerce #13 Contributor: Krasimir Berov 0.63 2015-11-28T08:17:59+0100 - Fix skip test in t/booleans.t 0.62 2015-11-27T12:13:08+0100 - Remove support for YAML.pm #jhthorsen/swagger2#50 - Remove support for YAML::Tiny #jhthorsen/swagger2#50 0.61 2015-11-11T21:01:13+0100 - Fix use of TO_JSON() on objects inside arrays #12 0.60 2015-11-09T14:35:56+0000 - Can use TO_JSON() when validating perl objects 0.59 2015-10-14T17:19:53+0200 - Move "collectionFormat" support to Swagger2 0.58 2015-10-13T14:47:25+0200 - Fix string "0" is not detected as boolean 0.57 2015-10-11T13:20:45+0200 - Trust guesswork if input data is undefined 0.56 2015-09-30T11:43:49+0200 - Can read YAML::XS booleans automatically #8 - Change coerce() into a method. #8 - Remove EXPERIMENTAL coerce attribute #8 - Remove EXPERIMENTAL JSON_VALIDATOR_COERCE_VALUES and SWAGGER_COERCE_VALUES #8 0.55 2015-09-29T19:01:05+0200 - Fix "required" cannot be a boolean on properties - Improved documentation of error object - Change anyOf/allOf/oneOf error message 0.54 2015-09-27T13:33:02+0200 - Add support for $ref to relative path #3 #4 #5 - Removed Swagger specific type "file" - Removed Swagger specific formats: "byte", "date", "double", "float", "int32" and "int64". 0.53 2015-09-13T10:52:16+0200 - Fix properties, patternProperties, additionalProperties interaction - patternProperty invalidates property - Fix validation for a keyword and instance SHOULD succeed when keywords does not match primitive type - Fix allOf with base schema - mismatch base schema - Fix checking for a boolean "required" 0.52 2015-09-05T13:52:39+0200 - Add guessing of schema type, based on other attributes - More strict on what is validated as "boolean" - Fix additionalItems are allowed by default - Fix additionalProperties allows a schema which should validate - Fix validating "enum" - Fix validating "array" against "additionalItems" - Fix bugs after running https://github.com/Relequestual/Test-JSON-Schema-Acceptance to validate 0.51 2015-08-24T16:19:06+0200 - Fix "$ref" pointing to a file on disk #1 0.50 2015-08-23T15:07:08+0200 - Fix missing namespace when registering new document - Made cache_dir() public - Bundled spec for json-schema and swagger 0.49 2015-08-23T00:51:08+0200 - Fix loading schema from files 0.48 2015-08-22T21:23:55+0200 - Merged core functionality from Swagger2 and Swagger2::SchemaValidator into this module, JSON::Validator See https://metacpan.org/source/JHTHORSEN/Swagger2-0.47/Changes for previous Changes (<=0.47) - Fix coercing collectionFormat strings into integers and numbers - Add support for reading schemas from __DATA__ section JSON-Validator-0.92/output.txt0000644000175000017500000001240113037426052015263 0ustar rebusrebus$ export PERL_HASH_SEED=1 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 0 wallclock secs ( 0.03 usr 0.00 sys + 0.69 cusr 0.04 csys = 0.76 CPU) Result: PASS $ export PERL_HASH_SEED=2 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 0 wallclock secs ( 0.02 usr 0.00 sys + 0.65 cusr 0.05 csys = 0.72 CPU) Result: PASS $ export PERL_HASH_SEED=3 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.02 usr 0.01 sys + 0.66 cusr 0.02 csys = 0.71 CPU) Result: PASS $ export PERL_HASH_SEED=4 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.02 usr 0.00 sys + 0.64 cusr 0.03 csys = 0.69 CPU) Result: PASS $ export PERL_HASH_SEED=5 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.03 usr 0.00 sys + 0.71 cusr 0.01 csys = 0.75 CPU) Result: PASS $ export PERL_HASH_SEED=6 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.02 usr 0.00 sys + 0.66 cusr 0.04 csys = 0.72 CPU) Result: PASS $ export PERL_HASH_SEED=7 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.01 usr 0.02 sys + 0.63 cusr 0.04 csys = 0.70 CPU) Result: PASS $ export PERL_HASH_SEED=8 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 0 wallclock secs ( 0.03 usr 0.01 sys + 0.54 cusr 0.04 csys = 0.62 CPU) Result: PASS $ export PERL_HASH_SEED=9 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.03 usr 0.00 sys + 0.76 cusr 0.03 csys = 0.82 CPU) Result: PASS $ export PERL_HASH_SEED=10 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. ok 1 - GET /v1/pets ok 2 - 200 OK ok 3 - exact match for JSON Pointer "/0/id" ok 4 - exact match for JSON Pointer "/0/name" ok 5 - GET /v1/pets ok 6 - 200 OK ok 7 - exact match for JSON Pointer "/0/id" ok 8 - exact match for JSON Pointer "/0/name" 1..8 ok All tests successful. Files=1, Tests=8, 1 wallclock secs ( 0.03 usr 0.00 sys + 0.64 cusr 0.03 csys = 0.70 CPU) Result: PASS $ export PERL_HASH_SEED=11 $ cd ../swagger2 && prove -l -v t/plugin-yaml.t t/plugin-yaml.t .. not ok 1 - Could not load Swagger2 plugin using YAML::XS ok 2 - GET /v1/pets ok 3 - 200 OK ok 4 - exact match for JSON Pointer "/0/id" ok 5 - exact match for JSON Pointer "/0/name" 1..5 Dubious, test returned 1 (wstat 256, 0x100) Failed 1/5 subtests Test Summary Report ------------------- t/plugin-yaml.t (Wstat: 256 Tests: 5 Failed: 1) Failed test: 1 Non-zero exit status: 1 Files=1, Tests=5, 1 wallclock secs ( 0.03 usr 0.00 sys + 0.66 cusr 0.02 csys = 0.71 CPU) Result: FAIL JSON-Validator-0.92/.ship.conf0000644000175000017500000000050412577772233015070 0ustar rebusrebus# Generated by git-ship. See 'git-ship --man' for help or https://github.com/jhthorsen/app-git-ship class = App::git::ship::perl project_name = homepage = https://github.com/jhthorsen/json-validator bugtracker = https://github.com/jhthorsen/json-validator/issues license = artistic_2 build_test_options = # Example: -l -j8 JSON-Validator-0.92/Makefile.PL0000644000175000017500000000142313037653533015144 0ustar rebusrebus# Generated by git-ship. See 'git-ship --man' for help or https://github.com/jhthorsen/app-git-ship use ExtUtils::MakeMaker; WriteMakefile( NAME => 'JSON::Validator', AUTHOR => 'Jan Henning Thorsen ', LICENSE => 'artistic_2', ABSTRACT_FROM => 'lib/JSON/Validator.pm', VERSION_FROM => 'lib/JSON/Validator.pm', EXE_FILES => [qw( )], META_MERGE => { resources => { bugtracker => 'https://github.com/jhthorsen/json-validator/issues', homepage => 'https://github.com/jhthorsen/json-validator', repository => 'https://github.com/jhthorsen/json-validator.git', }, }, BUILD_REQUIRES => { 'Test::More' => '0.88', 'Test::Warnings' => '0.016' } , PREREQ_PM => { 'Mojolicious' => '7.15' } , test => { TESTS => 't/*.t' }, ); JSON-Validator-0.92/t/0000755000175000017500000000000013037653534013436 5ustar rebusrebusJSON-Validator-0.92/t/relative-ref.t0000644000175000017500000000133112757522052016204 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $file = File::Spec->catfile(File::Basename::dirname(__FILE__), 'spec', 'with-relative-ref.json'); my $validator = JSON::Validator->new(cache_paths => [])->schema($file); is $validator->schema->get('/properties/age/type'), 'integer', 'loaded age.json from disk'; use Mojolicious::Lite; push @{app->static->paths}, File::Basename::dirname(__FILE__); $validator->ua(app->ua); $validator->schema(app->ua->server->url->clone->path('/spec/with-relative-ref.json')); is $validator->schema->get('/properties/age/type'), 'integer', 'loaded age.json from http'; my @errors = $validator->validate({age => 'not a number'}); is int(@errors), 1, 'invalid age'; done_testing; JSON-Validator-0.92/t/jv-number.t0000644000175000017500000000224513036173274015530 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = { type => 'object', properties => {mynumber => {type => 'number', minimum => -0.5, maximum => 2.7}} }; my @errors = $validator->validate({mynumber => 1}, $schema); is "@errors", "", "number"; @errors = $validator->validate({mynumber => "2"}, $schema); is "@errors", "/mynumber: Expected number - got string.", "a string"; $validator->coerce(numbers => 1); @errors = $validator->validate({mynumber => "-0.3"}, $schema); is "@errors", "", "coerced string into number"; @errors = $validator->validate({mynumber => "0.1e+1"}, $schema); is "@errors", "", "coerced scientific notation"; @errors = $validator->validate({mynumber => "2xyz"}, $schema); is "@errors", "/mynumber: Expected number - got string.", "a string"; @errors = $validator->validate({mynumber => ".1"}, $schema); is "@errors", "/mynumber: Expected number - got string.", "not a JSON number"; @errors = $validator->validate({validNumber => 2.01}, {type => "object", properties => {validNumber => {type => "number", multipleOf => 0.01}}}); is "@errors", "", "valid float magic"; done_testing; JSON-Validator-0.92/t/definitions/0000755000175000017500000000000013037653534015751 5ustar rebusrebusJSON-Validator-0.92/t/definitions/weight.json0000644000175000017500000000023512620126563020125 0ustar rebusrebus{ "type": "object", "description": "Weight with Units", "properties": { "mass": { "type": "integer" }, "unit": { "$ref": "./unit.json" } } } JSON-Validator-0.92/t/definitions/unit.json0000644000175000017500000000012312620126563017611 0ustar rebusrebus{ "type": "string", "description": "Unit of Mass", "pattern": "^kg|st|lb$" } JSON-Validator-0.92/t/definitions/age.json0000644000175000017500000000011112602203355017356 0ustar rebusrebus{ "type": "integer", "minimum": 0, "description": "Age in years" } JSON-Validator-0.92/t/openapi-formats.t0000644000175000017500000000774713036173274016743 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator::OpenAPI::Mojolicious; my $validator = JSON::Validator::OpenAPI::Mojolicious->new; my $schema = {type => 'object', properties => {v => {type => 'string'}}}; my @errors; { $schema->{properties}{v}{format} = 'byte'; @errors = $validator->validate({v => 'amh0aG9yc2Vu'}, $schema); is "@errors", "", "byte valid"; @errors = $validator->validate({v => "\0"}, $schema); is "@errors", "/v: Does not match byte format.", "byte invalid"; } { $schema->{properties}{v}{format} = 'date'; @errors = $validator->validate({v => '2014-12-09'}, $schema); is "@errors", "", "date valid"; @errors = $validator->validate({v => '2014-12-09T20:49:37Z'}, $schema); is "@errors", "/v: Does not match date format.", "date invalid"; } { $schema->{properties}{v}{format} = 'date-time'; @errors = $validator->validate({v => '2014-12-09T20:49:37Z'}, $schema); is "@errors", "", "date-time valid"; @errors = $validator->validate({v => '20:46:02'}, $schema); is "@errors", "/v: Does not match date-time format.", "date-time invalid"; } { local $schema->{properties}{v}{type} = 'number'; local $schema->{properties}{v}{format} = 'double'; @errors = $validator->validate({v => 1.1000000238418599085576943252817727625370025634765626}, $schema); local $TODO = "cannot test double, since input is already rounded"; is "@errors", "", "positive double valid"; } { local $schema->{properties}{v}{format} = 'email'; @errors = $validator->validate({v => 'jhthorsen@cpan.org'}, $schema); is "@errors", "", "email valid"; @errors = $validator->validate({v => 'foo'}, $schema); is "@errors", "/v: Does not match email format.", "email invalid"; } { local $TODO = 'No idea how to test floats'; local $schema->{properties}{v}{type} = 'number'; local $schema->{properties}{v}{format} = 'float'; @errors = $validator->validate({v => -1.10000002384186}, $schema); is "@errors", "", "negative float valid"; @errors = $validator->validate({v => 1.10000002384186}, $schema); is "@errors", "", "positive float valid"; @errors = $validator->validate({v => 0.10000000000000}, $schema); is "@errors", "/v: Does not match float format.", "float invalid"; } { local $schema->{properties}{v}{format} = 'ipv4'; @errors = $validator->validate({v => '255.100.30.1'}, $schema); is "@errors", "", "ipv4 valid"; @errors = $validator->validate({v => '300.0.0.0'}, $schema); is "@errors", "/v: Does not match ipv4 format.", "ipv4 invalid"; } { local $schema->{properties}{v}{type} = 'integer'; local $schema->{properties}{v}{format} = 'int32'; @errors = $validator->validate({v => -2147483648}, $schema); is "@errors", "", "negative int32 valid"; @errors = $validator->validate({v => 2147483647}, $schema); is "@errors", "", "positive int32 valid"; @errors = $validator->validate({v => 2147483648}, $schema); is "@errors", "/v: Does not match int32 format.", "int32 invalid"; } if (JSON::Validator::OpenAPI::IV_SIZE >= 8) { local $schema->{properties}{v}{type} = 'integer'; local $schema->{properties}{v}{format} = 'int64'; @errors = $validator->validate({v => -9223372036854775808}, $schema); is "@errors", "", "negative int64 valid"; @errors = $validator->validate({v => 9223372036854775807}, $schema); is "@errors", "", "positive int64 valid"; @errors = $validator->validate({v => 9223372036854775808}, $schema); is "@errors", "/v: Does not match int64 format.", "int64 invalid"; } { local $schema->{properties}{v}{format} = 'uri'; @errors = $validator->validate({v => 'http://mojolicio.us/?ø=123'}, $schema); is "@errors", "", "uri valid"; local $TODO = "Not sure how to make an invalid URI"; @errors = $validator->validate({v => 'anything'}, $schema); is "@errors", "/v: Does not match uri format.", "uri invalid"; } { local $schema->{properties}{v}{format} = 'unknown'; @errors = $validator->validate({v => 'whatever'}, $schema); is "@errors", "", "unknown is always valid"; } done_testing; JSON-Validator-0.92/t/jv-required.t0000644000175000017500000000160012721351037016045 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator 'validate_json'; my $schema0 = {type => 'object', properties => {mynumber => {type => 'string', required => 1}}}; my $schema1 = {type => 'object', properties => {mynumber => {type => 'string'}}, required => ['mynumber']}; my $schema2 = {type => 'object', properties => {mynumber => {type => 'string'}}}; my $data1 = {mynumber => "yay"}; my $data2 = {mynumbre => "err"}; my @errors = validate_json $data1, $schema1; is "@errors", "", "data1, schema1"; @errors = validate_json $data2, $schema0; is "@errors", "", "cannot have required on properties"; @errors = validate_json $data2, $schema1; is "@errors", "/mynumber: Missing property.", "data2, schema1"; @errors = validate_json $data1, $schema2; is "@errors", "", "data1, schema2"; @errors = validate_json $data2, $schema2; is "@errors", "", "data2, schema2"; done_testing; JSON-Validator-0.92/t/spec/0000755000175000017500000000000013037653534014370 5ustar rebusrebusJSON-Validator-0.92/t/spec/person.json0000644000175000017500000000053012602203355016554 0ustar rebusrebus{ "title": "Example Schema", "type": "object", "required": ["firstName", "lastName"], "properties": { "firstName": { "type": "string" }, "lastName": { "type": "string" }, "age": { "$ref": "#/definitions/age" } }, "definitions": { "age": { "type": "integer", "minimum": 0, "description": "Age in years" } } } JSON-Validator-0.92/t/spec/invalid-ref.t0000644000175000017500000000000012620126563016735 0ustar rebusrebusJSON-Validator-0.92/t/spec/with-relative-ref.json0000644000175000017500000000014012602203355020601 0ustar rebusrebus{ "type": "object", "properties": { "age": { "$ref": "../definitions/age.json#" } } } JSON-Validator-0.92/t/spec/with-deep-mixed-ref.json0000644000175000017500000000042413036174506021023 0ustar rebusrebus{ "type": "object", "properties": { "age": { "$ref": "../definitions/age.json#" }, "weight": { "$ref": "../definitions/weight.json" }, "height": { "$ref": "#/definitions/height" } }, "definitions": { "height": { "type": "integer", "minimum": 5 } } } JSON-Validator-0.92/t/spec/petstore.json0000644000175000017500000000226412620126563017126 0ustar rebusrebus{ "parameters": { "limit": { "name": "limit", "in": "query", "description": "How many items to return at one time (max 100)", "required": false, "type": "integer", "format": "int32" } }, "paths": { "/pets": { "get": { "tags": [ "pets" ], "parameters": [ { "$ref": "#/parameters/limit" } ], "responses": { "200": { "description": "pet response", "schema": { "type": "array", "items": { "$ref": "#/definitions/Pet" } } }, "default": { "description": "unexpected error", "schema": { "$ref": "#/definitions/Error" } } } } } }, "definitions": { "Pet": { "required": [ "id", "name" ], "properties": { "id": { "type": "integer", "format": "int64" }, "name": { "type": "string" }, "tag": { "type": "string" } } }, "Error": { "required": [ "code", "message" ], "properties": { "code": { "type": "integer", "format": "int32" }, "message": { "type": "string" } } } } } JSON-Validator-0.92/t/swagger-validate-response-object.t0000644000175000017500000000471612734715577022172 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; # # This test used to fail with error messages such as: # /paths/~1commands/get/responses/default: Expected only one to match. # /info/title: Missing property. # /definitions/Error/properties/errors/items: [0] Properties not allowed: message, path. [1] Expected array - got object. # The message that tripped me off was "Expected only one to match." which # made me believe there was a bug in JSON::Validator. The real reason was # however that spec.json contained an invalid spec. Such as "required":true, # instead of "required":["message"]. # I think it would be nice to have better error messages, but at right now I # don't have the capacity to figure out how to make those. # # - Jan Henning Thorsen # plan skip_all => 'Swagger2 0.66+ is required' unless eval 'require Swagger2;Swagger2->VERSION >= 0.66'; my $swagger = Swagger2->new('data://main/spec.json'); my @errors = $swagger->validate; is "@errors", "", "no errors in spec.json"; done_testing; __DATA__ @@ spec.json { "swagger": "2.0", "info": { "title": "(part of) Convos API specification", "version": "0.87" }, "host": "demo.convos.by", "basePath": "/1.0", "schemes": [ "http" ], "paths": { "/commands": { "get": { "responses": { "200": { "description": "List of commands.", "schema": { "type": "object", "properties": { "commands": { "type": "array", "$ref": "#/definitions/Command" } } } }, "default": { "description": "Error.", "schema": { "$ref": "#/definitions/Error" } } } } } }, "definitions": { "Command": { "required": ["id", "command"], "properties": { "id": { "type": "string", "description": "jhthorsen: Cannot remember what 'id' is." }, "command": { "type": "string", "description": "A command to be sent to backend" } } }, "Error": { "properties": { "errors": { "type": "array", "items": { "type": "object", "required": ["message"], "properties": { "message": { "type": "string", "description": "Human readable description of the error" }, "path": { "type": "string", "description": "JSON pointer to the input data where the error occur" } } } } } } } } JSON-Validator-0.92/t/swagger2-issues-50.t0000644000175000017500000000070112721351037017065 0ustar rebusrebususe Mojo::Base -strict; use Test::More; my $i = 0; my $doc = <<'HERE'; --- foo: - '$ref': '#/parameters/Foo' HERE for my $module (qw( YAML::XS YAML::Syck )) { next unless eval "require $module;1"; my $loader = eval "\\\&$module\::Load"; is_deeply eval { $loader->($doc) } || undef, {foo => [{'$ref' => '#/parameters/Foo'}]}, "loaded with $module"; $i++; } plan skip_all => 'No YAML module was installed' unless $i; done_testing; JSON-Validator-0.92/t/jv-oneof.t0000644000175000017500000000337612753344660015360 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = {oneOf => [{type => "string", maxLength => 5}, {type => "number", minimum => 0}]}; my @errors; @errors = $validator->validate("short", $schema); is "@errors", "", "string"; @errors = $validator->validate(12, $schema); is "@errors", "", "number"; $schema = {oneOf => [{type => "number", multipleOf => 5}, {type => "number", multipleOf => 3}]}; @errors = $validator->validate(10, $schema); is "@errors", "", "n:10"; @errors = $validator->validate(9, $schema); is "@errors", "", "n:9"; @errors = $validator->validate(15, $schema); is "@errors", "/: All of the oneOf rules match.", "n:15"; @errors = $validator->validate(13, $schema); is "@errors", "/: oneOf failed: Not multiple of 5. Not multiple of 3.", "n:13"; $schema = {oneOf => [{type => "object"}, {type => "string", multipleOf => 3}]}; @errors = $validator->validate(13, $schema); is "@errors", "/: oneOf failed: Expected object or string, got number.", "n:13 object/string"; $schema = {oneOf => [{type => "object"}, {type => "number", multipleOf => 3}]}; @errors = $validator->validate(13, $schema); is "@errors", "/: oneOf failed: Not multiple of 3.", "multipleOf"; # Alternative oneOf # http://json-schema.org/latest/json-schema-validation.html#anchor79 $schema = {type => 'object', properties => {x => {type => ['string', 'null'], format => 'date-time'}}}; @errors = $validator->validate({x => 'foo'}, $schema); is "@errors", "/x: anyOf failed: Does not match date-time format.", "date-time"; @errors = $validator->validate({x => '2015-04-21T20:30:43.000Z'}, $schema); is "@errors", "", "YYYY-MM-DDThh:mm:ss.fffZ"; @errors = $validator->validate({x => undef}, $schema); is "@errors", "", "null"; done_testing; JSON-Validator-0.92/t/jv-string.t0000644000175000017500000000231012721351037015532 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; use utf8; my $validator = JSON::Validator->new; my $schema = { type => 'object', properties => {nick => {type => 'string', minLength => 3, maxLength => 10, pattern => qr{^\w+$}}} }; my @errors = $validator->validate({nick => 'batman'}, $schema); is "@errors", "", "batman"; @errors = $validator->validate({nick => 1000}, $schema); is "@errors", "/nick: Expected string - got number.", "integer"; @errors = $validator->validate({nick => '1000'}, $schema); is "@errors", "", "number as string"; @errors = $validator->validate({nick => 'aa'}, $schema); is "@errors", "/nick: String is too short: 2/3.", "too short"; @errors = $validator->validate({nick => 'a' x 11}, $schema); is "@errors", "/nick: String is too long: 11/10.", "too long"; @errors = $validator->validate({nick => '[nick]'}, $schema); like "@errors", qr{/nick: String does not match}, "pattern"; delete $schema->{properties}{nick}{pattern}; @errors = $validator->validate({nick => 'Déjà vu'}, $schema); is "@errors", "", "unicode"; $validator->coerce(1); @errors = $validator->validate({nick => 1000}, $schema); is "@errors", "", "coerced integer into string"; done_testing; JSON-Validator-0.92/t/schema-as-attr.t0000644000175000017500000000056712734715577016455 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $json = JSON::Validator->new; my $schema; no warnings 'redefine'; *JSON::Validator::_validate = sub { $schema = shift->schema }; $json->validate({data => 1}, {type => 'object'}); is_deeply $schema->data, {type => 'object'}, 'schema() localized'; is $json->schema, undef, 'schema() is not set'; done_testing; JSON-Validator-0.92/t/acceptance.t0000644000175000017500000000204212721351037015677 0ustar rebusrebususe Mojo::Base -strict; use Mojo::JSON qw(encode_json decode_json ); use Mojo::Util 'dumper'; use Test::More; use JSON::Validator 'validate_json'; plan skip_all => 'cpanm Test::JSON::Schema::Acceptance' unless eval 'use Test::JSON::Schema::Acceptance; 1'; my $opts = { only_test => $ENV{ACCEPTANCE_TEST}, skip_tests => [ 'Unicode code point', # Valid unicode won't pass Mojo::JSON 'dependencies', # TODO 'valid definition schema', # This module does not validate the schema, it only validates data 'ref', # No way to fetch http://localhost:1234/... ], }; my @drafts = qw( 4 ); # ( 3 4 ) for my $draft (@drafts) { my $accepter = Test::JSON::Schema::Acceptance->new($draft); $accepter->acceptance( sub { my $schema = shift; my $input = decode_json shift; my @errors = validate_json $input, $schema; diag dumper([$input, $schema, @errors]) if $ENV{ACCEPTANCE_TEST}; return @errors ? 0 : 1; }, $opts, ); } done_testing(); JSON-Validator-0.92/t/booleans-xs.t0000644000175000017500000000123412721351037016045 0ustar rebusrebusBEGIN { $ENV{TEST_XS} = eval "require Cpanel::JSON::XS;require Mojo::JSON::MaybeXS;1"; } use Mojo::Base -strict; use Test::More; use JSON::Validator; plan skip_all => 'Cpanel::JSON::XS and Mojo::JSON::MaybeXS is required.' unless $ENV{TEST_XS}; my $schema = {properties => {disabled => {type => "boolean"}}}; my $validator = JSON::Validator->new->schema($schema); my $objects = [{disabled => 1}, {disabled => 0}]; my @errors; for my $o (@$objects) { $o->{disabled} = $o->{disabled} ? Mojo::JSON->true : Mojo::JSON->false; @errors = $validator->validate($o); ok !@errors, "boolean via Mojo::JSON::MaybeXS ($o->{disabled}). (@errors)"; } done_testing; JSON-Validator-0.92/t/jv-array.t0000644000175000017500000000367212620126563015360 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; use Mojo::JSON; my $validator = JSON::Validator->new; my @errors; my $simple = {type => "array", items => {type => "number"}}; my $length = {type => "array", minItems => 2, maxItems => 2}; my $unique = {type => 'array', uniqueItems => 1, items => {type => 'integer'}}; my $tuple = { type => "array", items => [ {type => "number"}, {type => "string"}, {type => "string", enum => ["Street", "Avenue", "Boulevard"]}, {type => "string", enum => ["NW", "NE", "SW", "SE"]} ] }; @errors = $validator->validate([1], $simple); is "@errors", "", "simple: success"; @errors = $validator->validate([1, "foo"], $simple); is "@errors", "/1: Expected number - got string.", "simple: got string"; @errors = $validator->validate([1], $length); is "@errors", "/: Not enough items: 1/2.", "length: not enough"; @errors = $validator->validate([1, 2], $length); is "@errors", "", "length: success"; @errors = $validator->validate([1, 2, 3], $length); is "@errors", "/: Too many items: 3/2.", "length: too many"; @errors = $validator->validate([123, 124], $unique); is "@errors", "", "unique: success"; @errors = $validator->validate([1, 2, 1], $unique); is "@errors", "/: Unique items required.", "unique: fail"; @errors = $validator->validate([1600, "Pennsylvania", "Avenue", "NW"], $tuple); is "@errors", "", "tuple: success"; @errors = $validator->validate([24, "Sussex", "Drive"], $tuple); is "@errors", "", "tuple: invalid"; @errors = $validator->validate([10, "Downing", "Street"], $tuple); is "@errors", "", "tuple: not complete length"; @errors = $validator->validate([1600, "Pennsylvania", "Avenue", "NW", "Washington"], $tuple); is "@errors", "", "tuple: too many"; $tuple->{additionalItems} = Mojo::JSON->false; @errors = $validator->validate([1600, "Pennsylvania", "Avenue", "NW", "Washington"], $tuple); is "@errors", "/: Invalid number of items: 5/4.", "tuple: additionalItems"; done_testing; JSON-Validator-0.92/t/load-data.t0000644000175000017500000000142112577772233015455 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my @errors = $validator->schema('data://Some::Module/spec.json')->validate({firstName => 'yikes!'}); is int(@errors), 1, 'one error'; is $errors[0]->path, '/lastName', 'lastName'; is $errors[0]->message, 'Missing property.', 'required'; is_deeply $errors[0]->TO_JSON, {path => '/lastName', message => 'Missing property.'}, 'TO_JSON'; done_testing; package Some::Module; __DATA__ @@ spec.json { "title": "Example Schema", "type": "object", "required": ["firstName", "lastName"], "properties": { "firstName": { "type": "string" }, "lastName": { "type": "string" }, "age": { "type": "integer", "minimum": 0, "description": "Age in years" } } } JSON-Validator-0.92/t/openapi.t0000644000175000017500000000403713036173274015257 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; use JSON::Validator::OpenAPI::Mojolicious; { local $TODO = 'Need to be updated to openapi spec'; is JSON::Validator::OpenAPI::SPECIFICATION_URL(), 'http://swagger.io/v2/schema.json', 'spec url'; } my $openapi = JSON::Validator::OpenAPI::Mojolicious->new; my ($schema, @errors); # standard $schema = {type => 'object', properties => {age => {type => 'integer'}}}; @errors = $openapi->validate_input({age => '42'}, $schema); like "@errors", qr{Expected integer - got string}, 'string != integer'; # readOnly $schema->{properties}{age}{readOnly} = Mojo::JSON->true; @errors = $openapi->validate_input({age => 42}, $schema); like "@errors", qr{Read-only}, 'ro'; # collectionFormat $schema = {type => 'array', items => {collectionFormat => 'csv', type => 'integer'}}; @errors = $openapi->validate_input('1,2,3', $schema); is "@errors", '', 'csv data'; # file $schema = {type => 'file', required => Mojo::JSON->true}; @errors = $openapi->validate_input(undef, $schema); like "@errors", qr{Missing property}, 'file'; # discriminator $openapi->schema( { definitions => { Cat => { type => 'object', required => ['huntingSkill'], properties => { huntingSkill => { default => 'lazy', enum => ['clueless', 'lazy', 'adventurous', 'aggressive'], type => 'string', } } } } } ); $schema = { discriminator => 'petType', properties => {petType => {'type' => 'string'}}, required => ['petType'], type => 'object', }; @errors = $openapi->validate_input({}, $schema); is "@errors", "/: Discriminator petType has no value.", "petType has no value"; @errors = $openapi->validate_input({petType => 'Bat'}, $schema); is "@errors", "/: No definition for discriminator Bat.", "no definition for discriminator"; @errors = $openapi->validate_input({petType => 'Cat'}, $schema); is "@errors", "/huntingSkill: Missing property.", "missing property"; diag join ',', @errors; done_testing; JSON-Validator-0.92/t/load-json.t0000644000175000017500000000170013036173274015504 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; use Mojo::File 'path'; my $file = File::Spec->catfile(File::Basename::dirname(__FILE__), 'spec', 'person.json'); my $validator = JSON::Validator->new->schema($file); my @errors = $validator->validate({firstName => 'yikes!'}); is int(@errors), 1, 'one error'; is $errors[0]->path, '/lastName', 'lastName'; is $errors[0]->message, 'Missing property.', 'required'; is_deeply $errors[0]->TO_JSON, {path => '/lastName', message => 'Missing property.'}, 'TO_JSON'; my $spec = path($file)->slurp; $spec =~ s!"#!"person.json#! or die "Invalid spec: $spec"; path("$file.2")->spurt($spec); ok eval { JSON::Validator->new->schema("$file.2") }, 'test issue #1 where $ref could not point to a file' or diag $@; unlink "$file.2"; # load from cache is(eval { JSON::Validator->new->schema('http://swagger.io/v2/schema.json'); 42 }, 42, 'loaded from cache') or diag $@; done_testing; JSON-Validator-0.92/t/validate-recursive.t0000644000175000017500000000214713037107245017416 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; use JSON::Validator 'validate_json'; { use Mojolicious::Lite; post '/' => sub { my $c = shift; my @errors = validate_json $c->req->json, 'data://main/spec.json'; $c->render(status => @errors ? 400 : 200, json => \@errors); }; } my $t = Test::Mojo->new; $t->post_ok('/', json => {})->status_is(400)->content_like(qr{/person}); $t->post_ok('/', json => {person => {name => "foo"}})->status_is(200); $t->post_ok('/', json => {person => {name => "foo", children => [{}]}})->status_is(400) ->json_is('/0/path' => '/person/children/0/name'); done_testing; __DATA__ @@ spec.json { "type": "object", "properties": { "person": { "$ref": "#/definitions/person" } }, "required": [ "person" ], "definitions": { "person": { "type": "object", "properties": { "name": { "type": "string" }, "children": { "type": "array", "items": { "$ref": "#/definitions/person" } } }, "required": [ "name" ] } } } JSON-Validator-0.92/t/load-yaml.t0000644000175000017500000000146712721351037015502 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; plan skip_all => $@ unless eval { JSON::Validator::_load_yaml("---\nfoo: bar") }; my $validator = JSON::Validator->new; my @errors = $validator->schema('data://Some::Module/s_pec-/-ficaTion')->validate({firstName => 'yikes!'}); is int(@errors), 1, 'one error'; is $errors[0]->path, '/lastName', 'lastName'; is $errors[0]->message, 'Missing property.', 'required'; is_deeply $errors[0]->TO_JSON, {path => '/lastName', message => 'Missing property.'}, 'TO_JSON'; done_testing; package Some::Module; __DATA__ @@ s_pec-/-ficaTion --- title: Example Schema type: object required: - firstName - lastName properties: firstName: type: string lastName: type: string age: type: integer minimum: 0 description: Age in years JSON-Validator-0.92/t/invalid-ref.t0000644000175000017500000000054112620126563016015 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; eval { $validator->schema('data://main/spec.json') }; like $@, qr{Could not find "\#/definitions/Pet"}, 'missing definition'; done_testing; __DATA__ @@ spec.json { "schema": { "type": "array", "items": { "$ref": "#/definitions/Pet" } } } JSON-Validator-0.92/t/to-json.t0000644000175000017500000000223612721351037015207 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator 'validate_json'; my @errors = validate_json(bless({path => '', message => 'yikes'}, 'JSON::Validator::Error'), 'data://main/spec.json'); ok !@errors, 'TO_JSON on objects' or diag join ', ', @errors; @errors = validate_json( { valid => Mojo::JSON->false, errors => [ bless({path => '', message => 'foo'}, 'JSON::Validator::Error'), bless({path => '', message => 'bar'}, 'JSON::Validator::Error') ] }, 'data://main/spec_array.json' ); ok !@errors, 'TO_JSON on objects inside arrays' or diag join ', ', @errors; done_testing; __DATA__ @@ spec.json { "type": "object", "properties": { "message": { "type": "string" } }, "required": ["message"] } @@ spec_array.json { "type": "object", "properties": { "valid": { "type": "boolean" }, "errors": { "type": "array", "items": { "type": "object", "properaties": { "message": { "type": "string" }, "path": { "type": "string" } }, "required": [ "message" ] } } }, "required": [ "errors" ] } JSON-Validator-0.92/t/openapi-set-request.t0000644000175000017500000000356612757522052017545 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; plan skip_all => 'Mojolicious::Plugin::OpenAPI 0.08 is required' unless eval 'use Mojolicious::Plugin::OpenAPI 0.08; 1'; use Mojolicious::Lite; get '/echo' => sub { my $c = shift->openapi->valid_input or return; $c->reply->openapi(200 => {bool => $c->param('bool')}); }, 'echo'; get '/echo/:whatever' => sub { my $c = shift->openapi->valid_input or return; $c->reply->openapi( 200 => {this_stack => $c->match->stack->[-1], whatever => $c->param('whatever')}); }, 'whatever'; plugin OpenAPI => {url => 'data://main/echo.json'}; my $t = Test::Mojo->new; $t->get_ok('/api/echo?bool=false')->status_is(200)->json_is('/bool' => Mojo::JSON->false); $t->get_ok('/api/echo?bool=true')->status_is(200)->json_is('/bool' => Mojo::JSON->true); $t->get_ok('/api/echo')->status_is(200)->json_is('/bool' => Mojo::JSON->true); $t->get_ok('/api/echo/something')->status_is(200)->json_is('/this_stack/whatever' => 'something') ->json_is('/whatever' => 'something'); done_testing; __DATA__ @@ echo.json { "swagger": "2.0", "info": { "version": "0.8", "title": "Pets" }, "schemes": [ "http" ], "basePath": "/api", "paths": { "/echo/{whatever}": { "get": { "x-mojo-name": "whatever", "parameters": [ { "in": "path", "name": "whatever", "type": "string", "required": true } ], "responses": { "200": { "description": "Echo response", "schema": { "type": "object" } } } } }, "/echo": { "get": { "x-mojo-name": "echo", "parameters": [ { "in": "query", "name": "bool", "type": "boolean", "default": true } ], "responses": { "200": { "description": "Echo response", "schema": { "type": "object" } } } } } } } JSON-Validator-0.92/t/jv-enum.t0000644000175000017500000000145212577772233015214 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $male = {type => 'object', properties => {chromosomes => {enum => [[qw( X Y )], [qw( Y X )]]}}}; my $female = {type => 'object', properties => {chromosomes => {enum => [[qw( X X )]]}}}; ok $validator->validate({name => "Kate", chromosomes => [qw( X X )]}, $male), "it's short for Bob"; ok !$validator->validate({name => "Kate", chromosomes => [qw( X X )]}, $female); ok !$validator->validate({name => "Dave", chromosomes => [qw( X Y )]}, $male); ok !$validator->validate({name => "Arnie", chromosomes => [qw( Y X )]}, $male); ok $validator->validate({name => "Eddie", chromosomes => [qw( X Y Y )]}, $male); ok $validator->validate({name => "Steve", chromosomes => 'XY'}, $male); done_testing; JSON-Validator-0.92/t/jv-not.t0000644000175000017500000000053212577772233015046 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = {not => {type => "string"}}; my @errors; @errors = $validator->validate(12, $schema); is "@errors", "", "not string"; @errors = $validator->validate("str", $schema); is "@errors", "/: Should not match.", "is string"; done_testing; JSON-Validator-0.92/t/jv-formats.t0000644000175000017500000000511112757522052015707 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = {type => 'object', properties => {v => {type => 'string'}}}; my @errors; { $schema->{properties}{v}{format} = 'date-time'; @errors = $validator->validate({v => '2014-12-09T20:49:37Z'}, $schema); is "@errors", "", "date-time valid"; @errors = $validator->validate({v => '20:46:02'}, $schema); is "@errors", "/v: Does not match date-time format.", "date-time invalid"; } { local $schema->{properties}{v}{format} = 'email'; @errors = $validator->validate({v => 'jhthorsen@cpan.org'}, $schema); is "@errors", "", "email valid"; @errors = $validator->validate({v => 'foo'}, $schema); is "@errors", "/v: Does not match email format.", "email invalid"; } if (JSON::Validator::VALIDATE_HOSTNAME) { local $schema->{properties}{v}{format} = 'hostname'; @errors = $validator->validate({v => 'mojolicio.us'}, $schema); is "@errors", "", "hostname valid"; @errors = $validator->validate({v => '[]'}, $schema); is "@errors", "/v: Does not match hostname format.", "hostname invalid"; } else { diag "Data::Validate::Domain is not installed"; } { local $schema->{properties}{v}{format} = 'ipv4'; @errors = $validator->validate({v => '255.100.30.1'}, $schema); is "@errors", "", "ipv4 valid"; @errors = $validator->validate({v => '300.0.0.0'}, $schema); is "@errors", "/v: Does not match ipv4 format.", "ipv4 invalid"; } if (JSON::Validator::VALIDATE_IP) { local $schema->{properties}{v}{format} = 'ipv6'; @errors = $validator->validate({v => '::1'}, $schema); is "@errors", "", "ipv6 valid"; @errors = $validator->validate({v => '300.0.0.0'}, $schema); is "@errors", "/v: Does not match ipv6 format.", "ipv6 invalid"; } else { diag "Data::Validate::IP is not installed"; } { $schema->{properties}{v}{format} = 'regex'; @errors = $validator->validate({v => '(\w+)'}, $schema); is "@errors", "", "regex valid"; @errors = $validator->validate({v => '(\w'}, $schema); is "@errors", "/v: Does not match regex format.", "ipv6 invalid"; } { local $schema->{properties}{v}{format} = 'uri'; @errors = $validator->validate({v => 'http://mojolicio.us/?ø=123'}, $schema); is "@errors", "", "uri valid"; local $TODO = "Not sure how to make an invalid URI"; @errors = $validator->validate({v => 'anything'}, $schema); is "@errors", "/v: Does not match uri format.", "uri invalid"; } { local $schema->{properties}{v}{format} = 'unknown'; @errors = $validator->validate({v => 'whatever'}, $schema); is "@errors", "", "unknown is always valid"; } done_testing; JSON-Validator-0.92/t/jv-object.t0000644000175000017500000000736513036173274015516 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my ($schema, @errors); { $schema = {type => 'object'}; @errors = $validator->validate({mynumber => 1}, $schema); is "@errors", "", "object"; @errors = $validator->validate([1], $schema); is "@errors", "/: Expected object - got array.", "got array"; } { $schema->{properties} = { number => {type => "number"}, street_name => {type => "string"}, street_type => {type => "string", enum => ["Street", "Avenue", "Boulevard"]} }; local $schema->{patternProperties} = {"^S_" => {type => "string"}, "^I_" => {type => "integer"}}; @errors = $validator->validate({number => 1600, street_name => "Pennsylvania", street_type => "Avenue"}, $schema); is "@errors", "", "object with properties"; @errors = $validator->validate( {number => "1600", street_name => "Pennsylvania", street_type => "Avenue"}, $schema); is "@errors", "/number: Expected number - got string.", "object with invalid number"; @errors = $validator->validate({number => 1600, street_name => "Pennsylvania"}, $schema); is "@errors", "", "object with missing properties"; @errors = $validator->validate( {number => 1600, street_name => "Pennsylvania", street_type => "Avenue", direction => "NW"}, $schema); is "@errors", "", "object with additional properties"; @errors = $validator->validate({"S_25" => "This is a string", "I_0" => 42}, $schema); is "@errors", "", "S_25 I_0"; @errors = $validator->validate({"S_0" => 42}, $schema); is "@errors", "/S_0: Expected string - got number.", "S_0"; } { local $schema->{additionalProperties} = 0; @errors = $validator->validate( {number => 1600, street_name => "Pennsylvania", street_type => "Avenue", direction => "NW"}, $schema); is "@errors", "/: Properties not allowed: direction.", "additionalProperties=0"; $schema->{additionalProperties} = {type => "string"}; @errors = $validator->validate( {number => 1600, street_name => "Pennsylvania", street_type => "Avenue", direction => "NW"}, $schema); is "@errors", "", "additionalProperties=object"; } { local $schema->{required} = ["number", "street_name"]; @errors = $validator->validate({number => 1600, street_type => "Avenue"}, $schema); is "@errors", "/street_name: Missing property.", "object with required"; } { $schema = {type => 'object', minProperties => 1}; @errors = $validator->validate({}, $schema); is "@errors", "/: Not enough properties: 0/1.", "not enough properties 0/1"; $schema = {type => 'object', minProperties => 2, maxProperties => 3}; @errors = $validator->validate({a => 1}, $schema); is "@errors", "/: Not enough properties: 1/2.", "not enough properties 1/2"; @errors = $validator->validate({a => 1, b => 2}, $schema); is "@errors", "", "object with required"; @errors = $validator->validate({a => 1, b => 2, c => 3, d => 4}, $schema); is "@errors", "/: Too many properties: 4/3.", "too many properties"; } { local $TODO = 'Add support for dependencies'; $schema = { type => "object", properties => { name => {type => "string"}, credit_card => {type => "number"}, billing_address => {type => "string"} }, required => ["name"], dependencies => {credit_card => ["billing_address"]} }; @errors = $validator->validate({name => "John Doe", credit_card => 5555555555555555}, $schema); is "@errors", "/credit_card: Missing billing_address.", "credit_card"; } sub TO_JSON { return {age => shift->{age}} } my $obj = bless {age => 'not_a_string'}, 'main'; @errors = $validator->validate($obj, {properties => {age => {type => 'integer'}}}); is "@errors", "/age: Expected integer - got string.", "age is not a string"; done_testing; JSON-Validator-0.92/t/openapi-compatibility.t0000644000175000017500000000210013036173274020113 0ustar rebusrebususe Mojo::Base -strict; use File::Spec; use Mojo::Util; use Test::More; ok( module_calls_deprecated('JSON::Validator::OpenAPI'), "JSON::Validator::OpenAPI->validate_request is deprecated" ); if (eval 'require Hash::MultiValue;1') { ok( !module_calls_deprecated('JSON::Validator::OpenAPI::Dancer2'), "JSON::Validator::OpenAPI::Dancer2->validate_request isn't deprecated" ); } else { ok 1, 'Skipping JSON::Validator::OpenAPI::Dancer2 test'; } ok( !module_calls_deprecated('JSON::Validator::OpenAPI::Mojolicious'), "JSON::Validator::OpenAPI::Mojolicious->validate_request isn't deprecated" ); done_testing; sub module_calls_deprecated { my $module = shift; my $called = 0; { no warnings 'redefine'; *Mojo::Util::deprecated = sub { ++$called }; } my $c = {}; my $schema = {parameters => [{name => 'foo', in => 'query', type => 'integer'}]}; my $input = {}; eval "require $module" or die $@; eval { # we don't care if this actually works out $module->new->validate_request($c, $schema, $input); }; return $called; } JSON-Validator-0.92/t/deep-mixed-ref.t0000644000175000017500000000167313036174501016414 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $file = File::Spec->catfile(File::Basename::dirname(__FILE__), 'spec', 'with-deep-mixed-ref.json'); my $validator = JSON::Validator->new(cache_paths => [])->schema($file); is $validator->schema->get('/properties/age/type'), 'integer', 'loaded age.json from disk'; is $validator->schema->get('/properties/height/minimum'), '5', 'loaded height from file'; is $validator->schema->get('/properties/weight/properties/unit/type'), 'string', 'loaded weight-unit type from file'; use Mojolicious::Lite; push @{app->static->paths}, File::Basename::dirname(__FILE__); $validator->ua(app->ua); $validator->schema(app->ua->server->url->clone->path('/spec/with-relative-ref.json')); is $validator->schema->get('/properties/age/type'), 'integer', 'loaded age.json from http'; my @errors = $validator->validate({age => 'not a number'}); is int(@errors), 1, 'invalid age'; done_testing; JSON-Validator-0.92/t/22-dup.t0000644000175000017500000000117512757522052014636 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $v = JSON::Validator->new->schema('data://main/test.schema'); my @errors; @errors = $v->validate({foo => 'x'}); is "@errors", "/foo: Not in enum list: bar, baz.", "fix https://github.com/jhthorsen/json-validator/issues/22"; @errors = $v->validate({foo => 123}); is "@errors", "/foo: Expected string - got number.", "do not check enum if type is wrong"; done_testing; __DATA__ @@ test.schema { "$schema": "http://json-schema.org/draft-04/schema#", "title": "test", "type": "object", "properties": { "foo": {"type": "string", "enum": ["bar", "baz"]} } } JSON-Validator-0.92/t/load-and-validate-spec.t0000644000175000017500000000337113036173274020022 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator::OpenAPI; my $validator = JSON::Validator::OpenAPI->new; is $validator->load_and_validate_spec('data://main/echo.json'), $validator, 'load_and_validate_spec no options'; is $validator->schema->get('/info/version'), '42.0', 'version'; eval { $validator->load_and_validate_spec('data://main/swagger2/issues/89.json') }; like $@, qr{Properties not allowed.*\$ref}si, 'ref in the wrong place'; eval { $validator->load_and_validate_spec('data://main/swagger2/issues/89.json', {allow_invalid_ref => 1, version_from_class => 'JSON::Validator'}); }; ok !$@, 'allow_invalid_ref=1'; is $validator->schema->get('/info/version'), JSON::Validator->VERSION, 'version_from_class'; done_testing; __DATA__ @@ echo.json { "swagger" : "2.0", "info" : { "version": "42.0", "title" : "Pets" }, "schemes" : [ "http" ], "basePath" : "/api", "paths" : { "/echo" : { "post" : { "x-mojo-name" : "echo", "parameters" : [ { "in": "body", "name": "body", "schema": { "type" : "object" } } ], "responses" : { "200": { "description": "Echo response", "schema": { "type": "object" } }, "400": { "description": "Echo response", "schema": { "type": "object" } } } } } } } @@ swagger2/issues/89.json { "swagger" : "2.0", "info" : { "version": "0.8", "title" : "Test auto response" }, "paths" : { "$ref": "#/x-def/paths" }, "definitions": { "$ref": "#/x-def/defs" }, "x-def": { "defs": { "foo": { "properties": {} } }, "paths": { "/auto" : { "post" : { "responses" : { "200": { "description": "response", "schema": { "type": "object" } } } } } } } } JSON-Validator-0.92/t/load-http.t0000644000175000017500000000071112577772233015524 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; plan skip_all => 'TEST_ONLINE=1' unless $ENV{TEST_ONLINE}; my $validator = JSON::Validator->new; $validator->schema('http://swagger.io/v2/schema.json'); isa_ok($validator->schema, 'Mojo::JSON::Pointer'); like $validator->schema->get('/title'), qr{swagger}i, 'got swagger spec'; ok $validator->schema->get('/patternProperties/^x-/description'), 'resolved vendorExtension $ref'; done_testing; JSON-Validator-0.92/t/validate-json.t0000644000175000017500000000112312602203742016345 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; use JSON::Validator 'validate_json'; { use Mojolicious::Lite; post '/' => sub { my $c = shift; my @errors = validate_json $c->req->json, 'data://main/spec.json'; $c->render(status => @errors ? 400 : 200, text => "@errors"); }; } my $t = Test::Mojo->new; $t->post_ok('/', json => {})->status_is(400)->content_like(qr{/name}); $t->post_ok('/', json => {name => "foo"})->status_is(200); done_testing; __DATA__ @@ spec.json { "type": "object", "properties": { "name": { "type": "string" } }, "required": ["name"] } JSON-Validator-0.92/t/jv-anyof.t0000644000175000017500000000367013036173274015357 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = {anyOf => [{type => "string", maxLength => 5}, {type => "number", minimum => 0}]}; my @errors; @errors = $validator->validate("short", $schema); is "@errors", "", "short"; @errors = $validator->validate("too long", $schema); is "@errors", "/: anyOf failed: String is too long: 8/5.", "too long"; @errors = $validator->validate(12, $schema); is "@errors", "", "number"; @errors = $validator->validate(-1, $schema); is "@errors", "/: anyOf failed: -1 < minimum(0)", "negative"; @errors = $validator->validate({}, $schema); is "@errors", "/: anyOf failed: Expected string or number, got object.", "object"; # anyOf with schema of the same 'type' # anyOf with explicit integer (where _guess_data_type returns 'number') my $schemaB = {anyOf => [{type => "integer"}, {minimum => 2}]}; @errors = $validator->validate(1, $schemaB); is "@errors", "", "schema 1 pass, schema 2 fail"; @errors = $validator->validate( {type => 'string'}, { properties => { type => { anyOf => [ {'$ref' => '#/definitions/simpleTypes'}, { type => 'array', items => {'$ref' => '#/definitions/simpleTypes'}, minItems => 1, uniqueItems => Mojo::JSON::true, } ] }, }, definitions => {simpleTypes => {enum => [qw(array boolean integer null number object string)]}} } ); is "@errors", "", "anyOf test with schema from http://json-schema.org/draft-04/schema"; @errors = $validator->validate( {age => 6}, { '$schema' => 'http://json-schema.org/draft-04/schema#', type => 'object', title => 'test', description => 'test', properties => {age => {type => 'number', anyOf => [{multipleOf => 5}, {multipleOf => 3}]}} } ); is "@errors", "", "https://github.com/jhthorsen/json-validator/issues/28"; done_testing; JSON-Validator-0.92/t/jv-integer.t0000644000175000017500000000305413036173274015674 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = {type => 'object', properties => {mynumber => {type => 'integer', minimum => 1, maximum => 4}}}; my @errors = $validator->validate({mynumber => 1}, $schema); is "@errors", "", "min"; @errors = $validator->validate({mynumber => 4}, $schema); is "@errors", "", "max"; @errors = $validator->validate({mynumber => 2}, $schema); is "@errors", "", "in the middle"; @errors = $validator->validate({mynumber => 0}, $schema); is "@errors", "/mynumber: 0 < minimum(1)", 'too small'; @errors = $validator->validate({mynumber => -1}, $schema); is "@errors", "/mynumber: -1 < minimum(1)", 'too small and neg'; @errors = $validator->validate({mynumber => 5}, $schema); is "@errors", "/mynumber: 5 > maximum(4)", "too big"; @errors = $validator->validate({mynumber => "2"}, $schema); is "@errors", "/mynumber: Expected integer - got string.", "a string"; $schema->{properties}{mynumber}{multipleOf} = 2; @errors = $validator->validate({mynumber => 3}, $schema); is "@errors", "/mynumber: Not multiple of 2.", "multipleOf"; $validator->coerce(numbers => 1); @errors = $validator->validate({mynumber => "2"}, $schema); is "@errors", "", "coerced string into integer"; @errors = $validator->validate({mynumber => "2xyz"}, $schema); is "@errors", "/mynumber: Expected integer - got string.", "a string"; $schema->{properties}{mynumber}{minimum} = -3; @errors = $validator->validate({mynumber => "-2"}, $schema); is "@errors", "", "coerced negative integer"; done_testing; JSON-Validator-0.92/t/recursion.t0000644000175000017500000000337513037653327015644 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; use JSON::Validator 'validate_json'; use JSON::Validator::OpenAPI; my $data = {}; $data->{rec} = $data; $SIG{ALRM} = sub { die 'Recursion!' }; alarm 2; my @errors = ('i_will_be_removed'); eval { @errors = validate_json {top => $data}, 'data://main/spec.json' }; is $@, '', 'no error'; is_deeply(\@errors, [], 'avoided recursion'); # this part of the test checks that we don't go into an infite loop my $validator = JSON::Validator::OpenAPI->new; $validator->load_and_validate_spec('data://main/user.json'); $validator->schema($validator->schema->data); done_testing; __DATA__ @@ spec.json { "properties": { "top": { "$ref": "#/definitions/again" } }, "definitions": { "again": { "anyOf": [ {"type": "string"}, { "type": "object", "properties": { "rec": {"$ref": "#/definitions/again"} } } ] } } } @@ user.json { "swagger" : "2.0", "info" : { "version": "0.8", "title" : "User schema" }, "schemes" : [ "http" ], "basePath" : "/api", "paths" : { "/user" : { "post" : { "operationId" : "User", "parameters": [{ "name": "data", "in": "body", "required": true, "schema": { "$ref": "#/definitions/user" } }], "responses" : { "200": { "description": "response", "schema": { "type": "object" } } } } } }, "definitions": { "user": { "type": "object", "properties": { "name": { "type": "string" }, "siblings": { "type": "array", "items": { "$ref": "#/definitions/user" } } } } } } JSON-Validator-0.92/t/resolve.t0000644000175000017500000000145712721351037015301 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; # from http://json-schema.org/latest/json-schema-core.html#anchor30 $validator->schema( { id => 'http://my.site/myschema#', definitions => { schema1 => {id => 'schema1', type => 'integer'}, schema2 => {type => 'array', items => {'$ref' => 'schema1'}} } } ); is_deeply( $validator->schema->get('/definitions/schema2'), {type => 'array', items => {type => 'integer'}}, 'expanded schema2' ); ok !find_key($validator->schema->data, '$ref'), 'no $ref'; done_testing; sub find_key { my ($data, $needle) = @_; for my $k (keys %$data) { return 1 if $k eq $needle; return 1 if ref $data->{$k} eq 'HASH' and find_key($data->{$k}, $needle); } return 0; } JSON-Validator-0.92/t/coerce-args.t0000644000175000017500000000065112721351037016007 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my %coerce = (booleans => 1); is_deeply($validator->coerce(%coerce)->coerce, {booleans => 1}, 'hash is accepted'); is_deeply($validator->coerce(\%coerce)->coerce, {booleans => 1}, 'hash reference is accepted'); is_deeply($validator->coerce(1)->coerce, {%coerce, numbers => 1, strings => 1}, '1 is accepted'); done_testing; JSON-Validator-0.92/t/issue-27-yaml-syck-false.t0000644000175000017500000000137612757522056020211 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; plan skip_all => $@ unless eval 'require YAML::Syck;1'; use JSON::Validator; Mojo::Util::monkey_patch('JSON::Validator' => _load_yaml => \&YAML::Syck::Load); my $validator = JSON::Validator->new->schema('data://main/yaml-syck.yml'); my @errors = $validator->validate({firstName => 'Jan Henning', lastName => 'Thorsen', age => 42}); ok $INC{'YAML/Syck.pm'}, 'YAML::Syck is loaded'; ok !$INC{'YAML/XS.pm'}, 'YAML::XS is not loaded'; is "@errors", "/: Properties not allowed: age.", "additionalProperties: false"; done_testing; __DATA__ @@ yaml-syck.yml --- type: object required: [firstName, lastName] additionalProperties: false properties: firstName: { type: string } lastName: { type: string } JSON-Validator-0.92/t/openapi-request.t0000644000175000017500000001143413036173274016744 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; use Mojo::JSON qw(false true); use Mojolicious::Controller; use JSON::Validator::OpenAPI::Mojolicious; my $t = Test::Mojo->new; my $c = Mojolicious::Controller->new(tx => Mojo::Transaction::HTTP->new); my $openapi = JSON::Validator::OpenAPI::Mojolicious->new; my $input = {}; # formData make_request( qq(multipart/form-data; boundary=---------------------------9051914041544843365972754266), qq(-----------------------------9051914041544843365972754266\x0d\x0a), qq(Content-Disposition: form-data; name="age"\x0d\x0a\x0d\x0a), qq(42\x0d\x0a), qq(-----------------------------9051914041544843365972754266\x0d\x0a), qq(Content-Disposition: form-data; name="too_cool"\x0d\x0a\x0d\x0a), qq(false\x0d\x0a), qq(-----------------------------9051914041544843365972754266\x0d\x0a), qq(Content-Disposition: form-data; name="age"\x0d\x0a\x0d\x0a), qq(34\x0d\x0a), qq(-----------------------------9051914041544843365972754266--), ); validate_request( { parameters => [ { name => 'age', type => 'array', collectionFormat => 'multi', items => {type => 'number'}, in => 'formData' }, {name => 'too_cool', type => 'boolean', in => 'formData'}, {name => 'x' => type => 'number', required => 1, default => 33, in => 'formData'}, ] }, sub { is "@_", "", "valid form"; is_deeply $input, {age => [42, 34], too_cool => false, x => 33}, 'formData'; } ); validate_request( {parameters => [{name => 'filex', type => 'file', in => 'formData', required => true}]}, sub { like "@_", qr{/filex: Missing property}, 'missing filex property'; is_deeply $input, {}, 'nothing in input'; } ); # collectionFormat make_request('application/json', qq([])); validate_request( { parameters => [ {name => 'x', in => 'query', type => 'integer'}, { name => 'c', in => 'query', type => 'array', collectionFormat => 'csv', items => {type => 'integer'} }, ] }, sub { is_deeply $input, {x => 0, c => [3, 1, 2]}, 'collectionFormat' } ); # json body make_request('application/json', qq([1,2,3])); validate_request( {parameters => [{name => 'body', in => 'body', schema => {type => 'object'}}]}, sub { like "@_", qr{/body: Expected object - got array}, 'expected object'; } ); make_request('application/json', qq({"age":42})); validate_request( {parameters => [{name => 'body', in => 'body', schema => {type => 'object'}}]}, sub { is_deeply $input, {body => {age => 42}}, 'json body'; is "@_", "", "valid json"; } ); # upload make_request( qq(multipart/form-data; boundary=---------------------------9051914041544843365972754266), qq(-----------------------------9051914041544843365972754266\x0d\x0a), qq(Content-Disposition: form-data; name="data"; filename="a.txt"\x0d\x0a), qq(Content-Type: text/plain\x0d\x0a\x0d\x0a), qq(binarydata\x0d\x0a), qq(-----------------------------9051914041544843365972754266--), ); validate_request( {parameters => [{name => 'data', type => 'file', in => 'formData', required => true}]}, sub { is "@_", "", "valid upload"; ok UNIVERSAL::can($input->{data}, 'slurp'), 'data can slurp' or diag $input->{data}; } ); validate_request( {parameters => [{name => 'filex', type => 'file', in => 'formData', required => true}]}, sub { like "@_", qr{/filex: Missing property}, 'missing filex property'; is_deeply $input, {}, 'nothing in input'; } ); # query make_request('application/json', qq([])); validate_request( {parameters => [{name => 'x', in => 'query', type => 'boolean'}]}, sub { is_deeply $input, {x => false}, 'query with boolean' } ); # colliding parameters should be resolved in M::P::OpenAPI validate_request( { todo => 'colliding parameters can be resolved by extracting them manually', parameters => [ {name => 'x' => type => 'number', required => 1, default => 33, in => 'formData'}, {name => 'x' => type => 'number', required => 1, in => 'query'}, ] }, sub { is_deeply $input, {x => 33}, 'colliding parameters in form/query'; } ); done_testing; sub make_request { my ($content_type) = shift; my $length = length join '', @_; my $req = $c->tx->req(Mojo::Message::Request->new)->req; $req->parse(qq(POST /whatever?c=3,1,2&x=0 HTTP/1.1\x0d\x0a)); $req->parse(qq(Content-Type: $content_type\x0d\x0a)); $req->parse(qq(Content-Length: $length\x0d\x0a\x0d\x0a)); $req->parse($_) for @_; ok $req->is_finished, "request $length is finished"; } sub validate_request { my ($schema, $cb) = @_; local $TODO = delete $schema->{todo}; $input = {}; $cb->($openapi->validate_request($c, $schema, $input)); } JSON-Validator-0.92/t/petstore.t0000644000175000017500000000143212721351037015460 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; $validator->schema(File::Spec->catfile(qw( t spec petstore.json ))); is_deeply( $validator->schema->get('/paths/~1pets/get/responses/200/schema/items'), { required => ["id", "name"], properties => { id => {type => "integer", format => "int64"}, name => {type => "string"}, tag => {type => "string"} } }, 'expanded /paths/~1pets/get/responses/200/schema/items' ); ok !find_key($validator->schema->data, '$ref'), 'no $ref in schema'; done_testing; sub find_key { my ($data, $needle) = @_; for my $k (keys %$data) { return 1 if $k eq $needle; return 1 if ref $data->{$k} eq 'HASH' and find_key($data->{$k}, $needle); } return 0; } JSON-Validator-0.92/t/jv-allof.t0000644000175000017500000000156012721636157015340 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my $schema = {allOf => [{type => "string", maxLength => 5}, {type => "string", minLength => 3}]}; my @errors; @errors = $validator->validate("short", $schema); is "@errors", "", "got string"; @errors = $validator->validate(12, $schema); is "@errors", "/: allOf failed: Expected string, not number.", "got number"; $schema = {allOf => [{type => "string", maxLength => 7}, {type => "string", maxLength => 5}]}; @errors = $validator->validate("superlong", $schema); is "@errors", "/: allOf failed: String is too long: 9/7. String is too long: 9/5.", "super long"; @errors = $validator->validate("toolong", $schema); is "@errors", "/: allOf failed: String is too long: 7/5.", "too long"; @errors = $validator->validate("short", $schema); is "@errors", "", "success"; done_testing; JSON-Validator-0.92/t/jv-basic.t0000644000175000017500000000200412620126563015307 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; use Mojo::JSON; my $validator = JSON::Validator->new; my @errors; for (undef, [], {}, 123, "foo") { my $type = $_; @errors = $validator->validate(j($_), {type => 'any'}); $type //= 'null'; is "@errors", "", "any $type"; } @errors = $validator->validate(j(undef), {type => 'null'}); is "@errors", "", "null"; @errors = $validator->validate(j(1), {type => 'null'}); is "@errors", "/: Not null.", "not null"; @errors = $validator->validate(j(Mojo::JSON->false), {type => 'boolean'}); is "@errors", "", "boolean false"; @errors = $validator->validate(j(Mojo::JSON->true), {type => 'boolean'}); is "@errors", "", "boolean true"; @errors = $validator->validate(j("foo"), {type => 'boolean'}); is "@errors", "/: Expected boolean - got string.", "not boolean"; @errors = $validator->validate(undef, {properties => {}}); is "@errors", "/: Expected object - got null.", "undef"; done_testing; sub j { Mojo::JSON::decode_json(Mojo::JSON::encode_json($_[0])); } JSON-Validator-0.92/t/openapi-response.t0000644000175000017500000000326513036173274017115 0ustar rebusrebususe Mojo::Base -strict; use Test::Mojo; use Test::More; use Mojo::JSON qw(false true); use Mojolicious::Controller; use JSON::Validator::OpenAPI::Mojolicious; my $t = Test::Mojo->new; my $c = Mojolicious::Controller->new(tx => Mojo::Transaction::HTTP->new); my $openapi = JSON::Validator::OpenAPI::Mojolicious->new; my ($schema, @errors); { local $TODO = "No idea why this changes to 'No validation rules defined' when running with prove"; $schema = {responses => {200 => {}}}; @errors = $openapi->validate_response($c, $schema, 404, {}); is "@errors", "/: No responses rules defined for status 404.", "no rules"; } $schema = {responses => {default => {}}}; @errors = $openapi->validate_response($c, $schema, 404, {}); is "@errors", "", "default rules"; $schema = {responses => {200 => {schema => {type => 'array'}}}}; @errors = $openapi->validate_response($c, $schema, 200, {}); is "@errors", "/: Expected array - got object.", "invalid response"; @errors = $openapi->validate_response($c, $schema, 200, [1, 2, 3]); is "@errors", "", "valid response"; $schema = {responses => {200 => {'x-json-schema' => {type => 'array'}}}}; @errors = $openapi->validate_response($c, $schema, 200, {}); is "@errors", "/: Expected array - got object.", "invalid x-json-schema response"; $schema = {responses => {200 => {headers => {'X-Location' => {type => 'string'}}}}}; $c->res->headers->header('X-Location' => 42); @errors = $openapi->validate_response($c, $schema, 200, {}); is "@errors", "/: Expected string - got number.", "invalid header"; $c->res->headers->header('X-Location' => 'where wifi is'); @errors = $openapi->validate_response($c, $schema, 200, {}); is "@errors", "", "valid header"; done_testing; JSON-Validator-0.92/t/booleans.t0000644000175000017500000000264613036173274015432 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new->schema({properties => {required => {type => 'boolean'}}}); my @errors = $validator->validate({required => '0'}); is $errors[0]->{message}, 'Expected boolean - got string.', 'string 0 is not detected as boolean'; $validator->coerce(booleans => 1); for my $value (!!1, !!0) { my @errors = $validator->validate({required => $value}); ok !@errors, "boolean ($value). (@errors)"; } for my $value (1, '1', '0', '') { my @errors = $validator->validate({required => $value}); ok @errors, "not boolean ($value). @errors"; } for my $value ('true', 'false') { my @errors = $validator->validate({required => $value}); ok !@errors, "boolean ($value). (@errors)"; } SKIP: { skip 'YAML::XS is not installed', 1 unless eval 'require YAML::XS;1'; $validator->coerce(booleans => 0); # see that _load_schema_from_text() turns it back on my @errors = $validator->validate($validator->_load_schema_from_text("---\nrequired: true\n")); ok !@errors, "true in YAML::XS is boolean. (@errors)"; ok $validator->coerce->{booleans}, 'coerce booleans'; } SKIP: { skip 'boolean not installed', 1 unless eval 'require boolean;1'; my @errors = $validator->validate({type => 'boolean'}, {type => 'object', properties => {type => {type => 'string'}}}); is "@errors", "", "avoid Can't use string (\"boolean\") as a SCALAR"; } done_testing; JSON-Validator-0.92/t/00-basic.t0000644000175000017500000000227013036173274015117 0ustar rebusrebususe Test::More; use File::Find; if (($ENV{HARNESS_PERL_SWITCHES} || '') =~ /Devel::Cover/) { plan skip_all => 'HARNESS_PERL_SWITCHES =~ /Devel::Cover/'; } if (!eval 'use Test::Pod; 1') { *Test::Pod::pod_file_ok = sub { SKIP: { skip "pod_file_ok(@_) (Test::Pod is required)", 1 } }; } if (!eval 'use Test::Pod::Coverage; 1') { *Test::Pod::Coverage::pod_coverage_ok = sub { SKIP: { skip "pod_coverage_ok(@_) (Test::Pod::Coverage is required)", 1 } }; } if (!eval 'use Test::CPAN::Changes; 1') { *Test::CPAN::Changes::changes_file_ok = sub { SKIP: { skip "changes_ok(@_) (Test::CPAN::Changes is required)", 4 } }; } find( {wanted => sub { /\.pm$/ and push @files, $File::Find::name }, no_chdir => 1}, -e 'blib' ? 'blib' : 'lib', ); unless (eval 'require Hash::MultiValue;1') { @files = grep { !/Dancer/ } @files; } plan tests => @files * 3 + 4; for my $file (@files) { my $module = $file; $module =~ s,\.pm$,,; $module =~ s,.*/?lib/,,; $module =~ s,/,::,g; ok eval "use $module; 1", "use $module" or diag $@; Test::Pod::pod_file_ok($file); Test::Pod::Coverage::pod_coverage_ok($module, {also_private => [qr/^[A-Z_]+$/],}); } Test::CPAN::Changes::changes_file_ok(); JSON-Validator-0.92/t/validate-id.t0000644000175000017500000000032112734715577016013 0ustar rebusrebususe Mojo::Base -strict; use Test::More; use JSON::Validator; my $validator = JSON::Validator->new; my @errors = $validator->validate({id => 1}, {type => 'object'}); is "@errors", "", "object"; done_testing; JSON-Validator-0.92/MANIFEST0000644000175000017500000000330413037653534014324 0ustar rebusrebus.perl-version .perltidyrc .ship.conf .travis.yml Changes cpanfile lib/JSON/Validator.pm lib/JSON/Validator/cache/36d1bd12eeed51e86c8695bd8876a9df lib/JSON/Validator/cache/49c95b866e40f788892a7fb3c816b0e8 lib/JSON/Validator/cache/630949337805585c8e52deea27d11419 lib/JSON/Validator/cache/a0f5b4b4e75ea17fc09e88ec0343d148 lib/JSON/Validator/cache/ea34d47d4e060a1c3b12d2287aff89a7 lib/JSON/Validator/cache/eaa832720f36cff0abc20c05236a9cd9 lib/JSON/Validator/Error.pm lib/JSON/Validator/OpenAPI.pm lib/JSON/Validator/OpenAPI/Dancer2.pm lib/JSON/Validator/OpenAPI/Mojolicious.pm Makefile.PL MANIFEST This list of files output.txt README t/00-basic.t t/22-dup.t t/acceptance.t t/booleans-xs.t t/booleans.t t/coerce-args.t t/deep-mixed-ref.t t/definitions/age.json t/definitions/unit.json t/definitions/weight.json t/invalid-ref.t t/issue-27-yaml-syck-false.t t/jv-allof.t t/jv-anyof.t t/jv-array.t t/jv-basic.t t/jv-enum.t t/jv-formats.t t/jv-integer.t t/jv-not.t t/jv-number.t t/jv-object.t t/jv-oneof.t t/jv-required.t t/jv-string.t t/load-and-validate-spec.t t/load-data.t t/load-http.t t/load-json.t t/load-yaml.t t/openapi-compatibility.t t/openapi-formats.t t/openapi-request.t t/openapi-response.t t/openapi-set-request.t t/openapi.t t/petstore.t t/recursion.t t/relative-ref.t t/resolve.t t/schema-as-attr.t t/spec/invalid-ref.t t/spec/person.json t/spec/petstore.json t/spec/with-deep-mixed-ref.json t/spec/with-relative-ref.json t/swagger-validate-response-object.t t/swagger2-issues-50.t t/to-json.t t/validate-id.t t/validate-json.t t/validate-recursive.t META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) JSON-Validator-0.92/.perl-version0000644000175000017500000000000713037653530015612 0ustar rebusrebus5.20.2 JSON-Validator-0.92/META.yml0000644000175000017500000000143513037653534014447 0ustar rebusrebus--- abstract: 'Validate data against a JSON schema' author: - 'Jan Henning Thorsen ' build_requires: Test::More: '0.88' Test::Warnings: '0.016' configure_requires: ExtUtils::MakeMaker: '0' dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 7.18, CPAN::Meta::Converter version 2.150005' license: artistic_2 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: JSON-Validator no_index: directory: - t - inc requires: Mojolicious: '7.15' resources: bugtracker: https://github.com/jhthorsen/json-validator/issues homepage: https://github.com/jhthorsen/json-validator repository: https://github.com/jhthorsen/json-validator.git version: '0.92' x_serialization_backend: 'CPAN::Meta::YAML version 0.018' JSON-Validator-0.92/META.json0000644000175000017500000000240513037653534014615 0ustar rebusrebus{ "abstract" : "Validate data against a JSON schema", "author" : [ "Jan Henning Thorsen " ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 7.18, CPAN::Meta::Converter version 2.150005", "license" : [ "artistic_2" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "JSON-Validator", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "Test::More" : "0.88", "Test::Warnings" : "0.016" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Mojolicious" : "7.15" } } }, "release_status" : "stable", "resources" : { "bugtracker" : { "web" : "https://github.com/jhthorsen/json-validator/issues" }, "homepage" : "https://github.com/jhthorsen/json-validator", "repository" : { "url" : "https://github.com/jhthorsen/json-validator.git" } }, "version" : "0.92", "x_serialization_backend" : "JSON::PP version 2.27400" } JSON-Validator-0.92/cpanfile0000644000175000017500000000075413036173274014702 0ustar rebusrebus# You can install this projct with curl -L http://cpanmin.us | perl - https://github.com/jhthorsen/json-validator/archive/master.tar.gz requires "Mojolicious" => "7.15"; recommends "Cpanel::JSON::XS" => "3.02"; recommends "Data::Validate::Domain" => "0.10"; recommends "Data::Validate::IP" => "0.24"; recommends "Mojo::JSON::MaybeXS" => "0.01"; recommends "YAML::XS" => "0.59"; test_requires "Test::More" => "0.88"; test_requires "Test::Warnings" => "0.016"; JSON-Validator-0.92/.perltidyrc0000644000175000017500000000071412721351037015347 0ustar rebusrebus-pbp # Start with Perl Best Practices -w # Show all warnings -iob # Ignore old breakpoints -l=100 # Characters per line -mbl=2 # No more than 2 blank lines -i=2 # Indentation is 2 columns -ci=2 # Continuation indentation is 2 columns -vt=0 # Less vertical tightness -pt=2 # High parenthesis tightness -bt=2 # High brace tightness -sbt=2 # High square bracket tightness -isbc # Don't indent comments without leading space JSON-Validator-0.92/lib/0000755000175000017500000000000013037653534013741 5ustar rebusrebusJSON-Validator-0.92/lib/JSON/0000755000175000017500000000000013037653534014512 5ustar rebusrebusJSON-Validator-0.92/lib/JSON/Validator/0000755000175000017500000000000013037653534016437 5ustar rebusrebusJSON-Validator-0.92/lib/JSON/Validator/OpenAPI.pm0000644000175000017500000003044713037653327020240 0ustar rebusrebuspackage JSON::Validator::OpenAPI; use Carp (); use Mojo::Base 'JSON::Validator'; use Mojo::Util qw(deprecated monkey_patch); use Scalar::Util (); use constant DEBUG => $ENV{JSON_VALIDATOR_DEBUG} || 0; use constant IV_SIZE => eval 'require Config;$Config::Config{ivsize}'; use constant SPECIFICATION_URL => 'http://swagger.io/v2/schema.json'; my %COLLECTION_RE = (pipes => qr{\|}, csv => qr{,}, ssv => qr{\s}, tsv => qr{\t}); has _json_validator => sub { state $v = JSON::Validator->new; }; sub load_and_validate_spec { my ($self, $spec, $args) = @_; my $openapi = JSON::Validator->new->schema($args->{schema} || SPECIFICATION_URL); my ($api_spec, @errors); # 1. first check if $ref is in the right place, # 2. then check if the spec is correct for my $r (sub { }, undef) { next if $r and $args->{allow_invalid_ref}; my $jv = JSON::Validator->new; $jv->resolver($r) if $r; $api_spec = $jv->schema($spec)->schema; @errors = $openapi->coerce($jv->coerce)->validate($api_spec->data); die join "\n", "[OpenAPI] Invalid spec:", @errors if @errors; } if (my $class = $args->{version_from_class}) { if (UNIVERSAL::can($class, 'VERSION') and $class->VERSION) { $api_spec->data->{info}{version} = $class->VERSION; } } warn "[OpenAPI] Loaded $spec\n" if DEBUG; $self->{schema} = $api_spec; $self; } sub validate_input { my $self = shift; local $self->{validate_input} = 1; local $self->{root} = $self->schema; $self->validate(@_); } sub validate_request { my ($self, $c, $schema, $input) = @_; my (%cache, @errors); for my $p (@{$schema->{parameters} || []}) { my ($in, $name, $type) = @$p{qw(in name type)}; my ($exists, $value); if ($in eq 'body') { $value = $self->_get_request_data($c, $in); $exists = length $value if defined $value; } elsif ($in eq 'formData' and $type eq 'file') { ($value) = $self->_get_request_uploads($c, $name); $exists = $value ? 1 : 0; } else { $value = $cache{$in} ||= $self->_get_request_data($c, $in); $exists = exists $value->{$name}; $value = $value->{$name}; } if (defined $value and ref $p->{items} eq 'HASH' and $p->{collectionFormat}) { $value = $self->_coerce_by_collection_format($value, $p); } if ($type and defined($value //= $p->{default})) { if (($type eq 'integer' or $type eq 'number') and Scalar::Util::looks_like_number($value)) { $value += 0; } elsif ($type eq 'boolean') { $value = (!$value or $value eq 'false') ? Mojo::JSON->false : Mojo::JSON->true; } } if (my @e = $self->_validate_request_value($p, $name => $value)) { push @errors, @e; } elsif ($exists or exists $p->{default}) { $input->{$name} = $value; $self->_set_request_data($c, $in, $name => $value); } elsif (!$exists and exists $p->{default}) { $self->_set_request_data($c, $in, $name => $value); } } return @errors; } sub validate_response { my ($self, $c, $schema, $status, $data) = @_; my @errors; if (my $blueprint = $schema->{responses}{$status} || $schema->{responses}{default}) { push @errors, $self->_validate_response_headers($c, $blueprint->{headers}) if $blueprint->{headers}; if ($blueprint->{'x-json-schema'}) { warn "[JSON::Validator::OpenAPI] Validate using x-json-schema\n" if DEBUG; push @errors, $self->_json_validator->validate($data, $blueprint->{'x-json-schema'}); } elsif ($blueprint->{schema}) { warn "[JSON::Validator::OpenAPI] Validate using schema\n" if DEBUG; push @errors, $self->validate($data, $blueprint->{schema}); } } else { push @errors, JSON::Validator::E('/' => "No responses rules defined for status $status."); } return @errors; } { my @proxy_methods = qw( _get_request_uploads _get_request_data _set_request_data _get_response_data _set_response_data ); for my $method (@proxy_methods) { monkey_patch(__PACKAGE__, $method => sub { deprecated "Using JSON::Validator::OpenAPI directly is DEPRECATED." . " For the Mojolicious-specific methods use JSON::Validator::OpenAPI::Mojolicious"; require JSON::Validator::OpenAPI::Mojolicious; my $self = shift; bless $self, 'JSON::Validator::OpenAPI::Mojolicious'; return $self->$method(@_); } ); } } sub _validate_request_value { my ($self, $p, $name, $value) = @_; my $type = $p->{type} || 'object'; my @e; return if !defined $value and !JSON::Validator::_is_true($p->{required}); my $in = $p->{in}; my $schema = { properties => {$name => $p->{'x-json-schema'} || $p->{schema} || $p}, required => [$p->{required} ? ($name) : ()] }; if ($in eq 'body') { warn "[JSON::Validator::OpenAPI] Validate $in $name\n" if DEBUG; if ($p->{'x-json-schema'}) { return $self->_json_validator->validate({$name => $value}, $schema); } else { return $self->validate_input({$name => $value}, $schema); } } elsif (defined $value) { warn "[JSON::Validator::OpenAPI] Validate $in $name=$value\n" if DEBUG; return $self->validate_input({$name => $value}, $schema); } else { warn "[JSON::Validator::OpenAPI] Validate $in $name=undef\n" if DEBUG; return $self->validate_input({$name => $value}, $schema); } return; } sub _validate_response_headers { my ($self, $c, $schema) = @_; my $input = $self->_get_response_data($c, 'header'); my @errors; for my $name (keys %$schema) { my $p = $schema->{$name}; # jhthorsen: I think that the only way to make a header required, # is by defining "array" and "minItems" >= 1. if ($p->{type} eq 'array') { push @errors, $self->validate($input->{$name}, $p); } elsif ($input->{$name}) { push @errors, $self->validate($input->{$name}[0], $p); $self->_set_response_data($c, 'header', $name => $input->{$name}[0] ? 'true' : 'false') if $p->{type} eq 'boolean' and !@errors; } } return @errors; } sub _validate_type_array { my ($self, $data, $path, $schema) = @_; if (ref $schema->{items} eq 'HASH' and $schema->{items}{collectionFormat}) { $data = $self->_coerce_by_collection_format($data, $schema->{items}); } return $self->SUPER::_validate_type_array($data, $path, $schema); } sub _validate_type_file { my ($self, $data, $path, $schema) = @_; if ($schema->{required} and (not defined $data or not length $data)) { return JSON::Validator::E($path => 'Missing property.'); } return; } sub _validate_type_object { return shift->SUPER::_validate_type_object(@_) unless $_[0]->{validate_input}; my ($self, $data, $path, $schema) = @_; my $properties = $schema->{properties} || {}; my $discriminator = $schema->{discriminator}; my (%ro, @e); for my $p (keys %$properties) { next unless $properties->{$p}{readOnly}; push @e, JSON::Validator::E("$path/$p", "Read-only.") if exists $data->{$p}; $ro{$p} = 1; } if ($discriminator and !$self->{inside_discriminator}) { my $name = $data->{$discriminator} or return JSON::Validator::E($path, "Discriminator $discriminator has no value."); my $dschema = $self->{root}->get("/definitions/$name") or return JSON::Validator::E($path, "No definition for discriminator $name."); local $self->{inside_discriminator} = 1; # prevent recursion return $self->_validate($data, $path, $dschema); } local $schema->{required} = [grep { !$ro{$_} } @{$schema->{required} || []}]; return @e, $self->SUPER::_validate_type_object($data, $path, $schema); } sub _build_formats { my $formats = shift->SUPER::_build_formats; $formats->{byte} = \&_is_byte_string; $formats->{date} = \&_is_date; $formats->{double} = \&Scalar::Util::looks_like_number; $formats->{float} = \&Scalar::Util::looks_like_number; $formats->{int32} = sub { _is_number($_[0], 'l'); }; $formats->{int64} = IV_SIZE >= 8 ? sub { _is_number($_[0], 'q'); } : sub {1}; $formats; } sub _coerce_by_collection_format { my ($self, $data, $schema) = @_; my $type = ($schema->{items} ? $schema->{items}{type} : $schema->{type}) || ''; if ($schema->{collectionFormat} eq 'multi') { $data = [$data] unless ref $data eq 'ARRAY'; @$data = map { $_ + 0 } @$data if $type eq 'integer' or $type eq 'number'; return $data; } my $re = $COLLECTION_RE{$schema->{collectionFormat}} || ','; my $single = ref $data eq 'ARRAY' ? 0 : ($data = [$data]); for my $i (0 .. @$data - 1) { my @d = split /$re/, ($data->[$i] // ''); $data->[$i] = ($type eq 'integer' or $type eq 'number') ? [map { $_ + 0 } @d] : \@d; } return $single ? $data->[0] : $data; } sub _invalid_in { my ($self, $in) = @_; Carp::confess( "Unsupported \$in: $in. Please report at https://github.com/jhthorsen/json-validator"); } sub _is_byte_string { $_[0] =~ /^[A-Za-z0-9\+\/\=]+$/ } sub _is_date { $_[0] =~ /^(\d+)-(\d+)-(\d+)$/ } sub _is_number { return unless $_[0] =~ /^-?\d+(\.\d+)?$/; return $_[0] eq unpack $_[1], pack $_[1], $_[0]; } 1; =encoding utf8 =head1 NAME JSON::Validator::OpenAPI - OpenAPI is both a subset and superset of JSON Schema =head1 DESCRIPTION L can validate Open API (also known as "Swagger") requests and responses that is passed through a L powered web application. L is currently EXPERIMENTAL. Let me know if you are interested in using this class with another framework than L. =head1 ATTRIBUTES L inherits all attributes from L. =head2 formats Open API support the same formats as L, but adds the following to the set: =over 4 =item * byte A padded, base64-encoded string of bytes, encoded with a URL and filename safe alphabet. Defined by RFC4648. =item * date An RFC3339 date in the format YYYY-MM-DD =item * double Cannot test double values with higher precision then what the "number" type already provides. =item * float Will always be true if the input is a number, meaning there is no difference between L and L. Patches are welcome. =item * int32 A signed 32 bit integer. =item * int64 A signed 64 bit integer. Note: This check is only available if Perl is compiled to use 64 bit integers. =back =head1 METHODS L inherits all attributes from L. =head2 load_and_validate_spec $self = $self->load_and_validate_spec($url, \%args); Will load and validate C<$url> against the OpenAPI specification. The exapnded specification will be stored in L on success. See L for the different version of C<$url> that can be accepted. C<%args> can be used to further instruct the expansion and validation process: =over 2 =item * allow_invalid_ref Setting this to a true value, will disable the first pass. This is useful if you don't like the restrictions set by OpenAPI, regarding where you can use C<$ref> in your specification. =item * version_from_class Setting this to a module/class name will use the version number from the class and overwrite the version in the specification: { "info": { "version": "1.00" // <-- this value } } =back The validation is done with a two pass process: =over 2 =item 1. First it will check if the C<$ref> is only specified on the correct places. This can be disabled by setting L to a true value. =item 2. Validate the expanded version of the spec, (without any C<$ref>) against the OpenAPI schema. =back =head2 validate_input @errors = $self->validate_input($data, $schema); This method will make sure "readOnly" is taken into account, when validating data sent to your API. =head2 validate_request @errors = $self->validate_request($c, $schema, \%input); Takes an L and a schema definition and returns a list of errors, if any. Validated input parameters are moved into the C<%input> hash. =head2 validate_response @errors = $self->validate_response($c, $schema, $status, $data); =head1 COPYRIGHT AND LICENSE Copyright (C) 2014-2015, Jan Henning Thorsen This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0. =head1 SEE ALSO L. L =cut JSON-Validator-0.92/lib/JSON/Validator/OpenAPI/0000755000175000017500000000000013037653534017672 5ustar rebusrebusJSON-Validator-0.92/lib/JSON/Validator/OpenAPI/Dancer2.pm0000644000175000017500000000423213036173274021504 0ustar rebusrebuspackage JSON::Validator::OpenAPI::Dancer2; use Hash::MultiValue; use Mojo::Base 'JSON::Validator::OpenAPI'; sub _get_request_data { my ($self, $dsl, $in) = @_; if ($in eq 'query') { return $dsl->query_parameters->as_hashref_mixed; } elsif ($in eq 'path') { return $dsl->route_parameters->as_hashref_mixed; } elsif ($in eq 'formData') { return $dsl->body_parameters->as_hashref_mixed; } elsif ($in eq 'header') { return Hash::MultiValue->new($dsl->app->request->headers->flatten)->as_hashref_mixed; } elsif ($in eq 'body') { return $dsl->app->request->data; } else { $self->_invalid_in($in); } } sub _get_request_uploads { my ($self, $dsl, $name) = @_; return ($dsl->app->request->upload($name)); # upload() is context-aware } sub _get_response_data { my ($self, $dsl, $in) = @_; if ($in eq 'header') { my @headers = $dsl->response->headers->flatten; return Hash::MultiValue->new(@headers)->as_hashref_mixed; } else { $self->_invalid_in($in); } } sub _set_request_data { my ($self, $dsl, $in, $name => $value) = @_; if ($in eq 'query') { $dsl->query_parameters->set($name => $value); $dsl->app->request->params->{$name} = $value; } elsif ($in eq 'path') { $dsl->route_parameters->set($name => $value); } elsif ($in eq 'formData') { $dsl->app->request->body_parameters->set($name => $value); $dsl->app->request->params->{$name} = $value; } elsif ($in eq 'header') { $dsl->app->request->headers->header($name => $value); } elsif ($in eq 'body') { } # no need to write body back else { $self->_invalid_in($in); } } sub _set_response_data { my ($self, $dsl, $in, $name => $value) = @_; if ($in eq 'header') { $dsl->response->headers->header($name => $value); } else { $self->_invalid_in($in); } } 1; =encoding utf8 =head1 NAME JSON::Validator::OpenAPI::Dancer2 - Request/response adapter for Dancer2 =head1 SYNOPSIS See L. =head1 DESCRIPTION This module contains private methods to get/set request/response data for L. =head1 SEE ALSO L. L. =cut JSON-Validator-0.92/lib/JSON/Validator/OpenAPI/Mojolicious.pm0000644000175000017500000000352613036173274022527 0ustar rebusrebuspackage JSON::Validator::OpenAPI::Mojolicious; use Mojo::Base 'JSON::Validator::OpenAPI'; sub _get_request_data { my ($self, $c, $in) = @_; return $c->req->url->query->to_hash if $in eq 'query'; return $c->match->stack->[-1] if $in eq 'path'; return $c->req->body_params->to_hash if $in eq 'formData'; return $c->req->headers->to_hash if $in eq 'header'; return $c->req->json if $in eq 'body'; $self->_invalid_in($in); } sub _get_request_uploads { my ($self, $c, $name) = @_; return @{$c->req->every_upload($name)}; } sub _get_response_data { my ($self, $c, $in) = @_; if ($in eq 'header') { return $c->res->headers->to_hash(1); } else { $self->_invalid_in($in); } } sub _set_request_data { my ($self, $c, $in, $name => $value) = @_; if ($in eq 'query') { $c->req->url->query([$name => $value]); $c->req->params->merge($name => $value); } elsif ($in eq 'path') { $c->stash($name => $value); } elsif ($in eq 'formData') { $c->req->params->merge($name => $value); $c->req->body_params->merge($name => $value); } elsif ($in eq 'header') { $c->req->headers->header($name => $value); } elsif ($in eq 'body') { } # no need to write body back else { $self->_invalid_in($in); } } sub _set_response_data { my ($self, $c, $in, $name => $value) = @_; if ($in eq 'header') { $c->res->headers->header($name => ref $value ? @$value : $value); } else { $self->_invalid_in($in); } } 1; =encoding utf8 =head1 NAME JSON::Validator::OpenAPI::Mojolicious - Request/response adapter for Mojolicious =head1 SYNOPSIS See L. =head1 DESCRIPTION This module contains private methods to get/set request/response data for L. =head1 SEE ALSO L. L. =cut JSON-Validator-0.92/lib/JSON/Validator/Error.pm0000644000175000017500000000212212753344660020064 0ustar rebusrebuspackage JSON::Validator::Error; use Mojo::Base -base; use overload q("") => sub { sprintf '%s: %s', @{$_[0]}{qw(path message)} }, bool => sub {1}, fallback => 1; sub new { my $self = bless {}, shift; @$self{qw(path message)} = ($_[0] || '/', $_[1] || ''); $self; } sub message { shift->{message} } sub path { shift->{path} } sub TO_JSON { {message => $_[0]->{message}, path => $_[0]->{path}} } 1; =encoding utf8 =head1 NAME JSON::Validator::Error - JSON::Validator error object =head1 SYNOPSIS use JSON::Validator::Error; my $err = JSON::Validator::Error->new($path, $message); =head1 DESCRIPTION L is a class representing validation errors from L. =head1 ATTRIBUTES =head2 message $str = $self->message; A human readable description of the error. Defaults to empty string. =head2 path $str = $self->path; A JSON pointer to where the error occurred. Defaults to "/". =head1 METHODS =head2 new $self = JSON::Validator::Error->new($path, $message); Object constructor. =head1 SEE ALSO L. =cut JSON-Validator-0.92/lib/JSON/Validator.pm0000644000175000017500000010421413037653533016776 0ustar rebusrebuspackage JSON::Validator; use Mojo::Base -base; use Exporter 'import'; use JSON::Validator::Error; use Mojo::File 'path'; use Mojo::JSON; use Mojo::JSON::Pointer; use Mojo::URL; use Mojo::Util 'deprecated'; use B; use Cwd (); use File::Basename (); use File::Spec; use Scalar::Util; use constant VALIDATE_HOSTNAME => eval 'require Data::Validate::Domain;1'; use constant VALIDATE_IP => eval 'require Data::Validate::IP;1'; use constant DEBUG => $ENV{JSON_VALIDATOR_DEBUG} || 0; our $VERSION = '0.92'; our @EXPORT_OK = 'validate_json'; my $HTTP_SCHEME_RE = qr{^https?:}; sub E { JSON::Validator::Error->new(@_) } sub S { Mojo::Util::md5_sum(Data::Dumper->new([@_])->Sortkeys(1)->Useqq(1)->Dump); } has cache_dir => sub { deprecated 'cache_dir() is replaced by cache_paths()'; shift->cache_paths->[0]; }; has cache_paths => sub { my $self = shift; my @paths = split /:/, ($ENV{JSON_VALIDATOR_CACHE_DIR} || ''); push @paths, $self->{cache_dir} if $self->{cache_dir}; push @paths, File::Spec->catdir(File::Basename::dirname(__FILE__), qw(Validator cache)); return \@paths; }; has formats => sub { shift->_build_formats }; has resolver => sub { \&_resolver }; has ua => sub { require Mojo::UserAgent; my $ua = Mojo::UserAgent->new; $ua->proxy->detect; $ua->max_redirects(3); $ua; }; sub coerce { my $self = shift; return $self->{coerce} ||= {} unless @_; $self->{coerce} = $_[0] eq '1' ? {booleans => 1, numbers => 1, strings => 1} : ref $_[0] ? {%{$_[0]}} : {@_}; $self; } sub schema { my ($self, $schema) = @_; if (@_ == 1) { return $self->{schema}; } elsif (ref $schema eq 'HASH') { $schema->{id} ||= $self->_default_id($schema); warn "[JSON::Validator] Schema from hash. id=$schema->{id}\n" if DEBUG; $schema = $self->_register_document($schema, $schema->{id}); } else { $schema = Cwd::abs_path($schema) if -e $schema; $schema = $self->_load_schema($schema); } $self->{schema} = $self->_resolve_schema($schema, $schema->data->{id}); $self; } sub singleton { state $validator = shift->new } sub validate { my ($self, $data, $schema) = @_; $schema ||= $self->schema->data; return E '/', 'No validation rules defined.' unless $schema and %$schema; local $self->{schema} = Mojo::JSON::Pointer->new($schema); local $self->{seen} = {}; return $self->_validate($data, '', $schema); } sub validate_json { __PACKAGE__->singleton->schema($_[1])->validate($_[0]); } sub _build_formats { return { 'date-time' => \&_is_date_time, 'email' => \&_is_email, 'hostname' => VALIDATE_HOSTNAME ? \&Data::Validate::Domain::is_domain : \&_is_domain, 'ipv4' => VALIDATE_IP ? \&Data::Validate::IP::is_ipv4 : \&_is_ipv4, 'ipv6' => VALIDATE_IP ? \&Data::Validate::IP::is_ipv6 : \&_is_ipv6, 'regex' => \&_is_regex, 'uri' => \&_is_uri, }; } sub _load_schema { my ($self, $url, $parent) = @_; my ($namespace, $scheme) = ("$url", "file"); my $doc; if ($namespace =~ $HTTP_SCHEME_RE) { $url = Mojo::URL->new($url); ($namespace, $scheme) = ($url->clone->fragment(undef)->to_string, $url->scheme); } elsif ($namespace =~ m!^data://(.*)!) { $scheme = 'data'; } elsif ($parent and $parent =~ $HTTP_SCHEME_RE) { $parent = Mojo::URL->new($parent); $url =~ s!#.*!!; $url = $parent->path($parent->path->merge($url)->canonicalize); ($namespace, $scheme) = ($url->to_string, $url->scheme); } elsif ($parent) { $url =~ s!#.*!!; $url = File::Spec->catfile(File::Basename::dirname($parent), split '/', $url); $namespace = Cwd::abs_path($url) || $url; } # Make sure we create the correct namespace if not already done by Mojo::URL $namespace =~ s!#.*$!! if $namespace eq $url; return $self->{cached}{$namespace} if $self->{cached}{$namespace}; return eval { warn "[JSON::Validator] Loading schema $url namespace=$namespace scheme=$scheme\n" if DEBUG; $doc = $scheme eq 'file' ? path($namespace)->slurp : $scheme eq 'data' ? $self->_load_schema_from_data($url, $namespace) : $self->_load_schema_from_url($url, $namespace); $self->_register_document($self->_load_schema_from_text($doc), $namespace); } || do { $doc ||= ''; die "Could not load document from $url: $@ ($doc)" if DEBUG; die "Could not load document from $url: $@"; }; } sub _load_schema_from_data { my ($self, $url, $namespace) = @_; require Mojo::Loader; my ($module, $file) = $namespace =~ m!^data://([^/]+)/(.*)$! or die "Invalid URL: $namespace."; Mojo::Loader::data_section($module, $file) || die "$file could not be found in __DATA__ section of $module."; } sub _load_schema_from_text { return Mojo::JSON::decode_json($_[1]) if $_[1] =~ /^\s*\{/s; $_[0]->coerce(1); # need to coerce all values... because YAML is awful :( local $YAML::Syck::ImplicitTyping = 1; _load_yaml($_[1]) || undef; } sub _load_schema_from_url { my ($self, $url, $namespace) = @_; my $cache_dir = $self->cache_paths->[0]; my $cache_file = Mojo::Util::md5_sum($namespace); my $tx; for (@{$self->cache_paths}) { my $path = File::Spec->catfile($_, $cache_file); next unless -r $path; warn "[JSON::Validator] Loading cached file $path\n" if DEBUG; return path($path)->slurp; } $tx = $self->ua->get($url); die $tx->error->{message} if $tx->error; if ($cache_dir and -w $cache_dir) { $cache_file = File::Spec->catfile($cache_dir, $cache_file); Mojo::Util::spurt($tx->res->body, $cache_file); } return $tx->res->body; } sub _default_id { my $path = Cwd::abs_path($0); state $id = 0; $path = File::Basename::dirname($path) if $path; $path = Cwd::getcwd unless $path; return File::Spec->catfile($path, sprintf 'json-validator-%s.json', ++$id); } sub _register_document { my ($self, $doc, $namespace) = @_; $doc = Mojo::JSON::Pointer->new($doc); $namespace = Mojo::URL->new($namespace) unless ref $namespace; $namespace->fragment(undef); $self->{cached}{$namespace} = $doc; $doc->data->{id} ||= "$namespace"; $self->{cached}{$doc->data->{id}} = $doc; warn "[JSON::Validator] Register id=$doc->{data}{id} namespace=$namespace\n" if DEBUG; return $doc; } # This method is used to resolve all the $ref's that we find inside JSON Schema # specification. # # $namespace is typically the "id" part at the top level of the schema # specification. Meaning some kind of URL. In the case of Swagger: Just make # something up instead using _default_id() sub _resolve_schema { my ($self, $schema, $namespace) = @_; my (@topics, @refs); # The if is true if we have already resolved this $namespace. This happens if # the same specification has "$ref" with the same value multiple times. # There's no need to resolve the same schema twice. return $self->{resolved}{$namespace} if $self->{resolved}{$namespace}; warn "[JSON::Validator] Resolving schema $namespace\n" if DEBUG; $self->{resolved}{$namespace} = Mojo::JSON::Pointer->new({%{$schema->data}}); @topics = ($self->{resolved}{$namespace}->data); # This while loop will traverse the whole specification and and track down # each and every "$ref" it finds. @topics is a list of all the data # structures that it finds. Note that is start out with just having one item: # A hash-ref to the complete specification, but as it goes along, the while() # loop will track down more objects and arrays inside the specification and # then loop over those as well, util it has "visited" the whole document. while (@topics) { my $topic = shift @topics; if (UNIVERSAL::isa($topic, 'HASH')) { for my $k (sort keys %$topic) { my $v = $topic->{$k}; # int($v) returns the memory address of the reference. The "if" below # will not resolve the same "$ref" over again. next if ref $v and $self->{seen}{int($v)}++; # Make sure we do not modify the input data structure. # Changing the input makes t/expand.t in swagger2.git fail. $topic->{$k} = [@$v] if UNIVERSAL::isa($v, 'ARRAY'); $topic->{$k} = {%$v} if UNIVERSAL::isa($v, 'HASH'); push @topics, $topic->{$k} if ref $topic->{$k}; push @refs, $topic if $k eq '$ref' and !ref $v; } } elsif (UNIVERSAL::isa($topic, 'ARRAY')) { push @topics, @$topic; } } # Resolve all the "$ref" we found. This will call _resolve_schema() again. $self->resolver->($self, $namespace, \@refs); $self->{resolved}{$namespace}; } sub _resolver { my ($self, $namespace, $refs) = @_; # Seconds step: Resolve $ref for my $topic (@$refs) { my $ref = $topic->{'$ref'} or next; # already resolved? $ref = "#/definitions/$ref" if $ref =~ /^\w+$/; # TODO: Figure out if this could be removed $ref = Mojo::URL->new($namespace)->fragment($ref) if $ref =~ s!^\#!!; $ref = Mojo::URL->new($ref) unless ref $ref; warn "[JSON::Validator] Resolving ref $ref defined in $namespace\n" if DEBUG == 2; my $look_in = $self->{resolved}{$ref->clone->fragment(undef)}; if (!$look_in) { $look_in = $self->_load_schema($ref, $namespace); $look_in = $self->_resolve_schema($look_in, $look_in->data->{id} || $namespace); warn "[JSON::Validator] Will look for $ref in $look_in->{data}{id}\n" if DEBUG == 2; } $ref = $look_in->get($ref->fragment || '') || die qq[Could not find "$topic->{'$ref'}" ($ref). Typo in schema "$namespace"?]; %$topic = %$ref; delete $topic->{id} unless ref $topic->{id}; # TODO: Is this correct? } } sub _validate { my ($self, $data, $path, $schema) = @_; my ($type, @errors); # Avoid recursion return if ref $data and $self->{seen}{"$schema\:$data"}++; # Make sure we validate plain data and not a perl object $data = $data->TO_JSON if Scalar::Util::blessed($data) and UNIVERSAL::can($data, 'TO_JSON'); $type = $schema->{type} || _guess_schema_type($schema, $data); # Test base schema before allOf, anyOf or oneOf if (ref $type eq 'ARRAY') { push @errors, $self->_validate_any_of($data, $path, [map { +{%$schema, type => $_} } @$type]); } elsif ($type) { my $method = sprintf '_validate_type_%s', $type; @errors = $self->$method($data, $path, $schema); warn "[JSON::Validator] type @{[$path||'/']} $method [@errors]\n" if DEBUG == 2; return @errors if @errors; } if (my $rules = $schema->{not}) { push @errors, $self->_validate($data, $path, $rules); warn "[JSON::Validator] not @{[$path||'/']} == [@errors]\n" if DEBUG == 2; return @errors ? () : (E $path, 'Should not match.'); } if (my $rules = $schema->{allOf}) { push @errors, $self->_validate_all_of($data, $path, $rules); } elsif ($rules = $schema->{anyOf}) { push @errors, $self->_validate_any_of($data, $path, $rules); } elsif ($rules = $schema->{oneOf}) { push @errors, $self->_validate_one_of($data, $path, $rules); } return @errors; } sub _validate_all_of { my ($self, $data, $path, $rules) = @_; my $type = _guess_data_type($data); my (@errors, @expected); for my $rule (@$rules) { my @e = $self->_validate($data, $path, $rule) or next; my $schema_type = _guess_schema_type($rule); push @errors, [@e] and next if !$schema_type or $schema_type eq $type; push @expected, $schema_type; } warn "[JSON::Validator] allOf @{[$path||'/']} == [@errors]\n" if DEBUG == 2; my $expected = join ' or ', _uniq(@expected); return E $path, "allOf failed: Expected $expected, not $type." if $expected and @errors + @expected == @$rules; return E $path, sprintf 'allOf failed: %s', _merge_errors(@errors) if @errors; return; } sub _validate_any_of { my ($self, $data, $path, $rules) = @_; my $type = _guess_data_type($data); my (@e, @errors, @expected); for my $rule (@$rules) { @e = $self->_validate($data, $path, $rule); if (!@e) { warn "[JSON::Validator] anyOf @{[$path||'/']} == success\n" if DEBUG == 2; return; } my $schema_type = _guess_schema_type($rule); push @errors, [@e] and next if !$schema_type or $schema_type eq $type; push @expected, $schema_type; } warn "[JSON::Validator] anyOf @{[$path||'/']} == [@errors]\n" if DEBUG == 2; my $expected = join ' or ', _uniq(@expected); return E $path, "anyOf failed: Expected $expected, got $type." unless @errors; return E $path, sprintf "anyOf failed: %s", _merge_errors(@errors); } sub _validate_one_of { my ($self, $data, $path, $rules) = @_; my $type = _guess_data_type($data); my (@errors, @expected); for my $rule (@$rules) { my @e = $self->_validate($data, $path, $rule) or next; my $schema_type = _guess_schema_type($rule); push @errors, [@e] and next if !$schema_type or $schema_type eq $type; push @expected, $schema_type; } if (@errors + @expected + 1 == @$rules) { warn "[JSON::Validator] oneOf @{[$path||'/']} == success\n" if DEBUG == 2; return; } if (DEBUG == 2) { warn sprintf "[JSON::Validator] oneOf %s == failed=%s/%s / @errors\n", $path || '/', @errors + @expected, int @$rules; } my $expected = join ' or ', _uniq(@expected); return E $path, 'All of the oneOf rules match.' unless @errors + @expected; return E $path, "oneOf failed: Expected $expected, got $type." unless @errors; return E $path, sprintf 'oneOf failed: %s', _merge_errors(@errors); } sub _validate_type_enum { my ($self, $data, $path, $schema) = @_; my $enum = $schema->{enum}; my $m = S $data; for my $i (@$enum) { return if !(defined $data and $self->_validate_type_boolean($data, $path)) and _is_true($data) == _is_true($i); return if $m eq S $i; } local $" = ', '; return E $path, "Not in enum list: @$enum."; } sub _validate_format { my ($self, $value, $path, $schema) = @_; my $code = $self->formats->{$schema->{format}}; return if $code and $code->($value); return do { warn "Format rule for '$schema->{format}' is missing"; return } unless $code; return E $path, "Does not match $schema->{format} format."; } sub _validate_type_any { } sub _validate_type_array { my ($self, $data, $path, $schema) = @_; my @errors; if (ref $data ne 'ARRAY') { return E $path, _expected(array => $data); } if (defined $schema->{minItems} and $schema->{minItems} > @$data) { push @errors, E $path, sprintf 'Not enough items: %s/%s.', int @$data, $schema->{minItems}; } if (defined $schema->{maxItems} and $schema->{maxItems} < @$data) { push @errors, E $path, sprintf 'Too many items: %s/%s.', int @$data, $schema->{maxItems}; } if ($schema->{uniqueItems}) { my %uniq; for (@$data) { next if !$uniq{S($_)}++; push @errors, E $path, 'Unique items required.'; last; } } if (ref $schema->{items} eq 'ARRAY') { my $additional_items = $schema->{additionalItems} // {type => 'any'}; my @v = @{$schema->{items}}; if ($additional_items) { push @v, $additional_items while @v < @$data; } if (@v == @$data) { for my $i (0 .. @v - 1) { push @errors, $self->_validate($data->[$i], "$path/$i", $v[$i]); } } elsif (!$additional_items) { push @errors, E $path, sprintf "Invalid number of items: %s/%s.", int(@$data), int(@v); } } elsif (ref $schema->{items} eq 'HASH') { for my $i (0 .. @$data - 1) { push @errors, $self->_validate($data->[$i], "$path/$i", $schema->{items}); } } return @errors; } sub _validate_type_boolean { my ($self, $value, $path, $schema) = @_; return if UNIVERSAL::isa($value, 'JSON::PP::Boolean'); return if Scalar::Util::blessed($value) and ("$value" eq "1" or !$value); if ( defined $value and $self->{coerce}{booleans} and (B::svref_2object(\$value)->FLAGS & B::SVp_NOK or $value =~ /^(true|false)$/)) { $_[1] = $value ? Mojo::JSON->true : Mojo::JSON->false; return; } return E $path, _expected(boolean => $value); } sub _validate_type_integer { my ($self, $value, $path, $schema) = @_; my @errors = $self->_validate_type_number($value, $path, $schema, 'integer'); return @errors if @errors; return if $value =~ /^-?\d+$/; return E $path, "Expected integer - got number."; } sub _validate_type_null { my ($self, $value, $path, $schema) = @_; return E $path, 'Not null.' if defined $value; return; } sub _validate_type_number { my ($self, $value, $path, $schema, $expected) = @_; my @errors; $expected ||= 'number'; if (!defined $value or ref $value) { return E $path, _expected($expected => $value); } unless (B::svref_2object(\$value)->FLAGS & (B::SVp_IOK | B::SVp_NOK) and 0 + $value eq $value and $value * 0 == 0) { return E $path, "Expected $expected - got string." if !$self->{coerce}{numbers} or $value !~ /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/; $_[1] = 0 + $value; # coerce input value } if ($schema->{format}) { push @errors, $self->_validate_format($value, $path, $schema); } if (my $e = _cmp($schema->{minimum}, $value, $schema->{exclusiveMinimum}, '<')) { push @errors, E $path, "$value $e minimum($schema->{minimum})"; } if (my $e = _cmp($value, $schema->{maximum}, $schema->{exclusiveMaximum}, '>')) { push @errors, E $path, "$value $e maximum($schema->{maximum})"; } if (my $d = $schema->{multipleOf}) { if (($value / $d) =~ /\.[^0]+$/) { push @errors, E $path, "Not multiple of $d."; } } return @errors; } sub _validate_type_object { my ($self, $data, $path, $schema) = @_; my %required = map { ($_ => 1) } @{$schema->{required} || []}; my ($additional, @errors, %rules); if (ref $data ne 'HASH') { return E $path, _expected(object => $data); } if (defined $schema->{maxProperties} and $schema->{maxProperties} < keys %$data) { push @errors, E $path, sprintf 'Too many properties: %s/%s.', int(keys %$data), $schema->{maxProperties}; } if (defined $schema->{minProperties} and $schema->{minProperties} > keys %$data) { push @errors, E $path, sprintf 'Not enough properties: %s/%s.', int(keys %$data), $schema->{minProperties}; } while (my ($k, $r) = each %{$schema->{properties}}) { push @{$rules{$k}}, $r if exists $data->{$k} or $required{$k}; } while (my ($p, $r) = each %{$schema->{patternProperties}}) { push @{$rules{$_}}, $r for grep { $_ =~ /$p/ } keys %$data; } $additional = exists $schema->{additionalProperties} ? $schema->{additionalProperties} : {}; if ($additional) { $additional = {} unless ref $additional eq 'HASH'; $rules{$_} ||= [$additional] for keys %$data; } else { # Special case used internally when validating schemas: This module adds "id" # on the top level which might conflict with very strict schemas, so we have to # remove it again unless there's a rule. local $rules{id} = 1 if !$path and exists $data->{id}; if (my @keys = grep { !$rules{$_} } keys %$data) { local $" = ', '; return E $path, "Properties not allowed: @keys."; } } for my $k (keys %required) { next if exists $data->{$k}; push @errors, E _path($path, $k), 'Missing property.'; delete $rules{$k}; } for my $k (keys %rules) { for my $r (@{$rules{$k}}) { if (!exists $data->{$k} and exists $schema->{default}) { $data->{$k} = $r->{default}; } else { my @e = $self->_validate($data->{$k}, _path($path, $k), $r); push @errors, @e; push @errors, $self->_validate_type_enum($data->{$k}, _path($path, $k), $r) if $r->{enum} and !@e; } } } return @errors; } sub _validate_type_string { my ($self, $value, $path, $schema) = @_; my @errors; if (!defined $value or ref $value) { return E $path, _expected(string => $value); } if ( B::svref_2object(\$value)->FLAGS & (B::SVp_IOK | B::SVp_NOK) and 0 + $value eq $value and $value * 0 == 0) { return E $path, "Expected string - got number." unless $self->{coerce}{strings}; $_[1] = "$value"; # coerce input value } if ($schema->{format}) { push @errors, $self->_validate_format($value, $path, $schema); } if (defined $schema->{maxLength}) { if (length($value) > $schema->{maxLength}) { push @errors, E $path, sprintf "String is too long: %s/%s.", length($value), $schema->{maxLength}; } } if (defined $schema->{minLength}) { if (length($value) < $schema->{minLength}) { push @errors, E $path, sprintf "String is too short: %s/%s.", length($value), $schema->{minLength}; } } if (defined $schema->{pattern}) { my $p = $schema->{pattern}; unless ($value =~ /$p/) { push @errors, E $path, "String does not match '$p'"; } } return @errors; } # FUNCTIONS ================================================================== sub _cmp { return undef if !defined $_[0] or !defined $_[1]; return "$_[3]=" if $_[2] and $_[0] >= $_[1]; return $_[3] if $_[0] > $_[1]; return ""; } sub _expected { my $type = _guess_data_type($_[1]); return "Expected $_[0] - got different $type." if $_[0] =~ /\b$type\b/; return "Expected $_[0] - got $type."; } sub _guess_data_type { local $_ = $_[0]; my $ref = ref; my $blessed = Scalar::Util::blessed($_[0]); return 'object' if $ref eq 'HASH'; return lc $ref if $ref and !$blessed; return 'null' if !defined; return 'boolean' if $blessed and ("$_" eq "1" or !"$_"); return 'number' if B::svref_2object(\$_)->FLAGS & (B::SVp_IOK | B::SVp_NOK) and 0 + $_ eq $_ and $_ * 0 == 0; return $blessed || 'string'; } sub _guess_schema_type { return $_[0]->{type} if $_[0]->{type}; return _guessed_right($_[1], 'object') if $_[0]->{additionalProperties}; return _guessed_right($_[1], 'object') if $_[0]->{patternProperties}; return _guessed_right($_[1], 'object') if $_[0]->{properties}; return _guessed_right($_[1], 'object') if defined $_[0]->{maxProperties} or defined $_[0]->{minProperties}; return _guessed_right($_[1], 'array') if $_[0]->{additionalItems}; return _guessed_right($_[1], 'array') if $_[0]->{items}; return _guessed_right($_[1], 'array') if $_[0]->{uniqueItems}; return _guessed_right($_[1], 'array') if defined $_[0]->{maxItems} or defined $_[0]->{minItems}; return _guessed_right($_[1], 'string') if $_[0]->{pattern}; return _guessed_right($_[1], 'string') if defined $_[0]->{maxLength} or defined $_[0]->{minLength}; return _guessed_right($_[1], 'number') if $_[0]->{multipleOf}; return _guessed_right($_[1], 'number') if defined $_[0]->{maximum} or defined $_[0]->{minimum}; return 'enum' if $_[0]->{enum}; return undef; } sub _guessed_right { return $_[1] unless defined $_[0]; return _guess_data_type($_[0]) eq $_[1] ? $_[1] : undef; } sub _is_date_time { $_[0] =~ qr/^(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+(?:\.\d+)?)(?:Z|([+-])(\d+):(\d+))?$/io; } sub _is_domain { warn "Data::Validate::Domain is not installed"; return; } sub _is_email { state $email_rfc5322_re = do { my $atom = qr;[a-zA-Z0-9_!#\$\%&'*+/=?\^`{}~|\-]+;o; my $quoted_string = qr/"(?:\\[^\r\n]|[^\\"])*"/o; my $domain_literal = qr/\[(?:\\[\x01-\x09\x0B-\x0c\x0e-\x7f]|[\x21-\x5a\x5e-\x7e])*\]/o; my $dot_atom = qr/$atom(?:[.]$atom)*/o; my $local_part = qr/(?:$dot_atom|$quoted_string)/o; my $domain = qr/(?:$dot_atom|$domain_literal)/o; qr/$local_part\@$domain/o; }; return $_[0] =~ $email_rfc5322_re; } sub _is_ipv4 { my (@octets) = $_[0] =~ /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/; return 4 == grep { $_ >= 0 && $_ <= 255 && $_ !~ /^0\d{1,2}$/ } @octets; } sub _is_ipv6 { warn "Data::Validate::IP is not installed"; return; } sub _is_true { local $_ = $_[0]; return 0 + $_ if ref $_ and !Scalar::Util::blessed($_); return 0 if !$_ or /^(n|false|off)/i; return 1; } sub _is_regex { eval {qr{$_[0]}}; } sub _is_uri { $_[0] =~ qr!^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?!o; } # Please report if you need to manually monkey patch this function # https://github.com/jhthorsen/json-validator/issues sub _load_yaml { require List::Util; my @YAML_MODULES = qw(YAML::XS YAML::Syck); # subject to change my $YAML_MODULE = (List::Util::first { eval "require $_;1" } @YAML_MODULES)[0]; die "Need to install one of these YAML modules: @YAML_MODULES (YAML::XS is recommended)" unless $YAML_MODULE; warn "[JSON::Validator] Using $YAML_MODULE to parse YAML\n" if DEBUG; Mojo::Util::monkey_patch(__PACKAGE__, _load_yaml => eval "\\\&$YAML_MODULE\::Load"); _load_yaml(@_); } sub _merge_errors { join ' ', map { my $e = $_; (@$e == 1) ? $e->[0]{message} : sprintf '(%s)', join '. ', map { $_->{message} } @$e; } @_; } sub _path { local $_ = $_[1]; s!~!~0!g; s!/!~1!g; "$_[0]/$_"; } sub _uniq { my %uniq; grep { !$uniq{$_}++ } @_; } 1; =encoding utf8 =head1 NAME JSON::Validator - Validate data against a JSON schema =head1 VERSION 0.92 =head1 SYNOPSIS use JSON::Validator; my $validator = JSON::Validator->new; # Define a schema - http://json-schema.org/examples.html # You can also load schema from disk or web $validator->schema( { type => "object", required => ["firstName", "lastName"], properties => { firstName => {type => "string"}, lastName => {type => "string"}, age => {type => "integer", minimum => 0, description => "Age in years"} } } ); # Validate your data @errors = $validator->validate({firstName => "Jan Henning", lastName => "Thorsen", age => -42}); # Do something if any errors was found die "@errors" if @errors; =head1 DESCRIPTION L is a class for validating data against JSON schemas. You might want to use this instead of L if you need to validate data against L of the specification. This module can be used standalone, but if you want to define a specification for your webserver's API, then have a look at L, which will replace L. =head2 Supported schema formats L can load JSON schemas in multiple formats: Plain perl data structured (as shown in L) or files on disk/web in the JSON/YAML format. The JSON parsing is done using L, while the YAML parsing is done with an optional modules which need to be installed manually. L will look for the YAML modules in this order: L, L. The order is set by which module that performs the best, so it might change in the future. =head2 Resources Here are some resources that are related to JSON schemas and validation: =over 4 =item * L =item * L =item * L =item * L =back =head2 Bundled specifications This module comes with some JSON specifications bundled, so your application don't have to fetch those from the web. These specifications should be up to date, but please submit an issue if they are not. Note that the bundled specifications can be ignored, by customizing L. =over 2 =item * JSON schema, draft 4 Web page: L C<$ref>: L =item * JSON schema for JSONPatch files Web page: L C<$ref>: L =item * Swagger / OpenAPI specification, version 2 Web page: L C<$ref>: L =item * Custom error document There is a custom schema used by L as a default error document. This document might be extended later, but it will always be backward compatible. Specification: L C<$ref>: L. =item * Swagger Petstore This is used for unit tests, and should probably not be relied on by external users. =back =head1 ERROR OBJECT =head2 Overview The method L and the function L returns error objects when the input data violates the L. Each of the objects looks like this: bless { message => "Some description", path => "/json/path/to/node", }, "JSON::Validator::Error" See also L. =head2 Operators The error object overloads the following operators: =over 4 =item * bool Returns a true value. =item * string Returns the "path" and "message" part as a string: "$path: $message". =back =head2 Special cases Have a look at the L for documented examples of the error cases. Especially look at C, C and C. The special cases for "allOf", "anyOf" and "oneOf" will contain the error messages from all the failing rules below. It can be a bit hard to read, so if the error message is long, then you might want to run a smaller test with C. Example error object: bless { message => "(String is too long: 8/5. String is too short: 8/12)", path => "/json/path/to/node", }, "JSON::Validator::Error" Note that these error messages are subject for change. Any suggestions are most welcome! =head1 FUNCTIONS =head2 validate_json use JSON::Validator "validate_json"; @errors = validate_json $data, $schema; This can be useful in web applications: @errors = validate_json $c->req->json, "data://main/spec.json"; See also L and L for more details. =head1 ATTRIBUTES =head2 cache_dir Deprecated in favor of L. =head2 cache_paths $self = $self->cache_paths(\@paths); $array_ref = $self->cache_paths; Search paths to where cached specifications are stored. Defaults to C and the bundled spec files that are shipped with this distribution. JSON_VALIDATOR_CACHE_DIR=/cache/dir:/some/other/location perl script.pl To download a file and add it to the cache, do this: $ curl http://swagger.io/v2/schema.json > /cache/dir/$(md5 -qs http://swagger.io/v2/schema.json) Files referenced to an URL will automatically be cached if the first path in L is writable. =head2 formats $hash_ref = $self->formats; $self = $self->formats(\%hash); Holds a hash-ref, where the keys are supported JSON type "formats", and the values holds a code block which can validate a given format. Note! The modules mentioned below are optional. =over 4 =item * date-time An RFC3339 timestamp in UTC time. This is formatted as "YYYY-MM-DDThh:mm:ss.fffZ". The milliseconds portion (".fff") is optional =item * email Validated against the RFC5322 spec. =item * hostname Will be validated using L if installed. =item * ipv4 Will be validated using L if installed or fall back to a plain IPv4 IP regex. =item * ipv6 Will be validated using L if installed. =item * regex EXPERIMENTAL. Will check if the string is a regex, using C. =item * uri Validated against the RFC3986 spec. =back =head2 resolver $code = $self->resolver; $self = $self->resolver(sub { my ($self, $namespace, $refs) = @_; }); Set this to a sub without any logic if you want to skip resolving references, like this: $self->resolver(sub {}); This attribute is EXPERIMENTAL. =head2 ua $ua = $self->ua; $self = $self->ua(Mojo::UserAgent->new); Holds a L object, used by L to load a JSON schema from remote location. Note that the default L will detect proxy settings and have L set to 3. (These settings are EXPERIMENTAL and might change without a warning) =head1 METHODS =head2 coerce $self = $self->coerce(booleans => 1, numbers => 1, strings => 1); $self = $self->coerce({booleans => 1, numbers => 1, strings => 1}); $self = $self->coerce(1) # enable all $hash = $self->coerce; Set the given type to coerce. Before enabling coercion this module is very strict when it comes to validating types. Example: The string C<"1"> is not the same as the number C<1>, unless you have coercion enabled. WARNING! Enabling coercion might hide bugs in your api, which would have been detected if you were strict. For example JavaScript is very picky on a number being an actual number. This module tries it best to convert the data on the fly into the proper value, but this means that you unit tests might be ok, but the client side libraries (that care about types) might break. Loading a YAML document will enable "booleans" automatically. This feature is experimental, but was added since YAML has no real concept of booleans, such as L or other JSON parsers. The coercion rules are EXPERIMENTAL and will be tighten/loosen if bugs are reported. See L for more details. =head2 schema $self = $self->schema(\%schema); $self = $self->schema($url); $schema = $self->schema; Used to set a schema from either a data structure or a URL. C<$schema> will be a L object when loaded, and C by default. The C<$url> can take many forms, but needs to point to a text file in the JSON or YAML format. =over 4 =item * http://... or https://... A web resource will be fetched using the L, stored in L. =item * data://Some::Module/file.name This version will use L to load "file.name" from the module "Some::Module". =item * /path/to/file An URL (without a recognized scheme) will be loaded from disk. =back =head2 singleton $self = $class->singleton; Returns the L object used by L. =head2 validate @errors = $self->validate($data); @errors = $self->validate($data, $schema); Validates C<$data> against a given JSON L. C<@errors> will contain validation error objects or be an empty list on success. See L for details. C<$schema> is optional, but when specified, it will override schema stored in L. Example: $self->validate({hero => "superwoman"}, {type => "object"}); =head1 COPYRIGHT AND LICENSE Copyright (C) 2014-2015, Jan Henning Thorsen This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0. =head1 AUTHOR Jan Henning Thorsen - C Daniel Böhmer - C Martin Renvoize - C =cut