json-schema 2.4.1 → 2.5.0

data/test/test_files_v3.rb

@@ -1,52 +1,43 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class JSONSchemaTest < Test::Unit::TestCase
+class JSONSchemaTest < Minitest::Test
 
   #
   # These tests are ONLY run if there is an appropriate JSON backend parser available
   #
 
   def test_schema_from_file
-    data = {"a" => 5}
-    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
-    data = {"a" => "bad"}
-    assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
+    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(JSON::Validator.validate_uri(schema,File.join(File.dirname(__FILE__),"data/good_data_1.json")))
-    assert(!JSON::Validator.validate_uri(schema,File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
+    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(JSON::Validator.validate_json(schema, %Q({"a" : 5})))
-      assert(!JSON::Validator.validate_json(schema, %Q({"a" : "poop"})))
+      assert_valid schema, %Q({"a": 5}), :json => true
+      refute_valid schema, %Q({"a": "poop"}), :json => true
     end
   end
 
   def test_both_from_file
-    assert(JSON::Validator.validate_uri(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/good_data_1.json")))
-    assert(!JSON::Validator.validate_uri(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),File.join(File.dirname(__FILE__),"data/bad_data_1.json")))
+    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
-    data = {"b" => {"a" => 5}}
-    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_2.json"),data))
-
-    data = {"b" => {"a" => "boo"}}
-    assert(!JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_1.json"),data))
+    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
-    data = {"a" => 5}
-    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_extends1.json"),data))
-
-    data = {"a" => 5, "b" => {"a" => 5}}
-    assert(JSON::Validator.validate(File.join(File.dirname(__FILE__),"schemas/good_schema_extends2.json"),data))
+    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

@@ -1,7 +1,6 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class FragmentResolution < Test::Unit::TestCase
+class FragmentResolution < Minitest::Test
   def test_fragment_resolution
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
@@ -17,14 +16,14 @@ class FragmentResolution < Test::Unit::TestCase
     }
 
     data = {"b" => 5}
-    assert(!JSON::Validator.validate(schema,data))
-    assert(JSON::Validator.validate(schema,data,:fragment => "#/properties/a"))
+    refute_valid schema, data
+    assert_valid schema, data, :fragment => "#/properties/a"
 
-    assert_raise JSON::Schema::SchemaError do
+    assert_raises JSON::Schema::SchemaError do
       JSON::Validator.validate!(schema,data,:fragment => "/properties/a")
     end
 
-    assert_raise JSON::Schema::SchemaError do
+    assert_raises JSON::Schema::SchemaError do
       JSON::Validator.validate!(schema,data,:fragment => "#/properties/b")
     end
   end

data/test/test_fragment_validation_with_ref.rb

@@ -1,7 +1,6 @@
 require File.expand_path('../test_helper', __FILE__)
-require 'json-schema'
 
-class FragmentValidationWithRef < Test::Unit::TestCase
+class FragmentValidationWithRef < Minitest::Test
   def whole_schema
     {
       "$schema" => "http://json-schema.org/draft-04/schema#",
@@ -30,11 +29,6 @@ class FragmentValidationWithRef < Test::Unit::TestCase
 
   def test_validation_of_fragment
     data = [{"content" => "ohai", "author" => "Bob"}]
-    v = nil
-    assert_nothing_raised do
-      v = JSON::Validator.fully_validate(whole_schema,data,:fragment => "#/definitions/posts")
-    end
-
-    assert(v.empty?, v.join("\n"))
+    assert_valid whole_schema, data, :fragment => "#/definitions/posts"
   end
 end

data/test/test_full_validation.rb

@@ -1,7 +1,6 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class JSONFullValidation < Test::Unit::TestCase
+class JSONFullValidation < Minitest::Test
     
   def test_full_validation
     data = {"b" => {"a" => 5}}

data/test/test_helper.rb

@@ -1,2 +1,47 @@
-require 'test/unit'
+require 'minitest/autorun'
+require 'webmock/minitest'
+
 $:.unshift(File.expand_path('../../lib', __FILE__))
+require 'json-schema'
+
+Dir[File.join(File.expand_path('../support', __FILE__), '*.rb')].each do |support_file|
+  require support_file
+end
+
+class Minitest::Test
+  def schema_fixture_path(filename)
+    File.join(File.dirname(__FILE__), 'schemas', filename)
+  end
+
+  def data_fixture_path(filename)
+    File.join(File.dirname(__FILE__), 'data', filename)
+  end
+
+  def assert_valid(schema, data, options = {})
+    if !options.key?(:version) && respond_to?(:schema_version)
+      options = options.merge(:version => schema_version)
+    end
+
+    errors = JSON::Validator.fully_validate(schema, data, options)
+    assert_equal([], errors, "#{data.inspect} should be valid for schema:\n#{schema.inspect}")
+  end
+
+  def refute_valid(schema, data, options = {})
+    if !options.key?(:version) && respond_to?(:schema_version)
+      options = options.merge(:version => schema_version)
+    end
+
+    errors = JSON::Validator.fully_validate(schema, data, options)
+    refute_equal([], errors, "#{data.inspect} should be invalid for schema:\n#{schema.inspect}")
+  end
+
+  def parser_error
+    if defined?(::Yajl)
+      Yajl::ParseError
+    elsif defined?(::MultiJson)
+      MultiJson::ParseError
+    else
+      JSON::ParserError
+    end
+  end
+end

data/test/test_initialize_data.rb

@@ -0,0 +1,118 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class InitializeDataTest < Minitest::Test
+
+  def test_parse_character_string
+    schema = {'type' => 'string'}
+    data = 'hello world'
+
+    assert(JSON::Validator.validate(schema, data))
+
+    assert(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert_raises(parser_error) do
+      JSON::Validator.validate(schema, data, :json => true)
+    end
+
+    assert_raises(Errno::ENOENT) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+
+  def test_parse_integer_string
+    schema = {'type' => 'integer'}
+    data = '42'
+
+    assert(JSON::Validator.validate(schema, data))
+
+    refute(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert(JSON::Validator.validate(schema, data, :json => true))
+
+    assert_raises(Errno::ENOENT) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+
+  def test_parse_hash_string
+    schema = { 'type' => 'object', 'properties' => { 'a' => { 'type' => 'string' } } }
+    data = '{"a": "b"}'
+
+    assert(JSON::Validator.validate(schema, data))
+
+    refute(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert(JSON::Validator.validate(schema, data, :json => true))
+
+    assert_raises(Errno::ENOENT) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+
+  def test_parse_json_string
+    schema = {'type' => 'string'}
+    data = '"hello world"'
+
+    assert(JSON::Validator.validate(schema, data))
+
+    assert(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert(JSON::Validator.validate(schema, data, :json => true))
+
+    assert_raises(Errno::ENOENT) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+
+  def test_parse_valid_uri_string
+    schema = {'type' => 'string'}
+    data = 'http://foo.bar/'
+
+    stub_request(:get, "foo.bar").to_return(:body => '"hello world"', :status => 200)
+
+    assert(JSON::Validator.validate(schema, data))
+
+    assert(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert_raises(parser_error) do
+      JSON::Validator.validate(schema, data, :json => true)
+    end
+
+    assert(JSON::Validator.validate(schema, data, :uri => true))
+  end
+
+  def test_parse_invalid_uri_string
+    schema = {'type' => 'string'}
+    data = 'http://foo.bar/'
+
+    stub_request(:get, "foo.bar").to_timeout
+
+    assert(JSON::Validator.validate(schema, data))
+
+    assert(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert_raises(parser_error) do
+      JSON::Validator.validate(schema, data, :json => true)
+    end
+
+    assert_raises(Timeout::Error) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+
+  def test_parse_integer
+    schema = {'type' => 'integer'}
+    data = 42
+
+    assert(JSON::Validator.validate(schema, data))
+
+    assert(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert_raises(TypeError) { JSON::Validator.validate(schema, data, :json => true) }
+
+    assert_raises(TypeError) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+
+  def test_parse_hash
+    schema = { 'type' => 'object', 'properties' => { 'a' => { 'type' => 'string' } } }
+    data = { 'a' => 'b' }
+
+    assert(JSON::Validator.validate(schema, data))
+
+    assert(JSON::Validator.validate(schema, data, :parse_data => false))
+
+    assert_raises(TypeError) { JSON::Validator.validate(schema, data, :json => true) }
+
+    assert_raises(TypeError) { JSON::Validator.validate(schema, data, :uri => true) }
+  end
+end

data/test/test_jsonschema_draft1.rb

@@ -1,169 +1,31 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class JSONSchemaDraft1Test < Test::Unit::TestCase
-  def test_types
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {}
-      }
-    }
-    data = {
-      "a" => nil
-    }
-
-    # Test integers
-    schema["properties"]["a"]["type"] = "integer"
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test numbers
-    schema["properties"]["a"]["type"] = "number"
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test strings
-    schema["properties"]["a"]["type"] = "string"
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test booleans
-    schema["properties"]["a"]["type"] = "boolean"
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = false
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test object
-    schema["properties"]["a"]["type"] = "object"
-    data["a"] = {}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test array
-    schema["properties"]["a"]["type"] = "array"
-    data["a"] = []
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test null
-    schema["properties"]["a"]["type"] = "null"
-    data["a"] = nil
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test any
-    schema["properties"]["a"]["type"] = "any"
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.2
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = 'string'
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data['a'] = true
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-
-    # Test a union type
-    schema["properties"]["a"]["type"] = ["integer","string"]
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = false
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+class JSONSchemaDraft1Test < Minitest::Test
+  def schema_version
+    :draft1
+  end
 
-    # Test a union type with schemas
-    schema["properties"]["a"]["type"] = [{ "type" => "string" }, {"type" => "object", "properties" => {"b" => {"type" => "integer"}}}]
+  def exclusive_minimum
+    { 'minimumCanEqual' => false }
+  end
 
-    data["a"] = "test"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+  def exclusive_maximum
+    { 'maximumCanEqual' => false }
+  end
 
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+  include ArrayValidation::ItemsTests
 
-    data["a"] = {"b" => 5}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+  include NumberValidation::MinMaxTests
 
-    data["a"] = {"b" => "taco"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-   end
+  include ObjectValidation::AdditionalPropertiesTests
 
+  include StringValidation::ValueTests
+  include StringValidation::FormatTests
+  include StringValidation::DateAndTimeFormatTests
 
+  include TypeValidation::SimpleTypeTests
+  include TypeValidation::AnyTypeTests
+  include TypeValidation::SchemaUnionTypeTests
 
   def test_optional
     # Set up the default datatype
@@ -174,9 +36,9 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     }
     data = {}
 
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
     data['a'] = "Hello"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     schema = {
       "properties" => {
@@ -185,237 +47,9 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     }
 
     data = {}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-  end
-
-
-
-  def test_minimum
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"minimum" => 5}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-
-    # Test an integer
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 4
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test a float
-    data["a"] = 5.0
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 4.9
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test a non-number
-    data["a"] = "a string"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test exclusiveMinimum
-    schema["properties"]["a"]["minimumCanEqual"] = false
-
-    data["a"] = 6
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test with float
-    data["a"] = 5.00000001
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.0
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-
-  def test_maximum
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"maximum" => 5}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-
-    # Test an integer
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 6
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test a float
-    data["a"] = 5.0
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.1
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test a non-number
-    data["a"] = "a string"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test exclusiveMinimum
-    schema["properties"]["a"]["maximumCanEqual"] = false
-
-    data["a"] = 4
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test with float
-    data["a"] = 4.9999999
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = 5.0
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-  def test_min_items
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"minItems" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test with an array
-    data["a"] = ["boo"]
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = []
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test with a non-array
-    data["a"] = "boo"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-
-  def test_max_items
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"maxItems" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test with an array
-    data["a"] = ["boo"]
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = ["boo","taco"]
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test with a non-array
-    data["a"] = "boo"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-  def test_pattern
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"pattern" => "\\d+ taco"}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test strings
-    data["a"] = "156 taco bell"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test a non-string
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = "taco"
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-  def test_min_length
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"minLength" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Try out strings
-    data["a"] = "t"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = ""
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Try out non-string
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-  def test_max_length
-    # Set up the default datatype
-    schema = {
-      "properties" => {
-        "a" => {"maxLength" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Try out strings
-    data["a"] = "t"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-
-    data["a"] = "tt"
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Try out non-string
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
   end
 
-
   def test_enum
     # Set up the default datatype
     schema = {
@@ -430,24 +64,24 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
     # Make sure all of the above are valid...
     data["a"] = 1
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     data["a"] = [1,2,3]
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     data["a"] = {"a" => "b"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     # Test something that doesn't exist
     data["a"] = 'taco'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
 
     # Try it without the key
     data = {}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
   end
 
 
@@ -464,22 +98,22 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
     }
 
     data["a"] = 3.35
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     data["a"] = 3.455
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
 
 
     schema["properties"]["a"]["maxDecimal"] = 0
 
     data["a"] = 4.0
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
 
     data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     data["a"] = 5
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
   end
 
 
@@ -498,225 +132,39 @@ class JSONSchemaDraft1Test < Test::Unit::TestCase
 
 
     data["a"] = 'string'
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
     data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
 
 
     schema["properties"]["a"]["disallow"] = ["integer","string"]
     data["a"] = 'string'
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
 
     data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
+    refute_valid schema, data
 
     data["a"] = false
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
+    assert_valid schema, data
 
   end
 
-
-
-  def test_additional_properties
-    # Test no additional properties allowed
-    schema = {
-      "properties" => {
-        "a" => { "type" => "integer" }
-      },
-      "additionalProperties" => false
-    }
-
-    data = {
-      "a" => 10
-    }
-
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data["b"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    # Test additional properties match a schema
-    schema["additionalProperties"] = { "type" => "string" }
-    data["b"] = "taco"
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data["b"] = 5
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-  def test_items
-    schema = {
-      "items" => { "type" => "integer" }
-    }
-
-    data = [1,2,4]
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = [1,2,"string"]
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-    schema = {
-      "items" => [
-        {"type" => "integer"},
-        {"type" => "string"}
-      ]
-    }
-
-    data = [1,"string"]
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = [1,"string",3]
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = ["string",1]
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-
-  end
-
-
-  def test_format_ipv4
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "ip-address"}}
-    }
-
-    data = {"a" => "1.1.1.1"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1.1.1"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1.1.1.300"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => 5}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1.1.1"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1.1.1.1b"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "b1.1.1.1"}
-  end
-
-
-  def test_format_ipv6
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "ipv6"}}
-    }
-
-    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1111:0:8888:0:0:0:eeee:ffff"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1111:2222:8888::eeee:ffff"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1111:2222:8888:99999:aaaa:cccc:eeee:ffff"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:gggg"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1111:2222::9999::cccc:eeee:ffff"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    assert(JSON::Validator.validate(schema, {"a" => "::1"}, :version => :draft1), 'validate with shortcut')
-    assert(!JSON::Validator.validate(schema, {"a" => "42"}, :version => :draft1), 'not validate a simple number')
-  end
-
-  def test_format_time
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "time"}}
-    }
-
-    data = {"a" => "12:00:00"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "12:00"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "12:00:60"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "12:60:00"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "24:00:00"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "0:00:00"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "-12:00:00"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "12:00:00b"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "12:00:00"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "12:00:00\nabc"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
-
-  def test_format_date
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "date"}}
-    }
-
-    data = {"a" => "2010-01-01"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-32"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "n2010-01-01"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-1-01"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-1"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01n"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01\nabc"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-  end
-
   def test_format_datetime
     schema = {
       "type" => "object",
       "properties" => { "a" => {"type" => "string", "format" => "date-time"}}
     }
 
-    data = {"a" => "2010-01-01T12:00:00Z"}
-    assert(JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-32T12:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-13-01T12:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01T24:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01T12:60:00Z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01T12:00:60Z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01T12:00:00z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-0112:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data,:version => :draft1))
-    data = {"a" => "2010-01-01T12:00:00Z\nabc"}
-    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"}
-    data2 = {"a" => nil}
-
-    schema = {
-      "type" => "object",
-      "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
-    }
-    assert(!JSON::Validator.validate(schema,data1,:version => :draft1))
-    assert(JSON::Validator.validate(schema,data2,:version => :draft1))
+    assert_valid schema, {"a" => "2010-01-01T12:00:00Z"}
+    refute_valid schema, {"a" => "2010-01-32T12:00:00Z"}
+    refute_valid schema, {"a" => "2010-13-01T12:00:00Z"}
+    refute_valid schema, {"a" => "2010-01-01T24:00:00Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:60:00Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:60Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00z"}
+    refute_valid schema, {"a" => "2010-01-0112:00:00Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00Z\nabc"}
   end
 
 end