schemacop 2.4.6 → 3.0.0.rc3

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

@@ -0,0 +1,323 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class IntegerNodeTest < V3Test
+      EXP_INVALID_TYPE = 'Invalid type, expected "integer".'.freeze
+
+      def test_basic
+        schema :integer
+
+        assert_json(type: :integer)
+
+        assert_validation 25
+        assert_validation(-14)
+      end
+
+      def test_hash
+        schema { int! :age }
+
+        assert_json(
+          type:                 :object,
+          properties:           {
+            age: { type: :integer }
+          },
+          required:             %i[age],
+          additionalProperties: false
+        )
+
+        assert_validation age: 30
+      end
+
+      def test_array
+        schema(:array) { int }
+
+        assert_json(
+          type:            :array,
+          items:           [
+            {
+              type: :integer
+            }
+          ],
+          additionalItems: false
+        )
+
+        assert_validation [30]
+        assert_validation [30, 42] do
+          error '/', 'Array has 2 items but must have exactly 1.'
+        end
+        assert_validation [30, '30'] do
+          error '/', 'Array has 2 items but must have exactly 1.'
+        end
+      end
+
+      def test_type
+        schema :integer
+
+        assert_json(
+          type: :integer
+        )
+
+        assert_validation 42.5 do
+          error '/', EXP_INVALID_TYPE
+        end
+
+        assert_validation '42.5' do
+          error '/', EXP_INVALID_TYPE
+        end
+
+        schema { int! :age }
+
+        assert_json(
+          type:                 :object,
+          properties:           {
+            age: { type: :integer }
+          },
+          required:             %i[age],
+          additionalProperties: false
+        )
+
+        assert_validation age: :foo do
+          error '/age', EXP_INVALID_TYPE
+        end
+
+        assert_validation age: '234' do
+          error '/age', EXP_INVALID_TYPE
+        end
+
+        assert_validation age: 10.0 do
+          error '/age', EXP_INVALID_TYPE
+        end
+
+        assert_validation age: 4r do
+          error '/age', EXP_INVALID_TYPE
+        end
+
+        assert_validation age: (4 + 0i) do
+          error '/age', EXP_INVALID_TYPE
+        end
+
+        assert_validation age: BigDecimal(5) do
+          error '/age', EXP_INVALID_TYPE
+        end
+      end
+
+      def test_minimum
+        schema :integer, minimum: 0
+
+        assert_json(
+          type:    :integer,
+          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 :integer, exclusive_minimum: 0
+
+        assert_json(
+          type:             :integer,
+          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 :integer, maximum: 5
+
+        assert_json(
+          type:    :integer,
+          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 :integer, exclusive_maximum: 5
+
+        assert_json(
+          type:             :integer,
+          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 :integer, multiple_of: 2
+
+        assert_json(
+          type:       :integer,
+          multipleOf: 2
+        )
+
+        assert_validation(-4)
+        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
+      end
+
+      def test_default
+        schema :integer, default: 5
+
+        assert_json(
+          type:    :integer,
+          default: 5
+        )
+
+        assert_validation(nil)
+        assert_validation(50)
+        assert_validation(5.2) do
+          error '/', 'Invalid type, expected "integer".'
+        end
+
+        assert_cast(5, 5)
+        assert_cast(6, 6)
+        assert_cast(nil, 5)
+      end
+
+      # Helper function that checks for all the options if the option is
+      # an integer 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 "integer"' do
+          schema :integer, minimum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "maximum" must be a "integer"' do
+          schema :integer, maximum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "exclusive_minimum" must be a "integer"' do
+          schema :integer, exclusive_minimum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "exclusive_maximum" must be a "integer"' do
+          schema :integer, exclusive_maximum: value_to_check
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "multiple_of" must be a "integer"' do
+          schema :integer, 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 :integer, minimum: 5, maximum: 4
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "exclusive_minimum" can\'t be '\
+                                   'greater than "exclusive_maximum".' do
+          schema :integer, exclusive_minimum: 5, exclusive_maximum: 4
+        end
+
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Option "multiple_of" can\'t be 0.' do
+          schema :integer, multiple_of: 0
+        end
+
+        validate_self_should_error(1.0) # Float
+        validate_self_should_error(1r)  # Rational
+        validate_self_should_error(1 + 0i) # Complex
+        validate_self_should_error(BigDecimal(5)) # BigDecimal
+        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('String')
+      end
+
+      def test_enum_schema
+        schema :integer, enum: [1, 2, 'foo', :bar, { qux: 42 }]
+
+        assert_json({
+                      type: :integer,
+                      enum: [1, 2, 'foo', :bar, { qux: 42 }]
+                    })
+
+        assert_validation(nil)
+        assert_validation(1)
+
+        # 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".'
+        end
+        assert_validation(:bar) do
+          error '/', 'Invalid type, expected "integer".'
+        end
+        assert_validation({ qux: 42 }) do
+          error '/', 'Invalid type, expected "integer".'
+        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".'
+        end
+
+        # These need to fail validation, as they are not in the enum list
+        assert_validation(13) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
+        end
+        assert_validation(4) do
+          error '/', 'Value not included in enum [1, 2, "foo", :bar, {:qux=>42}].'
+        end
+      end
+
+      def test_with_generic_keywords
+        schema :integer, enum:        [1, 'foo'],
+                         title:       'Integer schema',
+                         description: 'Integer schema holding generic keywords',
+                         examples:    [
+                           1
+                         ]
+
+        assert_json({
+                      type:        :integer,
+                      enum:        [1, 'foo'],
+                      title:       'Integer schema',
+                      description: 'Integer schema holding generic keywords',
+                      examples:    [
+                        1
+                      ]
+                    })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class IsNotNodeTest < V3Test
+      def test_optional
+        schema :is_not do
+          int minimum: 5
+        end
+
+        assert_json(
+          not: { type: :integer, minimum: 5 }
+        )
+
+        assert_validation(nil)
+        assert_validation({})
+        assert_validation(:foo)
+        assert_validation(4)
+        assert_validation(8) do
+          error '/', 'Must not match schema: {"type"=>"integer", "minimum"=>5}.'
+        end
+      end
+
+      def test_required
+        schema :is_not, required: true do
+          int minimum: 5
+        end
+
+        assert_json(
+          not: { type: :integer, minimum: 5 }
+        )
+
+        assert_validation(:foo)
+        assert_validation(4)
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+        assert_validation({})
+        assert_validation(8) do
+          error '/', 'Must not match schema: {"type"=>"integer", "minimum"=>5}.'
+        end
+      end
+
+      def test_enum_schema
+        schema :is_not do
+          str enum: ['bar', 'qux', 123, :faz]
+        end
+
+        assert_json({
+                      not: {
+                        type: :string,
+                        enum: ['bar', 'qux', 123, :faz]
+                      }
+                    })
+        assert_validation(nil)
+        assert_validation({ foo: 'bar' })
+        assert_validation('baz')
+        assert_validation(123)
+        assert_validation(:faz)
+
+        # Needs to fail the validation, as the value is included in the enum
+        # and a string (which the not turns into "failing the validation")
+        assert_validation('bar') do
+          error '/', 'Must not match schema: {"type"=>"string", "enum"=>["bar", "qux", 123, "faz"]}.'
+        end
+
+        assert_validation('qux') do
+          error '/', 'Must not match schema: {"type"=>"string", "enum"=>["bar", "qux", 123, "faz"]}.'
+        end
+      end
+
+      def test_with_generic_keywords
+        schema :is_not do
+          str enum: ['bar', 'qux', 123, :faz], title: 'Short title', description: 'Longer description', examples: ['foo']
+        end
+
+        assert_json({
+                      not: {
+                        type:        :string,
+                        enum:        ['bar', 'qux', 123, :faz],
+                        title:       'Short title',
+                        description: 'Longer description',
+                        examples:    ['foo']
+                      }
+                    })
+
+        # rubocop:disable Layout/LineLength
+
+        # Needs to fail the validation, as the value is included in the enum
+        # and a string (which the not turns into "failing the validation")
+        assert_validation('bar') do
+          error '/', 'Must not match schema: {"type"=>"string", "title"=>"Short title", "examples"=>["foo"], "description"=>"Longer description", "enum"=>["bar", "qux", 123, "faz"]}.'
+        end
+
+        assert_validation('qux') do
+          error '/', 'Must not match schema: {"type"=>"string", "title"=>"Short title", "examples"=>["foo"], "description"=>"Longer description", "enum"=>["bar", "qux", 123, "faz"]}.'
+        end
+
+        # rubocop:enable Layout/LineLength
+      end
+
+      def test_not_object_json
+        schema :is_not do
+          hsh do
+            int! :foo
+            str! :bar
+            add :integer
+          end
+        end
+
+        assert_json(
+          not: {
+            properties:           {
+              foo: {
+                type: :integer
+              },
+              bar: {
+                type: :string
+              }
+            },
+            additionalProperties: {
+              type: :integer
+            },
+            required:             %i[foo bar],
+            type:                 :object
+          }
+        )
+      end
+
+      def test_not_array
+        schema :is_not do
+          ary do
+            list :integer
+          end
+        end
+
+        assert_validation(nil)
+        assert_validation([]) do
+          error '/', 'Must not match schema: {"type"=>"array", "items"=>{"type"=>"integer"}}.'
+        end
+        assert_validation('foo')
+        assert_validation(['foo'])
+        assert_validation([1]) do
+          error '/', 'Must not match schema: {"type"=>"array", "items"=>{"type"=>"integer"}}.'
+        end
+      end
+
+      def test_invalid_schema
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Node "is_not" only allows exactly one item.' do
+          schema :is_not do
+            int
+            str
+          end
+        end
+      end
+
+      def test_casting
+        schema :is_not do
+          str format: :date
+        end
+
+        assert_validation(nil)
+        assert_validation([])
+        assert_validation(:bar)
+
+        assert_cast([], [])
+        assert_cast(1, 1)
+        assert_cast({ foo: :bar, baz: 'Str' }, { foo: :bar, baz: 'Str' })
+      end
+    end
+  end
+end