Skip to content

R
rails_param
Commit 44e4b51f by Stanton Cole Bradley
Options

Merge pull request #1 from stantoncbradley/array-validation 

Array validation
parents c6d98432 f028ba3f
Showing with 284 additions and 78 deletions
lib/rails_param/param.rb
module RailsParam module RailsParam
module Param module Param
DEFAULT_PRECISION = 14
class InvalidParameterError < StandardError class InvalidParameterError < StandardError
attr_accessor :param, :options attr_accessor :param, :options
end end
def param!(name, type, options = {}) class MockController
name = name.to_s include RailsParam::Param
attr_accessor :params
end
def param!(name, type, options = {}, &block)
name = name.to_s unless name.is_a? Integer # keep index for validating elements
return unless params.member?(name) || options[:default].present? || options[:required] return unless params.member?(name) || options[:default].present? || options[:required]
...@@ -15,8 +22,25 @@ module RailsParam ...@@ -15,8 +22,25 @@ module RailsParam
params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and options[:default] params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if params[name].nil? and options[:default]
params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform] params[name] = options[:transform].to_proc.call(params[name]) if params[name] and options[:transform]
validate!(params[name], options) validate!(params[name], options)
if block_given?
if type == Array
params[name].each_with_index do |element, i|
if element.is_a?(Hash)
recurse element, &block
else
params[name][i] = recurse({ i => element }, i, &block) # supply index as key unless value is hash
end
end
else
recurse params[name], &block
end
end
params[name]
rescue InvalidParameterError => exception rescue InvalidParameterError => exception
exception.param, exception.options = name, options exception.param ||= name
exception.options ||= options
raise exception raise exception
end end
end end
...@@ -41,6 +65,13 @@ module RailsParam ...@@ -41,6 +65,13 @@ module RailsParam
private private
def recurse(params, index = nil)
raise InvalidParameterError, 'no block given' unless block_given?
controller = RailsParam::Param::MockController.new
controller.params = params
yield(controller, index)
end
def coerce(param, type, options = {}) def coerce(param, type, options = {})
begin begin
return nil if param.nil? return nil if param.nil?
...@@ -52,8 +83,12 @@ module RailsParam ...@@ -52,8 +83,12 @@ module RailsParam
return Time.parse(param) if type == Time return Time.parse(param) if type == Time
return DateTime.parse(param) if type == DateTime return DateTime.parse(param) if type == DateTime
return Array(param.split(options[:delimiter] || ",")) if type == Array return Array(param.split(options[:delimiter] || ",")) if type == Array
return Hash[param.split(options[:delimiter] || ",").map{|c| c.split(options[:separator] || ":")}] if type == Hash return Hash[param.split(options[:delimiter] || ",").map { |c| c.split(options[:separator] || ":") }] if type == Hash
return (/(false|f|no|n|0)$/i === param.to_s ? false : (/(true|t|yes|y|1)$/i === param.to_s ? true : nil)) if type == TrueClass || type == FalseClass || type == :boolean return (/(false|f|no|n|0)$/i === param.to_s ? false : (/(true|t|yes|y|1)$/i === param.to_s ? true : nil)) if type == TrueClass || type == FalseClass || type == :boolean
if type == BigDecimal
param = param.delete('$,').strip.to_f if param.is_a?(String)
return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION))
end
return nil return nil
rescue ArgumentError rescue ArgumentError
raise InvalidParameterError, "'#{param}' is not a valid #{type}" raise InvalidParameterError, "'#{param}' is not a valid #{type}"
...@@ -63,37 +98,37 @@ module RailsParam ...@@ -63,37 +98,37 @@ module RailsParam
def validate!(param, options) def validate!(param, options)
options.each do |key, value| options.each do |key, value|
case key case key
when :required when :required
raise InvalidParameterError, "Parameter is required" if value && param.nil? raise InvalidParameterError, "Parameter is required" if value && param.nil?
when :blank when :blank
raise InvalidParameterError, "Parameter cannot be blank" if !value && case param raise InvalidParameterError, "Parameter cannot be blank" if !value && case param
when String when String
!(/\S/ === param) !(/\S/ === param)
when Array, Hash when Array, Hash
param.empty? param.empty?
else else
param.nil? param.nil?
end end
when :format when :format
raise InvalidParameterError, "Parameter must be a string if using the format validation" unless param.kind_of?(String) raise InvalidParameterError, "Parameter must be a string if using the format validation" unless param.kind_of?(String)
raise InvalidParameterError, "Parameter must match format #{value}" unless param =~ value raise InvalidParameterError, "Parameter must match format #{value}" unless param =~ value
when :is when :is
raise InvalidParameterError, "Parameter must be #{value}" unless param === value raise InvalidParameterError, "Parameter must be #{value}" unless param === value
when :in, :within, :range when :in, :within, :range
raise InvalidParameterError, "Parameter must be within #{value}" unless param.nil? || case value raise InvalidParameterError, "Parameter must be within #{value}" unless param.nil? || case value
when Range when Range
value.include?(param) value.include?(param)
else else
Array(value).include?(param) Array(value).include?(param)
end end
when :min when :min
raise InvalidParameterError, "Parameter cannot be less than #{value}" unless param.nil? || value <= param raise InvalidParameterError, "Parameter cannot be less than #{value}" unless param.nil? || value <= param
when :max when :max
raise InvalidParameterError, "Parameter cannot be greater than #{value}" unless param.nil? || value >= param raise InvalidParameterError, "Parameter cannot be greater than #{value}" unless param.nil? || value >= param
when :min_length when :min_length
raise InvalidParameterError, "Parameter cannot have length less than #{value}" unless param.nil? || value <= param.length raise InvalidParameterError, "Parameter cannot have length less than #{value}" unless param.nil? || value <= param.length
when :max_length when :max_length
raise InvalidParameterError, "Parameter cannot have length greater than #{value}" unless param.nil? || value >= param.length raise InvalidParameterError, "Parameter cannot have length greater than #{value}" unless param.nil? || value >= param.length
end end
end end
end end
......
spec/fixtures/controllers.rb
...@@ -17,4 +17,18 @@ class FakeController < ActionController::Base ...@@ -17,4 +17,18 @@ class FakeController < ActionController::Base
def new def new
render text: "new" render text: "new"
end end
def edit
param! :book, Hash, required: true do |b|
b.param! :title, String, required: true
b.param! :author, Hash do |a|
a.param! :first_name, String, required: true
a.param! :last_name, String, required: true
a.param! :age, Integer, required: true
end
b.param! :price, BigDecimal, required: true
end
render text: :book
end
end end
spec/fixtures/fake_rails_application.rb
...@@ -15,6 +15,7 @@ module Rails ...@@ -15,6 +15,7 @@ module Rails
get '/fake/new' => "fake#new" get '/fake/new' => "fake#new"
get '/fakes' => "fake#index" get '/fakes' => "fake#index"
get '/fake/(:id)' => "fake#show" get '/fake/(:id)' => "fake#show"
get '/fake/edit' => "fake#edit"
end end
@routes @routes
end end
......
spec/rails_integration_spec.rb
...@@ -10,12 +10,60 @@ describe FakeController, type: :controller do ...@@ -10,12 +10,60 @@ describe FakeController, type: :controller do
end end
end end
describe "nested_hash" do
it "validates nested properties" do
params = {
'book' => {
'title' => 'One Hundred Years of Solitude',
'author' => {
'first_name' => 'Garbriel Garcia',
'last_name' => 'Marquez',
'age' => '70'
},
'price' => '$1,000.00'
}}
get :edit, params
expect(controller.params[:book][:author][:age]).to eql 70
expect(controller.params[:book][:author][:age]).to be_kind_of Integer
expect(controller.params[:book][:price]).to eql 1000.0
expect(controller.params[:book][:price]).to be_instance_of BigDecimal
end
it "raises error when required nested attribute missing" do
params = {
'book' => {
'title' => 'One Hundred Years of Solitude',
'author' => {
'last_name' => 'Marquez',
'age' => '70'
},
'price' => '$1,000.00'
}}
expect { get :edit, params }.to raise_error { |error|
expect(error).to be_a(RailsParam::Param::InvalidParameterError)
expect(error.param).to eql("first_name")
expect(error.options).to eql({:required => true})
}
end
it "passes when hash that's not required but has required attributes is missing" do
params = {
'book' => {
'title' => 'One Hundred Years of Solitude',
'price' => '$1,000.00'
}}
get :edit, params
expect(controller.params[:book][:price]).to eql 1000.0
expect(controller.params[:book][:price]).to be_instance_of BigDecimal
end
end
describe "InvalidParameterError" do describe "InvalidParameterError" do
it "raises an exception with params attributes" do it "raises an exception with params attributes" do
expect { get :index, sort: "foo" }.to raise_error { |error| expect { get :index, sort: "foo" }.to raise_error { |error|
expect(error).to be_a(RailsParam::Param::InvalidParameterError) expect(error).to be_a(RailsParam::Param::InvalidParameterError)
expect(error.param).to eql("sort") expect(error.param).to eql("sort")
expect(error.options).to eql({ :in => ["asc", "desc"], :default => "asc", :transform => :downcase }) expect(error.options).to eql({:in => ["asc", "desc"], :default => "asc", :transform => :downcase})
} }
end end
end end
......
spec/rails_param/param_spec.rb
...@@ -4,7 +4,8 @@ require 'action_controller' ...@@ -4,7 +4,8 @@ require 'action_controller'
class MyController < ActionController::Base class MyController < ActionController::Base
include RailsParam::Param include RailsParam::Param
def params; end def params;
end
end end
describe RailsParam::Param do describe RailsParam::Param do
...@@ -18,7 +19,7 @@ describe RailsParam::Param do ...@@ -18,7 +19,7 @@ describe RailsParam::Param do
describe "transform" do describe "transform" do
context "with a method" do context "with a method" do
it "transforms the value" do it "transforms the value" do
allow(controller).to receive(:params).and_return({ "word" => "foo" }) allow(controller).to receive(:params).and_return({"word" => "foo"})
controller.param! :word, String, transform: :upcase controller.param! :word, String, transform: :upcase
expect(controller.params["word"]).to eql("FOO") expect(controller.params["word"]).to eql("FOO")
end end
...@@ -26,7 +27,7 @@ describe RailsParam::Param do ...@@ -26,7 +27,7 @@ describe RailsParam::Param do
context "with a block" do context "with a block" do
it "transforms the value" do it "transforms the value" do
allow(controller).to receive(:params).and_return({ "word" => "FOO" }) allow(controller).to receive(:params).and_return({"word" => "FOO"})
controller.param! :word, String, transform: lambda { |n| n.downcase } controller.param! :word, String, transform: lambda { |n| n.downcase }
expect(controller.params["word"]).to eql("foo") expect(controller.params["word"]).to eql("foo")
end end
...@@ -36,7 +37,7 @@ describe RailsParam::Param do ...@@ -36,7 +37,7 @@ describe RailsParam::Param do
describe "default" do describe "default" do
context "with a value" do context "with a value" do
it "defaults to the value" do it "defaults to the value" do
allow(controller).to receive(:params).and_return({ }) allow(controller).to receive(:params).and_return({})
controller.param! :word, String, default: "foo" controller.param! :word, String, default: "foo"
expect(controller.params["word"]).to eql("foo") expect(controller.params["word"]).to eql("foo")
end end
...@@ -44,7 +45,7 @@ describe RailsParam::Param do ...@@ -44,7 +45,7 @@ describe RailsParam::Param do
context "with a block" do context "with a block" do
it "defaults to the block value" do it "defaults to the block value" do
allow(controller).to receive(:params).and_return({ }) allow(controller).to receive(:params).and_return({})
controller.param! :word, String, default: lambda { "foo" } controller.param! :word, String, default: lambda { "foo" }
expect(controller.params["word"]).to eql("foo") expect(controller.params["word"]).to eql("foo")
end end
...@@ -53,210 +54,317 @@ describe RailsParam::Param do ...@@ -53,210 +54,317 @@ describe RailsParam::Param do
describe "coerce" do describe "coerce" do
it "converts to String" do it "converts to String" do
allow(controller).to receive(:params).and_return({ "foo" => :bar }) allow(controller).to receive(:params).and_return({"foo" => :bar})
controller.param! :foo, String controller.param! :foo, String
expect(controller.params["foo"]).to eql("bar") expect(controller.params["foo"]).to eql("bar")
end end
it "converts to Integer" do it "converts to Integer" do
allow(controller).to receive(:params).and_return({ "foo" => "42" }) allow(controller).to receive(:params).and_return({"foo" => "42"})
controller.param! :foo, Integer controller.param! :foo, Integer
expect(controller.params["foo"]).to eql(42) expect(controller.params["foo"]).to eql(42)
end end
it "converts to Float" do it "converts to Float" do
allow(controller).to receive(:params).and_return({ "foo" => "42.22" }) allow(controller).to receive(:params).and_return({"foo" => "42.22"})
controller.param! :foo, Float controller.param! :foo, Float
expect(controller.params["foo"]).to eql(42.22) expect(controller.params["foo"]).to eql(42.22)
end end
it "converts to Array" do it "converts to Array" do
allow(controller).to receive(:params).and_return({ "foo" => "2,3,4,5" }) allow(controller).to receive(:params).and_return({"foo" => "2,3,4,5"})
controller.param! :foo, Array controller.param! :foo, Array
expect(controller.params["foo"]).to eql(["2", "3", "4", "5"]) expect(controller.params["foo"]).to eql(["2", "3", "4", "5"])
end end
it "converts to Hash" do it "converts to Hash" do
allow(controller).to receive(:params).and_return({ "foo" => "key1:foo,key2:bar" }) allow(controller).to receive(:params).and_return({"foo" => "key1:foo,key2:bar"})
controller.param! :foo, Hash controller.param! :foo, Hash
expect(controller.params["foo"]).to eql({ "key1" => "foo", "key2" => "bar" }) expect(controller.params["foo"]).to eql({"key1" => "foo", "key2" => "bar"})
end end
it "converts to Date" do it "converts to Date" do
allow(controller).to receive(:params).and_return({ "foo" => "1984-01-10" }) allow(controller).to receive(:params).and_return({"foo" => "1984-01-10"})
controller.param! :foo, Date controller.param! :foo, Date
expect(controller.params["foo"]).to eql(Date.parse("1984-01-10")) expect(controller.params["foo"]).to eql(Date.parse("1984-01-10"))
end end
it "converts to Time" do it "converts to Time" do
allow(controller).to receive(:params).and_return({ "foo" => "2014-08-07T12:25:00.000+02:00" }) allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
controller.param! :foo, Time controller.param! :foo, Time
expect(controller.params["foo"]).to eql(Time.parse("2014-08-07T12:25:00.000+02:00")) expect(controller.params["foo"]).to eql(Time.parse("2014-08-07T12:25:00.000+02:00"))
end end
it "converts to DateTime" do it "converts to DateTime" do
allow(controller).to receive(:params).and_return({ "foo" => "2014-08-07T12:25:00.000+02:00" }) allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
controller.param! :foo, DateTime controller.param! :foo, DateTime
expect(controller.params["foo"]).to eql(DateTime.parse("2014-08-07T12:25:00.000+02:00")) expect(controller.params["foo"]).to eql(DateTime.parse("2014-08-07T12:25:00.000+02:00"))
end end
describe "BigDecimals" do
it "converts to BigDecimal using default precision" do
allow(controller).to receive(:params).and_return({"foo" => 12345.67890123456})
controller.param! :foo, BigDecimal
expect(controller.params["foo"]).to eql 12345.678901235
end
it "converts to BigDecimal using precision option" do
allow(controller).to receive(:params).and_return({"foo" => 12345.6789})
controller.param! :foo, BigDecimal, precision: 6
expect(controller.params["foo"]).to eql 12345.7
end
it "converts formatted currency string to big decimal" do
allow(controller).to receive(:params).and_return({"foo" => "$100,000"})
controller.param! :foo, BigDecimal
expect(controller.params["foo"]).to eql 100000.0
end
end
describe "booleans" do describe "booleans" do
it "converts 1/0" do it "converts 1/0" do
allow(controller).to receive(:params).and_return({ "foo" => "1" }) allow(controller).to receive(:params).and_return({"foo" => "1"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true) expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({ "foo" => "0" }) allow(controller).to receive(:params).and_return({"foo" => "0"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false) expect(controller.params["foo"]).to eql(false)
end end
it "converts true/false" do it "converts true/false" do
allow(controller).to receive(:params).and_return({ "foo" => "true" }) allow(controller).to receive(:params).and_return({"foo" => "true"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true) expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({ "foo" => "false" }) allow(controller).to receive(:params).and_return({"foo" => "false"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false) expect(controller.params["foo"]).to eql(false)
end end
it "converts t/f" do it "converts t/f" do
allow(controller).to receive(:params).and_return({ "foo" => "t" }) allow(controller).to receive(:params).and_return({"foo" => "t"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true) expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({ "foo" => "f" }) allow(controller).to receive(:params).and_return({"foo" => "f"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false) expect(controller.params["foo"]).to eql(false)
end end
it "converts yes/no" do it "converts yes/no" do
allow(controller).to receive(:params).and_return({ "foo" => "yes" }) allow(controller).to receive(:params).and_return({"foo" => "yes"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true) expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({ "foo" => "no" }) allow(controller).to receive(:params).and_return({"foo" => "no"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false) expect(controller.params["foo"]).to eql(false)
end end
it "converts y/n" do it "converts y/n" do
allow(controller).to receive(:params).and_return({ "foo" => "y" }) allow(controller).to receive(:params).and_return({"foo" => "y"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true) expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({ "foo" => "n" }) allow(controller).to receive(:params).and_return({"foo" => "n"})
controller.param! :foo, TrueClass controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false) expect(controller.params["foo"]).to eql(false)
end end
end end
it "raises InvalidParameterError if the value is invalid" do it "raises InvalidParameterError if the value is invalid" do
allow(controller).to receive(:params).and_return({ "foo" => "1984-01-32" }) allow(controller).to receive(:params).and_return({"foo" => "1984-01-32"})
expect { controller.param! :foo, Date }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :foo, Date }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe 'validating nested hash' do
it 'typecasts nested attribtues' do
allow(controller).to receive(:params).and_return({'foo' => {'bar' => 1, 'baz' => 2}})
controller.param! :foo, Hash do |p|
p.param! :bar, BigDecimal
p.param! :baz, Float
end
expect(controller.params['foo']['bar']).to be_instance_of BigDecimal
expect(controller.params['foo']['baz']).to be_instance_of Float
end
end
describe 'validating arrays' do
it 'typecasts array of primitive elements' do
allow(controller).to receive(:params).and_return({'array' => ['1', '2']})
controller.param! :array, Array do |a, i|
a.param! i, Integer, required: true
end
expect(controller.params['array'][0]).to be_a Integer
expect(controller.params['array'][1]).to be_a Integer
end
it 'validates array of hashes' do
params = {'array' => [{'object'=>{ 'num' => '1', 'float' => '1.5' }},{'object'=>{ 'num' => '2', 'float' => '2.3' }}] }
allow(controller).to receive(:params).and_return(params)
controller.param! :array, Array do |a|
a.param! :object, Hash do |h|
h.param! :num, Integer, required: true
h.param! :float, Float, required: true
end
end
expect(controller.params['array'][0]['object']['num']).to be_a Integer
expect(controller.params['array'][0]['object']['float']).to be_instance_of Float
expect(controller.params['array'][1]['object']['num']).to be_a Integer
expect(controller.params['array'][1]['object']['float']).to be_instance_of Float
end
it 'validates an array of arrays' do
params = {'array' => [[ '1', '2' ],[ '3', '4' ]] }
allow(controller).to receive(:params).and_return(params)
controller.param! :array, Array do |a, i|
a.param! i, Array do |b, e|
b.param! e, Integer, required: true
end
end
expect(controller.params['array'][0][0]).to be_a Integer
expect(controller.params['array'][0][1]).to be_a Integer
expect(controller.params['array'][1][0]).to be_a Integer
expect(controller.params['array'][1][1]).to be_a Integer
end
it 'raises exception when primitive element missing' do
allow(controller).to receive(:params).and_return({'array' => ['1', nil]})
expect {
controller.param! :array, Array do |a, i|
a.param! i, Integer, required: true
end
}.to raise_exception
end
it 'raises exception when nested hash element missing' do
params = {'array' => [{'object'=>{ 'num' => '1', 'float' => nil }},{'object'=>{ 'num' => '2', 'float' => '2.3' }}] }
allow(controller).to receive(:params).and_return(params)
expect {
controller.param! :array, Array do |a|
a.param! :object, Hash do |h|
h.param! :num, Integer, required: true
h.param! :float, Float, required: true
end
end
}.to raise_exception
end
it 'raises exception when nested array element missing' do
params = {'array' => [[ '1', '2' ],[ '3', nil ]] }
allow(controller).to receive(:params).and_return(params)
expect {
controller.param! :array, Array do |a, i|
a.param! i, Array do |b, e|
b.param! e, Integer, required: true
end
end
}.to raise_exception
end
end
describe "validation" do describe "validation" do
describe "required parameter" do describe "required parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, required: true }.to_not raise_error expect { controller.param! :price, Integer, required: true }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ }) allow(controller).to receive(:params).and_return({})
expect { controller.param! :price, Integer, required: true }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :price, Integer, required: true }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "blank parameter" do describe "blank parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, blank: false }.to_not raise_error expect { controller.param! :price, String, blank: false }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "price" => "" }) allow(controller).to receive(:params).and_return({"price" => ""})
expect { controller.param! :price, String, blank: false }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :price, String, blank: false }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "format parameter" do describe "format parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "price" => "50$" }) allow(controller).to receive(:params).and_return({"price" => "50$"})
expect { controller.param! :price, String, format: /[0-9]+\$/ }.to_not raise_error expect { controller.param! :price, String, format: /[0-9]+\$/ }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, format: /[0-9]+\$/ }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :price, String, format: /[0-9]+\$/ }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "is parameter" do describe "is parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, is: "50" }.to_not raise_error expect { controller.param! :price, String, is: "50" }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "price" => "51" }) allow(controller).to receive(:params).and_return({"price" => "51"})
expect { controller.param! :price, String, is: "50" }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :price, String, is: "50" }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "min parameter" do describe "min parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, min: 50 }.to_not raise_error expect { controller.param! :price, Integer, min: 50 }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, min: 51 }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :price, Integer, min: 51 }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "max parameter" do describe "max parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, max: 50 }.to_not raise_error expect { controller.param! :price, Integer, max: 50 }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "price" => "50" }) allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, max: 49 }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :price, Integer, max: 49 }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "min_length parameter" do describe "min_length parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "word" => "foo" }) allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, min_length: 3 }.to_not raise_error expect { controller.param! :word, String, min_length: 3 }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "word" => "foo" }) allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, min_length: 4 }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :word, String, min_length: 4 }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "max_length parameter" do describe "max_length parameter" do
it "succeeds" do it "succeeds" do
allow(controller).to receive(:params).and_return({ "word" => "foo" }) allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, max_length: 3 }.to_not raise_error expect { controller.param! :word, String, max_length: 3 }.to_not raise_error
end end
it "raises" do it "raises" do
allow(controller).to receive(:params).and_return({ "word" => "foo" }) allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, max_length: 2 }.to raise_error(RailsParam::Param::InvalidParameterError) expect { controller.param! :word, String, max_length: 2 }.to raise_error(RailsParam::Param::InvalidParameterError)
end end
end end
describe "in, within, range parameters" do describe "in, within, range parameters" do
before(:each) { allow(controller).to receive(:params).and_return({ "price" => "50" }) } before(:each) { allow(controller).to receive(:params).and_return({"price" => "50"}) }
it "succeeds in the range" do it "succeeds in the range" do
controller.param! :price, Integer, in: 1..100 controller.param! :price, Integer, in: 1..100
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment