json-schema 2.5.1 → 2.5.2

data/test/test_list_option.rb

@@ -1,21 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class ListOptionTest < Minitest::Test
-  def test_list_option_reusing_schemas
-    schema_hash = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "properties" => { "a" => { "type" => "integer" } }
-    }
-
-    uri = Addressable::URI.parse('http://example.com/item')
-    schema = JSON::Schema.new(schema_hash, uri)
-    JSON::Validator.add_schema(schema)
-
-    data = {"a" => 1}
-    assert_valid uri.to_s, data
-
-    data = [{"a" => 1}]
-    assert_valid uri.to_s, data, :list => true
-  end
-end

data/test/test_load_ref_schema.rb

@@ -1,40 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class LoadRefSchemaTests < Minitest::Test
-  def load_other_schema
-    JSON::Validator.add_schema(JSON::Schema.new(
-      {
-        '$schema' => 'http://json-schema.org/draft-04/schema#',
-        'type' => 'object',
-        'properties' => {
-          "title" => {
-            "type" => "string"
-          }
-        }
-      },
-      Addressable::URI.parse("http://example.com/schema#")
-    ))
-  end
-
-  def test_cached_schema
-    schema_url = "http://example.com/schema#"
-    schema = {
-      "$ref" => schema_url
-    }
-    data = {}
-    load_other_schema
-    validator = JSON::Validator.new(schema, data)
-    assert JSON::Validator.schema_loaded?(schema_url)
-  end
-
-  def test_cached_schema_with_fragment
-    schema_url = "http://example.com/schema#"
-    schema = {
-      "$ref" => "#{schema_url}/properties/title"
-    }
-    data = {}
-    load_other_schema
-    validator = JSON::Validator.new(schema, data)
-    assert JSON::Validator.schema_loaded?(schema_url)
-  end
-end

data/test/test_merge_missing_values.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class MergeMissingValuesTest < Minitest::Test
-  def test_merge_missing_values_for_string
-    original = 'foo'
-    updated = 'foo'
-    JSON::Validator.merge_missing_values(updated, original)
-    assert_equal('foo', original)
-  end
-
-  def test_merge_missing_values_for_empty_array
-    original = []
-    updated = []
-    JSON::Validator.merge_missing_values(updated, original)
-    assert_equal([], original)
-  end
-
-  def test_merge_missing_values_for_empty_hash
-    original = {}
-    updated = {}
-    JSON::Validator.merge_missing_values(updated, original)
-    assert_equal({}, original)
-  end
-
-  def test_merge_missing_values_for_new_values
-    original = {:hello => 'world'}
-    updated = {'hello' => 'world', 'foo' => 'bar'}
-    JSON::Validator.merge_missing_values(updated, original)
-    assert_equal({:hello => 'world', 'foo' => 'bar'}, original)
-  end
-
-  def test_merge_missing_values_for_nested_array
-    original = [:hello, 'world', 1, 2, 3, {:foo => :bar, 'baz' => 'qux'}]
-    updated = ['hello', 'world', 1, 2, 3, {'foo' => 'bar', 'baz' => 'qux', 'this_is' => 'new'}]
-    JSON::Validator.merge_missing_values(updated, original)
-    assert_equal([:hello, 'world', 1, 2, 3, {:foo => :bar, 'baz' => 'qux', 'this_is' => 'new'}], original)
-  end
-
-  def test_merge_missing_values_for_nested_hash
-    original = {:hello => 'world', :foo => ['bar', :baz, {:uno => {:due => 3}}]}
-    updated = {'hello' => 'world', 'foo' => ['bar', 'baz', {'uno' => {'due' => 3, 'this_is' => 'new'}}], 'ack' => 'sed'}
-    JSON::Validator.merge_missing_values(updated, original)
-    assert_equal({:hello => 'world', :foo => ['bar', :baz, {:uno => {:due => 3, 'this_is' => 'new'}}], 'ack' => 'sed'}, original)
-  end
-end

