schemacop 2.4.3 → 3.0.0.rc0

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

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

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class EmptyHashTest < V2Test
+      def test_empty_hash
+        schema = Schema.new do
+          type Hash
+        end
+
+        assert_nothing_raised { schema.validate!({}) }
+        assert_verr { schema.validate!(foo: :bar) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+# Note: A test for req and opt is part of validator_hash_test.rb
+
+module Schemacop
+  module V2
+    class NilDisAllowTest < V2Test
+      def test_req
+        s = Schema.new do
+          req? :o do
+            type :boolean
+          end
+
+          req :r do
+            type :boolean
+          end
+        end
+        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) }
+      end
+
+      def test_opt
+        s = Schema.new do
+          opt :o do
+            type :boolean
+          end
+          opt! :r do
+            type :boolean
+          end
+        end
+        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
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class NodeResolverTest < V2Test
+      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
+end

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

@@ -0,0 +1,351 @@
+require 'test_helper'
+
+module Schemacop
+  module V2
+    class ShortFormsTest < V2Test
+      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
+            type :integer
+          end
+          opt? :o do
+            type :integer
+          end
+        end
+
+        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) }
+      end
+
+      def test_field_defaults_to_any
+        s = Schema.new do
+          type :hash do
+            req :r
+            opt :o
+          end
+        end
+
+        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) }
+      end
+
+      def test_inline_type_with_attrs_in_hash
+        s = Schema.new do
+          type :hash do
+            req :i, :integer, min: 5
+            opt :f, :float, min: 2.3, max: 3
+          end
+        end
+
+        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) }
+        assert_verr { s.validate!(i: 5.3) }
+        assert_verr { s.validate!(j: 2.3) }
+        assert_verr { s.validate!({}) }
+      end
+
+      def test_inline_type_in_constructor
+        s = Schema.new :integer, min: 2, max: 4
+        assert_nothing_raised { s.validate!(3) }
+        assert_verr { s.validate!(5) }
+        assert_verr { s.validate!(1) }
+      end
+
+      def test_mixed_field_and_type_attrs
+        s = Schema.new do
+          req? :nilbool, :boolean
+          req? :nilint, :integer, min: 2, max: 3
+          opt! :optint, :integer, min: 2, max: 3
+        end
+
+        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) }
+      end
+
+      def test_array_shortform_simple
+        s = Schema.new do
+          type(:array, :string)
+        end
+        assert_nothing_raised { s.validate!(%w[a b]) }
+      end
+
+      # TODO: Get the exception message into the assertion
+      def test_array_shortform_invalid
+        assert_raises Exceptions::InvalidSchemaError do
+          Schema.new do
+            type(:array, %i[array integer], min: 2)
+          end
+        end
+      end
+
+      def test_array_shortform_advanced1
+        s = Schema.new do
+          type(:array, %i[array integer])
+        end
+        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'] }
+      end
+
+      def test_array_shortform_advanced2
+        assert_raises Exceptions::InvalidSchemaError, 'No validation class found for type [:array, :integer].' do
+          Schema.new do
+            type([:array, %i[array integer], :boolean])
+          end
+        end
+      end
+
+      # For explicit form test see types_test.rb
+      def test_array_subtype_shortform
+        s = Schema.new do
+          type :array, :integer
+        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
+
+      def test_array_subsubtype_shortform
+        s = Schema.new do
+          type :array, :array, :integer
+        end
+        assert_nothing_raised { s.validate! [[5]] }
+        assert_verr { 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
+
+      def test_wild_mix_should_pass
+        s = Schema.new do
+          req :foo do
+            req? :bar, :object, classes: NilClass
+          end
+          req :name, :integer, min: 5, max: 7
+          req :id, %i[integer string]
+          req :callback, :symbol
+          req :attrs do
+            req :color do
+              type :integer
+            end
+          end
+          req :colors, :array, %i[string integer]
+          req :cars, :array, :hash do
+            req? :years, :array, :integer
+            req! :make, :string
+            req! :ps, :integer
+            req? :electric, :boolean
+          end
+        end
+
+        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
+        s = Schema.new do
+          type :hash do
+            opt? :bla do
+              type :string
+            end
+            req :id do
+              type :string
+            end
+            req? :friends do
+              type :array do
+                type :string, min: 3, max: 6
+                type :boolean
+                type :hash do
+                  req :rod do
+                    type :hash do
+                      req :fritz do
+                        type :array, min: 2 do
+                          type :array do
+                            type :integer, min: 1
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          type :integer, min: 3
+        end
+
+        assert_nothing_raised do
+          s.validate!(
+            id:      'meine ID',
+            friends: [
+              'Rodney',
+              true,
+              false,
+              {
+                rod: {
+                  fritz:
+                         [
+                           [1],
+                           [3]
+                         ]
+                }
+              }
+            ]
+          )
+        end
+        assert_nothing_raised { s.validate!(id: 'my ID', friends: nil) }
+        assert_nothing_raised { s.validate!(3) }
+      end
+
+      def test_example_from_readme
+        schema = Schema.new do
+          req :naming, :hash do
+            opt :first_name, :string
+            req :last_name, :string
+          end
+          opt! :age, :integer, min: 18
+          req? :password do
+            type :string, check: proc { |pw| pw.include?('*') }
+            type :integer
+          end
+        end
+
+        assert_nothing_raised do
+          schema.validate!(
+            naming:   { first_name: 'John',
+                        last_name:  'Doe' },
+            age:      34,
+            password: 'my*pass'
+          )
+        end
+
+        assert_verr do
+          schema.validate!(
+            naming:   { first_name: 'John',
+                        last_name:  'Doe' },
+            age:      12,
+            password: 'my*pass'
+          )
+        end
+
+        assert_verr do
+          schema.validate!(
+            naming:   { first_name: 'John',
+                        last_name:  'Doe' },
+            age:      12,
+            password: 'mypass'
+          )
+        end
+
+        schema2 = Schema.new do
+          req :description,
+              :string,
+              if:    proc { |str| str.start_with?('Abstract: ') },
+              max:   35,
+              check: proc { |str| !str.end_with?('.') }
+          req :description, :string, min: 35
+        end
+
+        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.') }
+      end
+
+      def test_one_line_subtype_with_options
+        s = Schema.new do
+          type :array, :integer, min: 3
+        end
+        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_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_implicit_hash
+        s = Schema.new do
+          req :bar
+        end
+        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_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
+end