json-schema 2.4.1 → 2.5.0

data/test/test_jsonschema_draft4.rb

@@ -1,195 +1,37 @@
 # encoding: utf-8
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/json-schema'
+require File.expand_path('../test_helper', __FILE__)
 
-class JSONSchemaDraft4Test < Test::Unit::TestCase
-  def test_types
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "properties" => {
-        "a" => {}
-      }
-    }
-    data = {
-      "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-04/schema#",'type' => 'integer'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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-04/schema#",'type' => 'number'}, 3))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'number'}, 3.14159265358979))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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-04/schema#",'type' => 'string'}, 'hello'))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'string'}, 3.14159265358979))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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-04/schema#",'type' => 'boolean'}, true))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'boolean'}, false))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'boolean'}, nil))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'boolean'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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-04/schema#",'type' => 'object'}, {'a' => true}))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'object'}, {}))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'object'}, []))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'object'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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-04/schema#",'type' => 'array'}, ['a']))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'array'}, []))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'array'}, {}))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'array'}, 3))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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-04/schema#",'type' => 'null'}, nil))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'null'}, false))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'null'}, []))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/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))
+class JSONSchemaDraft4Test < Minitest::Test
+  def schema_version
+    :draft4
+  end
 
-    data['a'] = 'string'
-    assert(JSON::Validator.validate(schema,data))
+  def exclusive_minimum
+    { 'exclusiveMinimum' => true }
+  end
 
-    data['a'] = true
-    assert(JSON::Validator.validate(schema,data))
+  def exclusive_maximum
+    { 'exclusiveMaximum' => true }
+  end
 
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'any'}, true))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'any'}, nil))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'any'}, {}))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'any'}, 3))
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => 'any'}, "hello"))
+  def ipv4_format
+    'ipv4'
+  end
 
+  include ArrayValidation::ItemsTests
+  include ArrayValidation::AdditionalItemsTests
+  include ArrayValidation::UniqueItemsTests
 
-    # Test a union type
-    schema["properties"]["a"]["type"] = ["integer","string"]
-    data["a"] = 5
-    assert(JSON::Validator.validate(schema,data))
+  include NumberValidation::MinMaxTests
+  include NumberValidation::MultipleOfTests
 
-    data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data))
+  include ObjectValidation::AdditionalPropertiesTests
+  include ObjectValidation::PatternPropertiesTests
 
-    data["a"] = false
-    assert(!JSON::Validator.validate(schema,data))
+  include StringValidation::ValueTests
+  include StringValidation::FormatTests
 
-    assert(JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => ['string', 'null']}, "hello"))
-    assert(!JSON::Validator.validate({"$schema" => "http://json-schema.org/draft-04/schema#",'type' => ['integer', 'object']}, "hello"))
-  end
+  include TypeValidation::SimpleTypeTests
 
   def test_required
     # Set up the default datatype
@@ -202,9 +44,9 @@ class JSONSchemaDraft4Test < 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-04/schema#",
@@ -214,207 +56,30 @@ class JSONSchemaDraft4Test < 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-04/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-04/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-04/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))
+    assert_valid schema, data
   end
 
-
-
-  def test_max_items
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/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_min_properties
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "minProperties" => 2,
-      "properties" => {
-      }
-    }
-
-    data = {"a" => nil}
-    assert(!JSON::Validator.validate(schema,data))
+    schema = { 'minProperties' => 2 }
 
-    data = {"a" => nil, "b" => nil}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, {'a' => 1, 'b' => 2}
+    assert_valid schema, {'a' => 1, 'b' => 2, 'c' => 3}
 
-    data = {"a" => nil, "b" => nil, "c" => nil}
-    assert(JSON::Validator.validate(schema,data))
+    refute_valid schema, {'a' => 1}
+    refute_valid schema, {}
   end
 
-
-
   def test_max_properties
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "maxProperties" => 2,
-      "properties" => {
-      }
-    }
+    schema = { 'maxProperties' => 2 }
 
-    data = {"a" => nil}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, {'a' => 1, 'b' => 2}
+    assert_valid schema, {'a' => 1}
+    assert_valid schema, {}
 
-    data = {"a" => nil, "b" => nil}
-    assert(JSON::Validator.validate(schema,data))
-
-    data = {"a" => nil, "b" => nil, "c" => nil}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, {'a' => 1, 'b' => 2, 'c' => 3}
   end
 
-    def test_strict_properties
+  def test_strict_properties
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
       "properties" => {
@@ -494,156 +159,6 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     assert(!JSON::Validator.validate(schema,data,:strict => true))
   end
 
-  def test_unique_items
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/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))
-  end
-
-
-  def test_pattern
-    # Set up the default datatype
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/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-04/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-04/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 = {
@@ -659,24 +174,24 @@ class JSONSchemaDraft4Test < 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))
+    assert_valid schema, data
   end
 
   def test_enum_with_schema_validation
