schemacop 3.0.9 → 3.0.13

data/test/unit/schemacop/v3/array_node_test.rb

@@ -3,7 +3,9 @@ require 'test_helper'
 module Schemacop
   module V3
     class ArrayNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "array".'.freeze
+      def self.invalid_type_error(type)
+        "Invalid type, got type \"#{type}\", expected \"array\"."
+      end
 
       def test_basic
         schema :array
@@ -54,7 +56,7 @@ module Schemacop
           error '/', 'Array has 2 items but must have exactly 1.'
         end
         assert_validation [123] do
-          error '/[0]', 'Invalid type, expected "object".'
+          error '/[0]', 'Invalid type, got type "Integer", expected "object".'
         end
       end
 
@@ -64,7 +66,7 @@ module Schemacop
         assert_json(type: :array)
 
         assert_validation 42 do
-          error '/', EXP_INVALID_TYPE
+          error '/', ArrayNodeTest.invalid_type_error(Integer)
         end
 
         schema { ary! :foo }
@@ -79,11 +81,11 @@ module Schemacop
         )
 
         assert_validation foo: 42 do
-          error '/foo', EXP_INVALID_TYPE
+          error '/foo', ArrayNodeTest.invalid_type_error(Integer)
         end
 
         assert_validation foo: {} do
-          error '/foo', EXP_INVALID_TYPE
+          error '/foo', ArrayNodeTest.invalid_type_error(ActiveSupport::HashWithIndifferentAccess)
         end
       end
 
@@ -196,7 +198,7 @@ module Schemacop
         end
 
         assert_validation %i[foo] do
-          error '/[0]', 'Invalid type, expected "string".'
+          error '/[0]', 'Invalid type, got type "Symbol", expected "string".'
         end
       end
 
@@ -230,7 +232,7 @@ module Schemacop
         end
 
         assert_validation([42, 42, { name: 'Hello' }]) do
-          error '/[0]', 'Invalid type, expected "string".'
+          error '/[0]', 'Invalid type, got type "Integer", expected "string".'
         end
 
         assert_validation(['foo', 42, { namex: 'Hello' }]) do
@@ -305,7 +307,7 @@ module Schemacop
         assert_validation(['foo', 42])
         assert_validation(['foo', 42, 42])
         assert_validation(['foo', :foo]) do
-          error '/[1]', 'Invalid type, expected "integer".'
+          error '/[1]', 'Invalid type, got type "Symbol", expected "integer".'
         end
       end
 
@@ -328,7 +330,7 @@ module Schemacop
         assert_validation(['foo', 42])
         assert_validation(['foo', 42, 'additional', 'another'])
         assert_validation(['foo', 42, 'additional', 42, 'another']) do
-          error '/[3]', 'Invalid type, expected "string".'
+          error '/[3]', 'Invalid type, got type "Integer", expected "string".'
         end
 
         assert_cast(['foo', 42], ['foo', 42])
@@ -354,7 +356,7 @@ module Schemacop
         assert_validation(['foo', 42])
         assert_validation(['foo', 42, '1990-01-01'])
         assert_validation(['foo', 42, '1990-01-01', 42]) do
-          error '/[3]', 'Invalid type, expected "string".'
+          error '/[3]', 'Invalid type, got type "Integer", expected "string".'
         end
         assert_validation(['foo', 42, '1990-01-01', 'foo']) do
           error '/[3]', 'String does not match format "date".'
@@ -439,7 +441,7 @@ module Schemacop
         assert_validation(['foo', 42, { foo: '1990-01-01', bar: :baz }])
 
         assert_validation(['foo', 42, { foo: 1234 }]) do
-          error '/[2]/foo', 'Invalid type, expected "string".'
+          error '/[2]/foo', 'Invalid type, got type "Integer", expected "string".'
         end
         assert_validation(['foo', 42, { foo: 'String' }]) do
           error '/[2]/foo', 'String does not match format "date".'
@@ -555,16 +557,16 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not arrays
         assert_validation('foo') do
-          error '/', 'Invalid type, expected "array".'
+          error '/', ArrayNodeTest.invalid_type_error(String)
         end
         assert_validation(1) do
-          error '/', 'Invalid type, expected "array".'
+          error '/', ArrayNodeTest.invalid_type_error(Integer)
         end
         assert_validation(:bar) do
-          error '/', 'Invalid type, expected "array".'
+          error '/', ArrayNodeTest.invalid_type_error(Symbol)
         end
         assert_validation({ qux: 42 }) do
