schemacop 2.1.0 → 2.4.0

data/test/casting_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+module Schemacop
+  class CastingTest < Minitest::Test
+    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: ['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::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
+  end
+end

data/test/collector_test.rb

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

data/test/custom_check_test.rb

@@ -4,22 +4,29 @@ module Schemacop
   class CustomCheckTest < Minitest::Test
     def test_integer_check_short_form
       s = Schema.new :integer, check: proc { |i| i.even? }
-      assert_nil s.validate!(2)
-      assert_nil s.validate!(-8)
-      assert_nil s.validate!(0)
+      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_nil s.validate!(2)
-      assert_nil s.validate!(-8)
-      assert_nil s.validate!(0)
+      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) }
@@ -29,7 +36,7 @@ module Schemacop
       s = Schema.new do
         type :number, check: proc { |x| x == 42 }
       end
-      assert_nil s.validate!(42)
+      assert_nothing_raised { s.validate!(42) }
       assert_verr { s.validate!(42.1) }
       assert_verr { s.validate!(0) }
     end
@@ -40,7 +47,7 @@ module Schemacop
           type :integer
         end
       end
-      assert_nil s.validate!([1, 2, 3])
+      assert_nothing_raised { s.validate!([1, 2, 3]) }
       assert_verr { s.validate!([2, 3, 4]) }
     end
 
@@ -51,7 +58,7 @@ module Schemacop
         end
       end
 
-      assert_nil s.validate!([4, 3, 2])
+      assert_nothing_raised { s.validate!([4, 3, 2]) }
       assert_verr { s.validate!([3, 2]) }
       assert_verr { s.validate!([4, 1]) }
     end
@@ -61,7 +68,7 @@ module Schemacop
         opt 1, :integer
         opt 'two', :string
       end
-      assert_nil s.validate!(1 => 1, 'two' => 'two')
+      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
@@ -75,9 +82,9 @@ module Schemacop
         req :first_name, :string, min: 3
       end
 
-      assert_nil s.validate!(first_name: 'Bob')
-      assert_nil s.validate!(first_name: 'Sandy')
-      assert_nil s.validate!(first_name: 'Sansibar')
+      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') }

data/test/custom_if_test.rb

@@ -7,7 +7,7 @@ module Schemacop
         type :integer, if: proc { |data| data.odd? }
       end
 
-      assert_nil s.validate! 5
+      assert_nothing_raised { s.validate! 5 }
       assert_verr { s.validate! nil }
       assert_verr { s.validate! 4 }
     end
@@ -18,8 +18,8 @@ module Schemacop
         type :string
       end
 
-      assert_nil s.validate!(5)
-      assert_nil s.validate!('abc')
+      assert_nothing_raised { s.validate!(5) }
+      assert_nothing_raised { s.validate!('abc') }
       assert_verr { s.validate!(4) }
     end
 
@@ -29,8 +29,8 @@ module Schemacop
         req :foo, :string, min: 5
       end
 
-      assert_nil s.validate!(foo: 'abc')
-      assert_nil s.validate!(foo: 'bcdef')
+      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
@@ -41,8 +41,8 @@ module Schemacop
         req :foo, :integer
       end
 
-      assert_nil s.validate!(foo: 3)
-      assert_nil s.validate!(foo: 'abc')
+      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
@@ -61,8 +61,8 @@ module Schemacop
         end
       end
 
-      assert_nil s.validate!(user: [{ admin: true, admin_only: 'foo' }, { admin: false, non_admin_only: 'foo' }])
-      assert_nil s.validate!(user: [{ admin: true, admin_only: 'foo' }, { non_admin_only: 'foo' }])
+      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
@@ -75,8 +75,8 @@ module Schemacop
         req :bar, :integer
       end
 
-      assert_nil s.validate!(foo: 5, bar: 5)
-      assert_nil s.validate!(foo: 5, bar: 4)
+      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
@@ -87,7 +87,7 @@ module Schemacop
         opt :foo, :integer
       end
 
-      assert_nil s.validate!(foo: 4)
+      assert_nothing_raised { s.validate!(foo: 4) }
       assert_verr { s.validate!({}) }
       assert_verr { s.validate!('something') }
     end

