schemacop 2.4.5 → 3.0.0.rc2

data/lib/schemacop/validator/string_validator.rb

@@ -1,37 +0,0 @@
-module Schemacop
-  class StringValidator < Node
-    register symbols: :string, klasses: String
-
-    option :min
-    option :max
-
-    def initialize(options = {})
-      super(options)
-
-      validate_options!
-    end
-
-    def validate(data, collector)
-      super
-
-      if option?(:min) && data.size < option(:min)
-        collector.error "String must be longer (>=) than #{option(:min)} characters."
-      end
-      if option?(:max) && data.size > option(:max)
-        collector.error "String must be shorter (<=) than #{option(:max)} characters."
-      end
-    end
-
-    protected
-
-    def validate_options!
-      option_schema = Schema.new :integer, min: 0
-
-      if option?(:min) && option_schema.invalid?(option(:min))
-        fail Exceptions::InvalidSchemaError, 'String option :min must be an integer >= 0.'
-      elsif option?(:max) && option_schema.invalid?(option(:max))
-        fail Exceptions::InvalidSchemaError, 'String option :max must be an integer >= 0.'
-      end
-    end
-  end
-end

data/test/casting_test.rb

@@ -1,90 +0,0 @@
-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: %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::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

@@ -1,45 +0,0 @@
-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

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

data/test/custom_if_test.rb

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

data/test/defaults_test.rb

@@ -1,93 +0,0 @@
-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_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