avro-salsify-fork 1.9.0.3 → 1.9.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abbc9eb9ffc71e2b5be94e8371a6dc343fc22fb9
-  data.tar.gz: e4579b146b036580b5700699accecd3bbb58c835
+  metadata.gz: 4148d1a482eea909deae7631c18e93db4a7907c2
+  data.tar.gz: 70e111ad5d85ee5ca788b8385fed629d4f37fb3b
 SHA512:
-  metadata.gz: 8e797be1c562aeacfa9c449d2c6fc32f51fc3984653288b9937ff38c78ad42d17d9e578d4b73bbaaa8c5faba1db822afab8d9a5df76652364fe4d0b2a93ad40c
-  data.tar.gz: 35b17279b334db0b08d9679870b4059a7d8e87d033a6ca3d97a33415914b00b0a4c0f3ad445a74cba4ea8f0c65c142da74f670d2287cad8670171b43bd37769e
+  metadata.gz: e85db5cae3501913da2497112689d8fa433bf1d48d7f937842b0927deda3d55eaf9c4beb0b26b274cb2d8fac79bdfc820e5e343ec774ddc0a14d508dca7a8105
+  data.tar.gz: bbe69d3e6679d4f2c20aea2ca4dc09d63f30b1a75dd40de60b390e500f272a70c7aa34d904f83479965c730c40bdab61846eadbf5ff3f46bceb260440665c912

data/Manifest

@@ -14,6 +14,7 @@ lib/avro/protocol.rb
 lib/avro/schema.rb
 lib/avro/schema_compatibility.rb
 lib/avro/schema_normalization.rb
+lib/avro/schema_validator.rb
 test/case_finder.rb
 test/random_data.rb
 test/sample_ipc_client.rb
@@ -29,5 +30,6 @@ test/test_protocol.rb
 test/test_schema.rb
 test/test_schema_compatibility.rb
 test/test_schema_normalization.rb
+test/test_schema_validator.rb
 test/test_socket_transport.rb
 test/tool.rb

data/Rakefile

@@ -16,7 +16,7 @@
 
 require 'rubygems'
 require 'echoe'
-VERSION = '1.9.0.3'
+VERSION = '1.9.0.4'
 Echoe.new('avro-salsify-fork', VERSION) do |p|
   p.author = "Apache Software Foundation / Salsify Engineering"
   p.email = "engineering@salsify.com"

data/avro-salsify-fork.gemspec

@@ -1,25 +1,25 @@
 # -*- encoding: utf-8 -*-
-# stub: avro-salsify-fork 1.9.0.3 ruby lib
+# stub: avro-salsify-fork 1.9.0.4 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "avro-salsify-fork".freeze
-  s.version = "1.9.0.3"
+  s.version = "1.9.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Apache Software Foundation / Salsify Engineering".freeze]
-  s.date = "2016-12-17"
+  s.date = "2017-01-30"
   s.description = "Avro is a data serialization and RPC format.\nThis release contains the changes submitted in https://github.com/apache/avro/pull/116\nto support logical types in the Ruby gem.".freeze
   s.email = "engineering@salsify.com".freeze
