json-schema 2.4.1 → 2.5.0

data/test/test_jsonschema_draft3.rb

@@ -1,8 +1,41 @@
 # encoding: utf-8
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
+
+class JSONSchemaDraft3Test < Minitest::Test
+  def schema_version
+    :draft3
+  end
+
+  def exclusive_minimum
+    { 'exclusiveMinimum' => true }
+  end
+
+  def exclusive_maximum
+    { 'exclusiveMaximum' => true }
+  end
+
+  def multiple_of
+    'divisibleBy'
+  end
+
+  include ArrayValidation::ItemsTests
+  include ArrayValidation::AdditionalItemsTests
+  include ArrayValidation::UniqueItemsTests
+
+  include NumberValidation::MinMaxTests
+  include NumberValidation::MultipleOfTests
+
+  include ObjectValidation::AdditionalPropertiesTests
+  include ObjectValidation::PatternPropertiesTests
+
+  include StringValidation::ValueTests
+  include StringValidation::FormatTests
+  include StringValidation::DateAndTimeFormatTests
+
+  include TypeValidation::SimpleTypeTests
+  include TypeValidation::AnyTypeTests
+  include TypeValidation::SchemaUnionTypeTests
 
-class JSONSchemaDraft3Test < Test::Unit::TestCase
   def test_types
     # Set up the default datatype
     schema = {
@@ -15,197 +48,6 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       "a" => nil
     }
 
-    # Test integers
-    schema["properties"]["a"]["type"] = "integer"
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'integer'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'integer'}, "hello"))
-
-    # Test numbers
-    schema["properties"]["a"]["type"] = "number"
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'number'}, 3))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'number'}, 3.14159265358979))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'number'}, "hello"))
-
-
-    # Test strings
-    schema["properties"]["a"]["type"] = "string"
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'string'}, 'hello'))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'string'}, 3.14159265358979))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'string'}, []))
-
-
-    # Test booleans
-    schema["properties"]["a"]["type"] = "boolean"
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(JSON::Validator.validate(schema,data))
-
-    data['a'] = false
-    assert(JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'boolean'}, true))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'boolean'}, false))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'boolean'}, nil))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'boolean'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'boolean'}, "hello"))
-
-
-    # Test object
-    schema["properties"]["a"]["type"] = "object"
-    data["a"] = {}
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'object'}, {'a' => true}))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'object'}, {}))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'object'}, []))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'object'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'object'}, "hello"))
-
-
-    # Test array
-    schema["properties"]["a"]["type"] = "array"
-    data["a"] = []
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'array'}, ['a']))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'array'}, []))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'array'}, {}))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'array'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'array'}, "hello"))
-
-
-    # Test null
-    schema["properties"]["a"]["type"] = "null"
-    data["a"] = nil
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'null'}, nil))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'null'}, false))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'null'}, []))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'null'}, "hello"))
-
-
-    # Test any
-    schema["properties"]["a"]["type"] = "any"
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.2
-    assert(JSON::Validator.validate(schema,data))
-
-    data['a'] = 'string'
-    assert(JSON::Validator.validate(schema,data))
-
-    data['a'] = true
-    assert(JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'any'}, true))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'any'}, nil))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'any'}, {}))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'any'}, 3))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => 'any'}, "hello"))
-
-
-    # Test a union type
-    schema["properties"]["a"]["type"] = ["integer","string"]
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = false
-    assert(!JSON::Validator.validate(schema,data))
-
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => ['string', 'null']}, "hello"))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-03/schema#",'type' => ['integer', 'object']}, "hello"))
-
-    # Test a union type with schemas
-    schema["properties"]["a"]["type"] = [{ "type" => "string" }, {"type" => "object", "properties" => {"b" => {"type" => "integer"}}}]
-
-    data["a"] = "test"
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    data["a"] = {"b" => 5}
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = {"b" => "taco"}
-    assert(!JSON::Validator.validate(schema,data))
-
     # Test an array of unioned-type objects that prevent additionalProperties
     schema["properties"]["a"] = {
       'type' => 'array',
@@ -224,7 +66,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     # This should actually pass, because this matches the first schema in the union
     data["a"] << {"c" => false}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
   def test_required
@@ -237,9 +79,9 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
     data = {}
 
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
     data['a'] = "Hello"
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
@@ -249,236 +91,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {}
-    assert(JSON::Validator.validate(schema,data))
-
-  end
-
-
-
-  def test_minimum
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"minimum" => 5}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-
-    # Test an integer
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 4
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test a float
-    data["a"] = 5.0
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 4.9
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test a non-number
-    data["a"] = "a string"
-    assert(JSON::Validator.validate(schema,data))
-
-    # Test exclusiveMinimum
-    schema["properties"]["a"]["exclusiveMinimum"] = true
-
-    data["a"] = 6
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with float
-    data["a"] = 5.00000001
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.0
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-
-  def test_maximum
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"maximum" => 5}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-
-    # Test an integer
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 6
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test a float
-    data["a"] = 5.0
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.1
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test a non-number
-    data["a"] = "a string"
-    assert(JSON::Validator.validate(schema,data))
-
-    # Test exclusiveMinimum
-    schema["properties"]["a"]["exclusiveMaximum"] = true
-
-    data["a"] = 4
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with float
-    data["a"] = 4.9999999
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5.0
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_min_items
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"minItems" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test with an array
-    data["a"] = ["boo"]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = []
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with a non-array
-    data["a"] = "boo"
-    assert(JSON::Validator.validate(schema,data))
-  end
-
-
-
-  def test_max_items
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"maxItems" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test with an array
-    data["a"] = ["boo"]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = ["boo","taco"]
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with a non-array
-    data["a"] = "boo"
-    assert(JSON::Validator.validate(schema,data))
-  end
-
-
-
-  def test_unique_items
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"uniqueItems" => true}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test with nulls
-    data["a"] = [nil,5]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [nil,nil]
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with booleans
-    data["a"] = [true,4]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [true,false]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [true,true]
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with numbers
-    data["a"] = [4,true]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [4,4.1]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [4,4]
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with strings
-    data["a"] = ['a',true]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = ['a','ab']
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = ['a','a']
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with arrays
-    data["a"] = [[1],true]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [[1,2],[1,3]]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [[1,2,3],[1,2,3]]
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test with objects
-    data["a"] = [{"a" => 1},true]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [{"a" => 1},{"a" => 2}]
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = [{"a" => 1, "b" => 2}, {"a" => 1, "b" => 2}]
-    assert(!JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
   def test_strict_properties
@@ -580,84 +193,6 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:strict => true))
   end
 
