schemacop 2.4.5 → 3.0.0.rc2

data/test/validator_array_test.rb

@@ -1,97 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorArrayTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :array do
-          type :integer
-        end
-      end
-      assert_nothing_raised { s.validate!([]) }
-      assert_nothing_raised { s.validate!([0]) }
-      assert_nothing_raised { s.validate!([0, 1]) }
-      assert_verr { s.validate!(['string']) }
-    end
-
-    def test_option_min
-      s = Schema.new do
-        type :array, min: 2
-      end
-
-      assert_nothing_raised { s.validate!([0, 1]) }
-      assert_nothing_raised { s.validate!([0, 1, 2]) }
-      assert_verr { s.validate!([]) }
-      assert_verr { s.validate!([0]) }
-    end
-
-    def test_option_max
-      s = Schema.new do
-        type :array, max: 2
-      end
-
-      assert_nothing_raised { s.validate!([]) }
-      assert_nothing_raised { s.validate!([0]) }
-      assert_nothing_raised { s.validate!([0, 1]) }
-      assert_verr { s.validate!([0, 1, 2]) }
-    end
-
-    def test_options_min_max
-      s = Schema.new do
-        type :array, min: 2, max: 3 do
-          type :integer
-        end
-      end
-
-      assert_nothing_raised { s.validate!([1, 2]) }
-      assert_nothing_raised { s.validate!([1, 2, 3]) }
-      assert_verr { s.validate!([]) }
-      assert_verr { s.validate!([1]) }
-      assert_verr { s.validate!([1, 2, 3, 4]) }
-    end
-
-    def test_nil
-      s = Schema.new do
-        type :array, nil: true do
-          type :integer
-        end
-      end
-
-      assert_nothing_raised { s.validate!([1, nil, 2]) }
-      assert_verr { s.validate!([1, nil, 'nope']) }
-    end
-
-    def test_multiple_arrays
-      s = Schema.new do
-        type :array, if: proc { |arr| arr&.first&.is_a?(Integer) } do
-          type :integer
-        end
-        type :array, if: proc { |arr| arr&.first&.is_a?(String) } do
-          type :string
-        end
-      end
-
-      assert_nothing_raised { s.validate!([1, 2, 3]) }
-      assert_nothing_raised { s.validate!(%w(one two three)) }
-      assert_verr { s.validate!([1, 'mix']) }
-      assert_verr { s.validate!([]) }
-    end
-
-    def test_multiple_arrays_with_empty
-      s = Schema.new do
-        type :array, if: proc { |arr| arr&.first&.is_a?(Integer) } do
-          type :integer
-        end
-        type :array, if: proc { |arr| arr&.first&.is_a?(String) } do
-          type :string
-        end
-        type :array
-      end
-
-      assert_nothing_raised { s.validate!([]) }
-      assert_nothing_raised { s.validate!([1, 2, 3]) }
-      assert_nothing_raised { s.validate!(%w(one two three)) }
-      assert_verr { s.validate!([1, 'mix']) }
-    end
-  end
-end

data/test/validator_boolean_test.rb

@@ -1,15 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorBooleanTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :boolean
-      end
-      assert_nothing_raised { s.validate! true }
-      assert_nothing_raised { s.validate! false }
-      assert_verr { s.validate! nil }
-      assert_verr { s.validate! 1 }
-    end
-  end
-end

data/test/validator_float_test.rb

@@ -1,57 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorFloatTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :float
-      end
-      assert_nothing_raised { s.validate!(-3.0) }
-      assert_nothing_raised { s.validate!(-3.123) }
-      assert_nothing_raised { s.validate!(0.0) }
-      assert_nothing_raised { s.validate!(15.0) }
-      assert_nothing_raised { s.validate!(15.13) }
-      assert_verr { s.validate!(-3) }
-      assert_verr { s.validate!(0) }
-      assert_verr { s.validate!(15) }
-    end
-
-    def test_option_min
-      s = Schema.new do
-        type :float, min: -2
-      end
-
-      assert_nothing_raised { s.validate!(-2.0) }
-      assert_nothing_raised { s.validate!(-1.99999) }
-      assert_nothing_raised { s.validate!(1.2) }
-      assert_verr { s.validate!(-5.2) }
-      assert_verr { s.validate!(-2.00001) }
-    end
-
-    def test_option_max
-      s = Schema.new do
-        type :float, max: 5.2
-      end
-
-      assert_nothing_raised { s.validate!(-2.0) }
-      assert_nothing_raised { s.validate!(5.2) }
-      assert_verr { s.validate!(5.200001) }
-    end
-
-    def test_options_min_max
-      s = Schema.new do
-        type :float, min: -2, max: 5.2
-      end
-
-      assert_nothing_raised { s.validate!(-2.0) }
-      assert_nothing_raised { s.validate!(-1.99999) }
-      assert_nothing_raised { s.validate!(0.0) }
-      assert_nothing_raised { s.validate!(1.2) }
-      assert_nothing_raised { s.validate!(5.2) }
-      assert_verr { s.validate!(-2.00001) }
-      assert_verr { s.validate!(5.200001) }
-      assert_verr { s.validate!(6) }
-      assert_verr { s.validate!(0) }
-    end
-  end
-end

data/test/validator_hash_test.rb

