veto 0.0.1

data/spec/attribute_validator_factory_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'veto/attribute_validator_factory'
+require 'veto'
+
+describe Veto::AttributeValidatorFactory do
+	let(:factory) { Veto::AttributeValidatorFactory }
+	let(:type) { :format }
+
+	describe '::new_validator' do
+		let(:attribute){ :first_name }
+		let(:options) { {} }
+		let(:result) { factory.new_validator(type, attribute, options) }
+	
+		context 'when type is exact_length' do
+			let(:type) { :exact_length }
+			it { result.must_be_instance_of Veto::ExactLengthValidator }
+		end
+
+		context 'when type is format' do
+			let(:type) { :format }
+			it { result.must_be_instance_of Veto::FormatValidator }
+		end
+
+		context 'when type is inclusion' do
+			let(:type) { :inclusion }
+			it { result.must_be_instance_of Veto::InclusionValidator }
+		end
+
+		context 'when type is integer' do
+			let(:type) { :integer }
+			it { result.must_be_instance_of Veto::IntegerValidator }
+		end
+
+		context 'when type is length_range' do
+			let(:type) { :length_range }
+			it { result.must_be_instance_of Veto::LengthRangeValidator }
+		end
+
+		context 'when type is max_length' do
+			let(:type) { :max_length }
+			it { result.must_be_instance_of Veto::MaxLengthValidator }
+		end
+
+		context 'when type is min_length' do
+			let(:type) { :min_length }
+			it { result.must_be_instance_of Veto::MinLengthValidator }
+		end
+
+		context 'when type is not_null' do
+			let(:type) { :not_null }
+			it { result.must_be_instance_of Veto::NotNullValidator }
+		end
+
+		context 'when type is numeric' do
+			let(:type) { :numeric }
+			it { result.must_be_instance_of Veto::NumericValidator }
+		end
+
+		context 'when type is presence' do
+			let(:type) { :presence }
+			it { result.must_be_instance_of Veto::PresenceValidator }
+		end
+
+		context 'when type not recognized' do
+			let(:type) { :blah }
+			it 'raises error' do
+				e = proc{ result }.must_raise(ArgumentError)
+				e.message.must_equal 'Validator not found: ::Veto::BlahValidator'
+			end
+		end
+	end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,38 @@
+# require 'spec_helper'
+# require 'veto/builder'
+
+# describe Veto::Builder do
+# 	let(:context) {stub}
+# 	let(:context_conditions){ {:if => :is_good?} }
+# 	let(:builder) { Veto::Builder.new(context, context_conditions) }
+
+# 	describe '#with_options' do
+# 		it 'returns new builder instance' do
+# 			result = builder.with_options(:if => :is_tasty?, :unless => :rotten?)
+# 			result.must_be_instance_of Veto::Builder
+# 		end
+
+# 		it 'passes conditions to instance as new conditions context' do
+# 			result = builder.with_options(:if => :is_tasty?, :unless => :rotten?)
+# 			result.conditions_context.must_equal({:if=>[:is_good?, :is_tasty?], :unless=>[:rotten?]})
+# 		end
+# 	end
+
+# 	describe '#validates' do
+# 		it 'passes list of validators to validates_with' do
+# 			validators = stub
+# 			Veto::Builder::ValidatesBuilder.expects(:validators).returns(validators)
+# 			builder.expects(:validate_with).with(validators)
+# 			builder.validates(:first_name, :presence => true, :if => 'high5')
+# 		end
+# 	end
+
+# 	describe '#validate' do
+# 		it 'passes list of validators to validates_with' do
+# 			validators = stub
+# 			builder.expects(:validate_with)
+# 			Veto::Builder::ValidateBuilder.expects(:validators).returns(validators)
+# 			builder.validate(:meth1, :meth2, :if => :cond1)
+# 		end
+# 	end
+# end

data/spec/conditions_evaluator_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'veto/conditions_evaluator'
+
+describe Veto::ConditionsEvaluator do
+	let(:conditions){}
+	let(:entity){Object.new}
+	let(:context){Object.new}
+	let(:evaluator) { Veto::ConditionsEvaluator.new(conditions) }
+	
+	describe '::truthy?' do
+		let(:condition){}
+		let(:result) { Veto::ConditionsEvaluator.truthy?(condition, context, entity) }
+
+		context 'when condition is true' do
+			let(:condition) { true }
+			it { result.must_equal true }
+		end
+
+		context 'when condition is false' do
+			let(:condition) { false }
+			it { result.must_equal false }
+		end
+
+		context 'when condition is nil' do
+			let(:condition) { nil }
+			it { result.must_equal false }
+		end
+
+		context 'when condition is 0' do
+			let(:condition) { 0 }
+			it { result.must_equal true }
+		end
+
+		context 'when condition is string' do
+			let(:entity) { stub(:is_alive => true) }
+			let(:condition) { 'is_alive' }
+			it { result.must_equal true }
+		end
+
+		context 'when condition is empty string' do
+			let(:condition) { '' }
+			it { result.must_equal false }
+		end
+
+		context 'when condition is empty hash' do
+			let(:condition) { {} }
+			it { result.must_equal true }
+		end
+
+		context 'when condition is method_name symbol' do
+			let(:context) { stub(:active? => true) }
+			let(:condition) { :active? }
+			it { result.must_equal true }
+		end
+
+		context 'when condition is proc' do
+			let(:entity) { stub(:is_alive => true) }
+			let(:condition) { Proc.new{|e| e.is_alive } }
+			it { result.must_equal true }
+		end
+	end
+
+	describe '::truthy_conditions?' do
+		let(:conditions){}
+		let(:result) { Veto::ConditionsEvaluator.truthy_conditions?(conditions, context, entity) }
+
+		context 'when no conditions are assigned' do
+			let(:conditions){{}}
+			it { result.must_equal true }	
+		end
+
+		context 'when if conditions return true' do
+			context 'when unless conditions return false' do
+				let(:conditions){{:if => [true, true], :unless => [false, false]}}
+				it { result.must_equal true }
+			end
+
+			context 'when one unless conditions returns true' do
+				let(:conditions){{:if => [true, true], :unless => [true, false]}}
+				it { result.must_equal false }
+			end
+		end
+
+		context 'when one if condition returns false' do
+			let(:conditions){{:if => [false, true], :unless => [false, false]}}
+			it { result.must_equal false }
+		end
+	end
+
+end

