schemacop 2.4.7 → 3.0.0.rc4

data/test/types_test.rb

@@ -1,84 +0,0 @@
-require 'test_helper'
-
-module Schemacop
-  class TypesTest < Minitest::Test
-    def setup
-      @datatype_samples = { array: [],
-                            boolean: true,
-                            float: 2.3,
-                            hash: {},
-                            integer: -5,
-                            number: -3.2,
-                            symbol: :thing,
-                            object: self,
-                            string: 'miau' }.freeze
-    end
-
-    def test_multitype
-      assert_only_types_allowed(
-        Schema.new do
-          type :integer
-          type :boolean
-        end, [:integer, :boolean]
-      )
-
-      assert_only_types_allowed(
-        Schema.new([:integer, :boolean]),
-        [:integer, :boolean]
-      )
-    end
-
-    def test_all_data_types
-      @datatype_samples.keys.each do |type|
-        assert_only_types_allowed(Schema.new(type), type)
-      end
-    end
-
-    def test_conditional_types
-      s = Schema.new do
-        type :boolean
-        type :integer, min: 5
-      end
-
-      assert_nothing_raised { s.validate! true }
-      assert_nothing_raised { s.validate! false }
-      assert_nothing_raised { s.validate! 5 }
-
-      assert_verr { s.validate! 'sali' }
-      assert_verr { s.validate! 4 }
-    end
-
-    # For short form test see short_forms_test.rb
-    def test_array_subtype_explicit
-      s = Schema.new do
-        type :array do
-          type :integer
-        end
-      end
-      assert_nothing_raised { s.validate! [5] }
-      assert_verr { s.validate! [nil] }
-      assert_verr { s.validate! ['a'] }
-      assert_verr { s.validate! [5, 'a'] }
-      assert_verr { s.validate! [5, nil] }
-    end
-
-    private
-
-    def assert_only_types_allowed(schema, allowed_types)
-      allowed_types = [*allowed_types]
-      @datatype_samples.each do |type, data|
-        if allowed_types.include?(type) ||
-           # All the weird cases need to be differentiated
-           (type == :float && allowed_types.include?(:number)) ||
-           (type == :integer && allowed_types.include?(:number)) ||
-           (type == :number && allowed_types.include?(:float)) ||
-           allowed_types.include?(:object)
-
-          assert_nothing_raised { schema.validate! data }
-        else
-          assert_verr { schema.validate! data }
-        end
-      end
-    end
-  end
-end

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