@@ -1,93 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorHashTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :hash do
-          req :one do
-            type :integer
-          end
-          req :two do
-            type :boolean
-          end
-        end
-      end
-      assert_nothing_raised { s.validate!(one: 3, two: true) }
-      assert_verr { s.validate!(one: 3) }
-      assert_verr { s.validate!(two: true) }
-      assert_verr { s.validate!({}) }
-      assert_verr { s.validate!(one: 3, two: true, three: 3) }
-      assert_verr { s.validate!(one: 3, three: true) }
-    end
-
-    def test_allow_obsolete_keys
-      s = Schema.new do
-        type :hash, allow_obsolete_keys: true
-      end
-
-      assert_nothing_raised { s.validate!(foo: :bar) }
-      assert_equal({ foo: { bar: :baz } }, s.validate!(foo: { bar: :baz }))
-
-      assert_verr { s.validate!(3) }
-    end
-
-    def test_allow_obsolete_keys_with_substructore
-      s = Schema.new do
-        type :hash, allow_obsolete_keys: true do
-          req :foo
-        end
-      end
-
-      assert_nothing_raised { s.validate!(foo: :bar, bar: :baz) }
-      assert_verr { s.validate!(bar: :baz) }
-    end
-
-    def test_nested
-      s = Schema.new do
-        type :hash do
-          req :h do
-            type :hash do
-              req :i do
-                type :integer
-              end
-            end
-          end
-        end
-      end
-      s.validate(h: { i: 3 })
-      assert_verr { s.validate!(h: { i: true }) }
-      assert_verr { s.validate!(h: {}) }
-      assert_verr { s.validate!({}) }
-      assert_verr { s.validate!(g: { i: 3 }) }
-      assert_verr { s.validate!(h: { j: 3 }) }
-    end
-
-    def test_req_opt
-      s = Schema.new do
-        type :hash do
-          req :r do
-            type :boolean
-          end
-          req? :r_nil do
-            type :boolean
-          end
-          opt :o do
-            type :boolean
-          end
-          opt! :o_nonnil do
-            type :boolean
-          end
-        end
-      end
-
-      assert_nothing_raised { s.validate!(r: true, r_nil: false) }
-      assert_nothing_raised { s.validate!(r: true, r_nil: nil) }
-      assert_nothing_raised { s.validate!(r: true, r_nil: false, o: false) }
-      assert_nothing_raised { s.validate!(r: true, r_nil: false, o: nil) }
-      assert_verr { s.validate!(r: true, r_nil: false, o_nonnil: nil) }
-      assert_verr { s.validate!(o: true) }
-      assert_verr { s.validate!(r: nil, r_nil: false, o: true) }
-    end
-  end
-end

data/test/validator_integer_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorIntegerTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :integer
-      end
-      assert_nothing_raised { s.validate!(-3) }
-      assert_nothing_raised { s.validate!(0) }
-      assert_nothing_raised { s.validate!(15) }
-      assert_verr { s.validate!(0.0) }
-    end
-
-    def test_option_min
-      s = Schema.new do
-        type :integer, min: 6
-      end
-
-      assert_nothing_raised { s.validate!(6) }
-      assert_nothing_raised { s.validate!(7) }
-      assert_verr { s.validate!(5) }
-    end
-
-    def test_option_max
-      s = Schema.new do
-        type :integer, max: 7
-      end
-
-      assert_nothing_raised { s.validate!(6) }
-      assert_nothing_raised { s.validate!(7) }
-      assert_verr { s.validate!(8) }
-    end
-
-    def test_options_min_max
-      s = Schema.new do
-        type :integer, min: 6, max: 7
-      end
-
-      assert_nothing_raised { s.validate!(6) }
-      assert_nothing_raised { s.validate!(7) }
-      assert_verr { s.validate!(5) }
-      assert_verr { s.validate!(8) }
-    end
-  end
-end

data/test/validator_nil_test.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorNilTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :nil
-      end
-      assert_nothing_raised { s.validate! nil }
-      assert_verr { s.validate! false }
-    end
-  end
-end

data/test/validator_number_test.rb

@@ -1,60 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorNumberTest < Minitest::Test
-    def test_basic
-      s = Schema.new do
-        type :number
-      end
-      assert_nothing_raised { s.validate!(-3) }
-      assert_nothing_raised { s.validate!(-3.123) }
-      assert_nothing_raised { s.validate!(0) }
-      assert_nothing_raised { s.validate!(15) }
-      assert_nothing_raised { s.validate!(15.13) }
-      assert_verr { s.validate!('0.12') }
-    end
-
-    def test_option_min
-      s = Schema.new do
-        type :number, min: -2
-      end
-
-      assert_nothing_raised { s.validate!(-2) }
-      assert_nothing_raised { s.validate!(-1.99999) }
-      assert_nothing_raised { s.validate!(0) }
-      assert_nothing_raised { s.validate!(1.2) }
-      assert_verr { s.validate!(-3) }
-      assert_verr { s.validate!(-2.00001) }
-    end
-
-    def test_option_max
-      s = Schema.new do
-        type :number, max: 5.2
-      end
-
-      assert_nothing_raised { s.validate!(-2) }
-      assert_nothing_raised { s.validate!(-1.9) }
-      assert_nothing_raised { s.validate!(0) }
-      assert_nothing_raised { s.validate!(5.19999) }
-      assert_nothing_raised { s.validate!(5.2) }
-      assert_verr { s.validate!(5.200001) }
-      assert_verr { s.validate!(6) }
-    end
-
-    def test_options_min_max
-      s = Schema.new do
-        type :number, min: -2, max: 5.2
-      end
-
-      assert_nothing_raised { s.validate!(-2) }
-      assert_nothing_raised { s.validate!(-1.99999) }
-      assert_nothing_raised { s.validate!(0) }
-      assert_nothing_raised { s.validate!(1.2) }
-      assert_nothing_raised { s.validate!(5.2) }
-      assert_verr { s.validate!(-3) }
-      assert_verr { s.validate!(-2.00001) }
-      assert_verr { s.validate!(5.200001) }
-      assert_verr { s.validate!(6) }
-    end
-  end
-end

data/test/validator_object_test.rb

@@ -1,139 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class ValidatorObjectTest < Minitest::Test
-    # 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