data/test/test_minitems.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class MinItemsTest < Minitest::Test
-  def test_minitems_nils
-    schema = {
-      "type" => "array",
-      "minItems" => 1,
-      "items" => { "type" => "object" }
-    }
-
-    errors = JSON::Validator.fully_validate(schema, [nil])
-    assert_equal(errors.length, 1)
-    assert(errors[0] !~ /minimum/)
-    assert(errors[0] =~ /NilClass/)
-  end
-end

data/test/test_one_of.rb

@@ -1,85 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class OneOfTest < Minitest::Test
-  def test_one_of_links_schema
-    schema = schema_fixture_path('one_of_ref_links_schema.json')
-    data   = data_fixture_path('one_of_ref_links_data.json')
-    assert_valid schema, data
-  end
-
-  def test_one_of_with_string_patterns
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "oneOf" => [
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "foo"}},
-        },
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "bar"}},
-        },
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "baz"}},
-        }
-      ]
-    }
-
-    assert_valid schema, { "a" => "foo" }
-    refute_valid schema, { "a" => "foobar" }
-    assert_valid schema, { "a" => "baz" }
-    refute_valid schema, { "a" => 5 }
-  end
-
-  def test_one_of_sub_errors
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "oneOf" => [
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "foo"}},
-        },
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "bar"}},
-        },
-        {
-          "properties" => {"a" => {"type" => "number", "minimum" => 10}},
-        }
-      ]
-    }
-
-    errors = JSON::Validator.fully_validate(schema, { "a" => 5 }, :errors_as_objects => true)
-    nested_errors = errors[0][:errors]
-    assert_equal([:oneof_0,:oneof_1,:oneof_2], nested_errors.keys, 'should have nested errors for each allOf subschema')
-    assert_match(/the property '#\/a' of type Fixnum did not match the following type: string/i, nested_errors[:oneof_0][0][:message])
-    assert_match(/the property '#\/a' did not have a minimum value of 10, inclusively/i, nested_errors[:oneof_2][0][:message])
-  end
-
-  def test_one_of_sub_errors_message
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "oneOf" => [
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "foo"}},
-        },
-        {
-          "properties" => {"a" => {"type" => "string", "pattern" => "bar"}},
-        },
-        {
-          "properties" => {"a" => {"type" => "number", "minimum" => 10}},
-        }
-      ]
-    }
-
-    errors = JSON::Validator.fully_validate(schema, { "a" => 5 })
-    expected_message = """The property '#/' of type Hash did not match any of the required schemas. The schema specific errors were:
-
-- oneOf #0:
-    - The property '#/a' of type Fixnum did not match the following type: string
-- oneOf #1:
-    - The property '#/a' of type Fixnum did not match the following type: string
-- oneOf #2:
-    - The property '#/a' did not have a minimum value of 10, inclusively"""
-
-    assert_equal(expected_message, errors[0])
-
-  end
-
-end

data/test/test_ruby_schema.rb

@@ -1,59 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class RubySchemaTest < Minitest::Test
-  def test_string_keys
-    schema = {
-      "type" => 'object',
-      "required" => ["a"],
-      "properties" => {
-        "a" => {"type" => "integer", "default" => 42},
-        "b" => {"type" => "integer"}
-      }
-    }
-
-    assert_valid schema, { "a" => 5 }
-  end
-
-  def test_symbol_keys
-    schema = {
-      :type => 'object',
-      :required => ["a"],
-      :properties => {
-        :a => {:type => "integer", :default => 42},
-        :b => {:type => "integer"}
-      }
-    }
-
-    assert_valid schema, { :a => 5 }
-  end
-
-  def test_symbol_keys_in_hash_within_array
-    schema = {
-      :type => 'object',
-      :properties => {
-        :a => {
-          :type => "array",
-          :items => [
-            {
-              :properties => {
-                :b => {
-                  :type => "integer"
-                }
-              }
-            }
-          ]
-        }
-      }
-    }
-
-    data = {
-      :a => [
-        {
-          :b => 1
-        }
-      ]
-    }
-
-    assert_valid schema, data, :validate_schema => true
-  end
-end

data/test/test_schema_loader.rb

