json-schema 2.4.1 → 2.5.0

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

@@ -33,7 +33,7 @@ module JSON
           'uri' => UriFormat
         }
         @formats = @default_formats.clone
-        @uri = URI.parse("http://json-schema.org/draft-01/schema#")
+        @uri = Addressable::URI.parse("http://json-schema.org/draft-01/schema#")
         @names = ["draft1"]
         @metaschema_name = "draft-01.json"
       end

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

@@ -34,7 +34,7 @@ module JSON
           'uri' => UriFormat
         }
         @formats = @default_formats.clone
-        @uri = URI.parse("http://json-schema.org/draft-02/schema#")
+        @uri = Addressable::URI.parse("http://json-schema.org/draft-02/schema#")
         @names = ["draft2"]
         @metaschema_name = "draft-02.json"
       end

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

@@ -38,7 +38,7 @@ module JSON
           'uri' => UriFormat
         }
         @formats = @default_formats.clone
-        @uri = URI.parse("http://json-schema.org/draft-03/schema#")
+        @uri = Addressable::URI.parse("http://json-schema.org/draft-03/schema#")
         @names = ["draft3", "http://json-schema.org/draft-03/schema#"]
         @metaschema_name = "draft-03.json"
       end

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

@@ -43,7 +43,7 @@ module JSON
           'uri' => UriFormat
         }
         @formats = @default_formats.clone
-        @uri = URI.parse("http://json-schema.org/draft-04/schema#")
+        @uri = Addressable::URI.parse("http://json-schema.org/draft-04/schema#")
         @names = ["draft4", "http://json-schema.org/draft-04/schema#"]
         @metaschema_name = "draft-04.json"
       end

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

@@ -4,7 +4,7 @@ module JSON
     class HyperDraft4 < Draft4
       def initialize
         super
-        @uri = URI.parse("http://json-schema.org/draft-04/hyper-schema#")
+        @uri = Addressable::URI.parse("http://json-schema.org/draft-04/hyper-schema#")
       end
 
       JSON::Validator.register_validator(self.new)

data/test/schemas/address_microformat.json

@@ -0,0 +1,18 @@
+{
+    "description": "An Address following the convention of http://microformats.org/wiki/hcard",
+    "type": "object",
+    "properties": {
+        "post-office-box": { "type": "string" },
+        "extended-address": { "type": "string" },
+        "street-address": { "type": "string" },
+        "locality":{ "type": "string" },
+        "region": { "type": "string" },
+        "postal-code": { "type": "string" },
+        "country-name": { "type": "string"}
+    },
+    "required": ["locality", "region", "country-name"],
+    "dependencies": {
+        "post-office-box": "street-address",
+        "extended-address": "street-address"
+    }
+}

data/test/schemas/definition_schema.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "description": "schema with definition",
+  "type": "object",
+  "properties": {
+    "a": {
+      "$ref": "#/definitions/foo"
+    }
+  },
+  "definitions": {
+    "foo": {
+      "type": "integer"
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+{
+  "$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

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

data/test/test_all_of_ref_schema.rb

@@ -1,24 +1,23 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+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
 
-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")
+    refute_valid schema, data
   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")
+    assert_valid schema, %({"name": 42})
   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')
@@ -26,8 +25,6 @@ class AllOfRefSchemaTest < Test::Unit::TestCase
   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:
 

data/test/test_any_of_ref_schema.rb

@@ -1,16 +1,15 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
+
+class AnyOfRefSchemaTest < Minitest::Test
+  def schema
+    schema_fixture_path('any_of_ref_schema.json')
+  end
 
-class AnyOfRefSchemaTest < Test::Unit::TestCase
   def test_any_of_ref_schema
-    schema = File.join(File.dirname(__FILE__),"schemas/any_of_ref_schema.json")
-    data = File.join(File.dirname(__FILE__),"data/any_of_ref_data.json")
-    errors = JSON::Validator.fully_validate(schema,data, :errors_as_objects => true)
-    assert(errors.empty?, errors.map{|e| e[:message] }.join("\n"))
+    assert_valid schema, data_fixture_path('any_of_ref_data.json')
   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]
@@ -21,7 +20,6 @@ class AnyOfRefSchemaTest < Test::Unit::TestCase
   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:

data/test/test_bad_schema_ref.rb

@@ -1,33 +1,39 @@
-require 'test/unit'
+require File.expand_path('../test_helper', __FILE__)
 require 'socket'
-require File.dirname(__FILE__) + '/../lib/json-schema'
 
-class BadSchemaRefTest < Test::Unit::TestCase
+
+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"}
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "type" => "array",
+      "items" => { "$ref" => "../google.json"}
     }
 
     data = [1,2,3]
-    assert_raise(URI::BadURIError) do
+    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.com/json.schema"}
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "type" => "array",
+      "items" => { "$ref" => "http://ppcheesecheseunicornnuuuurrrrr.example.invalid/json.schema"}
     }
 
     data = [1,2,3]
-    assert_raise(SocketError, OpenURI::HTTPError) do
+    assert_raises(SocketError, OpenURI::HTTPError) do
       JSON::Validator.validate(schema,data)
     end
   end
-
 end

data/test/test_common_test_suite.rb

@@ -1,47 +1,63 @@
-require 'test/unit'
-require File.expand_path('../../lib/json-schema', __FILE__)
+require File.expand_path('../test_helper', __FILE__)
+require 'json'
 
-class CommonTestSuiteTest < Test::Unit::TestCase
+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
-  IGNORED_TESTS = [
-    "draft3/disallow.json",
-    "draft3/optional/format.json",
-    "draft3/optional/jsregex.json",
-    "draft3/refRemote.json",
-    "draft4/optional/format.json",
-    "draft4/refRemote.json",
-  ]
+  # 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::Validator.parse(File.read(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"]
-        v = nil
 
         test["tests"].each do |t|