-  def test_pattern
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"pattern" => "\\d+ taco"}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Test strings
-    data["a"] = "156 taco bell"
-    assert(JSON::Validator.validate(schema,data))
-
-    # Test a non-string
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = "taco"
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_min_length
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"minLength" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Try out strings
-    data["a"] = "t"
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = ""
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Try out non-string
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_max_length
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"maxLength" => 1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    # Try out strings
-    data["a"] = "t"
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = "tt"
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Try out non-string
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
-  end
-
-
   def test_enum
     # Set up the default datatype
     schema = {
@@ -673,61 +208,26 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     # Make sure all of the above are valid...
     data["a"] = 1
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data["a"] = [1,2,3]
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data["a"] = {"a" => "b"}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     # Test something that doesn't exist
     data["a"] = 'taco'
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     # Try it without the key
     data = {}
-    assert(JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_divisible_by
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {"divisibleBy" => 1.1}
-      }
-    }
-
-    data = {
-      "a" => nil
-    }
-
-    data["a"] = 3.3
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 3.4
-    assert(!JSON::Validator.validate(schema,data))
-
-    schema["properties"]["a"]["divisibleBy"] = 2.0
-
-    data["a"] = 4.0
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 5
-    schema["properties"]["a"]["divisibleBy"] = 0
-    assert(!JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
-
-
   def test_disallow
     # Set up the default datatype
     schema = {
@@ -743,21 +243,21 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
 
     data["a"] = 'string'
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
 
     schema["properties"]["a"]["disallow"] = ["integer","string"]
     data["a"] = 'string'
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data["a"] = 5
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data["a"] = false
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
   end
 
@@ -782,131 +282,14 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       "a" => 10
     }
 
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
     assert(!JSON::Validator.validate(schema2,data))
 
     schema["extends"] = schema2
 
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
   end
 
-  def test_pattern_properties
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "patternProperties" => {
-        "\\d+ taco" => {"type" => "integer"}
-      }
-    }
-
-    data = {
-      "a" => true,
-      "1 taco" => 1,
-      "20 tacos" => 20
-    }
-
-    assert(JSON::Validator.validate(schema,data))
-    data["20 tacos"] = "string!"
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_additional_properties
-    # Test no additional properties allowed
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => { "type" => "integer" }
-      },
-      "additionalProperties" => false
-    }
-
-    data = {
-      "a" => 10
-    }
-
-    assert(JSON::Validator.validate(schema,data))
-    data["b"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Test additional properties match a schema
-    schema["additionalProperties"] = { "type" => "string" }
-    data["b"] = "taco"
-    assert(JSON::Validator.validate(schema,data))
-    data["b"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-
-    # Make sure this works with pattern properties set, too
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "patternProperties" => {
-        "\\d+ taco" => {"type" => "integer"}
-      },
-      "additionalProperties" => false
-    }
-
-    data = {
-      "5 tacos" => 5,
-      "20 tacos" => 20
-    }
-
-    assert(JSON::Validator.validate(schema,data))
-    data["b"] = 5
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_items
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "items" => { "type" => "integer" }
-    }
-
-    data = [1,2,4]
-    assert(JSON::Validator.validate(schema,data))
-    data = [1,2,"string"]
-    assert(!JSON::Validator.validate(schema,data))
-
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "items" => [
-        {"type" => "integer"},
-        {"type" => "string"}
-      ]
-    }
-
-    data = [1,"string"]
-    assert(JSON::Validator.validate(schema,data))
-    data = [1,"string",3]
-    assert(JSON::Validator.validate(schema,data))
-    data = ["string",1]
-    assert(!JSON::Validator.validate(schema,data))
-
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "items" => [
-        {"type" => "integer"},
-        {"type" => "string"}
-      ],
-      "additionalItems" => false
-    }
-
-    data = [1,"string"]
-    assert(JSON::Validator.validate(schema,data))
-    data = [1,"string",3]
-    assert(!JSON::Validator.validate(schema,data))
-
-    schema = {"$schema" => "http://json-schema.org/draft-03/schema#","items" => [{"type" => "integer"},{"type" => "string"}],"additionalItems" => {"type" => "integer"}}
-
-    data = [1,"string"]
-    assert(JSON::Validator.validate(schema,data))
-    data = [1,"string",3]
-    assert(JSON::Validator.validate(schema,data))
-    data = [1,"string","string"]
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
   def test_list_option
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
@@ -916,7 +299,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
 
     data = [{"a" => 1},{"a" => 2},{"a" => 3}]
     assert(JSON::Validator.validate(schema,data,:list => true))
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"a" => 1}
     assert(!JSON::Validator.validate(schema,data,:list => true))
