parameters_schema 0.42

data/lib/parameters_schema.rb

@@ -0,0 +1,8 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'date'
+require 'parameters_schema/core_ext'
+require 'parameters_schema/options'
+require 'parameters_schema/exceptions'
+require 'parameters_schema/schema'

data/test/helpers.rb

@@ -0,0 +1,56 @@
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+    def must_equal_hash(other)
+      self.must_equal(other.with_indifferent_access)
+    end
+  end
+end
+
+module ParametersSchema
+  class Schema
+    def must_allow(values)
+      [values].flatten.each do |value|
+        if value.kind_of?(Range)
+          value.each do |v|
+            execute_must_allow(v)
+          end
+        else
+          execute_must_allow(value)
+        end
+      end
+
+      self
+    end
+
+    def must_deny(values, error_code = ParametersSchema::ErrorCode::DISALLOWED)
+      [values].flatten.each do |value|
+        if value.kind_of?(Range)
+          value.each do |v|
+            execute_must_deny(v, error_code)
+          end
+        else
+          execute_must_deny(value, error_code)
+        end
+      end
+
+      self
+    end
+
+    private
+
+    def execute_must_allow(value)
+      self
+        .validate!(potatoe: value)
+        .must_equal_hash(potatoe: value)
+    end
+
+    def execute_must_deny(value, error_code)
+        Proc.new do
+          self
+            .validate!(potatoe: value)
+        end
+          .must_raise(ParametersSchema::InvalidParameters)
+          .errors.must_equal_hash(potatoe: error_code)
+    end
+  end
+end

data/test/test_options.rb

@@ -0,0 +1,74 @@
+require 'minitest/autorun'
+require 'parameters_schema'
+require_relative 'helpers'
+
+describe 'Skipping parameters' do
+  before do
+    ParametersSchema::Options.reset_defaults
+
+    @schema = ParametersSchema::Schema.new do
+      param :potatoe
+    end
+  end
+
+  it 'skip default parameters in a Rails context' do
+    @schema
+      .validate!(potatoe: 'Ac Belmont', controller: 'potatoes', action: 'create', format: 'json')
+      .must_equal_hash(potatoe: 'Ac Belmont')
+  end
+
+  it 'redefines parameters to skip' do
+    ParametersSchema::Options.skip_parameters = [:banana]
+
+    @schema
+      .validate!(potatoe: 'Ac Belmont', banana: 'Cavendish')
+      .must_equal_hash(potatoe: 'Ac Belmont')
+
+    Proc
+      .new{ @schema.validate!(potatoe: 'Ac Belmont', controller: 'potatoes', action: 'create', format: 'json') }
+      .must_raise(ParametersSchema::InvalidParameters)
+  end
+
+  it 'augments parameters to skip' do
+    ParametersSchema::Options.skip_parameters = ParametersSchema::Options.skip_parameters + [:banana]
+    @schema
+      .validate!(potatoe: 'Ac Belmont', banana: 'Cavendish', controller: 'potatoes', action: 'create', format: 'json')
+      .must_equal_hash(potatoe: 'Ac Belmont')
+  end
+end
+
+describe 'Empty keyword' do
+  before do
+    ParametersSchema::Options.reset_defaults
+
+    @schema = ParametersSchema::Schema.new do
+      param :potatoe, allow: :empty
+    end
+  end
+
+  it 'uses the default value' do
+    ParametersSchema::Schema.new do
+      param :potatoe, allow: :empty
+    end
+      .validate!(potatoe: '')
+      .must_equal_hash(potatoe: '')
+  end
+
+  it 'redefines the value' do
+    ParametersSchema::Options.empty_keyword = :allow_empty
+
+    ParametersSchema::Schema.new do
+      param :potatoe, allow: :allow_empty
+    end
+      .validate!(potatoe: '')
+      .must_equal_hash(potatoe: '')
+
+    Proc.new do
+      ParametersSchema::Schema.new do
+        param :potatoe, allow: :empty
+      end.validate!(potatoe: '')
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: ParametersSchema::ErrorCode::EMPTY)
+  end
+end

data/test/test_schema_allow.rb