-  s.extra_rdoc_files = ["CHANGELOG".freeze, "LICENSE".freeze, "lib/avro.rb".freeze, "lib/avro/data_file.rb".freeze, "lib/avro/io.rb".freeze, "lib/avro/ipc.rb".freeze, "lib/avro/logical_types.rb".freeze, "lib/avro/protocol.rb".freeze, "lib/avro/schema.rb".freeze, "lib/avro/schema_compatibility.rb".freeze, "lib/avro/schema_normalization.rb".freeze]
-  s.files = ["CHANGELOG".freeze, "LICENSE".freeze, "Manifest".freeze, "NOTICE".freeze, "Rakefile".freeze, "avro-salsify-fork.gemspec".freeze, "avro.gemspec".freeze, "interop/test_interop.rb".freeze, "lib/avro.rb".freeze, "lib/avro/data_file.rb".freeze, "lib/avro/io.rb".freeze, "lib/avro/ipc.rb".freeze, "lib/avro/logical_types.rb".freeze, "lib/avro/protocol.rb".freeze, "lib/avro/schema.rb".freeze, "lib/avro/schema_compatibility.rb".freeze, "lib/avro/schema_normalization.rb".freeze, "test/case_finder.rb".freeze, "test/random_data.rb".freeze, "test/sample_ipc_client.rb".freeze, "test/sample_ipc_http_client.rb".freeze, "test/sample_ipc_http_server.rb".freeze, "test/sample_ipc_server.rb".freeze, "test/test_datafile.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_help.rb".freeze, "test/test_io.rb".freeze, "test/test_logical_types.rb".freeze, "test/test_protocol.rb".freeze, "test/test_schema.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_socket_transport.rb".freeze, "test/tool.rb".freeze]
+  s.extra_rdoc_files = ["CHANGELOG".freeze, "LICENSE".freeze, "lib/avro.rb".freeze, "lib/avro/data_file.rb".freeze, "lib/avro/io.rb".freeze, "lib/avro/ipc.rb".freeze, "lib/avro/logical_types.rb".freeze, "lib/avro/protocol.rb".freeze, "lib/avro/schema.rb".freeze, "lib/avro/schema_compatibility.rb".freeze, "lib/avro/schema_normalization.rb".freeze, "lib/avro/schema_validator.rb".freeze]
+  s.files = ["CHANGELOG".freeze, "LICENSE".freeze, "Manifest".freeze, "NOTICE".freeze, "Rakefile".freeze, "avro-salsify-fork.gemspec".freeze, "avro.gemspec".freeze, "interop/test_interop.rb".freeze, "lib/avro.rb".freeze, "lib/avro/data_file.rb".freeze, "lib/avro/io.rb".freeze, "lib/avro/ipc.rb".freeze, "lib/avro/logical_types.rb".freeze, "lib/avro/protocol.rb".freeze, "lib/avro/schema.rb".freeze, "lib/avro/schema_compatibility.rb".freeze, "lib/avro/schema_normalization.rb".freeze, "lib/avro/schema_validator.rb".freeze, "test/case_finder.rb".freeze, "test/random_data.rb".freeze, "test/sample_ipc_client.rb".freeze, "test/sample_ipc_http_client.rb".freeze, "test/sample_ipc_http_server.rb".freeze, "test/sample_ipc_server.rb".freeze, "test/test_datafile.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_help.rb".freeze, "test/test_io.rb".freeze, "test/test_logical_types.rb".freeze, "test/test_protocol.rb".freeze, "test/test_schema.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_schema_validator.rb".freeze, "test/test_socket_transport.rb".freeze, "test/tool.rb".freeze]
   s.homepage = "https://github.com/salsify/avro".freeze
   s.licenses = ["Apache License 2.0 (Apache-2.0)".freeze]
   s.rdoc_options = ["--line-numbers".freeze, "--title".freeze, "Avro-salsify-fork".freeze]
   s.rubyforge_project = "avro-salsify-fork".freeze
-  s.rubygems_version = "2.6.6".freeze
+  s.rubygems_version = "2.6.8".freeze
   s.summary = "Apache Avro for Ruby with logical types patch".freeze
-  s.test_files = ["test/test_datafile.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_help.rb".freeze, "test/test_io.rb".freeze, "test/test_logical_types.rb".freeze, "test/test_protocol.rb".freeze, "test/test_schema.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_socket_transport.rb".freeze]
+  s.test_files = ["test/test_datafile.rb".freeze, "test/test_fingerprints.rb".freeze, "test/test_help.rb".freeze, "test/test_io.rb".freeze, "test/test_logical_types.rb".freeze, "test/test_protocol.rb".freeze, "test/test_schema.rb".freeze, "test/test_schema_compatibility.rb".freeze, "test/test_schema_normalization.rb".freeze, "test/test_schema_validator.rb".freeze, "test/test_socket_transport.rb".freeze]
 
   if s.respond_to? :specification_version then
     s.specification_version = 4

data/lib/avro.rb

@@ -40,4 +40,5 @@ require 'avro/data_file'
 require 'avro/protocol'
 require 'avro/ipc'
 require 'avro/schema_normalization'
+require 'avro/schema_validator'
 require 'avro/schema_compatibility'

data/lib/avro/schema.rb

@@ -95,45 +95,10 @@ module Avro
 
     # Determine if a ruby datum is an instance of a schema
     def self.validate(expected_schema, logical_datum, encoded = false)
