veto 0.0.1

data/spec/system/validator_spec.rb

@@ -0,0 +1,380 @@
+require 'spec_helper'
+require 'veto'
+
+describe Veto do
+	let(:entity){ stub }
+	let(:validator_class) { Class.new{ include Veto.validator }}
+	let(:validator) { validator_class.new(entity) }
+
+	describe 'built-in validations' do
+		let(:value) { 'abc123' }
+		let(:entity) {stub(:name => value)}
+		let(:errors) { validator.valid?; validator.errors.on(:name) }
+		let(:validator_type){ :presence }
+		let(:options) { true }
+		let(:validator_class) do
+			klass = Class.new{ include Veto.validator }
+			klass.validates :name, options
+			klass
+		end	
+
+		describe 'exact_length' do
+			let(:options) {{:exact_length => 10}}
+
+			context 'when value exact length' do
+				let(:value) { 'abcdefghij' }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is too short' do
+				let(:value) { 'short' }
+				it { errors.must_equal ["is not 10 characters"] }
+			end
+
+			context 'when value is too long' do
+				let(:value) { 'this title is wayyyy to long' }
+				it { errors.must_equal ["is not 10 characters"] }
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is not 10 characters"] }
+			end
+		end
+
+		describe 'format' do
+			let(:options) {{:format => /^\d+$/}}
+
+			context 'when value matches pattern' do
+				let(:value) { 123 }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value does not match' do
+				let(:value) { 'abc' }
+				it { errors.must_equal ["is not valid"] }
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is not valid"] }
+			end
+		end
+
+		describe 'inclusion' do
+			context 'when set is array' do
+				let(:options) {{:inclusion => %w(cat dog bird rabbit)}}
+
+				context 'when value is in set' do
+					let(:value) { 'cat' }
+					it { errors.must_be_nil }
+				end
+
+				context 'when value is not in set' do
+					let(:value) { 'goat' }
+					it { errors.must_equal ["is not in set: [\"cat\", \"dog\", \"bird\", \"rabbit\"]"]}
+				end
+			end
+
+			context 'when set is range' do
+				let(:options) {{:inclusion => 10..20}}
+
+				context 'when value is in set' do
+					let(:value) { 11 }
+					it { errors.must_be_nil }
+				end
+
+				context 'when value is not in set' do
+					let(:value) { 5 }
+					it { errors.must_equal ["is not in set: 10..20"] }
+				end
+			end
+		end
+
+		describe 'integer' do
+			let(:options) {{:integer => true}}
+
+			context 'when value is integer' do
+				let(:value) { 123 }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is float' do
+				let(:value) { 123.4 }
+				it { errors.must_equal ["is not a number"]}
+			end
+
+			context 'when value is string' do
+				let(:value) { 'abc' }
+				it { errors.must_equal ["is not a number"]}
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is not a number"]}
+			end
+
+			context 'when value is everything else' do
+				let(:value) { ['array'] }
+				it { errors.must_equal ["is not a number"]}
+			end
+		end
+
+		describe 'length_range' do
+			context 'when range is array' do
+				let(:options) {{:length_range => [5, 8, 15]}}
+
+				context 'when value length is in array' do
+					let(:value) { 'abcde' }
+					it { errors.must_be_nil }
+				end
+
+				context 'when value length is not in array' do
+					let(:value) { 'abc' }
+					it { errors.must_equal ["is too short or too long"] }
+				end
+
+				context 'when value length is nil' do
+					let(:value) { nil }
+					it { errors.must_equal ["is too short or too long"] }
+				end
+			end
+
+			context 'when range is range' do
+				let(:options) {{:length_range => 5..10}}
+
+				context 'when value length is in range' do
+					let(:value) { 'abcdef' }
+					it { errors.must_be_nil }
+				end
+
+				context 'when value length is not in range' do
+					let(:value) { 'abc' }
+					it { errors.must_equal ["is too short or too long"] }
+				end
+
+				context 'when value length is nil' do
+					let(:value) { nil }
+					it { errors.must_equal ["is too short or too long"] }
+				end	
+			end
+		end
+
+		describe 'max_length' do
+			let(:options) {{:max_length => 10}}
+
+			context 'when value length is less than max' do
+				let(:value) { 'abc' }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is too long' do
+				let(:value) { 'abcdefghijklmnop' }
+				it { errors.must_equal ["is longer than 10 characters"] }
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is longer than 10 characters"] }
+			end
+		end
+
+		describe 'min_length' do
+			let(:options) {{:min_length => 5}}
+
+			context 'when value length is greater than min' do
+				let(:value) { 'abcdefg' }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is too short' do
+				let(:value) { 'abcd' }
+				it { errors.must_equal ["is shorter than 5 characters"] }
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is shorter than 5 characters"] }
+			end
+		end
+
+		describe 'not_null' do
+			let(:options) {{:not_null => 5}}
+
+			context 'when value is not null' do
+				let(:value) { 123 }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is not present"]}
+			end
+		end
+
+		describe 'numeric' do
+			let(:options) {{:numeric => true}}
+
+			context 'when value is integer' do
+				let(:value) { 123 }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is float' do
+				let(:value) { 123.4 }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is string' do
+				let(:value) { 'abc' }
+				it { errors.must_equal ["is not a number"]}
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is not a number"]}
+			end
+
+			context 'when value is everything else' do
+				let(:value) { ['array'] }
+				it { errors.must_equal ["is not a number"]}
+			end
+		end
+
+		describe 'presence' do
+			let(:options) {{:presence => true}}
+
+			context 'when value is not null' do
+				let(:value) { 123 }
+				it { errors.must_be_nil }
+			end
+
+			context 'when value is nil' do
+				let(:value) { nil }
+				it { errors.must_equal ["is not present"]}
+			end
+
+			context 'when value is empty string' do
+				let(:value) { '' }
+				it { errors.must_equal ["is not present"]}
+			end
+
+			context 'when value is string of whitespace' do
+				let(:value) { '    ' }
+				it { errors.must_equal ["is not present"]}
+			end
+
+			context 'when value is empty array' do
+				let(:value) { [] }
+				it { errors.must_equal ["is not present"]}	
+			end
+
+			context 'when value is empty hash' do
+				let(:value) {{}}
+				it { errors.must_equal ["is not present"]}	
+			end
+		end
+	end
+
+	describe 'conditions' do
+		describe 'with_options' do
+			let(:conditions) {{:if => true}}
+			let(:validator_class) do
+				klass = Class.new{
+					include Veto.validator
+
+					def create_errors
+						errors.add(:base, "error")
+					end
+				}
+				klass.with_options conditions do
+					validate :create_errors
+				end
+				klass
+			end	
+
+			context 'when conditions pass' do
+				let(:conditions) {{:if => true}}
+
+				it 'performs validations within block' do
+					validator.valid?.must_equal false
+					validator.errors.full_messages.must_equal ['base error']
+				end
+			end
+
+			context 'when conditions fail' do
+				let(:conditions) {{:if => false}}
+
+				it 'does not perform validations within block' do
+					validator.valid?
+					validator.errors.must_be_empty
+				end
+			end
+		end	
+
+		describe 'validates' do
+			let(:entity){ stub(:title => nil, :name => 'John') }
+			let(:options) {{}}
+			let(:validator_class) do
+				klass = Class.new{
+					include Veto.validator
+				}
+
+				klass.validates :title, options
+				klass
+			end	
+
+			context 'when outer conditions pass' do
+				context 'when inner conditions pass' do
+					let(:options) {{:not_null => {:with => true, :if => true}, :exact_length => {:with => 4, :if => true}, :if => true}}
+
+					it 'performs validation' do
+						validator.valid?.must_equal false
+						validator.errors.full_messages.must_equal ["title is not present", "title is not 4 characters"]
+					end				
+				end
+
+				context 'when inner conditions fail' do
+					let(:options) {{:not_null => {:with => true, :if => false}, :exact_length => {:with => 4, :if => true}, :if => true}}
+
+					it 'skips individual validator' do
+						validator.valid?.must_equal false
+						validator.errors.full_messages.must_equal ["title is not 4 characters"]
+					end
+				end
+			end
+
+			context 'when outer conditions fail' do
+				let(:options) {{:not_null => {:with => true, :if => true}, :exact_length => {:with => 4, :if => true}, :if => false}}
+
+				it 'skips validates block' do
+					validator.valid?.must_equal true
+				end
+			end
+		end
+	end
+
+	describe 'custom attribute validator class' do
+		let(:entity){ stub(:email_address => 'blah') }
+		let(:validator_class) do
+			klass = Class.new{
+				include Veto.validator
+
+				class EmailValidator < ::Veto::AttributeValidator
+					def validate entity, attribute, value, errors, options={}
+						unless value.to_s =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+							errors.add(attribute, "is not a valid email address")
+						end
+					end
+				end
+
+				validates :email_address, :email => true
+			}
+		end	
+
+		it 'uses custom validator' do
+			validator.valid?.must_equal false
+			validator.errors.full_messages.must_equal ["email_address is not a valid email address"]
+		end
+	end
+end