@@ -0,0 +1,114 @@
+require 'minitest/autorun'
+require 'parameters_schema'
+require_relative 'helpers'
+
+describe 'Allow and Deny' do
+  before do
+    ParametersSchema::Options.reset_defaults
+  end
+
+  it 'allows :any and denies :none by default' do
+    [{}, { allow: :any }, { deny: :none }, { allow: :any, deny: :none }].each do |options|
+      schema = ParametersSchema::Schema.new do
+        param :potatoe, options.merge(type: Fixnum)
+      end
+        .must_allow((-10..10))
+    end
+  end
+
+  it 'allows multiple :allow values' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, allow: [(1..2), (4..5)]
+    end
+      .must_allow([1, 2, 4, 5])
+      .must_deny(3)
+  end
+
+  it 'allows multiple :deny values' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, deny: [(1..2), (4..5)]
+    end
+      .must_allow([-1, 0, 3, 6, 7])
+      .must_deny([1, 2, 4, 5])
+  end
+
+  it 'gives priority to :any and :none in multiple :allow values' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, allow: [(1..2), :any]
+    end
+      .must_allow((-10..10))
+
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, allow: [(1..2), :none]
+    end
+      .must_deny((-10..10))
+  end
+
+  it 'gives priority to :any and :none in  multiple :deny values' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, deny: [(1..2), :none]
+    end
+      .must_allow((-10..10))
+
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, deny: [(1..2), :any]
+    end
+      .must_deny((-10..10))
+  end
+
+  it 'when using an array, the :allow is applied on the array values' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, array: true, allow: (1..3)
+    end
+
+    schema
+      .validate!(potatoe: [1, 2, 3, 2, 1])
+      .must_equal_hash(potatoe: [1, 2, 3, 2, 1])
+
+    Proc.new do
+      schema.validate!(potatoe: [1, 2, 3, 2, 1, 0])
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: ParametersSchema::ErrorCode::DISALLOWED)
+  end
+
+  it 'when using an array, the :deny is applied on the array values' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, array: true, deny: (1..3)
+    end
+
+    schema
+      .validate!(potatoe: [-1, 0, 4, 5, 6])
+      .must_equal_hash(potatoe: [-1, 0, 4, 5, 6])
+
+    Proc.new do
+      schema.validate!(potatoe: [-1, 0, 4, 5, 6, 1])
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: ParametersSchema::ErrorCode::DISALLOWED)
+  end
+
+  it 'allows a subset of values defined by a range' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, type: Fixnum, allow: (1..10)
+    end
+      .must_allow((1..10))
+      .must_deny(((-10..0).to_a + (11..20).to_a))
+  end
+
+  it 'allows a subset of values by choices' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, allow: ['a', 'b', 'c']
+    end
+      .must_allow(['a', 'b', 'c'])
+      .must_deny('d')
+  end
+
+  it 'allows a subset of values by regex' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe, allow: /^[A-Z]+$/
+    end
+      .must_allow(['A', 'BB', 'CDE'])
+      .must_deny(['a', 'Aa', 'F1'])
+  end
+end

data/test/test_schema_allow_empty.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'parameters_schema'
+require_relative 'helpers'
+
+describe 'Allow empty' do
+  before do
+    ParametersSchema::Options.reset_defaults
+  end
+
+  it 'requires a non-empty value by default' do
+    ParametersSchema::Schema.new do
+      param :potatoe
+    end
+      .must_deny('', ParametersSchema::ErrorCode::EMPTY)
+  end
+
+  it 'can be set to accept empty value' do
+    ParametersSchema::Schema.new do
+      param :potatoe, allow: :empty
+    end
+      .must_allow('')
+  end
+
+  it 'when set to accept empty, it still reject nil value' do
+    ParametersSchema::Schema.new do
+      param :potatoe, allow: :empty
+    end
+      .must_deny(nil, ParametersSchema::ErrorCode::NIL)
+  end
+end

data/test/test_schema_allow_nil.rb

@@ -0,0 +1,34 @@
+require 'minitest/autorun'
+require 'parameters_schema'
+require_relative 'helpers'
+
+describe 'Allow nil' do
+  before do
+    ParametersSchema::Options.reset_defaults
+    
+    @schema = ParametersSchema::Schema.new do
+      param :potatoe
+    end
+  end
+
+  it 'requires a non-nil value by default' do
+    ParametersSchema::Schema.new do
+      param :potatoe
+    end
+      .must_deny(nil, ParametersSchema::ErrorCode::NIL)
+  end
+
+  it 'can be set to accept nil' do
+    ParametersSchema::Schema.new do
+      param :potatoe, allow: :nil
+    end
+      .must_allow(nil)
+  end
+
+  it 'when set to accept nil, it still reject empty value' do
+    ParametersSchema::Schema.new do
+      param :potatoe, allow: :nil
+    end
+      .must_deny('', ParametersSchema::ErrorCode::EMPTY)
+  end
+end

