json-schema 2.5.1 → 2.5.2

data/test/schemas/extends_and_additionalProperties-2-filename.schema.json

@@ -1,33 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-03/schema#",
-  "type": "object",
-  "extends": "inner.schema.json",
-  "additionalProperties": {
-    "outerA": {
-      "description": "blah",
-      "required": false,
-      "additionalProperties": false,
-      "properties": {
-        "outerA1": {
-		  "type":"boolean",
-          "required": false
-        }
-      }
-    },
-    "outerB": {
-      "required": false,
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 50,
-      "items": {
-        "extends": "inner.schema.json",
-        "additionalProperties": false
-      }
-    },
-    "outerC": {
-      "description": "blah",
-      "type":"boolean",
-      "required": false
-    }
-  }
-}

data/test/schemas/extends_and_additionalProperties-2-ref.schema.json

@@ -1,33 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-03/schema#",
-  "type": "object",
-  "extends": {"$ref":"inner.schema.json#"},
-  "additionalProperties": {
-    "outerA": {
-      "description": "blah",
-      "required": false,
-      "additionalProperties": false,
-      "properties": {
-        "outerA1": {
-		  "type":"boolean",
-          "required": false
-        }
-      }
-    },
-    "outerB": {
-      "required": false,
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 50,
-      "items": {
-        "extends": {"$ref":"inner.schema.json#"},
-        "additionalProperties": false
-      }
-    },
-    "outerC": {
-      "description": "blah",
-      "type":"boolean",
-      "required": false
-    }
-  }
-}

data/test/schemas/good_schema_1.json

@@ -1,10 +0,0 @@
-{
-  "$schema" : "http://json-schema.org/draft-03/schema#",
-  "type" : "object",
-  "properties" : {
-    "a" : {
-      "type" : "integer",
-      "required" : true
-    }
-  }
-}

data/test/schemas/good_schema_2.json

@@ -1,10 +0,0 @@
-{
-  "$schema" : "http://json-schema.org/draft-03/schema#",
-  "type" : "object",
-  "properties" : {
-    "b" : {
-      "required" : true,
-      "$ref" : "good_schema_1.json"
-    }
-  }
-}

data/test/schemas/good_schema_extends1.json

@@ -1,10 +0,0 @@
-{
-  "$schema" : "http://json-schema.org/draft-03/schema#",
-  "type" : "object",
-  "extends": {"$ref": "good_schema_1.json"},
-  "properties" : {
-    "c" : {
-      "required" : false
-    }
-  }
-}

data/test/schemas/good_schema_extends2.json

@@ -1,13 +0,0 @@
-{
-  "$schema" : "http://json-schema.org/draft-03/schema#",
-  "type" : "object",
-  "extends": [
-    {"$ref": "good_schema_1.json"},
-    {"$ref": "good_schema_2.json"}
-  ],
-  "properties" : {
-    "c" : {
-      "required" : false
-    }
-  }
-}

data/test/schemas/inner.schema.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-03/schema#",
-  "type": "object",
-  "properties": {
-    "innerA": {
-      "description": "blah",
-      "type":"boolean",
-      "required": false
-    },
-    "innerB": {
-      "description": "blah",
-      "type":"boolean",
-      "required": false
-    },
-    "innerC": {
-      "description": "blah",
-      "required": false,
-      "type": "boolean"
-    }
-  }
-}

data/test/schemas/one_of_ref_links_schema.json

@@ -1,16 +0,0 @@
-{ "$schema": "http://json-schema.org/draft-04/schema#"
-, "type": "object"
-, "properties":
-  { "links" :
-    { "type" : "array"
-    , "items" :
-      { "type" : "object"
-      , "oneOf" :
-        [ { "$ref" : "self_link_schema.json"}
-        , { "$ref" : "up_link_schema.json" }
-        ]
-      }
-    }
-  }
-}
-

data/test/schemas/ref john with spaces schema.json

@@ -1,11 +0,0 @@
-{
-  "$schema" : "http://json-schema.org/draft-04/schema#",
-  "type" : "object",
-  "required" : ["first"],
-  "properties": {
-    "first": {
-      "type": "string",
-      "enum": ["john"]
-    }
-  }
-}

data/test/schemas/relative_definition_schema.json