-          error '/', 'Invalid type, expected "array".'
+          error '/', ArrayNodeTest.invalid_type_error(Hash)
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -669,8 +671,8 @@ module Schemacop
         assert_validation([1, 2, 3, 4, 5, 6])
 
         assert_validation([1, :foo, 'bar']) do
-          error '/[1]', 'Invalid type, expected "integer".'
-          error '/[2]', 'Invalid type, expected "integer".'
+          error '/[1]', 'Invalid type, got type "Symbol", expected "integer".'
+          error '/[2]', 'Invalid type, got type "String", expected "integer".'
         end
       end
 

data/test/unit/schemacop/v3/boolean_node_test.rb

@@ -4,7 +4,10 @@ require 'test_helper'
 module Schemacop
   module V3
     class BooleanNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "boolean".'.freeze
+      def self.invalid_type_error(type)
+        type = type.class unless type.class == Class
+        "Invalid type, got type \"#{type}\", expected \"boolean\"."
+      end
 
       def test_basic
         schema :boolean
@@ -47,12 +50,12 @@ module Schemacop
         assert_json(type: :boolean)
 
         assert_validation 42 do
-          error '/', EXP_INVALID_TYPE
+          error '/', BooleanNodeTest.invalid_type_error(Integer)
         end
 
         [:true, 'true', :false, 'false', 0, 1].each do |value|
           assert_validation value do
-            error '/', EXP_INVALID_TYPE
+            error '/', BooleanNodeTest.invalid_type_error(value)
           end
         end
 
@@ -68,7 +71,7 @@ module Schemacop
 
         [:true, 'true', :false, 'false', 0, 1].each do |value|
           assert_validation name: value do
-            error '/name', EXP_INVALID_TYPE
+            error '/name', BooleanNodeTest.invalid_type_error(value)
           end
         end
       end
@@ -87,13 +90,13 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not booleans
         assert_validation('foo') do
-          error '/', 'Invalid type, expected "boolean".'
+          error '/', BooleanNodeTest.invalid_type_error(String)
         end
         assert_validation(:bar) do
-          error '/', 'Invalid type, expected "boolean".'
+          error '/', BooleanNodeTest.invalid_type_error(Symbol)
         end
         assert_validation({ qux: 42 }) do
-          error '/', 'Invalid type, expected "boolean".'
+          error '/', BooleanNodeTest.invalid_type_error(Hash)
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -143,12 +146,49 @@ module Schemacop
         assert_cast('true', true)
         assert_cast('false', false)
 
+        assert_cast('1', true)
+        assert_cast('0', false)
+
+        assert_cast(true, true)
+        assert_cast(false, false)
+
+        assert_validation('5') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        # Nil can be validated, as it's not required
+        assert_validation(nil)
+
+        assert_validation('')
+
+        assert_cast('', nil)
+        assert_cast(nil, nil)
+      end
+
+      def test_cast_str_required
+        schema :boolean, cast_str: true, required: true
+
+        assert_cast('true', true)
+        assert_cast('false', false)
+
         assert_cast(true, true)
         assert_cast(false, false)
 
-        assert_validation('1') do
+        assert_validation('4') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_validation('foo') do
           error '/', 'Matches 0 definitions but should match exactly 1.'
         end
+
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+
+        assert_validation('') do
+          error '/', 'Value must be given.'
+        end
       end
     end
   end

data/test/unit/schemacop/v3/hash_node_test.rb

@@ -3,8 +3,6 @@ require 'test_helper'
 module Schemacop
   module V3
     class HashNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "hash".'.freeze
-
       def test_basic
         schema
         assert_validation({})
@@ -54,7 +52,7 @@ module Schemacop
 
         assert_validation(foo: 'bar', baz: 'foo', answer: '42')
         assert_validation(foo: 'bar', baz: 'foo', answer: 42) do