data/test/test_schema_hash.rb

@@ -0,0 +1,90 @@
+require 'minitest/autorun'
+require 'parameters_schema'
+require_relative 'helpers'
+
+describe 'Object' do
+  it 'creates a sub-schema for objects' do
+    ParametersSchema::Schema.new do
+      param :potatoe do
+        param :name
+      end
+    end
+      .must_allow({ name: 'Eramosa' })
+  end
+
+  it 'creates a as many sub-schemas as needed' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe do
+        param :quantity, type: Fixnum
+        param :description do
+          param :name
+          param :local, type: :boolean
+        end
+      end
+    end
+
+    schema
+      .validate!(potatoe: { quantity: '10', description: { name: 'Eramosa', local: 't' } })
+      .must_equal_hash(potatoe: { quantity: 10, description: { name: 'Eramosa', local: true } })
+  end
+
+  it 'allows an empty sub-schema' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoe do end
+    end
+      .must_deny(nil, ParametersSchema::ErrorCode::NIL)
+      .must_deny({}, ParametersSchema::ErrorCode::EMPTY)
+
+    Proc
+      .new{ schema.validate!(potatoe: { name: 'Eramosa' }) }
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: { name: ParametersSchema::ErrorCode::UNKNOWN })
+  end
+
+  it 'can be embeded in array' do
+    [{ array: true}, type: { Array => Hash }].each do |array_format|
+      schema = ParametersSchema::Schema.new do
+        param :potatoes, array_format do
+          param :name
+        end
+      end
+
+      schema
+        .validate!(potatoes: [{ name: 'Ac Belmont' }, { name: 'Eramosa' }])
+        .must_equal_hash(potatoes: [{ name: 'Ac Belmont' }, { name: 'Eramosa' }])
+    end
+  end
+
+  it 'can be embeded in array - complex' do
+    schema = ParametersSchema::Schema.new do
+      param :potatoes, array: true do
+        param :quantity, type: Fixnum
+        param :description do
+          param :name
+          param :local, type: :boolean
+        end
+      end
+    end
+
+    potatoes = [
+      {
+        quantity: 10,
+        description: {
+          name: 'Eramosa',
+          local: true
+        }
+      },
+      {
+        quantity: 1000,
+        description: {
+          name: 'Eramosa II',
+          local: false
+        }
+      }
+    ]
+
+    schema
+      .validate!(potatoes: potatoes)
+      .must_equal_hash(potatoes: potatoes)
+  end
+end

data/test/test_schema_required.rb

@@ -0,0 +1,74 @@
+require 'minitest/autorun'
+require 'parameters_schema'
+require_relative 'helpers'
+
+describe 'Required' do
+  before do
+    ParametersSchema::Options.reset_defaults
+  end
+  
+  it 'is required by default' do
+    Proc.new do
+      ParametersSchema::Schema.new do
+        param :potatoe
+      end.validate!({})
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: ParametersSchema::ErrorCode::MISSING)
+  end
+
+  it 'can be explicitly stated as required' do
+    Proc.new do
+      ParametersSchema::Schema.new do
+        param :potatoe, required: true
+      end.validate!({})
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: ParametersSchema::ErrorCode::MISSING)
+  end
+
+  it 'can be set to be not required' do
+    ParametersSchema::Schema.new do
+      param :potatoe, required: false
+    end
+      .validate!({})
+      .must_equal_hash({})
+  end
+
+  it 'applies to object params - validation successful' do
+    ParametersSchema::Schema.new do
+      param :potatoe do
+        param :name
+        param :type, required: false
+      end
+    end
+      .validate!(potatoe: { name: 'Eramosa' })
+      .must_equal_hash(potatoe: { name: 'Eramosa' })
+  end
+
+  it 'applies to object params - validation failed on name' do
+    Proc.new do
+      ParametersSchema::Schema.new do
+        param :potatoe do
+          param :name
+          param :type, required: false
+        end
+      end.validate!(potatoe: {})
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: { name: ParametersSchema::ErrorCode::MISSING })
+  end
+
+  it 'applies to object params - validation failed on potatoe' do
+    Proc.new do
+      ParametersSchema::Schema.new do
+        param :potatoe do
+          param :name
+          param :type, required: false
+        end
+      end.validate!({})
+    end
+      .must_raise(ParametersSchema::InvalidParameters)
+      .errors.must_equal_hash(potatoe: ParametersSchema::ErrorCode::MISSING)
+  end
+end