schemacop 3.0.0.rc1 → 3.0.0

data/test/unit/schemacop/v2/casting_test.rb

@@ -115,6 +115,43 @@ module Schemacop
         assert_equal expected_float, s.validate!(float_field: '')
         assert_equal expected_float, s.validate!(float_field: '     ')
       end
+
+      def test_float_to_integer
+        s = Schema.new do
+          req :foo, :integer, cast: [Float]
+        end
+
+        assert_equal({ foo: 42 }, s.validate!(foo: 42.0))
+        assert_equal({ foo: 42 }, s.validate!(foo: Float(42)))
+      end
+
+      def test_integer_to_float
+        s = Schema.new do
+          req :foo, :float, cast: [Integer]
+        end
+
+        assert_equal({ foo: 42.0 }, s.validate!(foo: 42))
+        assert_equal({ foo: 42.0 }, s.validate!(foo: Integer(42)))
+      end
+
+      def test_invalid_cast_option
+        s = Schema.new do
+          req :foo, :integer, cast: true
+        end
+
+        assert_raises Schemacop::Exceptions::InvalidSchemaError do
+          s.validate!({ foo: '42' })
+        end
+      end
+
+      def test_impossible_cast
+        s = Schema.new do
+          req :foo, :integer, cast: [String]
+        end
+
+        assert_equal({ foo: 42 }, s.validate!(foo: '42'))
+        assert_verr { s.validate!(foo: 'foo') }
+      end
     end
   end
 end

data/test/unit/schemacop/v2/validator_hash_test.rb

@@ -90,6 +90,17 @@ module Schemacop
         assert_verr { s.validate!(o: true) }
         assert_verr { s.validate!(r: nil, r_nil: false, o: true) }
       end
+
+      def test_invalid_hash
+        s = Schema.new do
+          type :hash do
+            req :foo
+          end
+        end
+
+        assert_verr { s.validate!({ foo: 42, 'foo' => 42 }) }
+        assert_nothing_raised { s.validate!({ foo: 42 }.with_indifferent_access) }
+      end
     end
   end
 end

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

@@ -142,8 +142,7 @@ module Schemacop
 
         assert_cast(
           { foo: '42', bar: '2020-01-15' },
-          foo: 42,
-          bar: Date.new(2020, 1, 15)
+          { foo: 42, bar: Date.new(2020, 1, 15) }.with_indifferent_access
         )
       end
 

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

@@ -133,11 +133,11 @@ module Schemacop
 
         assert_cast(
           { created_at: '2020-01-01' },
-          created_at: Date.new(2020, 1, 1)
+          { created_at: Date.new(2020, 1, 1) }.with_indifferent_access
         )
         assert_cast(
           { created_at: '2020-01-01T17:38:20' },
-          created_at: DateTime.new(2020, 1, 1, 17, 38, 20)
+          { created_at: DateTime.new(2020, 1, 1, 17, 38, 20) }.with_indifferent_access
         )
       end
 
@@ -158,12 +158,12 @@ module Schemacop
 
         assert_cast(
           { foo: { bar: nil } },
-          foo: { bar: nil }
+          { foo: { bar: nil } }.with_indifferent_access
         )
 
         assert_cast(
           { foo: { baz: nil } },
-          foo: { baz: 'Baz' }
+          { foo: { baz: 'Baz' } }.with_indifferent_access
         )
 
         schema do
@@ -175,12 +175,12 @@ module Schemacop
 
         assert_cast(
           { foo: { bar: '1990-01-13' } },
-          foo: { bar: Date.new(1990, 1, 13) }
+          { foo: { bar: Date.new(1990, 1, 13) } }.with_indifferent_access
         )
 
         assert_cast(
           { foo: { bar: '1990-01-13T10:00:00Z' } },
-          foo: { bar: DateTime.new(1990, 1, 13, 10, 0, 0) }
+          { foo: { bar: DateTime.new(1990, 1, 13, 10, 0, 0) } }.with_indifferent_access
         )
       end
 

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

@@ -446,8 +446,8 @@ module Schemacop
         end
 
         assert_cast(['foo', 42], ['foo', 42])
-        assert_cast(['foo', 42, { foo: '1990-01-01' }], ['foo', 42, { foo: Date.new(1990, 1, 1) }])
-        assert_cast(['foo', 42, { foo: '1990-01-01', bar: :baz }], ['foo', 42, { foo: Date.new(1990, 1, 1), bar: :baz }])
+        assert_cast(['foo', 42, { foo: '1990-01-01' }], ['foo', 42, { foo: Date.new(1990, 1, 1) }.with_indifferent_access])
+        assert_cast(['foo', 42, { foo: '1990-01-01', bar: :baz }], ['foo', 42, { foo: Date.new(1990, 1, 1), bar: :baz }.with_indifferent_access])
       end
 
       def test_multiple_add_in_schema
