schemacop 3.0.5 → 3.0.10

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
@@ -330,6 +332,17 @@ module Schemacop
                       ]
                     })
       end
+
+      def test_cast_str
+        schema :integer, cast_str: true
+
+        assert_cast('1', 1)
+        assert_cast(1, 1)
+
+        assert_validation('true') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+      end
     end
   end
 end

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
@@ -299,6 +301,35 @@ module Schemacop
                       ]
                     })
       end
+
+      def test_cast_str
+        schema :number, cast_str: true, minimum: 0.0, maximum: 50r, multiple_of: BigDecimal('0.5')
+
+        assert_cast('1', 1)
+        assert_cast(1, 1)
+
+        assert_cast('1.0', 1.0)
+        assert_cast(1.0, 1.0)
+
+        assert_validation('42')
+        assert_validation('0.5')
+
+        assert_validation('true') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_validation('51') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_validation('-2') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_validation('3.1415') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+      end
     end
   end
 end

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
 
@@ -59,7 +59,10 @@ module Schemacop
       end
 
       def test_hash
-        schema { obj! :myobj, String }
+        schema do
+          obj! :myobj, classes: String
+        end
+
         assert_json(
           type:                 :object,
           properties:           {
@@ -71,13 +74,23 @@ 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.'
         end
       end
 
+      def test_hash_no_class
+        schema do
+          obj! :myobj
+        end
+
+        assert_validation(myobj: 'str')
+        assert_validation(myobj: 123)
+        assert_validation(myobj: Object.new)
+      end
+
       def test_enum_schema
         schema :object, enum: [true, 'foo', :baz, [], { qux: '123' }]
 
@@ -121,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/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
 

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

@@ -3,7 +3,9 @@ require 'test_helper'
 module Schemacop
   module V3
     class StringNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "string".'.freeze
+      def self.invalid_type_error(type)
+        "Invalid type, got type \"#{type}\", expected \"string\"."
+      end
 
       def test_basic
         schema :string
@@ -33,7 +35,7 @@ module Schemacop
         assert_json(type: :string)
 
         assert_validation 42 do
-          error '/', EXP_INVALID_TYPE
+          error '/', StringNodeTest.invalid_type_error(Integer)
         end
 
         schema { str! :name }
@@ -41,11 +43,11 @@ module Schemacop
         assert_json(type: :object, properties: { name: { type: :string } }, required: %i[name], additionalProperties: false)
 
         assert_validation name: :foo do
-          error '/name', EXP_INVALID_TYPE
+          error '/name', StringNodeTest.invalid_type_error(Symbol)
         end
 
         assert_validation name: 234 do
-          error '/name', EXP_INVALID_TYPE
+          error '/name', StringNodeTest.invalid_type_error(Integer)
         end
       end
 
@@ -190,7 +192,7 @@ module Schemacop
         assert_validation ''
 
         assert_validation 234 do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Integer)
         end
 
         assert_cast(nil, nil)
@@ -218,7 +220,7 @@ module Schemacop
         # Integer value 42 is in the enum of allowed values, but it's not a string,
         # so the validation still fails
         assert_validation 42 do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Integer)
         end
       end
 
@@ -278,7 +280,7 @@ module Schemacop
         assert_validation(nil)
         assert_validation('Foo')
         assert_validation(5) do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Integer)
         end
 
         assert_cast('Foo', 'Foo')
@@ -297,7 +299,7 @@ module Schemacop
         assert_validation(nil)
         assert_validation('123')
         assert_validation(5) do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Integer)
         end
 
         assert_cast('123', 123)
@@ -364,13 +366,13 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not strings
         assert_validation(1) do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Integer)
         end
         assert_validation(:bar) do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Symbol)
         end
         assert_validation({ qux: 42 }) do
-          error '/', 'Invalid type, expected "string".'
+          error '/', StringNodeTest.invalid_type_error(Hash)
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -400,6 +402,53 @@ module Schemacop
                       ]
                     })
       end
+
+      def test_cast_empty_or_whitespace_string
+        schema :string
+
+        assert_cast(nil, nil)
+        assert_cast('', '')
+        assert_cast('    ', '    ')
+        assert_cast("\n", "\n")
+        assert_cast("\t", "\t")
+      end
+
+      def test_cast_empty_or_whitespace_string_required
+        schema :string, required: true
+
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+
+        assert_cast('', '')
+        assert_cast('    ', '    ')
+        assert_cast("\n", "\n")
+        assert_cast("\t", "\t")
+      end
+
+      def test_empty_or_whitespace_string_blank_not_allowed
+        schema :string, allow_blank: false
+
+        assert_validation(nil) do
+          error '/', 'String is blank but must not be blank!'
+        end
+
+        assert_validation('') do
+          error '/', 'String is blank but must not be blank!'
+        end
+
+        assert_validation('   ') do
+          error '/', 'String is blank but must not be blank!'
+        end
+
+        assert_validation("\n") do
+          error '/', 'String is blank but must not be blank!'
+        end
+
+        assert_validation("\t") do
+          error '/', 'String is blank but must not be blank!'
+        end
+      end
     end
   end
 end

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

@@ -3,7 +3,10 @@ require 'test_helper'
 module Schemacop
   module V3
     class SymbolNodeTest < V3Test
-      EXP_INVALID_TYPE = 'Invalid type, expected "Symbol".'.freeze
+      def self.invalid_type_error(type)
+        type = type.class unless type.class == Class
+        "Invalid type, got type \"#{type}\", expected \"Symbol\"."
+      end
 
       def test_basic
         schema :symbol
@@ -11,10 +14,10 @@ module Schemacop
         assert_validation :foo
         assert_validation :'n0238n)Q(hqr3hrw3'
         assert_validation 42 do
-          error '/', EXP_INVALID_TYPE
+          error '/', SymbolNodeTest.invalid_type_error(Integer)
         end
         assert_validation '42' do
-          error '/', EXP_INVALID_TYPE
+          error '/', SymbolNodeTest.invalid_type_error(String)
         end
         assert_json({})
       end
@@ -56,13 +59,13 @@ module Schemacop
         # Even we put those types in the enum, they need to fail the validations,
         # as they are not symbols
         assert_validation('foo') do
-          error '/', 'Invalid type, expected "Symbol".'
+          error '/', SymbolNodeTest.invalid_type_error(String)
         end
         assert_validation(1) do
-          error '/', 'Invalid type, expected "Symbol".'
+          error '/', SymbolNodeTest.invalid_type_error(Integer)
         end
         assert_validation({ qux: 42 }) do
-          error '/', 'Invalid type, expected "Symbol".'
+          error '/', SymbolNodeTest.invalid_type_error(Hash)
         end
 
         # These need to fail validation, as they are not in the enum list
@@ -70,6 +73,20 @@ module Schemacop
           error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
         end
       end
+
+      # rubocop:disable Lint/BooleanSymbol
+      def test_cast_str
+        schema :symbol, cast_str: true
+
+        assert_cast('true', :true)
+        assert_cast('foo', :foo)
+        assert_cast('1', :'1')
+
+        assert_cast(:true, :true)
+        assert_cast(:foo, :foo)
+        assert_cast(:'1', :'1')
+      end
+      # rubocop:enable Lint/BooleanSymbol
     end
   end
 end