data/spec/validator_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'veto/validator'
+
+describe Veto::Validator do
+	let(:entity){ stub }
+	let(:validator_class) { Class.new{ include Veto::Validator } }
+	let(:validator) { validator_class.new(entity) } 
+
+	describe '::builder' do
+		it 'returns builder' do
+			validator_class.send(:builder).must_be_instance_of Veto::Builder
+		end
+	end
+
+	describe '::with_options' do
+		it 'delegates to builder' do
+			builder = stub
+			validator_class.expects(:builder).returns(builder)
+			builder.expects(:with_options).with('args')
+			validator_class.with_options('args')
+		end
+	end
+
+	describe '::validates' do
+		it 'delegates to builder' do
+			builder = stub
+			validator_class.expects(:builder).returns(builder)
+			builder.expects(:validates).with('args')
+			validator_class.validates('args')
+		end	
+	end
+
+	describe '::validate' do
+		it 'delegates to builder' do
+			builder = stub
+			validator_class.expects(:builder).returns(builder)
+			builder.expects(:validate).with('args')
+			validator_class.validate('args')
+		end	
+	end
+
+	describe '::validate_with' do
+		it 'adds validator to validators array' do
+			validator = stub
+			validator_class.validate_with validator
+			validator_class.validators.must_equal [validator]
+		end
+
+		it 'adds validators to validators array' do
+			validator = stub
+			validator_class.validate_with [validator, validator]
+			validator_class.validators.must_equal [validator, validator]
+		end
+	end
+
+	describe '::validators' do
+		it 'returns validators list' do
+			validator_class.validators.must_equal []
+		end
+	end
+
+	describe '::valid?' do
+		it 'initializes new instance and delegates to instance method' do
+			validator_class.expects(:new).with(entity).returns(entity)
+			entity.expects(:valid?)
+			validator_class.valid?(entity)
+		end
+	end
+
+	describe '::validate!' do
+		it 'initializes new instance and delegates to instance method' do
+			validator_class.expects(:new).with(entity).returns(entity)
+			entity.expects(:validate!)
+			validator_class.validate!(entity)
+		end
+	end
+
+	describe '#valid?' do
+		context 'when entity is valid' do
+			it 'returns true' do
+				errors = stub(:empty? => true)
+				validator.expects(:errors => errors)
+				validator.valid?.must_equal true
+			end
+		end
+
+		context 'when entity is invalid' do
+			it 'returns false' do
+				errors = stub(:empty? => false)
+				validator.expects(:errors => errors)
+				validator.valid?.must_equal false
+			end
+		end
+	end
+
+	describe '#validate!' do
+		context 'when entity is valid' do
+			it 'returns true' do
+				validator.expects(:valid?).returns(true)
+				validator.validate!.must_be_nil
+			end
+		end
+
+		context 'when entity is invalid' do
+			it 'returns false' do
+				errors = stub(:full_messages => '')
+				validator.expects(:valid?).returns(false)
+				validator.expects(:errors => errors)
+				proc { validator.validate! }.must_raise ::Veto::InvalidEntity
+			end
+		end
+	end
+
+	describe '#errors' do
+		it 'returns errors object' do
+			validator.errors.must_be_instance_of Veto::Errors
+		end
+	end
+end

