schemacop 2.4.7 → 3.0.0.rc4

data/test/schemas/nested/group.rb

@@ -0,0 +1,6 @@
+schema do
+  str! :name
+  ary? :users do
+    ref 'user'
+  end
+end

data/test/schemas/user.rb

@@ -0,0 +1,7 @@
+schema do
+  str! :first_name
+  str! :last_name
+  ary? :groups do
+    ref 'nested/group'
+  end
+end

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

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class CastingTest < V2Test
+      def test_basic
+        s = Schema.new :integer, cast: [String]
+
+        input = '42'
+        output = s.validate!(input)
+
+        assert_equal(42, output)
+      end
+
+      def test_field
+        s = Schema.new do
+          req :foo, :integer, cast: [String]
+        end
+
+        input = { foo: '42' }
+        output = s.validate!(input)
+
+        assert_equal({ foo: '42' }, input)
+        assert_equal({ foo: 42 }, output)
+      end
+
+      def test_first_type_matches
+        s = Schema.new do
+          type TrueClass
+          type :integer, cast: [String]
+        end
+
+        assert_equal(42, s.validate!('42'))
+        assert_equal(42, s.validate!(42))
+        assert_equal(true, s.validate!(true))
+      end
+
+      def test_with_if
+        s = Schema.new do
+          type Float, if: proc { |data| !data.is_a?(String) || data.match(/\d+\.\d+/) }, cast: [String]
+          type Integer, cast: [String]
+        end
+
+        assert_equal 42.2, s.validate!('42.2')
+        assert_equal 42, s.validate!('42')
+      end
+
+      def test_arrays
+        s = Schema.new do
+          req :foo, :array, :integer, cast: [String]
+        end
+
+        assert_equal(
+          { foo: [1, 2, 3] },
+          s.validate!(foo: %w[1 2 3])
+        )
+      end
+
+      def test_check_after_cast
+        s = Schema.new do
+          type Integer, cast: [String], check: proc { |v| v > 41 }
+        end
+
+        assert_equal 42, s.validate!('42')
+        assert_equal 43, s.validate!('43')
+        assert_equal 42, s.validate!(42)
+        assert_verr { s.validate!('41') }
+        assert_verr { s.validate!(42.2) }
+      end
+
+      def test_multilple_types
+        e = assert_raises Exceptions::InvalidSchemaError do
+          Schema.new do
+            type :number, cast: [String]
+          end
+        end
+
+        assert_equal 'Casting is only allowed for single-value datatypes, '\
+                     'but type Schemacop::V2::NumberValidator has classes ["Integer", "Float"].',
+                     e.message
+      end
+
+      def test_custom_castings
+        s = Schema.new do
+          type :integer, cast: { String => proc { |v| Integer(v) } }
+        end
+
+        assert_equal 42, s.validate!('42')
+      end
+
+      def test_decimal_basis_castings
+        s = Schema.new do
+          type :integer, cast: [String]
+        end
+
+        assert_equal 1, s.validate!('01')
+        assert_equal 8, s.validate!('08')
+        assert_equal 11, s.validate!('011')
+      end
+
+      def test_string_to_nil_castings
+        s = Schema.new do
+          opt :int_field, :integer, cast: [String]
+          opt :float_field, :float, cast: [String]
+        end
+
+        expected_int = { int_field: nil }
+        expected_float = { float_field: nil }
+
+        assert_equal expected_int, s.validate!(int_field: nil)
+        assert_equal expected_int, s.validate!(int_field: '')
+        assert_equal expected_int, s.validate!(int_field: '     ')
+
+        assert_equal expected_float, s.validate!(float_field: nil)
+        assert_equal expected_float, s.validate!(float_field: '')
+        assert_equal expected_float, s.validate!(float_field: '     ')
+      end
+
+      def test_float_to_integer
+        s = Schema.new do
+          req :foo, :integer, cast: [Float]
+        end
+
+        assert_equal({ foo: 42 }, s.validate!(foo: 42.0))
+        assert_equal({ foo: 42 }, s.validate!(foo: Float(42)))
+      end
+
+      def test_integer_to_float
+        s = Schema.new do
+          req :foo, :float, cast: [Integer]
+        end
+
+        assert_equal({ foo: 42.0 }, s.validate!(foo: 42))
+        assert_equal({ foo: 42.0 }, s.validate!(foo: Integer(42)))
+      end
+
+      def test_invalid_cast_option
+        s = Schema.new do
+          req :foo, :integer, cast: true
+        end
+
+        assert_raises Schemacop::Exceptions::InvalidSchemaError do
+          s.validate!({ foo: '42' })
+        end
+      end
+
+      def test_impossible_cast
+        s = Schema.new do
+          req :foo, :integer, cast: [String]
+        end
+
+        assert_equal({ foo: 42 }, s.validate!(foo: '42'))
+        assert_verr { s.validate!(foo: 'foo') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class CollectorTest < V2Test
+      def test_no_root_node
+        s = Schema.new do
+          req :a, :string
+        end
+
+        col = s.validate(a: 0)
+        assert col.exceptions.first[:path].first !~ %r{^/root}, 'Root node is present in the path.'
+      end
+
+      def test_correct_path
+        s = Schema.new do
+          req :long_symbol, :string
+          req 'long_string', :string
+          req 123, :string
+        end
+
+        col = s.validate('long_string' => 0, long_symbol: 0, 123 => 0)
+
+        symbol = col.exceptions[0]
+        string = col.exceptions[1]
+        number = col.exceptions[2]
+
+        assert symbol[:path].first =~ %r{^/long_symbol}
+        assert string[:path].first =~ %r{^/long_string}
+        assert number[:path].first =~ %r{^/123}
+      end
+
+      def test_nested_paths
+        s = Schema.new do
+          req :one do
+            req :two, :string
+          end
+          req :three, :string
+        end
+
+        col = s.validate(one: { two: 0 }, three: 0)
+        assert_equal 2, col.exceptions[0][:path].length
+        assert_equal 1, col.exceptions[1][:path].length
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class CustomCheckTest < V2Test
+      def test_integer_check_short_form
+        s = Schema.new :integer, check: proc { |i| i.even? }
+        assert_nothing_raised { s.validate!(2) }
+        assert_nothing_raised { s.validate!(-8) }
+        assert_nothing_raised { s.validate!(0) }
+        assert_verr { s.validate!(1) }
+        assert_verr { s.validate!(-7) }
+        assert_verr { s.validate!(2.1) }
+      end
+
+      def test_custom_error_message
+        s = Schema.new :integer, check: proc { |i| i.even? ? true : 'Custom error' }
+        assert_nothing_raised { s.validate!(2) }
+        exception = assert_verr { s.validate!(3) }
+        assert_match(/Custom :check failed: Custom error\./, exception.message)
+      end
+
+      def test_integer_check_with_lambda
+        s = Schema.new do
+          type :integer, check: ->(i) { i.even? }
+        end
+
+        assert_nothing_raised { s.validate!(2) }
+        assert_nothing_raised { s.validate!(-8) }
+        assert_nothing_raised { s.validate!(0) }
+        assert_verr { s.validate!(1) }
+        assert_verr { s.validate!(-7) }
+        assert_verr { s.validate!(2.1) }
+      end
+
+      def test_in_type_dsl
+        s = Schema.new do
+          type :number, check: proc { |x| x == 42 }
+        end
+        assert_nothing_raised { s.validate!(42) }
+        assert_verr { s.validate!(42.1) }
+        assert_verr { s.validate!(0) }
+      end
+
+      def test_with_array
+        s = Schema.new do
+          type :array, check: proc { |a| a.first == 1 } do
+            type :integer
+          end
+        end
+        assert_nothing_raised { s.validate!([1, 2, 3]) }
+        assert_verr { s.validate!([2, 3, 4]) }
+      end
+
+      def test_with_array_nested
+        s = Schema.new do
+          type :array, check: proc { |a| a.first == 4 } do
+            type :integer, check: proc { |i| i >= 2 }
+          end
+        end
+
+        assert_nothing_raised { s.validate!([4, 3, 2]) }
+        assert_verr { s.validate!([3, 2]) }
+        assert_verr { s.validate!([4, 1]) }
+      end
+
+      def test_with_hash
+        s = Schema.new :hash, check: proc { |h| h.all? { |k, v| k == v } } do
+          opt 1, :integer
+          opt 'two', :string
+        end
+        assert_nothing_raised { s.validate!(1 => 1, 'two' => 'two') }
+        assert_verr { s.validate!(1 => 2, 'two' => 'two') }
+        assert_verr { s.validate!(1 => 1, 'two' => 'one') }
+      end
+
+      def test_mixed_if_check
+        s = Schema.new do
+          req :first_name,
+              :string,
+              if:    proc { |str| str.start_with?('Sand') },
+              check: proc { |str| str == 'Sandy' }
+          req :first_name, :string, min: 3
+        end
+
+        assert_nothing_raised { s.validate!(first_name: 'Bob') }
+        assert_nothing_raised { s.validate!(first_name: 'Sandy') }
+        assert_nothing_raised { s.validate!(first_name: 'Sansibar') }
+
+        assert_verr { s.validate!(first_name: 'Sandkasten') }
+        assert_verr { s.validate!(first_name: 'a') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class CustomIfTest < V2Test
+      def test_allowed_subset_only
+        s = Schema.new do
+          type :integer, if: proc { |data| data.odd? }
+        end
+
+        assert_nothing_raised { s.validate! 5 }
+        assert_verr { s.validate! nil }
+        assert_verr { s.validate! 4 }
+      end
+
+      def test_if_with_multiple_types
+        s = Schema.new do
+          type :integer, if: proc { |data| data.odd? }
+          type :string
+        end
+
+        assert_nothing_raised { s.validate!(5) }
+        assert_nothing_raised { s.validate!('abc') }
+        assert_verr { s.validate!(4) }
+      end
+
+      def test_if_with_string
+        s = Schema.new do
+          req :foo, :string, if: proc { |data| data.start_with?('a') }, min: 3
+          req :foo, :string, min: 5
+        end
+
+        assert_nothing_raised { s.validate!(foo: 'abc') }
+        assert_nothing_raised { s.validate!(foo: 'bcdef') }
+        assert_verr { s.validate!(foo: 'a') }
+        assert_verr { s.validate!(foo: 'bcde') }
+      end
+
+      def test_if_with_multiple_types_in_field
+        s = Schema.new do
+          req :foo, :string, if: proc { |data| data.start_with?('a') }
+          req :foo, :integer
+        end
+
+        assert_nothing_raised { s.validate!(foo: 3) }
+        assert_nothing_raised { s.validate!(foo: 'abc') }
+        assert_verr { s.validate!(foo: 'bcd') }
+        assert_verr { s.validate!(foo: true) }
+      end
+
+      def test_if_with_hash_in_array
+        s = Schema.new do
+          req :user, :array do
+            type :hash, if: proc { |data| data[:admin] } do
+              req :admin, :boolean
+              req :admin_only, :string
+            end
+            type :hash do
+              opt :admin
+              req :non_admin_only, :string
+            end
+          end
+        end
+
+        assert_nothing_raised { s.validate!(user: [{ admin: true, admin_only: 'foo' }, { admin: false, non_admin_only: 'foo' }]) }
+        assert_nothing_raised { s.validate!(user: [{ admin: true, admin_only: 'foo' }, { non_admin_only: 'foo' }]) }
+        assert_verr { s.validate!(user: [{ admin: false, admin_only: 'foo' }]) }
+        assert_verr { s.validate!(user: [{ admin: true, non_admin_only: 'foo' }]) }
+      end
+
+      def test_if_true_or_false
+        s = Schema.new do
+          req :foo, :integer, if: proc { true }, min: 5
+          req :bar, :integer, if: proc { false }, min: 5
+          # TODO: It should work without the following line
+          req :bar, :integer
+        end
+
+        assert_nothing_raised { s.validate!(foo: 5, bar: 5) }
+        assert_nothing_raised { s.validate!(foo: 5, bar: 4) }
+        assert_verr { s.validate!(foo: 4, bar: 5) }
+        assert_verr { s.validate!(foo: 4, bar: 4) }
+      end
+
+      def test_mixed_req_opt
+        s = Schema.new do
+          req :foo, :integer, if: proc { |data| !data.nil? }
+          opt :foo, :integer
+        end
+
+        assert_nothing_raised { s.validate!(foo: 4) }
+        assert_verr { s.validate!({}) }
+        assert_verr { s.validate!('something') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class DefaultsTest < V2Test
+      def test_basic
+        s = Schema.new :integer, default: 42
+
+        input = nil
+        output = s.validate!(input)
+
+        assert_equal(42, output)
+      end
+
+      def test_hash
+        s = Schema.new do
+          opt :foo, :string, default: 'bar'
+        end
+
+        input = { foo: nil }
+        output = s.validate!(input)
+        assert_equal({ foo: 'bar' }, output)
+      end
+
+      def test_missing_hash_key
+        s = Schema.new do
+          opt :foo, :string, default: 'bar'
+        end
+
+        input = {}
+        output = s.validate!(input)
+        assert_equal({ foo: 'bar' }, output)
+      end
+
+      def test_entire_hash
+        s = Schema.new do
+          opt :foo, :hash, default: { name: { first: 'Foo', last: 'Bar' } } do
+            req :name do
+              req :first
+              req :last
+            end
+          end
+        end
+
+        input = {}
+        output = s.validate!(input)
+        assert_equal({ foo: { name: { first: 'Foo', last: 'Bar' } } }, output)
+      end
+
+      def test_entire_array
+        s = Schema.new do
+          opt :foo, :array, default: [{ bar: 42 }] do
+            req :bar
+          end
+        end
+
+        input = {}
+        output = s.validate!(input)
+        assert_equal({ foo: [{ bar: 42 }] }, output)
+      end
+
+      def test_proc
+        s = Schema.new do
+          opt :year, :integer, default: -> { Time.now.year }
+        end
+
+        input = {}
+        output = s.validate!(input)
+        assert_equal({ year: Time.now.year }, output)
+      end
+
+      def test_nested_proc
+        myproc = proc { 42 }
+
+        s = Schema.new do
+          opt :myproc, Proc, default: -> { myproc }
+        end
+
+        input = {}
+        output = s.validate!(input)
+        assert_equal({ myproc: myproc }, output)
+      end
+
+      def test_invalid_default
+        s = Schema.new :integer, default: '42'
+
+        input = nil
+
+        assert_verr do
+          s.validate!(input)
+        end
+      end
+    end
+  end
+end