json-schema 2.2.5 → 2.3.0

data/lib/json-schema/validators/draft4.rb

@@ -1,3 +1,5 @@
+require 'json-schema/schema/validator'
+
 module JSON
   class Schema
 
@@ -34,7 +36,16 @@ module JSON
           "extends" => JSON::Schema::ExtendsAttribute,
           "$ref" => JSON::Schema::RefAttribute
         }
+        @default_formats = {
+          'date-time' => DateTimeFormat,
+          'ipv4' => IP4Format,
+          'ipv6' => IP6Format,
+          'uri' => UriFormat
+        }
+        @formats = @default_formats.clone
         @uri = URI.parse("http://json-schema.org/draft-04/schema#")
+        @names = ["draft4", "http://json-schema.org/draft-04/schema#"]
+        @metaschema = File.join("resources", "draft-04.json")
       end
 
       JSON::Validator.register_validator(self.new)
@@ -42,4 +53,4 @@ module JSON
     end
 
   end
-end
+end

data/test/test_all_of_ref_schema.rb

@@ -1,11 +1,38 @@
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/json-schema'
 
-class AnyOfRefSchemaTest < Test::Unit::TestCase
-  def test_all_of_ref_schema
+class AllOfRefSchemaTest < Test::Unit::TestCase
+  def test_all_of_ref_schema_fails
     schema = File.join(File.dirname(__FILE__),"schemas/all_of_ref_schema.json")
     data = File.join(File.dirname(__FILE__),"data/all_of_ref_data.json")
     errors = JSON::Validator.fully_validate(schema,data, :errors_as_objects => true)
     assert(!errors.empty?, "should have failed to validate")
   end
+
+  def test_all_of_ref_schema_succeeds
+    schema = File.join(File.dirname(__FILE__),"schemas/all_of_ref_schema.json")
+    data   = %({"name": 42})
+    errors = JSON::Validator.fully_validate(schema,data, :errors_as_objects => true)
+    assert(errors.empty?, "should have validated")
+  end
+
+  def test_all_of_ref_subschema_errors
+    schema = File.join(File.dirname(__FILE__), 'schemas/all_of_ref_schema.json')
+    data = File.join(File.dirname(__FILE__), 'data/all_of_ref_data.json')
+    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
+    schema = File.join(File.dirname(__FILE__), 'schemas/all_of_ref_schema.json')
+    data = File.join(File.dirname(__FILE__), 'data/all_of_ref_data.json')
+    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

@@ -8,4 +8,30 @@ class AnyOfRefSchemaTest < Test::Unit::TestCase
     errors = JSON::Validator.fully_validate(schema,data, :errors_as_objects => true)
     assert(errors.empty?, errors.map{|e| e[:message] }.join("\n"))
   end
+
+  def test_any_of_ref_subschema_errors
+    schema = File.join(File.dirname(__FILE__),'schemas/any_of_ref_schema.json')
+    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
+    schema = File.join(File.dirname(__FILE__),'schemas/any_of_ref_schema.json')
+    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

@@ -25,9 +25,9 @@ class BadSchemaRefTest < Test::Unit::TestCase
     }
 
     data = [1,2,3]
-    assert_raise(SocketError) do
+    assert_raise(SocketError, OpenURI::HTTPError) do
       JSON::Validator.validate(schema,data)
     end
   end
 
-end
+end

data/test/test_common_test_suite.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require File.expand_path('../../lib/json-schema', __FILE__)
+
+class CommonTestSuiteTest < Test::Unit::TestCase
+  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
+  IGNORED_TESTS = [
+    "draft3/disallow.json",
+    "draft3/optional/format.json",
+    "draft3/optional/jsregex.json",
+    "draft3/ref.json",
+    "draft3/refRemote.json",
+    "draft4/dependencies.json",
+    "draft4/optional/format.json",
+    "draft4/ref.json",
+    "draft4/refRemote.json",
+  ]
+
+  Dir["#{TEST_DIR}/*"].each do |suite|
+    version = File.basename(suite).to_sym
+    Dir["#{suite}/**/*.json"].each do |tfile|
+      test_list = JSON::Validator.parse(File.read(tfile))
+      rel_file = tfile[TEST_DIR.length+1..-1]
+
+      test_list.each do |test|
+        schema = test["schema"]
+        base_description = test["description"]
+        v = nil
+
+        test["tests"].each do |t|
+          err_id = "#{rel_file}, '#{base_description}'/'#{t['description']}'"
+
+          define_method("test_#{err_id}") do
+            skip "Known incompatibility with common test suite" if IGNORED_TESTS.include?(rel_file)
+
+            assert_nothing_raised("Exception raised running #{err_id}") do
+              v = JSON::Validator.fully_validate(schema,
+                                                 t["data"],
+                                                 :validate_schema => true,
+                                                 :version => version
+                                                )
+            end
+
+            assert v.empty? == t["valid"], "Common test suite case failed: #{err_id}\n#{v}"
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_custom_format.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/json-schema'
+
+class JSONSchemaCustomFormatTest < Test::Unit::TestCase
+  def setup
+    @all_versions = ['draft1', 'draft2', 'draft3', 'draft4']
+    @format_proc = -> 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_jsonschema_draft1.rb

