json-schema-openc-fork 0.0.1

data/test/test_custom_format.rb

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

data/test/test_definition.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class RelativeDefinitionTest < Minitest::Test
+
+  def test_definition_schema
+    assert_valid schema_fixture_path('definition_schema.json'), {"a" => 5}
+  end
+
+  def test_relative_definition
+    schema = schema_fixture_path('relative_definition_schema.json')
+    assert_valid schema, {"a" => 5}
+    refute_valid schema, {"a" => "foo"}
+  end
+
+end

data/test/test_extended_schema.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class BitwiseAndAttribute < JSON::Schema::Attribute
+  def self.validate(current_schema, data, fragments, processor, validator, options = {})
+    return unless data.is_a?(Integer)
+
+    if data & current_schema.schema['bitwise-and'].to_i == 0
+      message = "The property '#{build_fragment(fragments)}' did not evaluate to true when bitwise-AND'd with #{current_schema.schema['bitwise-and']}"
+      validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
+    end
+  end
+end
+
+class ExtendedSchema < JSON::Schema::Validator
+  def initialize
+    super
+    extend_schema_definition("http://json-schema.org/draft-03/schema#")
+    @attributes["bitwise-and"] = BitwiseAndAttribute
+    @uri = Addressable::URI.parse("http://test.com/test.json")
+  end
+
+  JSON::Validator.register_validator(self.new)
+end
+
+class TestExtendedSchema < Minitest::Test
+  def test_extended_schema_validation
+    schema = {
+      "$schema" => "http://test.com/test.json",
+      "properties" => {
+        "a" => {
+          "bitwise-and" => 1
+        },
+        "b" => {
+          "type" => "string"
+        }
+      }
+    }
+
+    assert_valid schema, {"a" => 1, "b" => "taco"}
+    refute_valid schema, {"a" => 0, "b" => "taco"}
+    refute_valid schema, {"a" => 1, "b" => 5}
+  end
+
+  def test_unextended_schema
+    # Verify that using the original schema disregards the `bitwise-and` property
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "properties" => {
+        "a" => {
+          "bitwise-and" => 1
+        },
+        "b" => {
+          "type" => "string"
+        }
+      }
+    }
+
+    assert_valid schema, {"a" => 0, "b" => "taco"}
+    assert_valid schema, {"a" => 1, "b" => "taco"}
+    refute_valid schema, {"a" => 1, "b" => 5}
+  end
+end

data/test/test_extends_and_additionalProperties.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class ExtendsNestedTest < Minitest::Test
+
+  def assert_validity(valid, schema_name, data, msg)
+    msg = "Schema should be #{valid ? :valid : :invalid}.\n(#{schema_name}) #{msg}"
+    schema = schema_fixture_path("#{schema_name}.schema.json")
+    errors = JSON::Validator.fully_validate(schema, data)
+
+    if valid
+      assert_equal([], errors, msg)
+    else
+      refute_equal([], errors, msg)
+    end
+  end
+
+  %w[
+    extends_and_additionalProperties-1-filename
+    extends_and_additionalProperties-1-ref
+    extends_and_additionalProperties-2-filename
+    extends_and_additionalProperties-2-ref
+  ].each do |schema_name|
+    test_prefix = 'test_' + schema_name.gsub('-','_')
+
+    class_eval <<-EOB
+      def #{test_prefix}_valid_outer
+        assert_validity true, '#{schema_name}', {"outerC"=>true}, "Outer defn is broken, maybe the outer extends overrode it"
+      end
+
+      def #{test_prefix}_valid_outer_extended
+        assert_validity true, '#{schema_name}', {"innerA"=>true}, "Extends at the root level isn't working"
+      end
+
+      def #{test_prefix}_valid_inner
+        assert_validity true, '#{schema_name}', {"outerB"=>[{"innerA"=>true}]}, "Extends isn't working in the array element defn"
+      end
+
+      def #{test_prefix}_invalid_inner
+        assert_validity false, '#{schema_name}', {"outerB"=>[{"whaaaaat"=>true}]}, "Array element defn allowing anything when it should only allow what's in inner.schema"
+      end
+    EOB
+
+    if schema_name['extends_and_additionalProperties-1']
+      class_eval <<-EOB
+        def #{test_prefix}_invalid_outer
+          assert_validity false, '#{schema_name}', {"whaaaaat"=>true}, "Outer defn allowing anything when it shouldn't"
+        end
+      EOB
+    end
+
+  end
+end

