schemacop 2.4.7 → 3.0.0.rc4

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

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class NodeTest < V3Test
+      def test_empty_schema
+        # Basic, empty schema, which will allow anything
+        @schema = Schemacop::Schema3.new
+
+        assert_json({})
+
+        assert_validation(nil)
+        assert_validation([nil])
+        assert_validation(1)
+        assert_validation('foo')
+        assert_validation(:bar)
+        assert_validation({ foo: 'bar', baz: 123 })
+        assert_validation([nil, 'foo', 1234, { bar: :bar }])
+      end
+
+      def test_empty_enum_schema
+        @schema = Schemacop::Schema3.new enum: [1, 2, 'foo', :bar, { qux: 42 }]
+
+        assert_json({ enum: [1, 2, 'foo', :bar, { qux: 42 }] })
+
+        assert_validation(nil)
+        assert_validation(1)
+        assert_validation('foo')
+        assert_validation(:bar)
+        assert_validation({ qux: 42 })
+
+        assert_validation(3) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
+        end
+        assert_validation('bar') do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
+        end
+        assert_validation(:foo) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
+        end
+        assert_validation({ qux: 13 }) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
+        end
+      end
+
+      def test_empty_schema_with_generic_keywords
+        @schema = Schemacop::Schema3.new enum:        [1, 'foo'],
+                                         title:       'Empty schema',
+                                         description: 'Empty schema holding generic keywords',
+                                         examples:    [
+                                           1,
+                                           'foo'
+                                         ]
+
+        assert_json({
+                      enum:        [1, 'foo'],
+                      title:       'Empty schema',
+                      description: 'Empty schema holding generic keywords',
+                      examples:    [
+                        1,
+                        'foo'
+                      ]
+                    })
+      end
+
+      def test_cast_in_root
+        schema :integer, cast_str: true, required: true
+
+        assert_json(
+          oneOf: [
+            { type: :integer },
+            { type: :string, format: :integer }
+          ]
+        )
+
+        assert_validation(5)
+
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+
+        assert_validation('5')
+        assert_validation('5.3') do
+          error '/', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_cast(5, 5)
+        assert_cast('5', 5)
+      end
+
+      def test_cast_in_array
+        schema :array do
+          list :number, cast_str: true, minimum: 3
+        end
+
+        assert_json(
+          type:  :array,
+          items: {
+            oneOf: [
+              { type: :number, minimum: 3 },
+              { type: :string, format: :number }
+            ]
+          }
+        )
+
+        assert_validation(nil)
+        assert_validation([nil])
+        assert_validation([5, 5.3, '42.0', '42.42'])
+        assert_validation([5, 5.3, '42.0', '42.42', 'bar']) do
+          error '/[4]', 'Matches 0 definitions but should match exactly 1.'
+        end
+        assert_validation([2]) do
+          error '/[0]', 'Matches 0 definitions but should match exactly 1.'
+        end
+        assert_validation(['2']) do
+          error '/[0]', 'Matches 0 definitions but should match exactly 1.'
+        end
+
+        assert_cast(['3'], [3])
+        assert_cast(['4', 5, '6'], [4, 5, 6])
+      end
+
+      def test_cast_in_array_required
+        schema :array do
+          num cast_str: true, minimum: 3, required: true
+        end
+
+        assert_json(
+          type:            :array,
+          items:           [
+            {
+              oneOf: [
+                { type: :number, minimum: 3 },
+                { type: :string, format: :number }
+              ]
+            }
+          ],
+          additionalItems: false
+        )
+
+        assert_validation(nil)
+        assert_validation([nil]) do
+          error '/[0]', 'Value must be given.'
+        end
+      end
+
+      def test_not_support_block
+        assert_raises_with_message Schemacop::Exceptions::InvalidSchemaError, 'Node Schemacop::V3::IntegerNode does not support blocks.' do
+          schema :integer do
+            int :foo
+          end
+        end
+      end
+
+      def test_node_no_children
+        @schema = Schemacop::Schema3.new
+
+        assert_equal(@schema.root.children, [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+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 test_basic
+        schema :number
+        assert_validation 25
+        assert_validation 3.323523242323523
+        assert_validation(-14)
+        assert_validation(-14.5)
+        assert_validation(1r)
+        assert_validation(2.5r)
+        assert_validation(BigDecimal(6))
+
+        assert_validation((6 + 0i)) do
+          error '/', EXP_INVALID_TYPE
+        end
+
+        assert_json(type: :number)
+      end
+
+      def test_hash
+        schema { num! :age }
+
+        assert_json(
+          type:                 :object,
+          properties:           {
+            age: { type: :number }
+          },
+          required:             %i[age],
+          additionalProperties: false
+        )
+        assert_validation age: 30
+        assert_validation age: 2.5r
+        assert_validation age: BigDecimal(5)
+      end
+
+      def test_array
+        schema(:array) do
+          list :number
+        end
+
+        assert_json(
+          type:  :array,
+          items: { type: :number }
+        )
+
+        assert_validation [30]
+        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
+        end
+      end
+
+      def test_type
+        schema :number
+
+        assert_json(
+          type: :number
+        )
+
+        assert_validation '42.5' do
+          error '/', EXP_INVALID_TYPE
+        end
+
+        schema { num! :age }
+
+        assert_validation age: :foo do
+          error '/age', EXP_INVALID_TYPE
+        end
+
+        assert_validation age: '234' do
+          error '/age', EXP_INVALID_TYPE
+        end
+      end
+
+      def test_minimum
+        schema :number, minimum: 0
+
+        assert_json(
+          type:    :number,
+          minimum: 0
+        )
+
+        assert_validation 5
+        assert_validation 0
+        assert_validation(-1) do
+          error '/', 'Value must have a minimum of 0.'
+        end
+      end
+
+      def test_exclusive_minimum
+        schema :number, exclusive_minimum: 0
+
+        assert_json(
+          type:             :number,
+          exclusiveMinimum: 0
+        )
+
+        assert_validation 5
+        assert_validation 1
+        assert_validation(0) do
+          error '/', 'Value must have an exclusive minimum of 0.'
+        end
+        assert_validation(-5) do
+          error '/', 'Value must have an exclusive minimum of 0.'
+        end
+      end
+
+      def test_maximum
+        schema :number, maximum: 5
+
+        assert_json(
+          type:    :number,
+          maximum: 5
+        )
+
+        assert_validation 5
+        assert_validation 0
+        assert_validation(6) do
+          error '/', 'Value must have a maximum of 5.'
+        end
+      end
+
+      def test_exclusive_maximum
+        schema :number, exclusive_maximum: 5
+
+        assert_json(
+          type:             :number,
+          exclusiveMaximum: 5
+        )
+
+        assert_validation 4
+        assert_validation 1
+        assert_validation(5) do
+          error '/', 'Value must have an exclusive maximum of 5.'
+        end
+        assert_validation(9) do
+          error '/', 'Value must have an exclusive maximum of 5.'
+        end
+      end
+
+      def test_multiple_of
+        schema :number, multiple_of: 2
+
+        assert_json(
+          type:       :number,
+          multipleOf: 2
+        )
+
+        assert_validation(-4.0)
+        assert_validation(-2)
+        assert_validation(0)
+        assert_validation(2)
+        assert_validation(300)
+
+        assert_validation(5) do
+          error '/', 'Value must be a multiple of 2.'
+        end
+
+        schema :number, multiple_of: 1.2
+
+        assert_json(
+          type:       :number,
+          multipleOf: 1.2
+        )
+
+        assert_validation(1.2)
+        assert_validation(2.4)
+        assert_validation(0)
+        assert_validation(-4.8)
+
+        assert_validation(3.8) do
+          error '/', 'Value must be a multiple of 1.2.'
+        end
+      end
+
+      # Helper function that checks for all the options if the option is
+      # an allowed class or something else, in which case it needs to raise
+      def validate_self_should_error(value_to_check)
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "minimum" must be a "big_decimal" or "float" or "integer" or "rational"' do
+          schema :number, minimum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "maximum" must be a "big_decimal" or "float" or "integer" or "rational"' do
+          schema :number, maximum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "exclusive_minimum" must be a "big_decimal" or "float" or "integer" or "rational"' do
+          schema :number, exclusive_minimum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "exclusive_maximum" must be a "big_decimal" or "float" or "integer" or "rational"' do
+          schema :number, exclusive_maximum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "multiple_of" must be a "big_decimal" or "float" or "integer" or "rational"' do
+          schema :number, multiple_of: value_to_check
+        end
+      end
+
+      def test_validate_self
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "minimum" can\'t be greater than "maximum".' do
+          schema :number, minimum: 5, maximum: 4
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "exclusive_minimum" can\'t be '\
+                                   'greater than "exclusive_maximum".' do
+          schema :number, exclusive_minimum: 5, exclusive_maximum: 4
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "multiple_of" can\'t be 0.' do
+          schema :number, multiple_of: 0
+        end
+
+        validate_self_should_error(1 + 0i) # Complex
+        validate_self_should_error(Object.new)
+        validate_self_should_error(true)
+        validate_self_should_error(false)
+        validate_self_should_error('1')
+        validate_self_should_error('1.0')
+        validate_self_should_error('String')
+      end
+
+      def test_enum_schema
+        schema :number, enum: [1, 2, 'foo', :bar, { qux: 42 }, 4.2]
+
+        assert_json({
+                      type: :number,
+                      enum: [1, 2, 'foo', :bar, { qux: 42 }, 4.2]
+                    })
+
+        assert_validation(nil)
+        assert_validation(1)
+        assert_validation(4.2)
+
+        # 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
+        end
+        assert_validation(:bar) do
+          error '/', EXP_INVALID_TYPE
+        end
+        assert_validation({ qux: 42 }) do
+          error '/', EXP_INVALID_TYPE
+        end
+
+        # These need to fail validation, as they are not in the enum list
+        assert_validation(0.5) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}, 4.2].'
+        end
+        assert_validation(4) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}, 4.2].'
+        end
+      end
+
+      def test_with_generic_keywords
+        schema :number, enum:        [1, 'foo', 4.2],
+                        title:       'Number schema',
+                        description: 'Number schema holding generic keywords',
+                        examples:    [
+                          1,
+                          4.2
+                        ]
+
+        assert_json({
+                      type:        :number,
+                      enum:        [1, 'foo', 4.2],
+                      title:       'Number schema',
+                      description: 'Number schema holding generic keywords',
+                      examples:    [
+                        1,
+                        4.2
+                      ]
+                    })
+      end
+    end
+  end
+end