data/test/defaults_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+module Schemacop
+  class DefaultsTest < Minitest::Test
+    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_invalid_default
+      s = Schema.new :integer, default: '42'
+
+      input = nil
+
+      assert_verr do
+        s.validate!(input)
+      end
+    end
+  end
+end

data/test/nil_dis_allow_test.rb

@@ -14,8 +14,8 @@ module Schemacop
           type :boolean
         end
       end
-      assert_nil s.validate!(o: nil, r: false)
-      assert_nil s.validate!(o: false, r: false)
+      assert_nothing_raised { s.validate!(o: nil, r: false) }
+      assert_nothing_raised { s.validate!(o: false, r: false) }
       assert_verr { s.validate!(o: true, r: nil) }
       assert_verr { s.validate!(o: nil, r: nil) }
       assert_verr { s.validate!(r: true) }
@@ -30,10 +30,10 @@ module Schemacop
           type :boolean
         end
       end
-      assert_nil s.validate!(o: nil, r: false)
-      assert_nil s.validate!(o: false, r: false)
-      assert_nil s.validate!(r: true)
-      assert_nil s.validate!({})
+      assert_nothing_raised { s.validate!(o: nil, r: false) }
+      assert_nothing_raised { s.validate!(o: false, r: false) }
+      assert_nothing_raised { s.validate!(r: true) }
+      assert_nothing_raised { s.validate!({}) }
       assert_verr { s.validate!(o: true, r: nil) }
       assert_verr { s.validate!(o: nil, r: nil) }
     end

data/test/node_resolver_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Schemacop
+  class NodeResolverTest < Minitest::Test
+    class ClassA; end
+    class ClassB; end
+    class ClassC; end
+    class ClassD; end
+
+    def test_insert_before
+      prev_node_classes = NodeResolver.node_classes
+
+      NodeResolver.node_classes = []
+
+      NodeResolver.register(ClassA)
+      NodeResolver.register(ClassB)
+      NodeResolver.register(ClassC)
+      NodeResolver.register(ClassD, before: ClassB)
+
+      assert_equal [ClassA, ClassD, ClassB, ClassC],
+                   NodeResolver.node_classes
+    ensure
+      NodeResolver.node_classes = prev_node_classes
+    end
+  end
+end

data/test/short_forms_test.rb

@@ -2,6 +2,9 @@ require 'test_helper'
 
 module Schemacop
   class ShortFormsTest < Minitest::Test
+    class User; end
+    class Group; end
+
     def test_constructor_defaults_to_hash
       s = Schema.new do
         req! :r do
@@ -12,8 +15,8 @@ module Schemacop
         end
       end
 
-      assert_nil s.validate!(r: 3)
-      assert_nil s.validate!(r: 3, o: 1)
+      assert_nothing_raised { s.validate!(r: 3) }
+      assert_nothing_raised { s.validate!(r: 3, o: 1) }
       assert_verr { s.validate!(o: 1) }
       assert_verr { s.validate!(1) }
       assert_verr { s.validate!(r: 3, n: 5) }
@@ -27,8 +30,8 @@ module Schemacop
         end
       end
 
-      assert_nil s.validate!(r: 3)
-      assert_nil s.validate!(r: 'asd', o: self)
+      assert_nothing_raised { s.validate!(r: 3) }
+      assert_nothing_raised { s.validate!(r: 'asd', o: self) }
       assert_verr { s.validate!(o: -5.3) }
       assert_verr { s.validate!(Class) }
       assert_verr { s.validate!(r: s, n: true) }
@@ -42,8 +45,8 @@ module Schemacop
         end
       end
 
-      assert_nil s.validate!(i: 5)
-      assert_nil s.validate!(i: 5, f: 2.3)
+      assert_nothing_raised { s.validate!(i: 5) }
+      assert_nothing_raised { s.validate!(i: 5, f: 2.3) }
       assert_verr { s.validate!(i: 4, f: 2.3) }
       assert_verr { s.validate!(i: 5, f: 2.2) }
       assert_verr { s.validate!(i: 5, f: 3.4) }