-          error '/answer', 'Invalid type, expected "string".'
+          error '/answer', 'Invalid type, got type "Integer", expected "string".'
         end
 
         assert_json(
@@ -70,7 +68,7 @@ module Schemacop
           @schema.validate!({ foo: 'foo' })
         end
 
-        assert_raises_with_message Exceptions::ValidationError, '/bar: Invalid type, expected "string".' do
+        assert_raises_with_message Exceptions::ValidationError, '/bar: Invalid type, got type "Symbol", expected "string".' do
           @schema.validate!({ foo: 'foo', bar: :baz })
         end
       end
@@ -247,7 +245,7 @@ module Schemacop
 
         assert_validation(name: 'John', xy: 'John', bar_baz: 'Doe') do
           error '/', 'Obsolete property "xy".'
-          error '/bar_baz', 'Invalid type, expected "integer".'
+          error '/bar_baz', 'Invalid type, got type "String", expected "integer".'
         end
 
         assert_json(
@@ -276,7 +274,7 @@ module Schemacop
         assert_validation(keyword: 'value')
 
         assert_validation(keyword: 42) do
-          error '/keyword', 'Invalid type, expected "string".'
+          error '/keyword', 'Invalid type, got type "Integer", expected "string".'
         end
 
         assert_json(
@@ -759,10 +757,10 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not strings
         assert_validation({ foo: 123 }) do
-          error '/foo', 'Invalid type, expected "string".'
+          error '/foo', 'Invalid type, got type "Integer", expected "string".'
         end
         assert_validation({ foo: :faz }) do
-          error '/foo', 'Invalid type, expected "string".'
+          error '/foo', 'Invalid type, got type "Symbol", expected "string".'
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -918,7 +916,7 @@ module Schemacop
         end
 
         assert_validation({ foo: '13' }) do
-          error '/foo', 'Invalid type, expected "integer".'
+          error '/foo', 'Invalid type, got type "String", expected "integer".'
         end
 
         assert_cast(nil, nil)
@@ -937,7 +935,7 @@ module Schemacop
         assert_validation({ foo: 42, bar: 13 })
 
         assert_validation({ foo: '13' }) do
-          error '/foo', 'Invalid type, expected "integer".'
+          error '/foo', 'Invalid type, got type "String", expected "integer".'
         end
 
         # assert_cast(nil, nil)
@@ -959,7 +957,7 @@ module Schemacop
         end
 
         assert_validation({ foo: '13' }) do
-          error '/foo', 'Invalid type, expected "integer".'
+          error '/foo', 'Invalid type, got type "String", expected "integer".'
         end
 
         assert_cast(nil, nil)
@@ -967,6 +965,46 @@ module Schemacop
         assert_cast({ foo: 42, bar: 13 }, { bar: 42 }.with_indifferent_access)
         assert_cast({ bar: 13, foo: 42 }, { bar: 42 }.with_indifferent_access)
       end
+
+      def test_cast_str_required
+        schema :hash do
+          boo! :active, cast_str: true
+          int! :id, cast_str: true
+        end
+
+        assert_validation({ active: true, id: 1 })
+        assert_validation({ active: 'true', id: '1' })
+
+        assert_validation({}) do
+          error '/active', 'Value must be given.'
+          error '/id', 'Value must be given.'
+        end
+
+        assert_cast({ active: 'true', id: '1' }, { active: true, id: 1 }.with_indifferent_access)
+
+        assert_validation({ active: '', id: '' }) do
+          error '/active', 'Value must be given.'
+          error '/id', 'Value must be given.'
+        end
+      end
+
+      def test_cast_str_optional
+        schema :hash do
+          boo? :active, cast_str: true
+          int? :id, cast_str: true
+        end
+
+        assert_validation({ active: true, id: 1 })
+        assert_validation({ active: 'true', id: '1' })
+
+        assert_cast({ active: 'true', id: '1' }, { active: true, id: 1 }.with_indifferent_access)
+
+        assert_validation({})
+        assert_validation({ active: nil, id: nil })
+
+        assert_validation({ active: '', id: '' })
+        assert_cast({ active: '', id: '' }, { active: nil, id: nil }.with_indifferent_access)
+      end
     end
   end
 end

data/test/unit/schemacop/v3/integer_node_test.rb

@@ -3,7 +3,9 @@ require 'test_helper'
 module Schemacop
   module V3
     class IntegerNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "integer".'.freeze
+      def self.invalid_type_error(type)
+        "Invalid type, got type \"#{type}\", expected \"integer\"."
+      end
 
       def test_basic
         schema :integer
@@ -59,11 +61,11 @@ module Schemacop
         )
 
         assert_validation 42.5 do
-          error '/', EXP_INVALID_TYPE
+          error '/', IntegerNodeTest.invalid_type_error(Float)
         end
 
         assert_validation '42.5' do
-          error '/', EXP_INVALID_TYPE
+          error '/', IntegerNodeTest.invalid_type_error(String)
         end
 
         schema { int! :age }
@@ -78,27 +80,27 @@ module Schemacop
         )
 
         assert_validation age: :foo do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', IntegerNodeTest.invalid_type_error(Symbol)
         end
 
         assert_validation age: '234' do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', IntegerNodeTest.invalid_type_error(String)
         end
 
         assert_validation age: 10.0 do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', IntegerNodeTest.invalid_type_error(Float)
         end
 
         assert_validation age: 4r do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', IntegerNodeTest.invalid_type_error(Rational)
         end
 
         assert_validation age: (4 + 0i) do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', IntegerNodeTest.invalid_type_error(Complex)
         end
 
         assert_validation age: BigDecimal(5) do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', IntegerNodeTest.invalid_type_error(BigDecimal)
         end
       end
 
@@ -210,7 +212,7 @@ module Schemacop
         assert_validation(nil)
         assert_validation(50)
         assert_validation(5.2) do
-          error '/', 'Invalid type, expected "integer".'
+          error '/', IntegerNodeTest.invalid_type_error(Float)
         end
 
         assert_cast(5, 5)
@@ -289,18 +291,18 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not integers
         assert_validation('foo') do
-          error '/', 'Invalid type, expected "integer".'
+          error '/', IntegerNodeTest.invalid_type_error(String)
         end
         assert_validation(:bar) do
-          error '/', 'Invalid type, expected "integer".'
+          error '/', IntegerNodeTest.invalid_type_error(Symbol)
         end
         assert_validation({ qux: 42 }) do
-          error '/', 'Invalid type, expected "integer".'
+          error '/', IntegerNodeTest.invalid_type_error(Hash)
         end
 
         # This needs to fail as it is a number (float) and not an integer
         assert_validation(4.2) do
-          error '/', 'Invalid type, expected "integer".'
+          error '/', IntegerNodeTest.invalid_type_error(Float)
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -337,6 +339,28 @@ module Schemacop
         assert_cast('1', 1)
         assert_cast(1, 1)
 
+        assert_cast(nil, nil)
+        assert_cast('', nil)
+
+        assert_validation('true') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+      end
+
+      def test_cast_str_required
+        schema :integer, cast_str: true, required: true
+
+        assert_cast('1', 1)
+        assert_cast(1, 1)
+
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+
+        assert_validation('') do
+          error '/', 'Value must be given.'
+        end
+
         assert_validation('true') do
           error '/', 'Matches 0 definitions but should match exactly 1.'
         end

data/test/unit/schemacop/v3/node_test.rb

@@ -93,6 +93,10 @@ module Schemacop
           error '/', 'Value must be given.'
         end
 
+        assert_validation('') do
+          error '/', 'Value must be given.'
+        end
+
         assert_validation('5')
         assert_validation('5.3') do
           error '/', 'Matches 0 definitions but should match exactly 1.'
@@ -156,6 +160,12 @@ module Schemacop
         assert_validation([nil]) do
           error '/[0]', 'Value must be given.'
         end
+        assert_validation(['']) do
+          error '/[0]', 'Value must be given.'
+        end
+        assert_validation([]) do
+          error '/', 'Array has 0 items but must have exactly 1.'
+        end
       end
 
       def test_not_support_block

data/test/unit/schemacop/v3/number_node_test.rb

@@ -3,7 +3,9 @@ require 'test_helper'
 module Schemacop
   module V3
     class NumberNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "big_decimal" or "float" or "integer" or "rational".'.freeze
+      def self.invalid_type_error(type)
+        "Invalid type, got type \"#{type}\", expected \"big_decimal\" or \"float\" or \"integer\" or \"rational\"."
+      end
 
       def test_basic
         schema :number
@@ -16,7 +18,7 @@ module Schemacop
         assert_validation(BigDecimal(6))
 
         assert_validation((6 + 0i)) do
-          error '/', EXP_INVALID_TYPE
+          error '/', NumberNodeTest.invalid_type_error(Complex)
         end
 
         assert_json(type: :number)
@@ -52,7 +54,7 @@ module Schemacop
         assert_validation [30.3, 42.0]
         assert_validation [30, 30r, 30.0, BigDecimal(30)]
         assert_validation ['30.3', 30.3] do
-          error '/[0]', EXP_INVALID_TYPE
+          error '/[0]', NumberNodeTest.invalid_type_error(String)
         end
       end
 
@@ -64,17 +66,17 @@ module Schemacop
         )
 
         assert_validation '42.5' do