@@ -1,8 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "properties": {
-    "a": {
-      "$ref": "definition_schema.json#/definitions/foo"
-    }
-  }
-}

data/test/schemas/self_link_schema.json

@@ -1,17 +0,0 @@
-{ "$schema": "http://json-schema.org/draft-04/schema#"
-, "type": "object"
-, "properties" :
-  { "rel" :
-    { "type" : "array"
-    , "items" :
-      [ { "type" : "string"
-        , "pattern" : "self"
-        }
-      ]
-    }
-  , "href" :
-    { "type" : "string"
-    }
-  }
-}
-

data/test/schemas/up_link_schema.json

@@ -1,17 +0,0 @@
-{ "$schema": "http://json-schema.org/draft-04/schema#"
-, "type": "object"
-, "properties" :
-  { "rel" :
-    { "type" : "array"
-    , "items" :
-      [ { "type" : "string"
-        , "pattern" : "up"
-        }
-      ]
-    }
-  , "href" :
-    { "type" : "string"
-    }
-  }
-}
-

data/test/test_all_of_ref_schema.rb

@@ -1,35 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class AllOfRefSchemaTest < Minitest::Test
-  def schema
-    schema_fixture_path('all_of_ref_schema.json')
-  end
-
-  def data
-    data_fixture_path('all_of_ref_data.json')
-  end
-
-  def test_all_of_ref_schema_fails
-    refute_valid schema, data
-  end
-
-  def test_all_of_ref_schema_succeeds
-    assert_valid schema, %({"name": 42})
-  end
-
-  def test_all_of_ref_subschema_errors
-    errors = JSON::Validator.fully_validate(schema, data, :errors_as_objects => true)
-    nested_errors = errors[0][:errors]
-    assert_equal([:allof_0], nested_errors.keys, 'should have nested errors for each allOf subschema')
-    assert_match(/the property '#\/name' of type String did not match the following type: integer/i, nested_errors[:allof_0][0][:message])
-  end
-
-  def test_all_of_ref_message
-    errors = JSON::Validator.fully_validate(schema, data)
-    expected_message = """The property '#/' of type Hash did not match all of the required schemas. The schema specific errors were:
-
-- allOf #0:
-    - The property '#/name' of type String did not match the following type: integer"""
-    assert_equal(expected_message, errors[0])
-  end
-end

data/test/test_any_of_ref_schema.rb

@@ -1,35 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class AnyOfRefSchemaTest < Minitest::Test
-  def schema
-    schema_fixture_path('any_of_ref_schema.json')
-  end
-
-  def test_any_of_ref_schema
-    assert_valid schema, data_fixture_path('any_of_ref_data.json')
-  end
-
-  def test_any_of_ref_subschema_errors
-    data = %({"names": ["jack"]})
-    errors = JSON::Validator.fully_validate(schema, data, :errors_as_objects => true)
-    nested_errors = errors[0][:errors]
-    assert_equal([:anyof_0, :anyof_1, :anyof_2], nested_errors.keys, 'should have nested errors for each anyOf subschema')
-    assert_match(/the property '#\/names\/0' value "jack" did not match the regex 'john'/i, nested_errors[:anyof_0][0][:message])
-    assert_match(/the property '#\/names\/0' value "jack" did not match the regex 'jane'/i, nested_errors[:anyof_1][0][:message])
-    assert_match(/the property '#\/names\/0' value "jack" did not match the regex 'jimmy'/i, nested_errors[:anyof_2][0][:message])
-  end
-
-  def test_any_of_ref_message
-    data = %({"names": ["jack"]})
-    errors = JSON::Validator.fully_validate(schema, data)
-    expected_message = """The property '#/names/0' of type String did not match one or more of the required schemas. The schema specific errors were:
-
-- anyOf #0:
-    - The property '#/names/0' value \"jack\" did not match the regex 'john'
-- anyOf #1:
-    - The property '#/names/0' value \"jack\" did not match the regex 'jane'
-- anyOf #2:
-    - The property '#/names/0' value \"jack\" did not match the regex 'jimmy'"""
-    assert_equal(expected_message, errors[0])
-  end
-end

data/test/test_bad_schema_ref.rb