data/spec/validators/exact_length_validator_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'veto/validators/exact_length_validator'
+require 'veto/errors'
+
+describe Veto::ExactLengthValidator do
+	let(:errors){ Veto::Errors.new }
+	let(:entity) { Object.new }
+	let(:attribute) { :title }
+	let(:value) { 'blahblah' }
+	let(:options) {{:with => 10}}
+	let(:validator){ Veto::ExactLengthValidator.new(stub, stub) }
+	let(:result){ validator.validate(entity, attribute, value, errors, options) }
+
+	describe '#validate' do
+		before { result }
+
+		context 'when value exact length' do
+			let(:value) { 'abcdefghij' }
+			it { errors[:title].must_be_nil }
+		end
+
+		context 'when value is too short' do
+			let(:value) { 'short' }
+			it { errors[:title].must_equal ["is not 10 characters"] }
+		end
+
+		context 'when value is too long' do
+			let(:value) { 'this title is wayyyy to long' }
+			it { errors[:title].must_equal ["is not 10 characters"] }
+		end
+
+		context 'when value is nil' do
+			let(:value) { nil }
+			it { errors[:title].must_equal ["is not 10 characters"] }
+		end
+	end
+end

data/spec/validators/format_validator_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'veto/validators/format_validator'
+require 'veto/errors'
+
+describe Veto::FormatValidator do
+	let(:errors){ Veto::Errors.new }
+	let(:entity) { Object.new }
+	let(:attribute) { :title }
+	let(:value) { 'blahblah' }
+	let(:options) {{:with => /^\d+$/}}
+	let(:validator){ Veto::FormatValidator.new(stub, stub) }
+	let(:result){ validator.validate(entity, attribute, value, errors, options) }
+
+	describe '#validate' do
+		before { result }
+
+		context 'when value matches pattern' do
+			let(:value) { 123 }
+			it { errors[:title].must_be_nil }
+		end
+
+		context 'when value does not match' do
+			let(:value) { 'abc' }
+			it { errors[:title].must_equal ["is not valid"] }
+		end
+
+		context 'when value is nil' do
+			let(:value) { nil }
+			it { errors[:title].must_equal ["is not valid"] }
+		end
+	end
+end