-          error '/', EXP_INVALID_TYPE
+          error '/', NumberNodeTest.invalid_type_error(String)
         end
 
         schema { num! :age }
 
         assert_validation age: :foo do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', NumberNodeTest.invalid_type_error(Symbol)
         end
 
         assert_validation age: '234' do
-          error '/age', EXP_INVALID_TYPE
+          error '/age', NumberNodeTest.invalid_type_error(String)
         end
       end
 
@@ -261,13 +263,13 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not numbers
         assert_validation('foo') do
-          error '/', EXP_INVALID_TYPE
+          error '/', NumberNodeTest.invalid_type_error(String)
         end
         assert_validation(:bar) do
-          error '/', EXP_INVALID_TYPE
+          error '/', NumberNodeTest.invalid_type_error(Symbol)
         end
         assert_validation({ qux: 42 }) do
-          error '/', EXP_INVALID_TYPE
+          error '/', NumberNodeTest.invalid_type_error(Hash)
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -306,6 +308,9 @@ module Schemacop
         assert_cast('1', 1)
         assert_cast(1, 1)
 
+        assert_validation(nil)
+        assert_validation('')
+
         assert_cast('1.0', 1.0)
         assert_cast(1.0, 1.0)
 

data/test/unit/schemacop/v3/object_node_test.rb