-      datum = if encoded
-                logical_datum
-              else
-                expected_schema.type_adapter.encode(logical_datum) rescue nil
-              end
-
-      case expected_schema.type_sym
-      when :null
-        datum.nil?
-      when :boolean
-        datum == true || datum == false
-      when :string, :bytes
-        datum.is_a? String
-      when :int
-        (datum.is_a?(Fixnum) || datum.is_a?(Bignum)) &&
-            (INT_MIN_VALUE <= datum) && (datum <= INT_MAX_VALUE)
-      when :long
-        (datum.is_a?(Fixnum) || datum.is_a?(Bignum)) &&
-            (LONG_MIN_VALUE <= datum) && (datum <= LONG_MAX_VALUE)
-      when :float, :double
-        datum.is_a?(Float) || datum.is_a?(Fixnum) || datum.is_a?(Bignum)
-      when :fixed
-        datum.is_a?(String) && datum.bytesize == expected_schema.size
-      when :enum
-        expected_schema.symbols.include? datum
-      when :array
-        datum.is_a?(Array) &&
-          datum.all?{|d| validate(expected_schema.items, d) }
-      when :map
-          datum.keys.all?{|k| k.is_a? String } &&
-          datum.values.all?{|v| validate(expected_schema.values, v) }
-      when :union
-        expected_schema.schemas.any?{|s| validate(s, datum) }
-      when :record, :error, :request
-        datum.is_a?(Hash) &&
-          expected_schema.fields.all?{|f| validate(f.type, datum[f.name]) }
-      else
-        raise "you suck #{expected_schema.inspect} is not allowed."
-      end
+      SchemaValidator.validate!(expected_schema, logical_datum, encoded)
+      true
+    rescue SchemaValidator::ValidationError
+      false
     end
 
     def initialize(type, logical_type=nil)

data/lib/avro/schema_validator.rb

