schemacop 1.0.2 → 2.0.0

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'schemacop'
+
+def assert_verr(&_block)
+  assert_raises(Schemacop::Exceptions::ValidationError) { yield }
+end

data/test/types_test.rb

@@ -0,0 +1,83 @@
+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,
+                            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_nil s.validate! true
+      assert_nil s.validate! false
+      assert_nil 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_nil 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_nil schema.validate! data
+        else
+          assert_verr { schema.validate! data }
+        end
+      end
+    end
+  end
+end

data/test/validator_array_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+module Schemacop
+  class ValidatorArrayTest < Minitest::Test
+    def test_basic
+      s = Schema.new do
+        type :array do
+          type :integer
+        end
+      end
+      assert_nil s.validate!([])
+      assert_nil s.validate!([0])
+      assert_nil s.validate!([0, 1])
+      assert_verr { s.validate!(['string']) }
+    end
+
+    def test_option_min
+      s = Schema.new do
+        type :array, min: 2
+      end
+
+      assert_nil s.validate!([0, 1])
+      assert_nil 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_nil s.validate!([])
+      assert_nil s.validate!([0])
+      assert_nil 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_nil s.validate!([1, 2])
+      assert_nil 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_nil 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_nil s.validate!([1, 2, 3])
+      assert_nil 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_nil s.validate!([])
+      assert_nil s.validate!([1, 2, 3])
+      assert_nil s.validate!(%w(one two three))
+      assert_verr { s.validate!([1, 'mix']) }
+    end
+  end
+end

data/test/validator_boolean_test.rb

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

data/test/validator_float_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Schemacop
+  class ValidatorFloatTest < Minitest::Test
+    def test_basic
+      s = Schema.new do
+        type :float
+      end
+      assert_nil s.validate!(-3.0)
+      assert_nil s.validate!(-3.123)
+      assert_nil s.validate!(0.0)
+      assert_nil s.validate!(15.0)
+      assert_nil 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_nil s.validate!(-2.0)
+      assert_nil s.validate!(-1.99999)
+      assert_nil 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_nil s.validate!(-2.0)
+      assert_nil 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_nil s.validate!(-2.0)
+      assert_nil s.validate!(-1.99999)
+      assert_nil s.validate!(0.0)
+      assert_nil s.validate!(1.2)
+      assert_nil 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

@@ -0,0 +1,71 @@
+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_nil 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_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_nil s.validate!(r: true, r_nil: false)
+      assert_nil s.validate!(r: true, r_nil: nil)
+      assert_nil s.validate!(r: true, r_nil: false, o: false)
+      assert_nil 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

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

data/test/validator_nil_test.rb

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

data/test/validator_number_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Schemacop
+  class ValidatorNumberTest < Minitest::Test
+    def test_basic
+      s = Schema.new do
+        type :number
+      end
+      assert_nil s.validate!(-3)
+      assert_nil s.validate!(-3.123)
+      assert_nil s.validate!(0)
+      assert_nil s.validate!(15)
+      assert_nil 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_nil s.validate!(-2)
+      assert_nil s.validate!(-1.99999)
+      assert_nil s.validate!(0)
+      assert_nil 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_nil s.validate!(-2)
+      assert_nil s.validate!(-1.9)
+      assert_nil s.validate!(0)
+      assert_nil s.validate!(5.19999)
+      assert_nil 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_nil s.validate!(-2)
+      assert_nil s.validate!(-1.99999)
+      assert_nil s.validate!(0)
+      assert_nil s.validate!(1.2)
+      assert_nil 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