@@ -54,7 +57,7 @@ module Schemacop
 
     def test_inline_type_in_constructor
       s = Schema.new :integer, min: 2, max: 4
-      assert_nil s.validate!(3)
+      assert_nothing_raised { s.validate!(3) }
       assert_verr { s.validate!(5) }
       assert_verr { s.validate!(1) }
     end
@@ -66,9 +69,9 @@ module Schemacop
         opt! :optint, :integer, min: 2, max: 3
       end
 
-      assert_nil s.validate!(nilbool: nil, nilint: nil)
-      assert_nil s.validate!(nilbool: false, nilint: 2)
-      assert_nil s.validate!(nilbool: false, nilint: 3, optint: 2)
+      assert_nothing_raised { s.validate!(nilbool: nil, nilint: nil) }
+      assert_nothing_raised { s.validate!(nilbool: false, nilint: 2) }
+      assert_nothing_raised { s.validate!(nilbool: false, nilint: 3, optint: 2) }
       assert_verr { s.validate!(nilbool: false, nilint: 2, optint: nil) }
       assert_verr { s.validate!(nilbool: false, nilint: 2, optint: 4) }
       assert_verr { s.validate!(nilbool: false, nilint: -5, optint: 2) }
@@ -78,7 +81,7 @@ module Schemacop
       s = Schema.new do
         type(:array, :string)
       end
-      assert_nil s.validate!(%w(a b))
+      assert_nothing_raised { s.validate!(%w(a b)) }
     end
 
     # TODO: Get the exception message into the assertion
@@ -94,10 +97,10 @@ module Schemacop
       s = Schema.new do
         type(:array, [:array, :integer])
       end
-      assert_nil s.validate! [[], 3]
-      assert_nil s.validate! [[:a, 9], 3]
-      assert_nil s.validate! [[]]
-      assert_nil s.validate! [3]
+      assert_nothing_raised { s.validate! [[], 3] }
+      assert_nothing_raised { s.validate! [[:a, 9], 3] }
+      assert_nothing_raised { s.validate! [[]] }
+      assert_nothing_raised { s.validate! [3] }
       assert_verr { s.validate! [[], 'string'] }
       assert_verr { s.validate! [3, 'string'] }
       assert_verr { s.validate! ['string'] }
@@ -116,7 +119,7 @@ module Schemacop
       s = Schema.new do
         type :array, :integer
       end
-      assert_nil s.validate! [5]
+      assert_nothing_raised { s.validate! [5] }
       assert_verr { s.validate! [nil] }
       assert_verr { s.validate! ['a'] }
       assert_verr { s.validate! [5, 'a'] }
@@ -127,7 +130,7 @@ module Schemacop
       s = Schema.new do
         type :array, :array, :integer
       end
-      assert_nil s.validate! [[5]]
+      assert_nothing_raised { s.validate! [[5]] }
       assert_verr { s.validate! [5] }
       assert_verr { s.validate! [[nil]] }
       assert_verr { s.validate! [['a']] }
@@ -142,6 +145,7 @@ module Schemacop
         end
         req :name, :integer, min: 5, max: 7
         req :id, [:integer, :string]
+        req :callback, :symbol
         req :attrs do
           req :color do
             type :integer
@@ -156,21 +160,24 @@ module Schemacop
         end
       end
 
-      assert_nil s.validate!(
-        name: 6,
-        foo: { bar: nil },
-        attrs: { color: 5 },
-        id: 'hallo',
-        colors: [5, 'sdf'],
-        cars: [
-          {
-            make: 'Tesla',
-            ps: 5,
-            electric: nil,
-            years: [1993, 1990]
-          }
-        ]
-      )
+      assert_nothing_raised do
+        s.validate!(
+          name: 6,
+          foo: { bar: nil },
+          attrs: { color: 5 },
+          id: 'hallo',
+          callback: :funky_function,
+          colors: [5, 'sdf'],
+          cars: [
+            {
+              make: 'Tesla',
+              ps: 5,
+              electric: nil,
+              years: [1993, 1990]
+            }
+          ]
+        )
+      end
     end
 
     def test_super_deep_wild_should_pass