@@ -933,110 +316,8 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       "properties" => { "a" => {"type" => "integer"}, "b" => {"$ref" => "#"}}
     }
 
-    data = {"a" => 5, "b" => {"b" => {"a" => 1}}}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => 5, "b" => {"b" => {"a" => 'taco'}}}
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_format_ipv4
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "ip-address"}}
-    }
-
-    data = {"a" => "1.1.1.1"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "1.1.1"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "1.1.1.300"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => 5}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "1.1.1"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "1.1.1.1b"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "b1.1.1.1"}
-  end
-
-
-  def test_format_ipv6
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/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))
-    data = {"a" => "1111:0:8888:0:0:0:eeee:ffff"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "1111:2222:8888::eeee:ffff"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "1111:2222:8888:99999:aaaa:cccc:eeee:ffff"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:gggg"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "1111:2222::9999::cccc:eeee:ffff"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "1111:2222:8888:9999:aaaa:cccc:eeee:ffff:bbbb"}
-    assert(!JSON::Validator.validate(schema,data))
-    assert(JSON::Validator.validate(schema, {"a" => "::1"}), 'validate with shortcut')
-    assert(!JSON::Validator.validate(schema, {"a" => "42"}), 'not validate a simple number')
-  end
-
-  def test_format_time
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/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))
-    data = {"a" => "12:00:00\nabc"}
-    assert(!JSON::Validator.validate(schema,data))
-  end
-
-
-  def test_format_date
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/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))
-    data = {"a" => "2010-01-01\nabc"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert_valid schema, {"a" => 5, "b" => {"b" => {"a" => 1}}}
+    refute_valid schema, {"a" => 5, "b" => {"b" => {"a" => 'taco'}}}
   end
 
   def test_format_datetime
@@ -1046,87 +327,36 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
       "properties" => { "a" => {"type" => "string", "format" => "date-time"}}
     }
 
