schemacop 2.3.0 → 2.4.2

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

@@ -5,6 +5,17 @@ module Schemacop
     class User; end
     class Group; end
 
+    def test_untyped
+      s = Schema.new do
+        req :foo
+      end
+
+      assert_nothing_raised { s.validate!(foo: 3) }
+      assert_nothing_raised { s.validate!(foo: '42') }
+      assert_nothing_raised { s.validate!(foo: Object.new) }
+      assert_verr { s.validate!(foo: nil) }
+    end
+
     def test_constructor_defaults_to_hash
       s = Schema.new do
         req! :r do
@@ -15,8 +26,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) }
@@ -30,8 +41,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) }
@@ -45,8 +56,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) }
@@ -57,7 +68,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
@@ -69,9 +80,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) }
@@ -81,7 +92,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
@@ -97,10 +108,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'] }
@@ -119,7 +130,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'] }
@@ -130,7 +141,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']] }
@@ -160,22 +171,24 @@ module Schemacop
         end
       end
 
-      assert_nil 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]
-          }
-        ]
-      )
+      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
@@ -210,25 +223,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
@@ -244,12 +259,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!(
@@ -259,6 +276,7 @@ module Schemacop
           password: 'my*pass'
         )
       end
+
       assert_verr do
         schema.validate!(
           naming: { first_name: 'John',
@@ -277,8 +295,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.') }
@@ -288,16 +306,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
@@ -306,14 +324,14 @@ 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
@@ -324,7 +342,7 @@ module Schemacop
         req :group, Group
       end
 
-      assert_nil s.validate!(user: User.new, group: Group.new)
+      assert_nothing_raised { s.validate!(user: User.new, group: Group.new) }
       assert_verr { s.validate!(user: Group.new, group: User.new) }
     end
   end