@@ -684,6 +684,18 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft1))
   end
 
+  def test_format_unknown
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"type" => "string", "format" => "unknown"}}
+    }
+
+    data = {"a" => "I can write what I want here"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    data = {"a" => ""}
+    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+  end
+
 
   def test_format_union
     data1 = {"a" => "boo"}

data/test/test_jsonschema_draft2.rb

@@ -756,6 +756,18 @@ class JSONSchemaDraft2Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:version => :draft2))
   end
 
+  def test_format_unknown
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"type" => "string", "format" => "unknown"}}
+    }
+
+    data = {"a" => "I can write what I want here"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft2))
+    data = {"a" => ""}
+    assert(JSON::Validator.validate(schema,data,:version => :draft2))
+  end
+
 
   def test_format_union
     data1 = {"a" => "boo"}

data/test/test_jsonschema_draft3.rb

@@ -503,6 +503,25 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:strict => true))
   end
 
+  def test_strict_properties_required_props
+    schema = {
+      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "properties" => {
+        "a" => {"type" => "string", "required" => true},
+        "b" => {"type" => "string", "required" => false}
+      }
+    }
+
+    data = {"a" => "a"}
+    assert(JSON::Validator.validate(schema,data,:strict => true))
+
+    data = {"b" => "b"}
+    assert(!JSON::Validator.validate(schema,data,:strict => true))
+
+    data = {"a" => "a", "b" => "b"}
+    assert(JSON::Validator.validate(schema,data,:strict => true))
+  end
+
   def test_strict_properties_additional_props
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
@@ -1076,6 +1095,18 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(JSON::Validator.validate(schema,data))
   end
 
+  def test_format_unknown
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"type" => "string", "format" => "unknown"}}
+    }
+
+    data = {"a" => "I can write what I want here"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft3))
+    data = {"a" => ""}
+    assert(JSON::Validator.validate(schema,data,:version => :draft3))
+  end
+
 
   def test_format_union
     data1 = {"a" => "boo"}

data/test/test_jsonschema_draft4.rb

@@ -887,7 +887,7 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
       "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "ip-address"}}
+      "properties" => { "a" => {"type" => "string", "format" => "ipv4"}}
     }
 
     data = {"a" => "1.1.1.1"}
@@ -929,52 +929,6 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data))
   end
 
-  def test_format_time
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "time"}}
-    }
-
-    data = {"a" => "12:00:00"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "12:00"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "12:00:60"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "12:60:00"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "24:00:00"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "0:00:00"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "-12:00:00"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "12:00:00b"}
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_format_date
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "date"}}
-    }
-
-    data = {"a" => "2010-01-01"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-32"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "n2010-01-01"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-1-01"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-1"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01n"}
-    assert(!JSON::Validator.validate(schema,data))
-  end
 
   def test_format_datetime
     schema = {
@@ -1025,6 +979,18 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     assert(JSON::Validator.validate(schema,data3))
   end
 
+  def test_format_unknown
+    schema = {
+      "type" => "object",
+      "properties" => { "a" => {"type" => "string", "format" => "unknown"}}
+    }
+
+    data = {"a" => "I can write what I want here"}
+    assert(JSON::Validator.validate(schema,data,:version => :draft4))
+    data = {"a" => ""}
+    assert(JSON::Validator.validate(schema,data,:version => :draft4))
+  end
+
 
   def test_format_union
     data1 = {"a" => "boo"}
@@ -1033,7 +999,7 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
       "type" => "object",
-      "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
+      "properties" => { "a" => {"type" => ["string","null"], "format" => "ipv4"}}
     }
     assert(!JSON::Validator.validate(schema,data1))
     assert(JSON::Validator.validate(schema,data2))