-          err_id = "#{rel_file}: #{base_description}/#{t['description']}"
-
-          unless IGNORED_TESTS.include?(rel_file)
-            define_method("test_#{err_id}") do
-              assert_nothing_raised("Exception raised running #{err_id}") do
-                v = JSON::Validator.fully_validate(schema,
-                                                   t["data"],
-                                                   :validate_schema => true,
-                                                   :version => version
-                                                  )
-              end
+          next if IGNORED_TESTS[rel_file] == :all
+          next if IGNORED_TESTS[rel_file].any? { |ignored|
+            base_description == ignored || "#{base_description}/#{t['description']}" == ignored
+          }
 
-              assert_equal t["valid"], v.empty?, "Common test suite case failed: #{err_id}\n#{v}"
-            end
+          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

data/test/test_custom_format.rb

@@ -1,8 +1,7 @@
 # encoding: utf-8
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class JSONSchemaCustomFormatTest < Test::Unit::TestCase
+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" }

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

@@ -1,11 +1,12 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
 class BitwiseAndAttribute < JSON::Schema::Attribute
   def self.validate(current_schema, data, fragments, processor, validator, options = {})
-    if data.is_a?(Integer) && 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-or']}"
-      raise JSON::Schema::ValidationError.new(message, fragments, self, current_schema)
+    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
@@ -15,16 +16,16 @@ class ExtendedSchema < JSON::Schema::Validator
     super
     extend_schema_definition("http://json-schema.org/draft-03/schema#")
     @attributes["bitwise-and"] = BitwiseAndAttribute
-    @uri = URI.parse("http://test.com/test.json")
+    @uri = Addressable::URI.parse("http://test.com/test.json")
   end
-  
+
   JSON::Validator.register_validator(self.new)
 end
 
-class JSONSchemaTestExtendedSchema < Test::Unit::TestCase
-  def test_schema_from_file
+class TestExtendedSchema < Minitest::Test
+  def test_extended_schema_validation
     schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
+      "$schema" => "http://test.com/test.json",
       "properties" => {
         "a" => {
           "bitwise-and" => 1
@@ -34,16 +35,16 @@ class JSONSchemaTestExtendedSchema < Test::Unit::TestCase
         }
       }
     }
-    
-    data = {"a" => 0, "b" => "taco"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => 1, "b" => "taco"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => 1, "b" => 5}
-    assert(!JSON::Validator.validate(schema,data))
-    
+
+    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://test.com/test.json",
+      "$schema" => "http://json-schema.org/draft-03/schema#",
       "properties" => {
         "a" => {
           "bitwise-and" => 1
@@ -53,16 +54,9 @@ class JSONSchemaTestExtendedSchema < Test::Unit::TestCase
         }
       }
     }
-    
-    data = {
-      "a" => 0
-    }
-    
-    data = {"a" => 1, "b" => "taco"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => 0, "b" => "taco"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => 1, "b" => 5}
-    assert(!JSON::Validator.validate(schema,data))
+
+    assert_valid schema, {"a" => 0, "b" => "taco"}
+    assert_valid schema, {"a" => 1, "b" => "taco"}
+    refute_valid schema, {"a" => 1, "b" => 5}
   end
-end
+end

data/test/test_extends_and_additionalProperties.rb

@@ -1,47 +1,49 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class ExtendsNestedTest < Test::Unit::TestCase
+class ExtendsNestedTest < Minitest::Test
 
-  def assert_validity(valid, schema_name, data, msg=nil)
-    file = File.expand_path("../schemas/#{schema_name}.schema.json",__FILE__)
-    errors = JSON::Validator.fully_validate file, data
-    msg.sub! /\.$/, '' if msg
-    send (valid ? :assert_equal : :assert_not_equal), [], errors, \
-      "Schema should be #{valid ? :valid : :invalid}#{msg ? ".\n[#{schema_name}] #{msg}" : ''}"
-  end
+  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)
 
-  def assert_valid(schema_name, data, msg=nil) assert_validity true, schema_name, data, msg end
-  def refute_valid(schema_name, data, msg=nil) assert_validity false, schema_name, data, msg end
+    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
+    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
+    test_prefix = 'test_' + schema_name.gsub('-','_')
 
+    class_eval <<-EOB
       def #{test_prefix}_valid_outer
-        assert_valid '#{schema_name}', {"outerC"=>true}, "Outer defn is broken, maybe the outer extends overrode it?"
+        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_valid '#{schema_name}', {"innerA"=>true}, "Extends at the root level isn't working."
+        assert_validity true, '#{schema_name}', {"innerA"=>true}, "Extends at the root level isn't working"
       end
 
       def #{test_prefix}_valid_inner
-        assert_valid '#{schema_name}', {"outerB"=>[{"innerA"=>true}]}, "Extends isn't working in the array element defn."
+        assert_validity true, '#{schema_name}', {"outerB"=>[{"innerA"=>true}]}, "Extends isn't working in the array element defn"
       end
 
       def #{test_prefix}_invalid_inner
-        refute_valid '#{schema_name}', {"outerB"=>[{"whaaaaat"=>true}]}, "Array element defn allowing anything when it should only allow what's in inner.schema"
+        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
-          refute_valid '#{schema_name}', {"whaaaaat"=>true}, "Outer defn allowing anything when it shouldn't."
+          assert_validity false, '#{schema_name}', {"whaaaaat"=>true}, "Outer defn allowing anything when it shouldn't"
         end
       EOB
     end