@@ -537,7 +537,7 @@ module Schemacop
           additionalItems: false
         )
 
-        assert_cast [{}], [{ name: 'John' }]
+        assert_cast [{}], [{ name: 'John' }.with_indifferent_access]
       end
 
       def test_enum_schema
@@ -800,6 +800,16 @@ module Schemacop
 
         assert_cast(%w[foo 1990-01-01], ['foo', Date.new(1990, 1, 1)])
       end
+
+      def test_contains_multiple_should_fail
+        assert_raises_with_message Exceptions::InvalidSchemaError, 'You can only use "cont" once.' do
+          schema :array do
+            list :string
+            cont :string
+            cont :integer
+          end
+        end
+      end
     end
   end
 end

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

@@ -25,8 +25,10 @@ module Schemacop
 
       def test_schemas
         assert_equal({}, GlobalContext.instance.schemas)
+        assert_equal({}, GlobalContext.schemas)
         GlobalContext.instance.eager_load!
         assert_equal(%i[nested/group user], GlobalContext.instance.schemas.keys)
+        assert_equal(%i[nested/group user], GlobalContext.schemas.keys)
         assert_is_a Node, GlobalContext.instance.schemas.values.first
       end
 

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

@@ -16,7 +16,7 @@ module Schemacop
         assert_json(type: :object, additionalProperties: false)
       end
 
-      def test_additional_properties_false
+      def test_additional_properties_false_by_default
         schema
         assert_validation({})
         assert_validation(foo: :bar, bar: :baz) do
@@ -26,6 +26,17 @@ module Schemacop
         assert_json(type: :object, additionalProperties: false)
       end
 
+      def test_additional_properties_false
+        schema :hash, additional_properties: false
+
+        assert_validation({})
+        assert_validation(foo: :bar, bar: :baz) do
+          error '/', 'Obsolete property "foo".'
+          error '/', 'Obsolete property "bar".'
+        end
+        assert_json(type: :object, additionalProperties: false)
+      end
+
       def test_additional_properties_true
         schema :hash, additional_properties: true
         assert_validation({})
@@ -54,6 +65,14 @@ module Schemacop
           type:                 :object,
           additionalProperties: { type: :string }
         )
+
+        assert_nothing_raised do
+          @schema.validate!({ foo: 'foo' })
+        end
+
+        assert_raises_with_message Exceptions::ValidationError, '/bar: Invalid type, expected "string".' do
+          @schema.validate!({ foo: 'foo', bar: :baz })
+        end
       end
 
       def test_property_names
@@ -72,8 +91,8 @@ module Schemacop
           propertyNames:        '^[a-zA-Z0-9]+$'
         )
 
-        assert_cast({ foo: 123 }, { foo: 123 })
-        assert_cast({ Foo: 123 }, { Foo: 123 })
+        assert_cast({ foo: 123 }, { foo: 123 }.with_indifferent_access)
+        assert_cast({ Foo: 123 }, { Foo: 123 }.with_indifferent_access)
 
         # New schema
         schema :hash, additional_properties: true, property_names: '^[a-z]+$'
@@ -82,13 +101,13 @@ module Schemacop
         assert_validation(foo: :bar)
         assert_validation('foo' => 'bar')
         assert_validation(Foo: :bar) do
-          error '/', 'Property name :Foo does not match "^[a-z]+$".'
+          error '/', 'Property name "Foo" does not match "^[a-z]+$".'
         end
         assert_validation('_foo39sjfdoi 345893(%' => 'bar', 'foo' => 'bar') do
           error '/', 'Property name "_foo39sjfdoi 345893(%" does not match "^[a-z]+$".'
         end
 
-        assert_cast({ foo: 123 }, { foo: 123 })
+        assert_cast({ foo: 123 }, { foo: 123 }.with_indifferent_access)
       end
 
       def test_required
@@ -293,9 +312,9 @@ module Schemacop
         assert_validation({ id_foo: 1, id_bar: 2 })
         assert_validation({ id_foo: 1, id_bar: 2, value: 4 })
 