@@ -1,39 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-require 'socket'
-
-
-class BadSchemaRefTest < Minitest::Test
-  def setup
-    WebMock.allow_net_connect!
-  end
-
-  def teardown
-    WebMock.disable_net_connect!
-  end
-
-  def test_bad_uri_ref
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "array",
-      "items" => { "$ref" => "../google.json"}
-    }
-
-    data = [1,2,3]
-    assert_raises(Errno::ENOENT) do
-      JSON::Validator.validate(schema,data)
-    end
-  end
-
-  def test_bad_host_ref
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "array",
-      "items" => { "$ref" => "http://ppcheesecheseunicornnuuuurrrrr.example.invalid/json.schema"}
-    }
-
-    data = [1,2,3]
-    assert_raises(SocketError, OpenURI::HTTPError) do
-      JSON::Validator.validate(schema,data)
-    end
-  end
-end

data/test/test_common_test_suite.rb

@@ -1,66 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-require 'json'
-
-class CommonTestSuiteTest < Minitest::Test
-  TEST_DIR = File.expand_path('../test-suite/tests', __FILE__)
-
-  # These are test files which we know fail spectacularly, either because we
-  # don't support that functionality or because they require external
-  # dependencies.  To allow finer-grained control over which tests to run,
-  # you can replace `:all` with an array containing the names of individual
-  # tests to skip.
-  IGNORED_TESTS = Hash.new { |h,k| h[k] = [] }.merge({
-    "draft3/optional/jsregex.json" => :all,
-    "draft3/optional/format.json" => [
-      "validation of regular expressions",
-      "validation of e-mail addresses",
-      "validation of URIs",
-      "validation of host names",
-      "validation of CSS colors"
-    ],
-    "draft4/optional/format.json" => [
-      "validation of URIs",
-      "validation of e-mail addresses",
-      "validation of host names"
-    ]
-  })
-
-  def setup
-    Dir["#{TEST_DIR}/../remotes/**/*.json"].each do |path|
-      schema = path.sub(%r{^.*/remotes/}, '')
-      stub_request(:get, "http://localhost:1234/#{schema}").
-        to_return(:body => File.read(path), :status => 200)
-    end
-  end
-
-  Dir["#{TEST_DIR}/*"].each do |suite|
-    version = File.basename(suite).to_sym
-    Dir["#{suite}/**/*.json"].each do |tfile|
-      test_list = JSON.parse(File.read(tfile))
-      rel_file = tfile[TEST_DIR.length+1..-1]
-
-      test_list.each do |test|
-        schema = test["schema"]
-        base_description = test["description"]
-
-        test["tests"].each do |t|
-          next if IGNORED_TESTS[rel_file] == :all
-          next if IGNORED_TESTS[rel_file].any? { |ignored|
-            base_description == ignored || "#{base_description}/#{t['description']}" == ignored
-          }
-
-          err_id = "#{rel_file}: #{base_description}/#{t['description']}"
-          define_method("test_#{err_id}") do
-            errors = JSON::Validator.fully_validate(schema,
-              t["data"],
-              :parse_data => false,
-              :validate_schema => true,
-              :version => version
-            )
-            assert_equal t["valid"], errors.empty?, "Common test suite case failed: #{err_id}"
-          end
-        end
-      end
-    end
-  end
-end

data/test/test_custom_format.rb