@@ -0,0 +1,194 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Avro
+  class SchemaValidator
+    ROOT_IDENTIFIER = '.'.freeze
+    PATH_SEPARATOR = '.'.freeze
+    INT_RANGE = Schema::INT_MIN_VALUE..Schema::INT_MAX_VALUE
+    LONG_RANGE = Schema::LONG_MIN_VALUE..Schema::LONG_MAX_VALUE
+    COMPLEX_TYPES = [:array, :error, :map, :record, :request]
+
+    class Result
+      attr_reader :errors
+
+      def initialize
+        @errors = []
+      end
+
+      def <<(error)
+        @errors << error
+      end
+
+      def add_error(path, message)
+        self << "at #{path} #{message}"
+      end
+
+      def failure?
+        @errors.any?
+      end
+
+      def to_s
+        errors.join("\n")
+      end
+    end
+
+    class ValidationError < StandardError
+      attr_reader :result
+
+      def initialize(result = Result.new)
+        @result = result
+        super
+      end
+
+      def to_s
+        result.to_s
+      end
+    end
+
+    TypeMismatchError = Class.new(ValidationError)
+
+    class << self
+      def validate!(expected_schema, logical_datum, encoded = false)
+        result = Result.new
+        validate_recursive(expected_schema, logical_datum, ROOT_IDENTIFIER, result, encoded)
+        fail ValidationError, result if result.failure?
+        result
+      end
+
+      private
+
+      def validate_recursive(expected_schema, logical_datum, path, result, encoded = false)
+        datum = if encoded
+                  logical_datum
+                else
+                  expected_schema.type_adapter.encode(logical_datum) rescue nil
+                end
+
+        case expected_schema.type_sym
+        when :null
+          fail TypeMismatchError unless datum.nil?
+        when :boolean
+          fail TypeMismatchError unless [true, false].include?(datum)
+        when :string, :bytes
+          fail TypeMismatchError unless datum.is_a?(String)
+        when :int
+          fail TypeMismatchError unless datum.is_a?(Fixnum) || datum.is_a?(Bignum)
+          result.add_error(path, "out of bound value #{datum}") unless INT_RANGE.cover?(datum)
+        when :long
+          fail TypeMismatchError unless datum.is_a?(Fixnum) || datum.is_a?(Bignum)
+          result.add_error(path, "out of bound value #{datum}") unless LONG_RANGE.cover?(datum)
+        when :float, :double
+          fail TypeMismatchError unless [Float, Fixnum, Bignum].any?(&datum.method(:is_a?))
+        when :fixed
+          if datum.is_a? String
+            message = "expected fixed with size #{expected_schema.size}, got \"#{datum}\" with size #{datum.size}"
+            result.add_error(path, message) unless datum.bytesize == expected_schema.size
+          else
+            result.add_error(path, "expected fixed with size #{expected_schema.size}, got #{actual_value_message(datum)}")
+          end
+        when :enum
+          message = "expected enum with values #{expected_schema.symbols}, got #{actual_value_message(datum)}"
+          result.add_error(path, message) unless expected_schema.symbols.include?(datum)
+        when :array
+          validate_array(expected_schema, datum, path, result)
+        when :map
+          validate_map(expected_schema, datum, path, result)
+        when :union
+          validate_union(expected_schema, datum, path, result)
+        when :record, :error, :request
+          fail TypeMismatchError unless datum.is_a?(Hash)
+          expected_schema.fields.each do |field|
+            deeper_path = deeper_path_for_hash(field.name, path)
+            validate_recursive(field.type, datum[field.name], deeper_path, result)
+          end
+        else
+          fail "Unexpected schema type #{expected_schema.type_sym} #{expected_schema.inspect}"
+        end
+      rescue TypeMismatchError
+        result.add_error(path, "expected type #{expected_schema.type_sym}, got #{actual_value_message(datum)}")
+      end
+
+      def validate_array(expected_schema, datum, path, result)
+        fail TypeMismatchError unless datum.is_a?(Array)
+        datum.each_with_index do |d, i|
+          validate_recursive(expected_schema.items, d, path + "[#{i}]", result)
+        end
+      end
+
+      def validate_map(expected_schema, datum, path, result)
+        datum.keys.each do |k|
+          result.add_error(path, "unexpected key type '#{ruby_to_avro_type(k.class)}' in map") unless k.is_a?(String)
+        end
+        datum.each do |k, v|
+          deeper_path = deeper_path_for_hash(k, path)
+          validate_recursive(expected_schema.values, v, deeper_path, result)
+        end
+      end
+
+      def validate_union(expected_schema, datum, path, result)
+        if expected_schema.schemas.size == 1
+          validate_recursive(expected_schema.schemas.first, datum, path, result)
+          return
+        end
+        types_and_results = validate_possible_types(datum, expected_schema, path)
+        failures, successes = types_and_results.partition { |r| r[:result].failure? }
+        return if successes.any?
+        complex_type_failed = failures.detect { |r| COMPLEX_TYPES.include?(r[:type]) }
+        if complex_type_failed
+          complex_type_failed[:result].errors.each { |error| result << error }
+        else
+          types = expected_schema.schemas.map { |s| "'#{s.type_sym}'" }.join(', ')
+          result.add_error(path, "expected union of [#{types}], got #{actual_value_message(datum)}")
+        end
+      end
+
+      def validate_possible_types(datum, expected_schema, path)
+        expected_schema.schemas.map do |schema|
+          result = Result.new
+          validate_recursive(schema, datum, path, result)
+          { type: schema.type_sym, result: result }
+        end
+      end
+
+      def deeper_path_for_hash(sub_key, path)
+        "#{path}#{PATH_SEPARATOR}#{sub_key}".squeeze(PATH_SEPARATOR)
+      end
+
+      private
+
+      def actual_value_message(value)
+        avro_type = ruby_to_avro_type(value.class)
+        if value.nil?
+          avro_type
+        else
+          "#{avro_type} with value #{value.inspect}"
+        end
+      end
+
+      def ruby_to_avro_type(ruby_class)
+        {
+          NilClass => 'null',
+          String => 'string',
+          Fixnum => 'int',
+          Bignum => 'long',
+          Float => 'float',
+          Hash => 'record'
+        }.fetch(ruby_class, ruby_class)
+      end
+    end
+  end
+end

data/test/test_schema.rb

@@ -27,13 +27,13 @@ class TestSchema < Test::Unit::TestCase
       ]}
     SCHEMA
 
-    assert_equal schema.name, 'OuterRecord'
-    assert_equal schema.fullname, 'OuterRecord'
+    assert_equal 'OuterRecord', schema.name
+    assert_equal 'OuterRecord', schema.fullname
     assert_nil schema.namespace
 
     schema.fields.each do |field|
-      assert_equal field.type.name, 'InnerRecord'
-      assert_equal field.type.fullname, 'InnerRecord'
+      assert_equal 'InnerRecord', field.type.name
+      assert_equal 'InnerRecord', field.type.fullname
       assert_nil field.type.namespace
     end
   end
@@ -50,13 +50,13 @@ class TestSchema < Test::Unit::TestCase
       ]}
     SCHEMA
 