@@ -696,177 +211,115 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     assert(JSON::Validator.validate(schema,data,:validate_schema => true))
   end
 
-
-  def test_multiple_of
-    # Set up the default datatype
+  def test_list_option
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
-      "properties" => {
-        "a" => {"multipleOf" => 1.1}
-      }
-    }
-
-    data = {
-      "a" => nil
+      "type" => "object",
+      "required" => ["a"],
+      "properties" => { "a" => {"type" => "integer"} }
     }
 
-    data["a"] = 3.3
-    assert(JSON::Validator.validate(schema,data))
-
-    data["a"] = 3.4
-    assert(!JSON::Validator.validate(schema,data))
-
-    schema["properties"]["a"]["multipleOf"] = 2.0
-
-    data["a"] = 4.0
-    assert(JSON::Validator.validate(schema,data))
+    data = [{"a" => 1},{"a" => 2},{"a" => 3}]
+    assert(JSON::Validator.validate(schema,data,:list => true))
+    refute_valid schema, data
 
-    data["a"] = 'boo'
-    assert(JSON::Validator.validate(schema,data))
+    data = {"a" => 1}
+    assert(!JSON::Validator.validate(schema,data,:list => true))
 
-    data["a"] = 5
-    schema["properties"]["a"]["multipleOf"] = 0
-    assert(!JSON::Validator.validate(schema,data))
+    data = [{"a" => 1},{"b" => 2},{"a" => 3}]
+    assert(!JSON::Validator.validate(schema,data,:list => true))
   end
 
-
-  def test_pattern_properties
-    # Set up the default datatype
+  def test_default_with_strict_and_anyof
     schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "patternProperties" => {
-        "\\d+ taco" => {"type" => "integer"}
-      }
+      "anyOf" => [
+        {
+          "type" => "object",
+          "properties" => {
+            "foo" => {
+              "enum" => ["view", "search"],
+              "default" => "view"
+            }
+          }
+        },
+        {
+          "type" => "object",
+          "properties" => {
+            "bar" => {
+              "type" => "string"
+            }
+          }
+        }
+      ]
     }
 
     data = {
-      "a" => true,
-      "1 taco" => 1,
-      "20 tacos" => 20
+      "bar" => "baz"
     }
 
-    assert(JSON::Validator.validate(schema,data))
-    data["20 tacos"] = "string!"
-    assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema, data, :insert_defaults => true, :strict => true))
   end
 
-
-  def test_additional_properties
-    # Test no additional properties allowed
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/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
+  def test_default_with_anyof
     schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "patternProperties" => {
-        "\\d+ taco" => {"type" => "integer"}
-      },
-      "additionalProperties" => false
+      "anyOf" => [
+        {
+          "type" => "object",
+          "properties" => {
+            "foo" => {
+              "enum" => ["view", "search"],
+              "default" => "view"
+            }
+          }
+        },
+        {
+          "type" => "object",
+          "properties" => {
+            "bar" => {
+              "type" => "string"
+            }
+          }
+        }
+      ]
     }
 
-    data = {
-      "5 tacos" => 5,
-      "20 tacos" => 20
-    }
+    data = {}
 
-    assert(JSON::Validator.validate(schema,data))
-    data["b"] = 5
-    assert(!JSON::Validator.validate(schema,data))
+    assert(JSON::Validator.validate(schema, data, :insert_defaults => true, :strict => true))
+    assert(data['foo'] == 'view')
   end
 
-
-  def test_items
+  def test_default_with_strict_and_oneof
     schema = {
-      "$schema" => "http://json-schema.org/draft-04/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-04/schema#",
-      "items" => [
-        {"type" => "integer"},
-        {"type" => "string"}
+      "oneOf" => [
+        {
+          "type" => "object",
+          "properties" => {
+            "bar" => {
+              "type" => "string"
+            }
+          }
+        },
+        {
+          "type" => "object",
+          "properties" => {
+            "foo" => {
+              "enum" => ["view", "search"],
+              "default" => "view"
+            }
+          }
+        }
       ]
     }
 
-    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-04/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-04/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-04/schema#",
-      "type" => "object",
-      "required" => ["a"],
-      "properties" => { "a" => {"type" => "integer"} }
+    data = {
+      "bar" => "baz"
     }
 
-    data = [{"a" => 1},{"a" => 2},{"a" => 3}]
-    assert(JSON::Validator.validate(schema,data,:list => true))
-    assert(!JSON::Validator.validate(schema,data))
-
-    data = {"a" => 1}
-    assert(!JSON::Validator.validate(schema,data,:list => true))
-
-    data = [{"a" => 1},{"b" => 2},{"a" => 3}]
-    assert(!JSON::Validator.validate(schema,data,:list => true))
+    assert(JSON::Validator.validate(schema, data, :insert_defaults => true, :strict => true))
+    assert(!data.key?('foo'))
   end
 
-
   def test_self_reference
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
@@ -874,62 +327,10 @@ class JSONSchemaDraft4Test < 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-04/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"type" => "string", "format" => "ipv4"}}
-    }
-
-    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-04/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')
+    assert_valid schema, {"a" => 5, "b" => {"b" => {"a" => 1}}}
+    refute_valid schema, {"a" => 5, "b" => {"b" => {"a" => 'taco'}}}
   end
 
