json-schema 2.5.1 → 2.5.2

data/test/test_definition.rb

@@ -1,15 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class RelativeDefinitionTest < Minitest::Test
-
-  def test_definition_schema
-    assert_valid schema_fixture_path('definition_schema.json'), {"a" => 5}
-  end
-
-  def test_relative_definition
-    schema = schema_fixture_path('relative_definition_schema.json')
-    assert_valid schema, {"a" => 5}
-    refute_valid schema, {"a" => "foo"}
-  end
-
-end

data/test/test_extended_schema.rb

@@ -1,62 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class BitwiseAndAttribute < JSON::Schema::Attribute
-  def self.validate(current_schema, data, fragments, processor, validator, options = {})
-    return unless data.is_a?(Integer)
-
-    if data & current_schema.schema['bitwise-and'].to_i == 0
-      message = "The property '#{build_fragment(fragments)}' did not evaluate to true when bitwise-AND'd with #{current_schema.schema['bitwise-and']}"
-      validation_error(processor, message, fragments, current_schema, self, options[:record_errors])
-    end
-  end
-end
-
-class ExtendedSchema < JSON::Schema::Validator
-  def initialize
-    super
-    extend_schema_definition("http://json-schema.org/draft-03/schema#")
-    @attributes["bitwise-and"] = BitwiseAndAttribute
-    @uri = Addressable::URI.parse("http://test.com/test.json")
-  end
-
-  JSON::Validator.register_validator(self.new)
-end
-
-class TestExtendedSchema < Minitest::Test
-  def test_extended_schema_validation
-    schema = {
-      "$schema" => "http://test.com/test.json",
-      "properties" => {
-        "a" => {
-          "bitwise-and" => 1
-        },
-        "b" => {
-          "type" => "string"
-        }
-      }
-    }
-
-    assert_valid schema, {"a" => 1, "b" => "taco"}
-    refute_valid schema, {"a" => 0, "b" => "taco"}
-    refute_valid schema, {"a" => 1, "b" => 5}
-  end
-
-  def test_unextended_schema
-    # Verify that using the original schema disregards the `bitwise-and` property
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "properties" => {
-        "a" => {
-          "bitwise-and" => 1
-        },
-        "b" => {
-          "type" => "string"
-        }
-      }
-    }
-
-    assert_valid schema, {"a" => 0, "b" => "taco"}
-    assert_valid schema, {"a" => 1, "b" => "taco"}
-    refute_valid schema, {"a" => 1, "b" => 5}
-  end
-end

data/test/test_extends_and_additionalProperties.rb

@@ -1,52 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class ExtendsNestedTest < Minitest::Test
-
-  def assert_validity(valid, schema_name, data, msg)
-    msg = "Schema should be #{valid ? :valid : :invalid}.\n(#{schema_name}) #{msg}"
-    schema = schema_fixture_path("#{schema_name}.schema.json")
-    errors = JSON::Validator.fully_validate(schema, data)
-
-    if valid
-      assert_equal([], errors, msg)
-    else
-      refute_equal([], errors, msg)
-    end
-  end
-
-  %w[
-    extends_and_additionalProperties-1-filename
-    extends_and_additionalProperties-1-ref
-    extends_and_additionalProperties-2-filename
-    extends_and_additionalProperties-2-ref
-  ].each do |schema_name|
-    test_prefix = 'test_' + schema_name.gsub('-','_')
-
-    class_eval <<-EOB
-      def #{test_prefix}_valid_outer
-        assert_validity true, '#{schema_name}', {"outerC"=>true}, "Outer defn is broken, maybe the outer extends overrode it"
-      end
-
-      def #{test_prefix}_valid_outer_extended
-        assert_validity true, '#{schema_name}', {"innerA"=>true}, "Extends at the root level isn't working"
-      end
-
-      def #{test_prefix}_valid_inner
-        assert_validity true, '#{schema_name}', {"outerB"=>[{"innerA"=>true}]}, "Extends isn't working in the array element defn"
-      end
-
-      def #{test_prefix}_invalid_inner
-        assert_validity false, '#{schema_name}', {"outerB"=>[{"whaaaaat"=>true}]}, "Array element defn allowing anything when it should only allow what's in inner.schema"
-      end
-    EOB
-
-    if schema_name['extends_and_additionalProperties-1']
-      class_eval <<-EOB
-        def #{test_prefix}_invalid_outer
-          assert_validity false, '#{schema_name}', {"whaaaaat"=>true}, "Outer defn allowing anything when it shouldn't"
-        end
-      EOB
-    end
-
-  end
-end

data/test/test_files_v3.rb

@@ -1,43 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class JSONSchemaTest < Minitest::Test
-
-  #
-  # These tests are ONLY run if there is an appropriate JSON backend parser available
-  #
-
-  def test_schema_from_file
-    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_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_valid schema, %Q({"a": 5}), :json => true
-      refute_valid schema, %Q({"a": "poop"}), :json => true
-    end
-  end
-
-  def test_both_from_file
-    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
-    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
-    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,30 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class FragmentResolution < Minitest::Test
-  def test_fragment_resolution
-    schema = {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "required" => ["a"],
-      "properties" => {
-        "a" => {
-          "type" => "object",
-          "properties" => {
-            "b" => {"type" => "integer" }
-          }
-        }
-      }
-    }
-
-    data = {"b" => 5}
-    refute_valid schema, data
-    assert_valid schema, data, :fragment => "#/properties/a"
-
-    assert_raises JSON::Schema::SchemaError do
-      JSON::Validator.validate!(schema,data,:fragment => "/properties/a")
-    end
-
-    assert_raises JSON::Schema::SchemaError do
-      JSON::Validator.validate!(schema,data,:fragment => "#/properties/b")
-    end
-  end
-end