data/spec/conditions_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'veto/conditions'
+
+describe Veto::Conditions do
+	let(:params){{:if => :condition1, :unless => :condition2}}
+	let(:conditions){ Veto::Conditions.new(params) }
+
+	describe '::merge' do
+		it 'extracts and merges condition values' do
+			cond1 = {:if => [:is_good?, :is_tasty?]}
+			cond2 = {:if => "shaking", :unless => :is_bad?, :anotherkey => 'value'}
+			result = Veto::Conditions.merge(cond1, cond2)
+			result.must_equal({:if => [:is_good?, :is_tasty?, "shaking"], :unless => [:is_bad?]})
+		end
+	end
+end

data/spec/configuration/message_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'veto/configuration'
+
+describe Veto::Configuration::Message do
+	let(:msg_proc){ Proc.new{'custom message'} }
+	let(:msg){ Veto::Configuration::Message.new }
+
+	describe '#set' do
+		it 'sets options on type' do
+			msg.send(:custom_messages).must_equal({})
+			msg.set(:exact_format, msg_proc)
+			msg.send(:custom_messages).must_equal({:exact_format => msg_proc})
+		end
+	end
+
+	describe '#get' do
+		context 'when custom_message is defined' do
+			it 'returns custom message' do
+				msg.set(:presence, msg_proc)
+				msg.get(:presence).must_equal 'custom message'				
+			end
+		end
+
+		context 'when custom_message is not defined' do
+			it 'returns default message' do
+				msg.get(:presence).must_equal 'is not present'				
+			end
+		end
+	end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'veto/configuration'
+
+describe Veto::Configuration do
+	let(:configuration){ Veto::Configuration.new }
+end

data/spec/errors_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'veto/errors'
+require 'veto'
+
+describe Veto::Errors do
+	let(:errors){ Veto::Errors.new }
+	describe '#add' do
+		context 'when message is string' do
+			it 'adds message to errors' do
+				errors.add(:name, 'is too long')
+				errors[:name].must_equal ['is too long']
+			end
+		end
+
+		context 'when message contains message dictionary key' do
+			it 'adds dictionary message to errors' do
+				errors.add(:name, :presence)
+				errors[:name].must_equal ["is not present"]
+			end
+		end
+	end
+end

data/spec/model_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'veto/model'
+
+describe Veto::Model do
+	let(:validator){stub}
+	let(:validator_class){stub(:new => validator)}
+	let(:entity_class) {  
+		klass = Class.new{
+			include Veto::Model
+			attr_accessor :first_name, :last_name
+		}
+		klass.validates_with validator_class
+		klass
+	}
+	let(:entity){ entity_class.new }
+
+	describe '::validates_with' do
+		it 'assigns validator' do
+			obj = Object.new
+			entity_class.validates_with obj
+			entity_class.validator.must_equal obj
+		end
+	end
+
+	describe '::validator' do
+		context 'when validator is assigned' do
+			it 'returns validator' do
+				entity_class.validator.must_equal validator_class
+			end
+		end
+
+		context 'when validator is not assigned' do
+			before { entity_class.validates_with nil }
+
+			it 'raises error' do
+				proc{ entity_class.validator }.must_raise ::Veto::ValidatorNotAssigned
+			end
+		end
+	end
+
+	describe '#validator' do
+		it 'initializes, memoizes, and returns validator instance' do
+			entity.send(:validator).must_equal validator
+		end
+	end
+
+	describe '#errors' do
+		it 'delegates method to validator' do
+			validator.expects(:errors)
+			entity.errors
+		end
+	end
+
+	describe '#valid?' do
+		it 'delegates method to validator' do
+			validator.expects(:valid?)
+			entity.valid?
+		end
+	end
+
+	describe '#validate!' do
+		it 'delegates method to validator' do
+			validator.expects(:validate!)
+			entity.validate!
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'mocha/setup'
+
+def context *args, &block
+	describe *args, &block
+end