-        assert_cast({ id_foo: 1 }, { id_foo: 1 })
-        assert_cast({ id_foo: 1, id_bar: 2 }, { id_foo: 1, id_bar: 2 })
-        assert_cast({ id_foo: 1, id_bar: 2, value: 4 }, { id_foo: 1, id_bar: 2, value: 4 })
+        assert_cast({ id_foo: 1 }, { id_foo: 1 }.with_indifferent_access)
+        assert_cast({ id_foo: 1, id_bar: 2 }, { id_foo: 1, id_bar: 2 }.with_indifferent_access)
+        assert_cast({ id_foo: 1, id_bar: 2, value: 4 }, { id_foo: 1, id_bar: 2, value: 4 }.with_indifferent_access)
       end
 
       def test_defaults
@@ -311,7 +330,9 @@ module Schemacop
         data = { last_name: 'Doeringer', active: 'true' }
         data_was = data.dup
 
-        assert_equal({ first_name: 'John', last_name: 'Doeringer', active: true, address: { street: 'Example 42' } }, @schema.validate(data).data)
+        expected_data = { first_name: 'John', last_name: 'Doeringer', active: true, address: { street: 'Example 42' } }.with_indifferent_access
+
+        assert_equal(expected_data, @schema.validate(data).data)
         assert_equal data_was, data
 
         schema do
@@ -526,7 +547,7 @@ module Schemacop
 
         assert_validation(nil)
         assert_validation(foo: '1')
-        assert_cast({ foo: '1' }, { foo: 1 })
+        assert_cast({ foo: '1' }, { foo: 1 }.with_indifferent_access)
 
         assert_validation(foo: '1', bar: '2') do
           error '/', 'Obsolete property "bar".'
@@ -552,11 +573,11 @@ module Schemacop
 
         assert_validation(nil)
         assert_validation(foo: '1')
-        assert_cast({ foo: '1' }, { foo: 1 })
+        assert_cast({ foo: '1' }, { foo: 1 }.with_indifferent_access)
 
         assert_validation(foo: '1', bar: nil)
         assert_validation(foo: '1', bar: '2')
-        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: '2' })
+        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: '2' }.with_indifferent_access)
 
         assert_json(
           type:                 'object',
@@ -589,11 +610,11 @@ module Schemacop
 
         assert_validation(nil)
         assert_validation(foo: '1')
-        assert_cast({ foo: '1' }, { foo: 1 })
+        assert_cast({ foo: '1' }, { foo: 1 }.with_indifferent_access)
 
         assert_validation(foo: '1', bar: nil)
         assert_validation(foo: '1', bar: '2')
-        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: '2' })
+        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: '2' }.with_indifferent_access)
 
         assert_json(
           type:                 'object',
@@ -616,11 +637,11 @@ module Schemacop
 
         assert_validation(nil)
         assert_validation(foo: '1')
-        assert_cast({ foo: '1' }, { foo: 1 })
+        assert_cast({ foo: '1' }, { foo: 1 }.with_indifferent_access)
 
         assert_validation(foo: '1', bar: nil)
         assert_validation(foo: '1', bar: '2')
-        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: 2 })
+        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: 2 }.with_indifferent_access)
       end
 
       def test_cast_with_additional_any_of
@@ -634,7 +655,7 @@ module Schemacop
 
         assert_validation(nil)
         assert_validation(foo: '1')
-        assert_cast({ foo: '1' }, { foo: 1 })
+        assert_cast({ foo: '1' }, { foo: 1 }.with_indifferent_access)
 
         assert_validation(foo: '1', bar: nil)
         assert_validation(foo: '1', bar: '2')
@@ -643,7 +664,7 @@ module Schemacop
           error '/qux', 'Does not match any anyOf condition.'
         end
 