data/test/test_fragment_validation_with_ref.rb

@@ -1,34 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class FragmentValidationWithRef < Minitest::Test
-  def whole_schema
-    {
-      "$schema" => "http://json-schema.org/draft-04/schema#",
-      "type" => "object",
-      "definitions" => {
-        "post" => {
-          "type" => "object",
-          "properties" => {
-            "content" => {
-              "type" => "string"
-            },
-            "author" => {
-              "type" => "string"
-            }
-          }
-        },
-        "posts" => {
-          "type" => "array",
-          "items" => {
-            "$ref" => "#/definitions/post"
-          }
-        }
-      }
-    }
-  end
-
-  def test_validation_of_fragment
-    data = [{"content" => "ohai", "author" => "Bob"}]
-    assert_valid whole_schema, data, :fragment => "#/definitions/posts"
-  end
-end

data/test/test_full_validation.rb

@@ -1,208 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class JSONFullValidation < Minitest::Test
-    
-  def test_full_validation
-    data = {"b" => {"a" => 5}}
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "required" => true
-        }
-      }
-    }
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.empty?)
-
-    data = {"c" => 5}
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "required" => true
-        },
-        "c" => {
-          "type" => "string"
-        }
-      }
-    }
-
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.length == 2)
-  end
-  
-  def test_full_validation_with_union_types
-    data = {"b" => 5}
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "type" => ["null","integer"]
-        }
-      }
-    }
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.empty?)
-    
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "type" => ["integer","null"]
-        }
-      }
-    }
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.empty?)
-    
-    data = {"b" => "a string"}
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.length == 1)
-   
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "type" => [
-            {
-              "type" => "object",
-              "properties" => {
-                "c" => {"type" => "string"}
-              }
-            },
-            {
-              "type" => "object",
-              "properties" => {
-                "d" => {"type" => "integer"}
-              }
-            }
-          ]
-        }
-      }
-    }
-    
-    data = {"b" => {"c" => "taco"}}
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.empty?)
-    
-    data = {"b" => {"d" => 6}}
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.empty?)
-    
-    data = {"b" => {"c" => 6, "d" => "OH GOD"}}
-    
-    errors = JSON::Validator.fully_validate(schema,data)
-    assert(errors.length == 1)
-  end
-  
-  
-  def test_full_validation_with_object_errors
-    data = {"b" => {"a" => 5}}
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "required" => true
-        }
-      }
-    }
-    
-    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
-    assert(errors.empty?)
-
-    data = {"c" => 5}
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "b" => {
-          "required" => true
-        },
-        "c" => {
-          "type" => "string"
-        }
-      }
-    }
-
-    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
-    assert(errors.length == 2)
-    assert(errors[0][:failed_attribute] == "Properties")
-    assert(errors[0][:fragment] == "#/")
-    assert(errors[1][:failed_attribute] == "Type")
-    assert(errors[1][:fragment] == "#/c")
-  end
-  
-  def test_full_validation_with_nested_required_properties
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "x" => {
-          "required" => true,
-          "type" => "object",
-          "properties" => {
-            "a" => {"type"=>"integer","required"=>true},
-            "b" => {"type"=>"integer","required"=>true},
-            "c" => {"type"=>"integer","required"=>false},
-            "d" => {"type"=>"integer","required"=>false},
-            "e" => {"type"=>"integer","required"=>false},
-          }
-        }
-      }
-    }
-    data = {"x" => {"a"=>5, "d"=>5, "e"=>"what?"}}
-    
-    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
-    assert_equal 2, errors.length
-    assert_equal '#/x', errors[0][:fragment]
-    assert_equal 'Properties', errors[0][:failed_attribute]
-    assert_equal '#/x/e', errors[1][:fragment]
-    assert_equal 'Type', errors[1][:failed_attribute]
-  end
-  
-  def test_full_validation_with_nested_required_propertiesin_array
-    schema = {
-      "$schema" => "http://json-schema.org/draft-03/schema#",
-      "type" => "object",
-      "properties" => {
-        "x" => {
-          "required" => true,
-          "type" => "array",
-          "items" => {
-            "type" => "object",
-            "properties" => {
-              "a" => {"type"=>"integer","required"=>true},
-              "b" => {"type"=>"integer","required"=>true},
-              "c" => {"type"=>"integer","required"=>false},
-              "d" => {"type"=>"integer","required"=>false},
-              "e" => {"type"=>"integer","required"=>false},
-            }
-          }
-        }
-      }
-    }
-    missing_b= {"a"=>5}
-    e_is_wrong_type= {"a"=>5,"b"=>5,"e"=>"what?"}
-    data = {"x" => [missing_b, e_is_wrong_type]}
-    
-    errors = JSON::Validator.fully_validate(schema,data,:errors_as_objects => true)
-    assert_equal 2, errors.length
-    assert_equal '#/x/0', errors[0][:fragment]
-    assert_equal 'Properties', errors[0][:failed_attribute]
-    assert_equal '#/x/1/e', errors[1][:fragment]
-    assert_equal 'Type', errors[1][:failed_attribute]
-  end
-end