-    data = {"a" => "2010-01-01T12:00:00Z"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00.1Z"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00,1Z"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-32T12:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-13-01T12:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T24:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:60:00Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:60Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-0112:00:00Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00.1Z\nabc"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert_valid schema, {"a" => "2010-01-01T12:00:00Z"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00.1Z"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00,1Z"}
+    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:00.1Z\nabc"}
 
     # test with a specific timezone
-    data = {"a" => "2010-01-01T12:00:00+01"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+01:00"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+01:30"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+0234"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+01:"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+0"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert_valid schema, {"a" => "2010-01-01T12:00:00+01"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00+01:00"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00+01:30"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00+0234"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00+01:"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00+0"}
     # do not allow mixing Z and specific timezone
-    data = {"a" => "2010-01-01T12:00:00Z+01"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+01Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+01:30Z"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+0Z"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, {"a" => "2010-01-01T12:00:00Z+01"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00+01Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00+01:30Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00+0Z"}
 
     # test without any timezone
-    data = {"a" => "2010-01-01T12:00:00"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00.12345"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00,12345"}
-    assert(JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00.12345"}
-    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"}
-    data2 = {"a" => nil}
-
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"type" => ["string","null"], "format" => "ip-address"}}
-    }
-    assert(!JSON::Validator.validate(schema,data1))
-    assert(JSON::Validator.validate(schema,data2))
+    assert_valid schema, {"a" => "2010-01-01T12:00:00"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00.12345"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00,12345"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00.12345"}
   end
 
   def test_format_uri
@@ -1154,13 +384,13 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {"a" => "taco"}
-    assert(!JSON::Validator.validate(schema,data))
+    assert(!JSON::Validator.validate(schema, data))
 
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
       "type" => "object"
     }
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
   def test_dependency
@@ -1177,9 +407,9 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {"a" => 1, "b" => 2}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
     data = {"a" => 1}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     schema = {
       "$schema" => "http://json-schema.org/draft-03/schema#",
@@ -1195,9 +425,9 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {"a" => 1, "c" => 2}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
     data = {"a" => 1, "b" => 2, "c" => 3}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
   def test_default
@@ -1211,7 +441,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {:b => 2}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
     assert_nil(data["a"])
     assert(JSON::Validator.validate(schema,data, :insert_defaults => true))
     assert_equal(42, data["a"])
@@ -1227,7 +457,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {:b => 2}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
     assert_nil(data["a"])
     assert(JSON::Validator.validate(schema,data, :insert_defaults => true))
     assert_equal(42, data["a"])
@@ -1243,7 +473,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {:b => 2}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
     assert_nil(data["a"])
     assert(!JSON::Validator.validate(schema,data, :insert_defaults => true))
     assert_nil(data["a"])
@@ -1259,7 +489,7 @@ class JSONSchemaDraft3Test < Test::Unit::TestCase
     }
 
     data = {:b => 2}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
     assert_nil(data["a"])
     assert(!JSON::Validator.validate(schema,data, :insert_defaults => true))
     assert_equal("42",data["a"])