-    assert_equal schema.name, 'OuterRecord'
-    assert_equal schema.fullname, 'my.name.space.OuterRecord'
-    assert_equal schema.namespace, 'my.name.space'
+    assert_equal 'OuterRecord', schema.name
+    assert_equal 'my.name.space.OuterRecord', schema.fullname
+    assert_equal 'my.name.space', schema.namespace
     schema.fields.each do |field|
-      assert_equal field.type.name, 'InnerRecord'
-      assert_equal field.type.fullname, 'my.name.space.InnerRecord'
-      assert_equal field.type.namespace, 'my.name.space'
+      assert_equal 'InnerRecord', field.type.name
+      assert_equal 'my.name.space.InnerRecord', field.type.fullname
+      assert_equal 'my.name.space', field.type.namespace
     end
   end
 
@@ -71,13 +71,13 @@ class TestSchema < Test::Unit::TestCase
       ]}
     SCHEMA
 
-    assert_equal schema.name, 'OuterRecord'
-    assert_equal schema.fullname, 'my.name.space.OuterRecord'
-    assert_equal schema.namespace, 'my.name.space'
+    assert_equal 'OuterRecord', schema.name
+    assert_equal 'my.name.space.OuterRecord', schema.fullname
+    assert_equal 'my.name.space', schema.namespace
     schema.fields.each do |field|
-      assert_equal field.type.name, 'InnerEnum'
-      assert_equal field.type.fullname, 'my.name.space.InnerEnum'
-      assert_equal field.type.namespace, 'my.name.space'
+      assert_equal 'InnerEnum', field.type.name
+      assert_equal 'my.name.space.InnerEnum', field.type.fullname
+      assert_equal 'my.name.space', field.type.namespace
     end
   end
 
@@ -96,18 +96,18 @@ class TestSchema < Test::Unit::TestCase
       ]}
     SCHEMA
 
-    assert_equal schema.name, 'OuterRecord'
-    assert_equal schema.fullname, 'outer.OuterRecord'
-    assert_equal schema.namespace, 'outer'
+    assert_equal 'OuterRecord', schema.name
+    assert_equal 'outer.OuterRecord', schema.fullname
+    assert_equal 'outer', schema.namespace
     middle = schema.fields.first.type
-    assert_equal middle.name, 'MiddleRecord'
-    assert_equal middle.fullname, 'middle.MiddleRecord'
-    assert_equal middle.namespace, 'middle'
+    assert_equal 'MiddleRecord', middle.name
+    assert_equal 'middle.MiddleRecord', middle.fullname
+    assert_equal 'middle', middle.namespace
     inner = middle.fields.first.type
-    assert_equal inner.name, 'InnerRecord'
-    assert_equal inner.fullname, 'middle.InnerRecord'
-    assert_equal inner.namespace, 'middle'
-    assert_equal inner.fields.first.type, middle
+    assert_equal 'InnerRecord', inner.name
+    assert_equal 'middle.InnerRecord', inner.fullname
+    assert_equal 'middle', inner.namespace
+    assert_equal middle, inner.fields.first.type
   end
 
   def test_to_avro_includes_namespaces
@@ -120,7 +120,7 @@ class TestSchema < Test::Unit::TestCase
       ]}
     SCHEMA
 
-    assert_equal schema.to_avro, {
+    assert_equal({
       'type' => 'record', 'name' => 'OuterRecord', 'namespace' => 'my.name.space',
       'fields' => [
         {'name' => 'definition', 'type' => {
@@ -129,7 +129,7 @@ class TestSchema < Test::Unit::TestCase
         }},
         {'name' => 'reference', 'type' => 'my.name.space.InnerFixed'}
       ]
-    }
+    }, schema.to_avro)
   end
 
   def test_to_avro_includes_logical_type

data/test/test_schema_validator.rb