-
   def test_format_datetime
     schema = {
       "$schema" => "http://json-schema.org/draft-04/schema#",
@@ -937,30 +338,18 @@ class JSONSchemaDraft4Test < 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-01T12:00:00+0000"}
-    assert(!JSON::Validator.validate(schema,data))
-    data = {"a" => "2010-01-01T12:00:00+00:00"}
-    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))
+    assert_valid schema, {"a" => "2010-01-01T12:00:00Z"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00.1Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00,1Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:00:00+0000"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00+00:00"}
+    refute_valid schema, {"a" => "2010-01-32T12:00:00Z"}
+    refute_valid schema, {"a" => "2010-13-01T12:00:00Z"}
+    assert_valid schema, {"a" => "2010-01-01T24:00:00Z"}
+    refute_valid schema, {"a" => "2010-01-01T12:60:00Z"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:60Z"}
+    assert_valid schema, {"a" => "2010-01-01T12:00:00z"}
+    refute_valid schema, {"a" => "2010-01-0112:00:00Z"}
   end
 
   def test_format_uri
@@ -969,9 +358,9 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     data3 = {"a" => "http://ja.wikipedia.org/wiki/メインページ"}
 
     schema = {
-        "$schema" => "http://json-schema.org/draft-04/schema#",
-        "type" => "object",
-        "properties" => { "a" => {"type" => "string", "format" => "uri"}}
+      "$schema" => "http://json-schema.org/draft-04/schema#",
+      "type" => "object",
+      "properties" => { "a" => {"type" => "string", "format" => "uri"}}
     }
 
     assert(JSON::Validator.validate(schema,data1))
@@ -979,34 +368,6 @@ 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"}
-    data2 = {"a" => nil}
-
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "properties" => { "a" => {"type" => ["string","null"], "format" => "ipv4"}}
-    }
-    assert(!JSON::Validator.validate(schema,data1))
-    assert(JSON::Validator.validate(schema,data2))
-  end
-
-
-
   def test_schema
     schema = {
       "$schema" => "http://json-schema.org/THIS-IS-NOT-A-SCHEMA",
@@ -1020,7 +381,7 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
       "$schema" => "http://json-schema.org/draft-04/schema#",
       "type" => "object"
     }
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
   def test_dependency
@@ -1037,9 +398,9 @@ class JSONSchemaDraft4Test < 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-04/schema#",
@@ -1055,9 +416,9 @@ class JSONSchemaDraft4Test < 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_schema_dependency
@@ -1097,7 +458,7 @@ class JSONSchemaDraft4Test < 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"])
@@ -1114,7 +475,7 @@ class JSONSchemaDraft4Test < 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"])
@@ -1131,7 +492,7 @@ class JSONSchemaDraft4Test < 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"])
@@ -1147,7 +508,7 @@ class JSONSchemaDraft4Test < 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"])
@@ -1171,16 +532,16 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     }
 
     data = {"a" => "hello", "b" => 5}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => "hello"}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => "hello", "b" => "taco"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"b" => 5}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
   end
 
 
@@ -1199,19 +560,19 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     }
 
     data = {"a" => "hello", "b" => 5}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => "hello"}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => "hello", "b" => "taco"}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"b" => 5}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => 5, "b" => "taco"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
   end
 
 
@@ -1230,20 +591,20 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     }
 
     data = {"a" => "hello", "b" => 5}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     # This passes because b is not required, thus matches both schemas
     data = {"a" => "hello"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"a" => "hello", "b" => "taco"}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"b" => 5}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => 5, "b" => "taco"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
   end
 
 
@@ -1257,13 +618,13 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     }
 
     data = {"a" => 1}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => "hi!"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"a" => true}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     # Sub-schema not
     schema = {
@@ -1285,19 +646,19 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     }
 
     data = {"a" => 1}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = {"a" => "hi!"}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"a" => true}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"a" => {"b" => true}}
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
 
     data = {"a" => {"b" => 5}}
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
   end
 
   def test_not_fully_validate
@@ -1333,10 +694,10 @@ class JSONSchemaDraft4Test < Test::Unit::TestCase
     }
 
     data = [1,2,3]
-    assert(JSON::Validator.validate(schema,data))
+    assert_valid schema, data
 
     data = [-1,2,3]
-    assert(!JSON::Validator.validate(schema,data))
+    refute_valid schema, data
   end
 end