data/test/test_files_v3.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class JSONSchemaTest < Minitest::Test
+
+  #
+  # These tests are ONLY run if there is an appropriate JSON backend parser available
+  #
+
+  def test_schema_from_file
+    assert_valid schema_fixture_path('good_schema_1.json'), { "a" => 5 }
+    refute_valid schema_fixture_path('good_schema_1.json'), { "a" => "bad" }
+  end
+
+  def test_data_from_file
+    schema = {"$schema" => "http://json-schema.org/draft-03/schema#","type" => "object", "properties" => {"a" => {"type" => "integer"}}}
+    assert_valid schema, data_fixture_path('good_data_1.json'), :uri => true
+    refute_valid schema, data_fixture_path('bad_data_1.json'), :uri => true
+  end
+
+  def test_data_from_json
+    if JSON::Validator.json_backend != nil
+      schema = {"$schema" => "http://json-schema.org/draft-03/schema#","type" => "object", "properties" => {"a" => {"type" => "integer"}}}
+      assert_valid schema, %Q({"a": 5}), :json => true
+      refute_valid schema, %Q({"a": "poop"}), :json => true
+    end
+  end
+
+  def test_both_from_file
+    assert_valid schema_fixture_path('good_schema_1.json'), data_fixture_path('good_data_1.json'), :uri => true
+    refute_valid schema_fixture_path('good_schema_1.json'), data_fixture_path('bad_data_1.json'), :uri => true
+  end
+
+  def test_file_ref
+    assert_valid schema_fixture_path('good_schema_2.json'), { "b" => { "a" => 5 } }
+    refute_valid schema_fixture_path('good_schema_1.json'), { "b" => { "a" => "boo" } }
+  end
+
+  def test_file_extends
+    assert_valid schema_fixture_path('good_schema_extends1.json'), { "a" => 5 }
+    assert_valid schema_fixture_path('good_schema_extends2.json'), { "a" => 5, "b" => { "a" => 5 } }
+  end
+
+end

data/test/test_fragment_resolution.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class FragmentResolution < Minitest::Test
+  def test_fragment_resolution
+    schema = {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "required" => ["a"],
+      "properties" => {
+        "a" => {
+          "type" => "object",
+          "properties" => {
+            "b" => {"type" => "integer" }
+          }
+        }
+      }
+    }
+
+    data = {"b" => 5}
+    refute_valid schema, data
+    assert_valid schema, data, :fragment => "#/properties/a"
+
+    assert_raises JSON::Schema::SchemaError do
+      JSON::Validator.validate!(schema,data,:fragment => "/properties/a")
+    end
+
+    assert_raises JSON::Schema::SchemaError do
+      JSON::Validator.validate!(schema,data,:fragment => "#/properties/b")
+    end
+  end
+end

data/test/test_fragment_validation_with_ref.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class FragmentValidationWithRef < Minitest::Test
+  def whole_schema
+    {
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "type" => "object",
+      "definitions" => {
+        "post" => {
+          "type" => "object",
+          "properties" => {
+            "content" => {
+              "type" => "string"
+            },
+            "author" => {
+              "type" => "string"
+            }
+          }
+        },
+        "posts" => {
+          "type" => "array",
+          "items" => {
+            "$ref" => "#/definitions/post"
+          }
+        }
+      }
+    }
+  end
+
+  def test_validation_of_fragment
+    data = [{"content" => "ohai", "author" => "Bob"}]
+    assert_valid whole_schema, data, :fragment => "#/definitions/posts"
+  end
+end