@@ -1,74 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class TestSchemaReader < Minitest::Test
-  ADDRESS_SCHEMA_URI  = 'http://json-schema.org/address'
-  ADDRESS_SCHEMA_PATH = File.expand_path('../schemas/address_microformat.json', __FILE__)
-
-  def stub_address_request(body = File.read(ADDRESS_SCHEMA_PATH))
-    stub_request(:get, ADDRESS_SCHEMA_URI).
-      to_return(:body => body, :status => 200)
-  end
-
-  def test_accept_all_uris
-    stub_address_request
-
-    reader = JSON::Schema::Reader.new
-    schema = reader.read(ADDRESS_SCHEMA_URI)
-
-    assert_equal schema.uri, Addressable::URI.parse("#{ADDRESS_SCHEMA_URI}#")
-  end
-
-  def test_accept_all_files
-    reader = JSON::Schema::Reader.new
-    schema = reader.read(ADDRESS_SCHEMA_PATH)
-
-    assert_equal schema.uri, Addressable::URI.convert_path(ADDRESS_SCHEMA_PATH + '#')
-  end
-
-  def test_refuse_all_uris
-    reader = JSON::Schema::Reader.new(:accept_uri => false)
-    refute reader.accept_uri?(Addressable::URI.parse('http://foo.com'))
-  end
-
-  def test_refuse_all_files
-    reader = JSON::Schema::Reader.new(:accept_file => false)
-    refute reader.accept_file?(Pathname.new('/foo/bar/baz'))
-  end
-
-  def test_accept_uri_proc
-    reader = JSON::Schema::Reader.new(
-      :accept_uri => proc { |uri| uri.host == 'json-schema.org' }
-    )
-
-    assert reader.accept_uri?(Addressable::URI.parse('http://json-schema.org/address'))
-    refute reader.accept_uri?(Addressable::URI.parse('http://sub.json-schema.org/address'))
-  end
-
-  def test_accept_file_proc
-    test_root = Pathname.new(__FILE__).expand_path.dirname
-
-    reader = JSON::Schema::Reader.new(
-      :accept_file => proc { |path| path.to_s.start_with?(test_root.to_s) }
-    )
-
-    assert reader.accept_file?(test_root.join('anything.json'))
-    refute reader.accept_file?(test_root.join('..', 'anything.json'))
-  end
-
-  def test_file_scheme
-    reader = JSON::Schema::Reader.new(:accept_uri => true, :accept_file => false)
-    assert_raises(JSON::Schema::ReadRefused) do
-      reader.read('file://' + ADDRESS_SCHEMA_PATH)
-    end
-  end
-
-  def test_parse_error
-    stub_address_request('this is totally not valid JSON!')
-
-    reader = JSON::Schema::Reader.new
-
-    assert_raises(parser_error) do
-      reader.read(ADDRESS_SCHEMA_URI)
-    end
-  end
-end

data/test/test_schema_type_attribute.rb

@@ -1,20 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class TestSchemaTypeAttribute < Minitest::Test
-  def test_type_of_data
-    assert_equal(type_of_data(String.new), 'string')
-    assert_equal(type_of_data(Numeric.new), 'number')
-    assert_equal(type_of_data(1), 'integer')
-    assert_equal(type_of_data(true), 'boolean')
-    assert_equal(type_of_data(false), 'boolean')
-    assert_equal(type_of_data(Hash.new), 'object')
-    assert_equal(type_of_data(nil), 'null')
-    assert_equal(type_of_data(Object.new), 'any')
-  end
-
-  private
-
-  def type_of_data(data)
-    JSON::Schema::TypeAttribute.type_of_data(data)
-  end
-end

data/test/test_schema_validation.rb

