schemacop 2.4.6 → 3.0.0.rc3

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

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class ValidatorObjectTest < V2Test
+      # Classes used in the tests below
+      class User; end
+      class AdminUser; end
+      class SubUser < User; end
+
+      def test_basic
+        s = Schema.new do
+          type :object, classes: User
+        end
+
+        assert_nothing_raised { s.validate!(User.new) }
+        assert_verr { s.validate!(SubUser.new) }
+        assert_verr { s.validate!(AdminUser.new) }
+      end
+
+      # In modern versions of ruby, some classes such as Tempfile are not derived
+      # from Object but from BasicObject. Before the time of writing this test,
+      # the ObjectValidator only accepted subclasses of Object and classes like
+      # Tempfile did not work at all. This test ensures that this is working now.
+      def test_basic_object
+        refute Tempfile <= Object
+        assert Tempfile <= BasicObject
+
+        s = Schema.new do
+          type :object
+        end
+
+        assert_nothing_raised { s.validate!(Tempfile.new) }
+
+        s = Schema.new do
+          req :foo
+        end
+
+        assert_nothing_raised { s.validate!(foo: Tempfile.new) }
+
+        s = Schema.new do
+          req :foo, Tempfile
+        end
+
+        assert_nothing_raised { s.validate!(foo: Tempfile.new) }
+        assert_verr { s.validate!(foo: Time.new) }
+
+        s = Schema.new do
+          req :foo, :object, classes: Tempfile
+        end
+
+        assert_nothing_raised { s.validate!(foo: Tempfile.new) }
+      end
+
+      def test_multiple_classes_long
+        s = Schema.new do
+          type :object, classes: User
+          type :object, classes: AdminUser
+        end
+
+        assert_nothing_raised { s.validate!(User.new) }
+        assert_nothing_raised { s.validate!(AdminUser.new) }
+        assert_verr { s.validate!(SubUser.new) }
+        assert_verr { s.validate!([User.new, AdminUser.new]) }
+      end
+
+      def test_multiple_classes_short
+        s = Schema.new do
+          type :object, classes: [User, AdminUser]
+        end
+
+        assert_nothing_raised { s.validate!(User.new) }
+        assert_nothing_raised { s.validate!(AdminUser.new) }
+        assert_verr { s.validate!(SubUser.new) }
+        assert_verr { s.validate!([User.new, AdminUser.new]) }
+      end
+
+      def test_hash_of_objects
+        s = Schema.new do
+          req :user do
+            type :object, classes: User
+          end
+          opt :multitype do
+            type :object, classes: [User, AdminUser]
+          end
+        end
+
+        assert_nothing_raised { s.validate!(user: User.new) }
+        assert_nothing_raised { s.validate!(user: User.new, multitype: AdminUser.new) }
+        assert_nothing_raised { s.validate!(user: User.new, multitype: User.new) }
+        assert_verr { s.validate!(user: AdminUser.new) }
+        assert_verr { s.validate!(user: User.new, multitype: 12) }
+        assert_verr { s.validate!(user: User.new, multitype: self) }
+      end
+
+      def test_any
+        s = Schema.new do
+          type :object
+        end
+
+        assert_nothing_raised { s.validate!(User.new) }
+        assert_nothing_raised { s.validate!(123) }
+        assert_nothing_raised { s.validate!('sali') }
+        assert_nothing_raised { s.validate!(self) }
+        assert_nothing_raised { s.validate!(self.class) }
+        assert_verr { s.validate!(nil) }
+      end
+
+      def test_any_in_hash
+        s = Schema.new do
+          req :fld do
+            type :object
+          end
+        end
+
+        assert_nothing_raised { s.validate!(fld: User.new) }
+        assert_nothing_raised { s.validate!(fld: self) }
+        assert_verr { s.validate!(fld: nil) }
+        assert_verr { s.validate!({}) }
+      end
+
+      def test_strict_option
+        s = Schema.new do
+          req :o_strict do
+            type :object, classes: User, strict: true
+          end
+          opt :o_ns do
+            type :object, classes: User, strict: false
+          end
+        end
+
+        assert_nothing_raised { s.validate!(o_strict: User.new, o_ns: User.new) }
+        assert_nothing_raised { s.validate!(o_strict: User.new, o_ns: SubUser.new) }
+        assert_nothing_raised { s.validate!(o_strict: User.new) }
+        assert_verr { s.validate!(o_strict: SubUser.new) }
+        assert_verr { s.validate!(o_strict: User.new, o_ns: AdminUser.new) }
+        assert_verr { s.validate!(o_strict: SubUser.new, o_ns: User.new) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class ValidatorStringTest < V2Test
+      def test_basic
+        s = Schema.new do
+          type :string
+        end
+        assert_nothing_raised { s.validate! '' }
+        assert_nothing_raised { s.validate! 'abc' }
+        assert_nothing_raised { s.validate! 123.to_s }
+        assert_nothing_raised { s.validate! inspect }
+      end
+
+      def test_option_min
+        s = Schema.new do
+          type :string, min: 3
+        end
+
+        assert_nothing_raised { s.validate!('abc') }
+        assert_nothing_raised { s.validate!('abcd') }
+        assert_verr { s.validate!('ab') }
+        assert_verr { s.validate!('') }
+      end
+
+      def test_option_max
+        s = Schema.new do
+          type :string, max: 5
+        end
+
+        assert_nothing_raised { s.validate!('') }
+        assert_nothing_raised { s.validate!('abcd') }
+        assert_nothing_raised { s.validate!('abcde') }
+        assert_verr { s.validate!('abcdef') }
+      end
+
+      def test_options_min_max
+        s = Schema.new do
+          type :string, min: 3, max: 5
+        end
+
+        assert_nothing_raised { s.validate!('abc') }
+        assert_nothing_raised { s.validate!('abcd') }
+        assert_nothing_raised { s.validate!('abcde') }
+        assert_verr { s.validate!('ab') }
+        assert_verr { s.validate!('abcdef') }
+        assert_verr { s.validate!('') }
+      end
+
+      def test_float_options
+        assert_raises Exceptions::InvalidSchemaError, 'String option :min must be an integer >= 0.' do
+          Schema.new do
+            type :string, min: 3.2
+          end
+        end
+
+        assert_raises Exceptions::InvalidSchemaError, 'String option :max must be an integer >= 0.' do
+          Schema.new do
+            type :string, max: 5.2
+          end
+        end
+
+        assert_raises Exceptions::InvalidSchemaError, 'String option :min must be an integer >= 0.' do
+          Schema.new do
+            type :string, min: 3.2, max: 5
+          end
+        end
+
+        assert_raises Exceptions::InvalidSchemaError, 'String option :max must be an integer >= 0.' do
+          Schema.new do
+            type :string, min: 3, max: 5.2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class ValidatorSymbolTest < V2Test
+      def test_basic
+        s = Schema.new do
+          type :symbol
+        end
+
+        assert_nothing_raised { s.validate!(:good) }
+        assert_nothing_raised { s.validate!('-+/'.to_sym) }
+        assert_verr { s.validate!('bad') }
+        assert_verr { s.validate!(456) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,198 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class AllOfNodeTest < V3Test
+      def test_optional
+        schema :all_of do
+          str min_length: 2
+          str max_length: 4
+        end
+
+        assert_validation(nil)
+        assert_validation('12')
+        assert_validation('1234')
+        assert_validation('1') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_validation('12345') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+      end
+
+      def test_required
+        schema :all_of, required: true do
+          int minimum: 2
+          int maximum: 4
+        end
+
+        assert_validation(2)
+        assert_validation(3)
+        assert_validation(4)
+
+        assert_validation(5) do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_validation(1) do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_validation({}) do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_validation(42) do
+          error '/', 'Does not match all allOf conditions.'
+        end
+      end
+
+      def test_nested
+        schema :all_of do
+          hsh additional_properties: true do
+            all_of! :foo do
+              int minimum: 2
+              int maximum: 4
+            end
+          end
+          hsh additional_properties: true do
+            any_of! :bar do
+              int minimum: 6
+              int maximum: 8
+            end
+          end
+        end
+
+        assert_validation(foo: 2, bar: 7)
+        assert_validation(foo: 5, bar: 7) do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_validation(foo: 5) do
+          error '/', 'Does not match all allOf conditions.'
+        end
+      end
+
+      def test_simple_casting
+        schema :all_of do
+          str format: :integer
+        end
+
+        assert_validation(nil)
+        assert_validation('1')
+        assert_validation('Foo') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+
+        assert_cast('1', 1)
+        assert_cast('1337', 1337)
+      end
+
+      def test_casting_with_conditions
+        schema :all_of do
+          str format:     :integer
+          str min_length: 2
+          str max_length: 3
+        end
+
+        assert_validation(nil)
+        assert_validation('12')
+        assert_validation('123')
+
+        assert_validation('1') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+
+        assert_validation('1234') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_cast('42', 42)
+      end
+
+      def test_casting_with_conditions_changed_order
+        schema :all_of do
+          str min_length: 2
+          str max_length: 3
+          str format:     :integer
+        end
+
+        assert_validation(nil)
+        assert_validation('12')
+        assert_validation('123')
+
+        assert_validation('1') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+
+        assert_validation('1234') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+
+        assert_cast('42', 42)
+        assert_cast('123', 123)
+      end
+
+      def test_hash_casting
+        schema :all_of do
+          hsh additional_properties: true do
+            str! :foo, format: :integer
+          end
+          hsh additional_properties: true do
+            str! :bar, format: :date
+          end
+        end
+
+        assert_validation(foo: '42', bar: '2020-01-15')
+
+        assert_cast(
+          { foo: '42', bar: '2020-01-15' },
+          { foo: 42, bar: Date.new(2020, 1, 15) }.with_indifferent_access
+        )
+      end
+
+      def test_nonsensical_casting
+        schema :all_of do
+          str format: :integer
+          str format: :boolean
+        end
+
+        assert_validation(nil)
+        assert_validation('42') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+        assert_validation('true') do
+          error '/', 'Does not match all allOf conditions.'
+        end
+      end
+
+      def test_defaults
+        schema :all_of do
+          str default: 'foobar'
+        end
+
+        assert_validation(nil)
+        assert_validation('Hello World')
+
+        assert_json({
+                      allOf: [
+                        type:    :string,
+                        default: 'foobar'
+                      ]
+                    })
+      end
+
+      def test_with_generic_keywords
+        schema :all_of, title:       'allOf schema',
+                        description: 'allOf schema holding generic keywords',
+                        examples:    [
+                          'foo'
+                        ]
+
+        assert_json({
+                      allOf:       [],
+                      title:       'allOf schema',
+                      description: 'allOf schema holding generic keywords',
+                      examples:    [
+                        'foo'
+                      ]
+                    })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+require 'test_helper'
+
+module Schemacop
+  module V3
+    class AnyOfNodeTest < V3Test
+      def test_optional
+        schema :any_of do
+          str
+          int
+        end
+
+        assert_validation(nil)
+        assert_validation('string')
+        assert_validation(42)
+        assert_validation(42.1) do
+          error '/', 'Does not match any anyOf condition.'
+        end
+        assert_validation({}) do
+          error '/', 'Does not match any anyOf condition.'
+        end
+      end
+
+      def test_required
+        schema :any_of, required: true do
+          str
+          int
+        end
+
+        assert_validation('string')
+        assert_validation(42)
+
+        assert_validation(nil) do
+          error '/', 'Value must be given.'
+        end
+
+        assert_validation(42.1) do
+          error '/', 'Does not match any anyOf condition.'
+        end
+        assert_validation({}) do
+          error '/', 'Does not match any anyOf condition.'
+        end
+      end
+
+      def test_nested
+        schema :any_of do
+          hsh do
+            any_of! :foo do
+              int
+              str
+            end
+          end
+          int
+        end
+
+        assert_validation(nil)
+        assert_validation(42)
+        assert_validation(foo: 42)
+        assert_validation(foo: 'str')
+        assert_validation('string') do
+          error '/', 'Does not match any anyOf condition.'
+        end
+        assert_validation(bar: :baz) do
+          error '/', 'Does not match any anyOf condition.'
+        end
+        assert_validation(foo: :bar) do
+          error '/', 'Does not match any anyOf condition.'
+        end
+      end
+
+      def test_all_types
+        schema :any_of do
+          all_of do
+            hsh { str! :foo }
+          end
+          any_of do
+            obj(Date)
+            obj(Time)
+          end
+          ary
+          boo
+          int
+          num
+          hsh { int! :bar }
+          one_of do
+            hsh { str! :a, pattern: '^a' }
+            hsh { str! :a, pattern: 'z$' }
+          end
+          ref :MyDate
+          str max_length: 2
+        end
+
+        context = Context.new
+        context.schema :MyDate, :string, format: :date
+
+        Schemacop.with_context context do
+          assert_validation(nil)
+          assert_validation(foo: 'str')
+          assert_validation([1, 2, 3])
+          assert_validation(true)
+          assert_validation(false)
+          assert_validation(42)
+          assert_validation(42.2)
+          assert_validation(bar: 42)
+          assert_validation(a: 'a hello')
+          assert_validation(a: 'hello z')
+          assert_validation('1990-01-13')
+          assert_validation('12')
+          assert_validation(Date.new(1990, 1, 13))
+          assert_validation(Time.now)
+
+          assert_validation('1990-01-13 12') do
+            error '/', 'Does not match any anyOf condition.'
+          end
+          assert_validation(a: 'a hello z') do
+            error '/', 'Does not match any anyOf condition.'
+          end
+          assert_validation(Object.new) do
+            error '/', 'Does not match any anyOf condition.'
+          end
+        end
+      end
+
+      def test_casting
+        schema do
+          any_of! :created_at do
+            str format: :date
+            str format: :date_time
+          end
+        end
+
+        assert_validation(created_at: '2020-01-01')
+        assert_validation(created_at: '2020-01-01T17:38:20')
+
+        assert_cast(
+          { created_at: '2020-01-01' },
+          { 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) }.with_indifferent_access
+        )
+      end
+
+      def test_defaults
+        schema do
+          any_of! :foo do
+            hsh { str? :bar }
+            hsh { str? :baz, default: 'Baz' }
+          end
+        end
+
+        assert_validation(foo: { bar: 'Bar' })
+        assert_validation(foo: { baz: 'Baz' })
+
+        assert_validation(foo: { xyz: 'Baz' }) do
+          error '/foo', 'Does not match any anyOf condition.'
+        end
+
+        assert_cast(
+          { foo: { bar: nil } },
+          { foo: { bar: nil } }.with_indifferent_access
+        )
+
+        assert_cast(
+          { foo: { baz: nil } },
+          { foo: { baz: 'Baz' } }.with_indifferent_access
+        )
+
+        schema do
+          any_of! :foo do
+            hsh { str? :bar, format: :date }
+            hsh { str? :bar, default: 'Baz', format: :date_time }
+          end
+        end
+
+        assert_cast(
+          { foo: { bar: '1990-01-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) } }.with_indifferent_access
+        )
+      end
+
+      def test_with_generic_keywords
+        schema :any_of, title:       'anyOf schema',
+                        description: 'anyOf schema holding generic keywords',
+                        examples:    [
+                          'foo'
+                        ] do
+                          str
+                          int
+                        end
+
+        assert_json({
+                      anyOf:       [
+                        { type: :string },
+                        { type: :integer }
+                      ],
+                      title:       'anyOf schema',
+                      description: 'anyOf schema holding generic keywords',
+                      examples:    [
+                        'foo'
+                      ]
+                    })
+      end
+
+      def test_invalid_schema
+        assert_raises_with_message Exceptions::InvalidSchemaError,
+                                   'Node "any_of" makes only sense with at least 1 item.' do
+          schema :any_of
+        end
+      end
+    end
+  end
+end