@@ -205,25 +212,27 @@ module Schemacop
         type :integer, min: 3
       end
 
-      assert_nil s.validate!(
-        id: 'meine ID',
-        friends: [
-          'Rodney',
-          true,
-          false,
-          {
-            rod: {
-              fritz:
-              [
-                [1],
-                [3]
-              ]
+      assert_nothing_raised do
+        s.validate!(
+          id: 'meine ID',
+          friends: [
+            'Rodney',
+            true,
+            false,
+            {
+              rod: {
+                fritz:
+                [
+                  [1],
+                  [3]
+                ]
+              }
             }
-          }
-        ]
-      )
-      assert_nil s.validate!(id: 'my ID', friends: nil)
-      assert_nil s.validate!(3)
+          ]
+        )
+      end
+      assert_nothing_raised { s.validate!(id: 'my ID', friends: nil) }
+      assert_nothing_raised { s.validate!(3) }
     end
 
     def test_example_from_readme
@@ -239,12 +248,14 @@ module Schemacop
         end
       end
 
-      assert_nil schema.validate!(
-        naming: { first_name: 'John',
-                  last_name: 'Doe' },
-        age: 34,
-        password: 'my*pass'
-      )
+      assert_nothing_raised do
+        schema.validate!(
+          naming: { first_name: 'John',
+                    last_name: 'Doe' },
+          age: 34,
+          password: 'my*pass'
+        )
+      end
 
       assert_verr do
         schema.validate!(
@@ -254,6 +265,7 @@ module Schemacop
           password: 'my*pass'
         )
       end
+
       assert_verr do
         schema.validate!(
           naming: { first_name: 'John',
@@ -272,8 +284,8 @@ module Schemacop
         req :description, :string, min: 35
       end
 
-      assert_nil schema2.validate!(description: 'Abstract: a short description')
-      assert_nil schema2.validate!(description: 'Since this is no abstract, we expect it to be longer.')
+      assert_nothing_raised { schema2.validate!(description: 'Abstract: a short description') }
+      assert_nothing_raised { schema2.validate!(description: 'Since this is no abstract, we expect it to be longer.') }
       assert_verr { schema2.validate!(description: 'Abstract: A short description.') }
       assert_verr { schema2.validate!(description: 'Abstract: This is gonna be way way too long for an abstract.') }
       assert_verr { schema2.validate!(description: 'This is too short.') }
@@ -283,16 +295,16 @@ module Schemacop
       s = Schema.new do
         type :array, :integer, min: 3
       end
-      assert_nil s.validate!([3])
-      assert_nil s.validate!([3, 4, 5])
+      assert_nothing_raised { s.validate!([3]) }
+      assert_nothing_raised { s.validate!([3, 4, 5]) }
       assert_verr { s.validate!([3, 2]) }
       assert_verr { s.validate!([5, 'string']) }
     end
 
     def test_one_line_array_schema
       s = Schema.new :array, :integer, min: 3
-      assert_nil s.validate!([3])
-      assert_nil s.validate!([3, 4, 5])
+      assert_nothing_raised { s.validate!([3]) }
+      assert_nothing_raised { s.validate!([3, 4, 5]) }
       assert_verr { s.validate!([3, 2]) }
       assert_verr { s.validate!([5, 'string']) }
     end
@@ -301,16 +313,26 @@ module Schemacop
       s = Schema.new do
         req :bar
       end
-      assert_nil s.validate!(bar: 2)
+      assert_nothing_raised { s.validate!(bar: 2) }
       assert_verr { s.validate!(foo: 2) }
       assert_verr { s.validate!([2]) }
     end
 
     def test_one_line_string_schema
       s = Schema.new :string, min: 4
-      assert_nil s.validate!('1234')
+      assert_nothing_raised { s.validate!('1234') }
       assert_verr { s.validate!('123') }
       assert_verr { s.validate!(string: '1234') }
     end
+
+    def test_inline_objects
+      s = Schema.new do
+        req :user, User
+        req :group, Group
+      end
+
+      assert_nothing_raised { s.validate!(user: User.new, group: Group.new) }
+      assert_verr { s.validate!(user: Group.new, group: User.new) }
+    end
   end
 end