data/test/test_full_validation.rb

@@ -0,0 +1,208 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class JSONFullValidation < Minitest::Test
+    
+  def test_full_validation
+    data = {"b" => {"a" => 5}}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "required" => true
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+
+    data = {"c" => 5}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "required" => true
+        },
+        "c" => {
+          "type" => "string"
+        }
+      }
+    }
+
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.length == 2)
+  end
+  
+  def test_full_validation_with_union_types
+    data = {"b" => 5}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "type" => ["null","integer"]
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "type" => ["integer","null"]
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    data = {"b" => "a string"}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.length == 1)
+   
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "type" => [
+            {
+              "type" => "object",
+              "properties" => {
+                "c" => {"type" => "string"}
+              }
+            },
+            {
+              "type" => "object",
+              "properties" => {
+                "d" => {"type" => "integer"}
+              }
+            }
+          ]
+        }
+      }
+    }
+    
+    data = {"b" => {"c" => "taco"}}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    data = {"b" => {"d" => 6}}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.empty?)
+    
+    data = {"b" => {"c" => 6, "d" => "OH GOD"}}
+    
+    errors = JSON::Validator.fully_validate(schema,data)
+    assert(errors.length == 1)
+  end
+  
+  
+  def test_full_validation_with_object_errors
+    data = {"b" => {"a" => 5}}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "required" => true
+        }
+      }
+    }
+    
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert(errors.empty?)
+
+    data = {"c" => 5}
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "b" => {
+          "required" => true
+        },
+        "c" => {
+          "type" => "string"
+        }
+      }
+    }
+
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert(errors.length == 2)
+    assert(errors[0][:failed_attribute] == "Properties")
+    assert(errors[0][:fragment] == "#/")
+    assert(errors[1][:failed_attribute] == "Type")
+    assert(errors[1][:fragment] == "#/c")
+  end
+  
+  def test_full_validation_with_nested_required_properties
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "x" => {
+          "required" => true,
+          "type" => "object",
+          "properties" => {
+            "a" => {"type"=>"integer","required"=>true},
+            "b" => {"type"=>"integer","required"=>true},
+            "c" => {"type"=>"integer","required"=>false},
+            "d" => {"type"=>"integer","required"=>false},
+            "e" => {"type"=>"integer","required"=>false},
+          }
+        }
+      }
+    }
+    data = {"x" => {"a"=>5, "d"=>5, "e"=>"what?"}}
+    
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert_equal 2, errors.length
+    assert_equal '#/x', errors[0][:fragment]
+    assert_equal 'Properties', errors[0][:failed_attribute]
+    assert_equal '#/x/e', errors[1][:fragment]
+    assert_equal 'Type', errors[1][:failed_attribute]
+  end
+  
+  def test_full_validation_with_nested_required_propertiesin_array
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "type" => "object",
+      "properties" => {
+        "x" => {
+          "required" => true,
+          "type" => "array",
+          "items" => {
+            "type" => "object",
+            "properties" => {
+              "a" => {"type"=>"integer","required"=>true},
+              "b" => {"type"=>"integer","required"=>true},
+              "c" => {"type"=>"integer","required"=>false},
+              "d" => {"type"=>"integer","required"=>false},
+              "e" => {"type"=>"integer","required"=>false},
+            }
+          }
+        }
+      }
+    }
+    missing_b= {"a"=>5}
+    e_is_wrong_type= {"a"=>5,"b"=>5,"e"=>"what?"}
+    data = {"x" => [missing_b, e_is_wrong_type]}
+    
+    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
+    assert_equal 2, errors.length
+    assert_equal '#/x/0', errors[0][:fragment]
+    assert_equal 'Properties', errors[0][:failed_attribute]
+    assert_equal '#/x/1/e', errors[1][:fragment]
+    assert_equal 'Type', errors[1][:failed_attribute]
+  end
+end