@@ -28,10 +28,10 @@ module Schemacop
         assert_validation 'foo'
         assert_validation Date.today
         assert_validation({}.with_indifferent_access) do
-          error '/', 'Invalid type, expected "Date" or "String".'
+          error '/', 'Invalid type, got type "ActiveSupport::HashWithIndifferentAccess", expected "Date" or "String".'
         end
         assert_validation DateTime.now do
-          error '/', 'Invalid type, expected "Date" or "String".'
+          error '/', 'Invalid type, got type "DateTime", expected "Date" or "String".'
         end
       end
 
@@ -44,7 +44,7 @@ module Schemacop
         assert_validation DateTime.now
         assert_validation({}.with_indifferent_access)
         assert_validation Time.now do
-          error '/', 'Invalid type, expected "Date" or "Hash" or "String".'
+          error '/', 'Invalid type, got type "Time", expected "Date" or "Hash" or "String".'
         end
       end
 
@@ -74,7 +74,7 @@ module Schemacop
         assert_validation myobj: ''
         assert_validation myobj: '42'
         assert_validation myobj: Date.today do
-          error '/myobj', 'Invalid type, expected "String".'
+          error '/myobj', 'Invalid type, got type "Date", expected "String".'
         end
         assert_validation({}) do
           error '/myobj', 'Value must be given.'
@@ -134,13 +134,13 @@ module Schemacop
 
         # These will fail, as they aren't of one of the classed we defined above
         assert_validation([]) do
-          error '/', 'Invalid type, expected "String" or "Symbol" or "TrueClass".'
+          error '/', 'Invalid type, got type "Array", expected "String" or "Symbol" or "TrueClass".'
         end
         assert_validation({ qux: '123' }) do
-          error '/', 'Invalid type, expected "String" or "Symbol" or "TrueClass".'
+          error '/', 'Invalid type, got type "Hash", expected "String" or "Symbol" or "TrueClass".'
         end
         assert_validation(false) do
-          error '/', 'Invalid type, expected "String" or "Symbol" or "TrueClass".'
+          error '/', 'Invalid type, got type "FalseClass", expected "String" or "Symbol" or "TrueClass".'
         end
       end
 

data/test/unit/schemacop/v3/one_of_node_test.rb

@@ -182,6 +182,18 @@ module Schemacop
           schema :one_of
         end
       end
+
+      def test_treat_blank_as_nil
+        schema :one_of, treat_blank_as_nil: true do
+          boo
+          str format: :boolean
+        end
+
+        assert_validation(nil)
+        assert_validation('')
+        assert_validation('true')
+        assert_validation(true)
+      end
     end
   end
 end

data/test/unit/schemacop/v3/reference_node_test.rb

@@ -26,13 +26,13 @@ module Schemacop
           assert_validation(bar: { foo: 'String', baz: { foo: 42 } })
 
           assert_validation(foo: 42) do
-            error '/foo', 'Invalid type, expected "string".'
+            error '/foo', 'Invalid type, got type "Integer", expected "string".'
           end
           assert_validation(bar: { foo: 42 }) do
-            error '/bar/foo', 'Invalid type, expected "string".'
+            error '/bar/foo', 'Invalid type, got type "Integer", expected "string".'
           end
           assert_validation(bar: { foo: 'String', baz: { foo: '42' } }) do
-            error '/bar/baz/foo', 'Invalid type, expected "integer".'
+            error '/bar/baz/foo', 'Invalid type, got type "String", expected "integer".'
           end
 
           assert_json({
@@ -306,7 +306,7 @@ module Schemacop
         with_context context do
           assert_validation(first_name: 'John', last_name: 'Doe')
           assert_validation(first_name: 'John', last_name: 42) do
-            error '/last_name', 'Invalid type, expected "string".'
+            error '/last_name', 'Invalid type, got type "Integer", expected "string".'
           end
         end