Skip to content

R
rails_param
Commit 5187e6a6 by cole bradley
Options

change tabs back to 2 spaces to resemble original style

parent e17d84f4
Showing with 442 additions and 442 deletions
lib/rails_param/param.rb
module RailsParam module RailsParam
module Param module Param
DEFAULT_PRECISION = 14 DEFAULT_PRECISION = 14
class InvalidParameterError < StandardError class InvalidParameterError < StandardError
attr_accessor :param, :options attr_accessor :param, :options
end end
class MockController class MockController
include RailsParam::Param include RailsParam::Param
attr_accessor :params attr_accessor :params
end end
def param!(name, type, options = {}) def param!(name, type, options = {})
name = name.to_s name = name.to_s
return unless params.member?(name) || options[:default].present? || options[:required] return unless params.member?(name) || options[:default].present? || options[:required]
begin begin
params[name] = coerce(params[name], type, options) params[name] = coerce(params[name], type, options)
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 block_given?
controller = RailsParam::Param::MockController.new controller = RailsParam::Param::MockController.new
controller.params = params[name] controller.params = params[name]
yield(controller) yield(controller)
end
rescue InvalidParameterError => exception
exception.param ||= name
exception.options ||= options
raise exception
end
end end
rescue InvalidParameterError => exception
exception.param ||= name
exception.options ||= options
raise exception
end
end
# TODO: should we reintegrate this method? # TODO: should we reintegrate this method?
# def one_of!(*names) # def one_of!(*names)
# count = 0 # count = 0
# names.each do |name| # names.each do |name|
# if params[name] and params[name].present? # if params[name] and params[name].present?
# count += 1 # count += 1
# next unless count > 1 # next unless count > 1
# #
# error = "Parameters #{names.join(', ')} are mutually exclusive" # error = "Parameters #{names.join(', ')} are mutually exclusive"
# if content_type and content_type.match(mime_type(:json)) # if content_type and content_type.match(mime_type(:json))
# error = {message: error}.to_json # error = {message: error}.to_json
# end # end
# #
# # do something with error object # # do something with error object
# end # end
# end # end
# end # end
private private
def coerce(param, type, options = {}) def coerce(param, type, options = {})
begin begin
return nil if param.nil? return nil if param.nil?
return param if (param.is_a?(type) rescue false) return param if (param.is_a?(type) rescue false)
return Integer(param) if type == Integer return Integer(param) if type == Integer
return Float(param) if type == Float return Float(param) if type == Float
return String(param) if type == String return String(param) if type == String
return Date.parse(param) if type == Date return Date.parse(param) if type == Date
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 if type == BigDecimal
param = param.delete('$,').strip.to_f if param.is_a?(String) param = param.delete('$,').strip.to_f if param.is_a?(String)
return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION)) return BigDecimal.new(param, (options[:precision] || DEFAULT_PRECISION))
end
return nil
rescue ArgumentError
raise InvalidParameterError, "'#{param}' is not a valid #{type}"
end
end end
return nil
rescue ArgumentError
raise InvalidParameterError, "'#{param}' is not a valid #{type}"
end
end
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 end
end
end end
spec/fixtures/controllers.rb
...@@ -18,17 +18,17 @@ class FakeController < ActionController::Base ...@@ -18,17 +18,17 @@ class FakeController < ActionController::Base
render text: "new" render text: "new"
end end
def edit def edit
param! :book, Hash, required: true do |b| param! :book, Hash, required: true do |b|
b.param! :title, String, required: true b.param! :title, String, required: true
b.param! :author, Hash do |a| b.param! :author, Hash do |a|
a.param! :first_name, String, required: true a.param! :first_name, String, required: true
a.param! :last_name, String, required: true a.param! :last_name, String, required: true
a.param! :age, Integer, required: true a.param! :age, Integer, required: true
end end
b.param! :price, BigDecimal, required: true b.param! :price, BigDecimal, required: true
end
render text: :book
end end
render text: :book
end
end end
spec/rails_integration_spec.rb
...@@ -11,51 +11,51 @@ describe FakeController, type: :controller do ...@@ -11,51 +11,51 @@ describe FakeController, type: :controller do
end end
describe "nested_hash" do describe "nested_hash" do
it "validates nested properties" do it "validates nested properties" do
params = { params = {
'book' => { 'book' => {
'title' => 'One Hundred Years of Solitude', 'title' => 'One Hundred Years of Solitude',
'author' => { 'author' => {
'first_name' => 'Garbriel Garcia', 'first_name' => 'Garbriel Garcia',
'last_name' => 'Marquez', 'last_name' => 'Marquez',
'age' => '70' 'age' => '70'
}, },
'price' => '$1,000.00' 'price' => '$1,000.00'
}} }}
get :edit, params get :edit, params
expect(controller.params[:book][:author][:age]).to eql 70 expect(controller.params[:book][:author][:age]).to eql 70
expect(controller.params[:book][:author][:age]).to be_kind_of Integer 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 eql 1000.0
expect(controller.params[:book][:price]).to be_instance_of BigDecimal expect(controller.params[:book][:price]).to be_instance_of BigDecimal
end end
it "raises error when required nested attribute missing" do it "raises error when required nested attribute missing" do
params = { params = {
'book' => { 'book' => {
'title' => 'One Hundred Years of Solitude', 'title' => 'One Hundred Years of Solitude',
'author' => { 'author' => {
'last_name' => 'Marquez', 'last_name' => 'Marquez',
'age' => '70' 'age' => '70'
}, },
'price' => '$1,000.00' 'price' => '$1,000.00'
}} }}
expect { get :edit, params }.to raise_error { |error| expect { get :edit, params }.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("first_name") expect(error.param).to eql("first_name")
expect(error.options).to eql({ :required => true }) expect(error.options).to eql({:required => true})
} }
end end
it "passes when hash that's not required but has required attributes is missing" do it "passes when hash that's not required but has required attributes is missing" do
params = { params = {
'book' => { 'book' => {
'title' => 'One Hundred Years of Solitude', 'title' => 'One Hundred Years of Solitude',
'price' => '$1,000.00' 'price' => '$1,000.00'
}} }}
get :edit, params get :edit, params
expect(controller.params[:book][:price]).to eql 1000.0 expect(controller.params[:book][:price]).to eql 1000.0
expect(controller.params[:book][:price]).to be_instance_of BigDecimal expect(controller.params[:book][:price]).to be_instance_of BigDecimal
end end
end end
describe "InvalidParameterError" do describe "InvalidParameterError" do
...@@ -63,7 +63,7 @@ describe FakeController, type: :controller do ...@@ -63,7 +63,7 @@ describe FakeController, type: :controller 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
...@@ -2,305 +2,305 @@ require 'rails_param/param' ...@@ -2,305 +2,305 @@ require 'rails_param/param'
require 'action_controller' require 'action_controller'
class MyController < ActionController::Base class MyController < ActionController::Base
include RailsParam::Param include RailsParam::Param
def params; def params;
end end
end end
describe RailsParam::Param do describe RailsParam::Param do
describe ".param!" do describe ".param!" do
let(:controller) { MyController.new } let(:controller) { MyController.new }
it "defines the method" do it "defines the method" do
expect(controller).to respond_to(:param!) expect(controller).to respond_to(:param!)
end
describe "transform" do
context "with a method" do
it "transforms the value" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
controller.param! :word, String, transform: :upcase
expect(controller.params["word"]).to eql("FOO")
end end
end
describe "transform" do context "with a block" 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: lambda { |n| n.downcase }
controller.param! :word, String, transform: :upcase expect(controller.params["word"]).to eql("foo")
expect(controller.params["word"]).to eql("FOO")
end
end
context "with a block" do
it "transforms the value" do
allow(controller).to receive(:params).and_return({"word" => "FOO"})
controller.param! :word, String, transform: lambda { |n| n.downcase }
expect(controller.params["word"]).to eql("foo")
end
end
end end
end
end
describe "default" do
context "with a value" do
it "defaults to the value" do
allow(controller).to receive(:params).and_return({})
controller.param! :word, String, default: "foo"
expect(controller.params["word"]).to eql("foo")
end
end
context "with a block" do
it "defaults to the block value" do
allow(controller).to receive(:params).and_return({})
controller.param! :word, String, default: lambda { "foo" }
expect(controller.params["word"]).to eql("foo")
end
end
end
describe "default" do describe "coerce" do
context "with a value" do it "converts to String" do
it "defaults to the value" do allow(controller).to receive(:params).and_return({"foo" => :bar})
allow(controller).to receive(:params).and_return({}) controller.param! :foo, String
controller.param! :word, String, default: "foo" expect(controller.params["foo"]).to eql("bar")
expect(controller.params["word"]).to eql("foo") end
end
end it "converts to Integer" do
allow(controller).to receive(:params).and_return({"foo" => "42"})
context "with a block" do controller.param! :foo, Integer
it "defaults to the block value" do expect(controller.params["foo"]).to eql(42)
allow(controller).to receive(:params).and_return({}) end
controller.param! :word, String, default: lambda { "foo" }
expect(controller.params["word"]).to eql("foo") it "converts to Float" do
end allow(controller).to receive(:params).and_return({"foo" => "42.22"})
end controller.param! :foo, Float
expect(controller.params["foo"]).to eql(42.22)
end
it "converts to Array" do
allow(controller).to receive(:params).and_return({"foo" => "2,3,4,5"})
controller.param! :foo, Array
expect(controller.params["foo"]).to eql(["2", "3", "4", "5"])
end
it "converts to Hash" do
allow(controller).to receive(:params).and_return({"foo" => "key1:foo,key2:bar"})
controller.param! :foo, Hash
expect(controller.params["foo"]).to eql({"key1" => "foo", "key2" => "bar"})
end
it "converts to Date" do
allow(controller).to receive(:params).and_return({"foo" => "1984-01-10"})
controller.param! :foo, Date
expect(controller.params["foo"]).to eql(Date.parse("1984-01-10"))
end
it "converts to Time" do
allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
controller.param! :foo, Time
expect(controller.params["foo"]).to eql(Time.parse("2014-08-07T12:25:00.000+02:00"))
end
it "converts to DateTime" do
allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
controller.param! :foo, DateTime
expect(controller.params["foo"]).to eql(DateTime.parse("2014-08-07T12:25:00.000+02:00"))
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 end
describe "coerce" do it "converts to BigDecimal using precision option" do
it "converts to String" do allow(controller).to receive(:params).and_return({"foo" => 12345.6789})
allow(controller).to receive(:params).and_return({"foo" => :bar}) controller.param! :foo, BigDecimal, precision: 6
controller.param! :foo, String expect(controller.params["foo"]).to eql 12345.7
expect(controller.params["foo"]).to eql("bar")
end
it "converts to Integer" do
allow(controller).to receive(:params).and_return({"foo" => "42"})
controller.param! :foo, Integer
expect(controller.params["foo"]).to eql(42)
end
it "converts to Float" do
allow(controller).to receive(:params).and_return({"foo" => "42.22"})
controller.param! :foo, Float
expect(controller.params["foo"]).to eql(42.22)
end
it "converts to Array" do
allow(controller).to receive(:params).and_return({"foo" => "2,3,4,5"})
controller.param! :foo, Array
expect(controller.params["foo"]).to eql(["2", "3", "4", "5"])
end
it "converts to Hash" do
allow(controller).to receive(:params).and_return({"foo" => "key1:foo,key2:bar"})
controller.param! :foo, Hash
expect(controller.params["foo"]).to eql({"key1" => "foo", "key2" => "bar"})
end
it "converts to Date" do
allow(controller).to receive(:params).and_return({"foo" => "1984-01-10"})
controller.param! :foo, Date
expect(controller.params["foo"]).to eql(Date.parse("1984-01-10"))
end
it "converts to Time" do
allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
controller.param! :foo, Time
expect(controller.params["foo"]).to eql(Time.parse("2014-08-07T12:25:00.000+02:00"))
end
it "converts to DateTime" do
allow(controller).to receive(:params).and_return({"foo" => "2014-08-07T12:25:00.000+02:00"})
controller.param! :foo, DateTime
expect(controller.params["foo"]).to eql(DateTime.parse("2014-08-07T12:25:00.000+02:00"))
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
it "converts 1/0" do
allow(controller).to receive(:params).and_return({"foo" => "1"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "0"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts true/false" do
allow(controller).to receive(:params).and_return({"foo" => "true"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "false"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts t/f" do
allow(controller).to receive(:params).and_return({"foo" => "t"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "f"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts yes/no" do
allow(controller).to receive(:params).and_return({"foo" => "yes"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "no"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts y/n" do
allow(controller).to receive(:params).and_return({"foo" => "y"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "n"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
end
it "raises InvalidParameterError if the value is invalid" do
allow(controller).to receive(:params).and_return({"foo" => "1984-01-32"})
expect { controller.param! :foo, Date }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end end
describe 'validating nested hash' do it "converts formatted currency string to big decimal" do
it 'typecasts nested attribtues' do allow(controller).to receive(:params).and_return({"foo" => "$100,000"})
allow(controller).to receive(:params).and_return({'foo' => {'bar' => 1, 'baz' => 2}}) controller.param! :foo, BigDecimal
controller.param! :foo, Hash do |p| expect(controller.params["foo"]).to eql 100000.0
p.param! :bar, BigDecimal end
p.param! :baz, Float
end end
expect(controller.params['foo']['bar']).to be_instance_of BigDecimal
expect(controller.params['foo']['baz']).to be_instance_of Float describe "booleans" do
end it "converts 1/0" do
allow(controller).to receive(:params).and_return({"foo" => "1"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "0"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts true/false" do
allow(controller).to receive(:params).and_return({"foo" => "true"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "false"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts t/f" do
allow(controller).to receive(:params).and_return({"foo" => "t"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "f"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts yes/no" do
allow(controller).to receive(:params).and_return({"foo" => "yes"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "no"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
it "converts y/n" do
allow(controller).to receive(:params).and_return({"foo" => "y"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(true)
allow(controller).to receive(:params).and_return({"foo" => "n"})
controller.param! :foo, TrueClass
expect(controller.params["foo"]).to eql(false)
end
end
it "raises InvalidParameterError if the value is invalid" do
allow(controller).to receive(:params).and_return({"foo" => "1984-01-32"})
expect { controller.param! :foo, Date }.to raise_error(RailsParam::Param::InvalidParameterError)
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 "validation" do
describe "required parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, required: true }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({})
expect { controller.param! :price, Integer, required: true }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "blank parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, blank: false }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => ""})
expect { controller.param! :price, String, blank: false }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "format parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50$"})
expect { controller.param! :price, String, format: /[0-9]+\$/ }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, format: /[0-9]+\$/ }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "is parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, is: "50" }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "51"})
expect { controller.param! :price, String, is: "50" }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "min parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, min: 50 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, min: 51 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "max parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, max: 50 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, max: 49 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "min_length parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, min_length: 3 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, min_length: 4 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "max_length parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, max_length: 3 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, max_length: 2 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "in, within, range parameters" do
before(:each) { allow(controller).to receive(:params).and_return({"price" => "50"}) }
it "succeeds in the range" do
controller.param! :price, Integer, in: 1..100
expect(controller.params["price"]).to eql(50)
end end
describe "validation" do it "raises outside the range" do
describe "required parameter" do expect { controller.param! :price, Integer, in: 51..100 }.to raise_error(RailsParam::Param::InvalidParameterError)
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, required: true }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({})
expect { controller.param! :price, Integer, required: true }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "blank parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, blank: false }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => ""})
expect { controller.param! :price, String, blank: false }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "format parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50$"})
expect { controller.param! :price, String, format: /[0-9]+\$/ }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, format: /[0-9]+\$/ }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "is parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, String, is: "50" }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "51"})
expect { controller.param! :price, String, is: "50" }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "min parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, min: 50 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, min: 51 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "max parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, max: 50 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"price" => "50"})
expect { controller.param! :price, Integer, max: 49 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "min_length parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, min_length: 3 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, min_length: 4 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "max_length parameter" do
it "succeeds" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, max_length: 3 }.to_not raise_error
end
it "raises" do
allow(controller).to receive(:params).and_return({"word" => "foo"})
expect { controller.param! :word, String, max_length: 2 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
describe "in, within, range parameters" do
before(:each) { allow(controller).to receive(:params).and_return({"price" => "50"}) }
it "succeeds in the range" do
controller.param! :price, Integer, in: 1..100
expect(controller.params["price"]).to eql(50)
end
it "raises outside the range" do
expect { controller.param! :price, Integer, in: 51..100 }.to raise_error(RailsParam::Param::InvalidParameterError)
end
end
end end
end
end end
end
end end
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