@@ -1,116 +0,0 @@
-# encoding: utf-8
-require File.expand_path('../test_helper', __FILE__)
-
-class JSONSchemaCustomFormatTest < Minitest::Test
-  def setup
-    @all_versions = ['draft1', 'draft2', 'draft3', 'draft4']
-    @format_proc = lambda { |value| raise JSON::Schema::CustomFormatError.new("must be 42") unless value == "42" }
-    @schema_4 = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "properties" => {
-        "a" => {
-          "type" => "string",
-          "format" => "custom",
-        },
-      }
-    }
-    @schema_3 = @schema_4.clone
-    @schema_3["$schema"] = "http://json-schema.org/draft-03/schema#"
-    @schema_2 = @schema_4.clone
-    @schema_2["$schema"] = "http://json-schema.org/draft-02/schema#"
-    @schema_1 = @schema_4.clone
-    @schema_1["$schema"] = "http://json-schema.org/draft-01/schema#"
-    @schemas = {
-      "draft1" => @schema_1,
-      "draft2" => @schema_2,
-      "draft3" => @schema_3,
-      "draft4" => @schema_4
-    }
-    JSON::Validator.restore_default_formats
-  end
-
-  def test_single_registration
-    @all_versions.each do |version|
-      assert(JSON::Validator.validator_for_name(version).formats['custom'].nil?, "Format 'custom' for #{version} should be nil")
-      JSON::Validator.register_format_validator("custom", @format_proc, [version])
-      assert(JSON::Validator.validator_for_name(version).formats['custom'].is_a?(JSON::Schema::CustomFormat), "Format 'custom' should be registered for #{version}")
-      (@all_versions - [version]).each do |other_version|
-        assert(JSON::Validator.validator_for_name(other_version).formats['custom'].nil?, "Format 'custom' should still be nil for #{other_version}")
-      end
-      JSON::Validator.deregister_format_validator("custom", [version])
-      assert(JSON::Validator.validator_for_name(version).formats['custom'].nil?, "Format 'custom' should be deregistered for #{version}")
-    end
-  end
-
-  def test_register_for_all_by_default
-    JSON::Validator.register_format_validator("custom", @format_proc)
-    @all_versions.each do |version|
-      assert(JSON::Validator.validator_for_name(version).formats['custom'].is_a?(JSON::Schema::CustomFormat), "Format 'custom' should be registered for #{version}")
-    end
-    JSON::Validator.restore_default_formats
-    @all_versions.each do |version|
-      assert(JSON::Validator.validator_for_name(version).formats['custom'].nil?, "Format 'custom' should still be nil for #{version}")
-    end
-  end
-
-  def test_multi_registration
-    unregistered_version = @all_versions.delete("draft1")
-    JSON::Validator.register_format_validator("custom", @format_proc, @all_versions)
-    @all_versions.each do |version|
-      assert(JSON::Validator.validator_for_name(version).formats['custom'].is_a?(JSON::Schema::CustomFormat), "Format 'custom' should be registered for #{version}")
-    end
-    assert(JSON::Validator.validator_for_name(unregistered_version).formats['custom'].nil?, "Format 'custom' should still be nil for #{unregistered_version}")
-  end
-
-  def test_format_validation
-    @all_versions.each do |version|
-      data = {
-        "a" => "23"
-      }
-      schema = @schemas[version]
-      prefix = "Validation for '#{version}'"
-
-      assert(JSON::Validator.validate(schema, data), "#{prefix} succeeds with no 'custom' format validator registered")
-
-      JSON::Validator.register_format_validator("custom", @format_proc, [version])
-      data["a"] = "42"
-      assert(JSON::Validator.validate(schema, data), "#{prefix} succeeds with 'custom' format validator and correct data")
-
-      data["a"] = "23"
-      assert(!JSON::Validator.validate(schema, data), "#{prefix} fails with 'custom' format validator and wrong data")
-
-      errors = JSON::Validator.fully_validate(schema, data)
-      assert(errors.count == 1 && errors.first.match(/The property '#\/a' must be 42 in schema/), "#{prefix} records fromat error")
-
-      data["a"] = 23
-      errors = JSON::Validator.fully_validate(schema, data)
-      assert(errors.count == 1 && errors.first.match(/The property '#\/a' of type (?:integer|Fixnum) did not match the following type: string/), "#{prefix} records no fromat error on type mismatch")
-    end
-  end
-
-  def test_override_default_format
-    @all_versions.each do |version|
-      data = {
-        "a" => "2001:db8:85a3:0:0:8a2e:370:7334"
-      }
-      schema = @schemas[version]
-      schema["properties"]["a"]["format"] = "ipv6"
-      prefix = "Validation for '#{version}'"
-
-      assert(JSON::Validator.validate(schema, data), "#{prefix} succeeds for default format with correct data")
-
-      data["a"] = "no_ip6_address"
-      assert(!JSON::Validator.validate(schema, data), "#{prefix} fails for default format and wrong data")
-
-      data["a"] = "42"
-      JSON::Validator.register_format_validator("ipv6", @format_proc, [version])
-      assert(JSON::Validator.validate(schema, data), "#{prefix} succeeds with overriden default format and correct data")
-
-      JSON::Validator.deregister_format_validator("ipv6", [version])
-      data["a"] = "2001:db8:85a3:0:0:8a2e:370:7334"
-      assert(JSON::Validator.validate(schema, data), "#{prefix} restores the default format on deregistration")
-    end
-  end
-end
-
-