data/spec/validators/inclusion_validator_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'veto/validators/inclusion_validator'
+require 'veto/errors'
+
+describe Veto::InclusionValidator do
+	let(:errors){ Veto::Errors.new }
+	let(:entity) { Object.new }
+	let(:attribute) { :title }
+	let(:value) { 'blahblah' }
+	let(:options) {{:in => %w(cat dog bird rabbit)}}
+	let(:validator){ Veto::InclusionValidator.new(stub, stub) }
+	let(:result){ validator.validate(entity, attribute, value, errors, options) }
+
+	describe '#validate' do
+		before { result }
+
+		context 'when set is array' do
+			let(:options) {{:in => %w(cat dog bird rabbit)}}
+
+			context 'when value is in set' do
+				let(:value) { 'cat' }
+				it { errors[:title].must_be_nil }
+			end
+
+			context 'when value is not in set' do
+				let(:value) { 'goat' }
+				it { errors[:title].must_equal ["is not in set: [\"cat\", \"dog\", \"bird\", \"rabbit\"]"]}
+			end
+		end
+
+		context 'when set is range' do
+			let(:options) {{:in => (10..20)}}
+
+			context 'when value is in set' do
+				let(:value) { 11 }
+				it { errors[:title].must_be_nil }
+			end
+
+			context 'when value is not in set' do
+				let(:value) { 5 }
+				it { errors[:title].must_equal ["is not in set: 10..20"] }
+			end
+		end
+	end
+end

data/spec/validators/integer_validator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'veto/validators/integer_validator'
+require 'veto/errors'
+
+describe Veto::IntegerValidator do
+	let(:errors){ Veto::Errors.new }
+	let(:entity) { Object.new }
+	let(:attribute) { :title }
+	let(:value) { 'blahblah' }
+	let(:options) {{:with => {}}}
+	let(:validator){ Veto::IntegerValidator.new(stub, stub) }
+	let(:result){ validator.validate(entity, attribute, value, errors, options) }
+
+	describe '#validate' do
+		before { result }
+
+		context 'when value is integer' do
+			let(:value) { 123 }
+			it { errors[:title].must_be_nil }
+		end
+
+		context 'when value is float' do
+			let(:value) { 123.4 }
+			it { errors[:title].must_equal ["is not a number"]}
+		end
+
+		context 'when value is string' do
+			let(:value) { 'abc' }
+			it { errors[:title].must_equal ["is not a number"]}
+		end
+
+		context 'when value is nil' do
+			let(:value) { nil }
+			it { errors[:title].must_equal ["is not a number"]}
+		end
+
+		context 'when value is everything else' do
+			let(:value) { ['array'] }
+			it { errors[:title].must_equal ["is not a number"]}
+		end
+	end
+end

data/spec/validators/length_range_validator_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'veto/validators/length_range_validator'
+require 'veto/errors'
+
+describe Veto::LengthRangeValidator do
+	let(:errors){ Veto::Errors.new }
+	let(:entity) { Object.new }
+	let(:attribute) { :title }
+	let(:value) { 'blahblah' }
+	let(:options) {{:in => (1..10)}}
+	let(:validator){ Veto::LengthRangeValidator.new(attribute, options) }
+	let(:result){ validator.validate(entity, attribute, value, errors, options) }
+
+	describe '#validate' do
+		before { result }
+
+		context 'when range is array' do
+			let(:options) {{:in => [5, 8, 15]}}
+
+			context 'when value length is in array' do
+				let(:value) { 'abcde' }
+				it { errors[:title].must_be_nil }
+			end
+
+			context 'when value length is not in array' do
+				let(:value) { 'abc' }
+				it { errors[:title].must_equal ["is too short or too long"] }
+			end
+
+			context 'when value length is nil' do
+				let(:value) { nil }
+				it { errors[:title].must_equal ["is too short or too long"] }
+			end
+		end
+
+		context 'when range is range' do
+			let(:options) {{:in => (5..10)}}
+
+			context 'when value length is in range' do
+				let(:value) { 'abcdef' }
+				it { errors[:title].must_be_nil }
+			end
+
+			context 'when value length is not in range' do
+				let(:value) { 'abc' }
+				it { errors[:title].must_equal ["is too short or too long"] }
+			end
+
+			context 'when value length is nil' do
+				let(:value) { nil }
+				it { errors[:title].must_equal ["is too short or too long"] }
+			end	
+		end
+	end
+end