json-schema-openc-fork 0.0.1

data/test/test_list_option.rb

@@ -0,0 +1,21 @@
+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_merge_missing_values.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,185 @@
+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