@@ -1,185 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-require 'tmpdir'
-
-class JSONSchemaValidation < Minitest::Test
-  def valid_schema_v3
-    {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "required" => true
-        }
-      }
-    }
-  end
-
-  def invalid_schema_v3
-    {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "required" => "true"
-        }
-      }
-    }
-  end
-
-  def valid_schema_v4
-    {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "required" => ["b"],
-      "properties" => {
-      }
-    }
-  end
-
-  def invalid_schema_v4
-    {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "required" => "b",
-      "properties" => {
-      }
-    }
-  end
-
-  def symbolized_schema
-    {
-      :type => :object,
-      :required => [
-        :id,
-        :name,
-        :real_name,
-        :role,
-        :website,
-        :biography,
-        :created_at,
-        :demographic
-      ],
-      :properties => {
-        :id => {
-          :type => [
-            :integer
-          ]
-        },
-        :name => {
-          :type => [
-            :string
-          ]
-        },
-        :real_name => {
-          :type => [
-            :string
-          ]
-        },
-        :role => {
-          :type => [
-            :string
-          ]
-        },
-        :website => {
-          :type => [
-            :string,
-            :null
-          ]
-        },
-        :created_at => {
-          :type => [
-            :string
-          ]
-        },
-        :biography => {
-          :type => [
-            :string,
-            :null
-          ]
-        }
-      },
-      :relationships => {
-        :demographic => {
-          :type => :object,
-          :required => [
-            :id,
-            :gender
-          ],
-          :properties => {
-            :id => {
-              :type => [
-                :integer
-              ]
-            },
-            :gender => {
-              :type => [
-                :string
-              ]
-            }
-          }
-        }
-      }
-    }
-  end
-
-  def test_draft03_validation
-    data = {"b" => {"a" => 5}}
-    assert(JSON::Validator.validate(valid_schema_v3,data,:validate_schema => true, :version => :draft3))
-    assert(!JSON::Validator.validate(invalid_schema_v3,data,:validate_schema => true, :version => :draft3))
-  end
-
-  def test_validate_just_schema_draft03
-    errors = JSON::Validator.fully_validate_schema(valid_schema_v3, :version => :draft3)
-    assert_equal [], errors
-
-    errors = JSON::Validator.fully_validate_schema(invalid_schema_v3, :version => :draft3)
-    assert_equal 1, errors.size
-    assert_match(/the property .*required.*did not match/i, errors.first)
-  end
-
-
-  def test_draft04_validation
-    data = {"b" => {"a" => 5}}
-    assert(JSON::Validator.validate(valid_schema_v4,data,:validate_schema => true, :version => :draft4))
-    assert(!JSON::Validator.validate(invalid_schema_v4,data,:validate_schema => true, :version => :draft4))
-  end
-
-  def test_validate_just_schema_draft04
-    errors = JSON::Validator.fully_validate_schema(valid_schema_v4, :version => :draft4)
-    assert_equal [], errors
-
-    errors = JSON::Validator.fully_validate_schema(invalid_schema_v4, :version => :draft4)
-    assert_equal 1, errors.size
-    assert_match(/the property .*required.*did not match/i, errors.first)
-  end
-
-  def test_validate_schema_3_without_version_option
-    data = {"b" => {"a" => 5}}
-    assert(JSON::Validator.validate(valid_schema_v3,data,:validate_schema => true))
-    assert(!JSON::Validator.validate(invalid_schema_v3,data,:validate_schema => true))
-  end
-
-  def test_schema_validation_from_different_directory
-    Dir.mktmpdir do |tmpdir|
-      Dir.chdir(tmpdir) do
-        data = {"b" => {"a" => 5}}
-        assert(JSON::Validator.validate(valid_schema_v4,data,:validate_schema => true, :version => :draft4))
-        assert(!JSON::Validator.validate(invalid_schema_v4,data,:validate_schema => true, :version => :draft4))
-      end
-    end
-  end
-
-  def test_validate_schema_with_symbol_keys
-    data = {
-      "created_at" => "2014-01-25T00:58:33-08:00",
-      "id" => 8517194300913402149003,
-      "name" => "chelsey",
-      "real_name" => "Mekhi Hegmann",
-      "website" => nil,
-      "role" => "user",
-      "biography" => nil,
-      "demographic" => nil
-    }
-    assert(JSON::Validator.validate!(symbolized_schema, data, :validate_schema => true))
-  end
-end