-        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: '2' })
+        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: '2' }.with_indifferent_access)
 
         assert_json(
           type:                 'object',
@@ -675,7 +696,7 @@ module Schemacop
 
         assert_validation(nil)
         assert_validation(foo: '1')
-        assert_cast({ foo: '1' }, { foo: 1 })
+        assert_cast({ foo: '1' }, { foo: 1 }.with_indifferent_access)
 
         assert_validation(foo: '1', bar: nil)
         assert_validation(foo: '1', bar: '2')
@@ -684,8 +705,8 @@ module Schemacop
           error '/qux', 'Does not match any anyOf condition.'
         end
 
-        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: 2 })
-        assert_cast({ foo: '1', bar: '2', qux: '2020-01-13', asd: 1 }, { foo: 1, bar: 2, qux: Date.new(2020, 1, 13), asd: 1 })
+        assert_cast({ foo: '1', bar: '2' }, { foo: 1, bar: 2 }.with_indifferent_access)
+        assert_cast({ foo: '1', bar: '2', qux: '2020-01-13', asd: 1 }, { foo: 1, bar: 2, qux: Date.new(2020, 1, 13), asd: 1 }.with_indifferent_access)
 
         assert_json(
           type:                 'object',
@@ -821,6 +842,131 @@ module Schemacop
           end
         end
       end
+
+      def test_schema_with_string_keys
+        schema :hash do
+          int! 'foo'
+        end
+
+        assert_validation(nil)
+        assert_validation({ 'foo' => 42 })
+        assert_validation({ foo: 42 })
+
+        assert_cast({ 'foo' => 42 }, { 'foo' => 42 })
+        assert_cast({ foo: 42 }, { foo: 42 }.with_indifferent_access)
+
+        assert_validation({}) do
+          error '/foo', 'Value must be given.'
+        end
+
+        assert_validation({ :foo => 42, 'foo' => 43 }) do
+          error '/', 'Has 1 ambiguous properties: [:foo].'
+        end
+      end
+
+      def test_schema_with_string_keys_in_data
+        schema :hash do
+          int! :foo
+        end
+
+        assert_validation(nil)
+        assert_validation({ 'foo' => 42 })
+        assert_validation({ foo: 42 })
+
+        assert_cast({ 'foo' => 42 }, { 'foo' => 42 })
+        assert_cast({ foo: 42 }, { foo: 42 }.with_indifferent_access)
+
+        assert_validation({}) do
+          error '/foo', 'Value must be given.'
+        end
+
+        assert_validation({ :foo => 42, 'foo' => 43 }) do
+          error '/', 'Has 1 ambiguous properties: [:foo].'
+        end
+      end
+
+      def test_invalid_options
+        assert_raises_with_message Schemacop::Exceptions::InvalidSchemaError, 'Options [:foo] are not allowed for this node.' do
+          schema :hash, foo: 'bar' do
+            int! :id
+          end
+        end
+      end
+
+      def test_casting_optional
+        schema :hash do
+          str? :foo, format: :integer
+        end
+
+        assert_validation(nil)
+        assert_validation({})
+
+        assert_cast(nil, nil)
+        assert_cast({}, {}.with_indifferent_access)
+      end
+
+      def test_as_option
+        schema :hash do
+          int! :foo, as: :bar
+        end
+
+        assert_validation(nil)
+        assert_validation({ foo: 42 })
+        assert_validation({ bar: 13 }) do
+          error '/', 'Obsolete property "bar".'
+          error '/foo', 'Value must be given.'
+        end
+
+        assert_validation({ foo: '13' }) do
+          error '/foo', 'Invalid type, expected "integer".'
+        end
+
+        assert_cast(nil, nil)
+        assert_cast({ foo: 42 }, { bar: 42 }.with_indifferent_access)
+      end
+
+      def test_as_option_overriding
+        schema :hash do
+          int? :foo, as: :bar
+          int? :bar
+        end
+
+        assert_validation(nil)
+        assert_validation({})
+        assert_validation({ foo: 42 })
+        assert_validation({ foo: 42, bar: 13 })
+
+        assert_validation({ foo: '13' }) do
+          error '/foo', 'Invalid type, expected "integer".'
+        end
+
+        # assert_cast(nil, nil)
+        assert_cast({ foo: 42 }, { bar: 42 }.with_indifferent_access)
+        assert_cast({ foo: 42, bar: 13 }, { bar: 13 }.with_indifferent_access)
+        assert_cast({ bar: 13, foo: 42 }, { bar: 13 }.with_indifferent_access)
+
+        # Swap order
+        schema :hash do
+          int? :bar
+          int! :foo, as: :bar
+        end
+
+        assert_validation(nil)
+        assert_validation({ foo: 42 })
+        assert_validation({ foo: 42, bar: 13 })
+        assert_validation({ bar: 13 }) do
+          error '/foo', 'Value must be given.'
+        end
+
+        assert_validation({ foo: '13' }) do
+          error '/foo', 'Invalid type, expected "integer".'
+        end
+
+        assert_cast(nil, nil)
+        assert_cast({ foo: 42 }, { bar: 42 }.with_indifferent_access)
+        assert_cast({ foo: 42, bar: 13 }, { bar: 42 }.with_indifferent_access)
+        assert_cast({ bar: 13, foo: 42 }, { bar: 42 }.with_indifferent_access)
+      end
     end
   end
 end