@@ -0,0 +1,402 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test_help'
+
+class TestSchema < Test::Unit::TestCase
+  def validate!(schema, value)
+    Avro::SchemaValidator.validate!(schema, value)
+  end
+
+  def hash_to_schema(hash)
+    Avro::Schema.parse(hash.to_json)
+  end
+
+  def assert_failed_validation(messages)
+    error = assert_raise(Avro::SchemaValidator::ValidationError) { yield }
+
+    assert_messages = [messages].flatten
+    result_errors = error.result.errors
+    assert_messages.each do |message|
+      assert(result_errors.include?(message), "expected '#{message}' to be in '#{result_errors}'")
+    end
+    assert_equal(assert_messages.size, result_errors.size)
+  end
+
+  def assert_valid_schema(schema, valid, invalid)
+    valid.each do |value|
+      assert_nothing_raised { Avro::SchemaValidator.validate!(schema, value) }
+    end
+
+    invalid.each do |value|
+      assert_raise { Avro::SchemaValidator.validate!(schema, value) }
+    end
+  end
+
+  def test_validate_nil
+    schema = hash_to_schema(type: 'null', name: 'name')
+
+    assert_nothing_raised { validate!(schema, nil) }
+
+    assert_failed_validation('at . expected type null, got int with value 1') do
+      validate!(schema, 1)
+    end
+  end
+
+  def test_validate_boolean
+    schema = hash_to_schema(type: 'boolean', name: 'name')
+
+    assert_nothing_raised { validate!(schema, true) }
+    assert_nothing_raised { validate!(schema, false) }
+
+    assert_failed_validation('at . expected type boolean, got int with value 1') do
+      validate!(schema, 1)
+    end
+
+    assert_failed_validation('at . expected type boolean, got null') do
+      validate!(schema, nil)
+    end
+  end
+
+  def test_fixed_size_string
+    schema = hash_to_schema(type: 'fixed', name: 'some', size: 3)
+
+    assert_nothing_raised { validate!(schema, 'baf') }
+
+    assert_failed_validation('at . expected fixed with size 3, got "some" with size 4') do
+      validate!(schema, 'some')
+    end
+
+    assert_failed_validation('at . expected fixed with size 3, got null') do
+      validate!(schema, nil)
+    end
+  end
+
+  def test_original_validate_nil
+    schema = hash_to_schema(type: 'null', name: 'name')
+
+    assert_valid_schema(schema, [nil], ['something'])
+  end
+
+  def test_original_validate_boolean
+    schema = hash_to_schema(type: 'boolean', name: 'name')
+
+    assert_valid_schema(schema, [true, false], [nil, 1])
+  end
+
+  def test_validate_string
+    schema = hash_to_schema(type: 'string', name: 'name')
+
+    assert_valid_schema(schema, ['string'], [nil, 1])
+  end
+
+  def test_validate_bytes
+    schema = hash_to_schema(type: 'bytes', name: 'name')
+
+    assert_valid_schema(schema, ['string'], [nil, 1])
+  end
+
+  def test_validate_int
+    schema = hash_to_schema(type: 'int', name: 'name')
+
+    assert_valid_schema(
+      schema,
+      [Avro::Schema::INT_MIN_VALUE, Avro::Schema::INT_MAX_VALUE, 1],
+      [Avro::Schema::LONG_MIN_VALUE, Avro::Schema::LONG_MAX_VALUE, 'string']
+    )
+    assert_failed_validation('at . out of bound value 9223372036854775807') do
+      validate!(schema, Avro::Schema::LONG_MAX_VALUE)
+    end
+  end
+
+  def test_validate_long
+    schema = hash_to_schema(type: 'long', name: 'name')
+
+    assert_valid_schema(schema, [Avro::Schema::LONG_MIN_VALUE, Avro::Schema::LONG_MAX_VALUE, 1], [1.1, 'string'])
+  end
+
+  def test_validate_float
+    schema = hash_to_schema(type: 'float', name: 'name')
+
+    assert_valid_schema(schema, [1.1, 1, Avro::Schema::LONG_MAX_VALUE], ['string'])
+  end
+
+  def test_validate_double
+    schema = hash_to_schema(type: 'double', name: 'name')
+
+    assert_valid_schema(schema, [1.1, 1, Avro::Schema::LONG_MAX_VALUE], ['string'])
+  end
+
+  def test_validate_fixed
+    schema = hash_to_schema(type: 'fixed', name: 'name', size: 3)
+
+    assert_valid_schema(schema, ['abc'], ['ab', 1, 1.1, true])
+  end
+
+  def test_validate_original_num
+    schema = hash_to_schema(type: 'enum', name: 'name', symbols: %w(a b))
+
+    assert_valid_schema(schema, ['a', 'b'], ['c'])
+  end
+
+  def test_validate_record
+    schema = hash_to_schema(type: 'record', name: 'name', fields: [{ type: 'null', name: 'sub' }])
+
+    assert_valid_schema(schema, [{ 'sub' => nil }], [{ 'sub' => 1 }])
+  end
+
+  def test_validate_shallow_record
+    schema = hash_to_schema(
+      type: 'record', name: 'name', fields: [{ type: 'int', name: 'sub' }]
+    )
+
+    assert_nothing_raised { validate!(schema, 'sub' => 1) }
+
+    assert_failed_validation('at .sub expected type int, got null') do
+      validate!(schema, {})
+    end
+
+    assert_failed_validation('at . expected type record, got float with value 1.2') do
+      validate!(schema, 1.2)
+    end
+
+    assert_failed_validation('at .sub expected type int, got float with value 1.2') do
+      validate!(schema, 'sub' => 1.2)
+    end
+
+    assert_failed_validation('at .sub expected type int, got null') do
+      validate!(schema, {})
+    end
+  end
+
+  def test_validate_array
+    schema = hash_to_schema(type: 'array',
+                            name: 'person',
+                            items: [{ type: 'int', name: 'height' }])
+
+    assert_nothing_raised { validate!(schema, []) }
+
+    assert_failed_validation 'at . expected type array, got null' do
+      validate!(schema, nil)
+    end
+
+    assert_failed_validation('at .[0] expected type int, got null') do
+      validate!(schema, [nil])
+    end
+
+    assert_failed_validation('at .[3] expected type int, got string with value "so wrong"') do
+      validate!(schema, [1, 3, 9, 'so wrong'])
+    end
+  end
+
+  def test_validate_enum
+    schema = hash_to_schema(type: 'enum',
+                            name: 'person',
+                            symbols: %w(one two three))
+
+    assert_nothing_raised { validate!(schema, 'one') }
+
+    assert_failed_validation('at . expected enum with values ["one", "two", "three"], got string with value "five"') do
+      validate!(schema, 'five')
+    end
+  end
+
+  def test_validate_union_on_primitive_types
+    schema = hash_to_schema(
+      name: 'should_not_matter',
+      type: 'record',
+      fields: [
+        { name: 'what_ever', type: %w(long string) }
+      ]
+    )
+
+    assert_failed_validation('at .what_ever expected union of [\'long\', \'string\'], got null') {
+      validate!(schema, 'what_ever' => nil)
+    }
+  end
+
+  def test_validate_union_of_nil_and_record_inside_array
+    schema = hash_to_schema(
+      name: 'this does not matter',
+      type: 'record',
+      fields: [
+        {
+          name: 'person',
+          type: {
+            name: 'person_entry',
+            type: 'record',
+            fields: [
+              {
+                name: 'houses',
+                type: [
+                  'null',
+                  {
+                    name: 'houses_entry',
+                    type: 'array',
+                    items: [
+                      {
+                        name: 'house_entry',
+                        type: 'record',
+                        fields: [
+                          { name: 'number_of_rooms', type: 'long' }
+                        ]
+                      }
+                    ]
+                  }
+                ],
+              }
+            ]
+          }
+        }
+      ]
+    )
+
+    assert_failed_validation('at .person expected type record, got null') {
+      validate!(schema, 'not at all' => nil)
+    }
+    assert_nothing_raised { validate!(schema, 'person' => {}) }
+    assert_nothing_raised { validate!(schema, 'person' => { houses: [] }) }
+    assert_nothing_raised { validate!(schema, 'person' => { 'houses' => [{ 'number_of_rooms' => 1 }] }) }
+
+    message = 'at .person.houses[1].number_of_rooms expected type long, got string with value "not valid at all"'
+    assert_failed_validation(message) do
+      validate!(
+        schema,
+        'person' => {
+          'houses' => [
+            { 'number_of_rooms' => 2 },
+            { 'number_of_rooms' => 'not valid at all' }
+          ]
+        }
+      )
+    end
+  end
+
+  def test_validate_map
+    schema = hash_to_schema(type: 'map',
+                            name: 'numbers',
+                            values: [
+                              { name: 'some', type: 'int' }
+                            ])
+
+    assert_nothing_raised { validate!(schema, 'some' => 1) }
+
+    assert_failed_validation('at .some expected type int, got string with value "nope"') do
+      validate!(schema, 'some' => 'nope')
+    end
+
+    assert_failed_validation("at . unexpected key type 'Symbol' in map") do
+      validate!(schema, some: 1)
+    end
+  end
+
+  def test_validate_deep_record
+    schema = hash_to_schema(type: 'record',
+                            name: 'person',
+                            fields: [
+                              {
+                                name: 'head',
+                                type: {
+                                  name: 'head',
+                                  type: 'record',
+                                  fields: [
+                                    {
+                                      name: 'hair',
+                                      type: {
+                                        name: 'hair',
+                                        type: 'record',
+                                        fields: [
+                                          {
+                                            name: 'color',
+                                            type: 'string'
+                                          }
+                                        ]
+                                      }
+                                    }
+                                  ]
+                                }
+                              }
+                            ])
+
+    assert_nothing_raised { validate!(schema, 'head' => { 'hair' => { 'color' => 'black' } }) }
+
+    assert_failed_validation('at .head.hair.color expected type string, got null') do
+      validate!(schema, 'head' => { 'hair' => { 'color' => nil } })
+    end
+
+    assert_failed_validation('at .head.hair.color expected type string, got null') do
+      validate!(schema, 'head' => { 'hair' => {} })
+    end
+
+    assert_failed_validation('at .head.hair expected type record, got null') do
+      validate!(schema, 'head' => {})
+    end
+
+    assert_failed_validation('at . expected type record, got null') do
+      validate!(schema, nil)
+    end
+  end
+
+  def test_validate_deep_record_with_array
+    schema = hash_to_schema(type: 'record',
+                            name: 'fruits',
+                            fields: [
+                              {
+                                name: 'fruits',
+                                type: {
+                                  name: 'fruits',
+                                  type: 'array',
+                                  items: [
+                                    {
+                                      name: 'fruit',
+                                      type: 'record',
+                                      fields: [
+                                        { name: 'name', type: 'string' },
+                                        { name: 'weight', type: 'float' }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            ])
+    assert_nothing_raised { validate!(schema, 'fruits' => [{ 'name' => 'apple', 'weight' => 30.2 }]) }
+
+    assert_failed_validation('at .fruits[0].name expected type string, got null') do
+      validate!(schema, 'fruits' => [{ 'name' => nil, 'weight' => 30.2 }])
+    end
+
+    assert_failed_validation('at .fruits expected type array, got int with value 1') do
+      validate!(schema, 'fruits' => 1)
+    end
+  end
+
+  def test_validate_multiple_errors
+    schema = hash_to_schema(type: 'array',
+                            name: 'ages',
+                            items: [
+                              { type: 'int', name: 'age' }
+                            ])
+
+    exception = assert_raise(Avro::SchemaValidator::ValidationError) do
+      validate!(schema, [nil, 'e'])
+    end
+    assert_equal 2, exception.result.errors.size
+    assert_equal(
+      "at .[0] expected type int, got null\nat .[1] expected type int, got string with value \"e\"",
+      exception.to_s
+    )
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro-salsify-fork
 version: !ruby/object:Gem::Version
-  version: 1.9.0.3
+  version: 1.9.0.4
 platform: ruby
 authors:
 - Apache Software Foundation / Salsify Engineering
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-17 00:00:00.000000000 Z
+date: 2017-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -43,6 +43,7 @@ extra_rdoc_files:
 - lib/avro/schema.rb
 - lib/avro/schema_compatibility.rb
 - lib/avro/schema_normalization.rb
+- lib/avro/schema_validator.rb
 files:
 - CHANGELOG
 - LICENSE
@@ -61,6 +62,7 @@ files:
 - lib/avro/schema.rb
 - lib/avro/schema_compatibility.rb
 - lib/avro/schema_normalization.rb
+- lib/avro/schema_validator.rb
 - test/case_finder.rb
 - test/random_data.rb
 - test/sample_ipc_client.rb
@@ -76,6 +78,7 @@ files:
 - test/test_schema.rb
 - test/test_schema_compatibility.rb
 - test/test_schema_normalization.rb
+- test/test_schema_validator.rb
 - test/test_socket_transport.rb
 - test/tool.rb
 homepage: https://github.com/salsify/avro
@@ -101,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '1.2'
 requirements: []
 rubyforge_project: avro-salsify-fork
-rubygems_version: 2.6.6
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Apache Avro for Ruby with logical types patch
@@ -115,4 +118,5 @@ test_files:
 - test/test_schema.rb
 - test/test_schema_compatibility.rb
 - test/test_schema_normalization.rb
+- test/test_schema_validator.rb
 - test/test_socket_transport.rb