veto 0.1.3 → 1.0.0

data/spec/blocks/block_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Veto::Block do
+  it 'can have children assigned' do
+    block = new_block
+    child = stub
+    block << child
+    block.children.must_equal([child])
+  end
+
+  it 'can :call each child' do
+    block = new_block
+    
+    child1 = stub
+    child2 = stub
+
+    block << child1
+    block << child2
+
+    args = stub
+
+    child1.expects(:call).with(args).once
+    child2.expects(:call).with(args).once
+
+    block.call(args)
+  end
+
+  def new_block
+    Veto::Block.new
+  end
+end

data/spec/blocks/check_block_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Veto::ValidatesBlock::CheckBlock do
+  it 'gets attribute_name' do
+    block = new_block(:presence, :first_name, true)
+    block.attribute_name.must_equal(:first_name)
+  end
+
+  it 'gets type' do
+    block = new_block(:presence, :first_name, true)
+    block.type.must_equal(:presence)
+  end
+
+  it 'converts true value to hash' do
+    block = new_block(:presence, :first_name, true)
+    block.options.must_equal({})
+  end
+
+  it 'converts range value to hash' do
+    block = new_block(:presence, :first_name, 1..9)
+    block.options.must_equal(:in => 1..9)
+  end
+
+  it 'converts array value to hash' do
+    block = new_block(:presence, :first_name, ['cat', 'dog'])
+    block.options.must_equal(:in => ['cat', 'dog'])
+  end
+
+  it 'converts other value to hash' do
+    block = new_block(:presence, :first_name, 23)
+    block.options.must_equal(:with => 23)
+  end
+
+  it 'can build structure and assign check child' do
+    block = build_block(:presence, :first_name, true)
+    block.children.map{|c| c.class.name}.must_equal(["Veto::PresenceCheck"])
+  end
+
+  def new_block(*args)
+    Veto::ValidatesBlock::CheckBlock.new(*args)
+  end
+
+  def build_block(*args)
+    Veto::ValidatesBlock::CheckBlock.build(*args)
+  end
+end

data/spec/blocks/conditional_block_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Veto::ConditionalBlock do
+  it 'exposes options with conditions removed' do
+    block = new_block(:if => 'blah', :opt1 => 'blahblah')
+    block.options.must_equal(:opt1 => 'blahblah')
+  end
+
+  context 'when conditions pass' do
+    it 'will :call children' do
+      block = new_block(:if => true, :opt1 => 'blahblah')
+      child = stub
+
+      block << child
+
+      child.expects(:call).once
+      block.call
+    end
+  end
+
+  context 'when conditions fail' do
+    it 'will not :call children' do
+      block = new_block(:if => false, :opt1 => 'blahblah')
+      child = stub
+
+      block << child
+
+      child.expects(:call).never
+      block.call
+    end
+  end
+
+  def new_block(*args)
+    Veto::ConditionalBlock.new(*args)
+  end
+end

data/spec/blocks/validate_block_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Veto::ValidateBlock do
+  it 'can build itself and assign check child' do
+    block = Veto::ValidateBlock.build(:good_method?, :if => true)
+    block.children.size.must_equal(1)
+    block.children[0].must_be_instance_of(Veto::MethodCheck)
+  end
+
+  it 'has method_name' do
+    block = new_block(:good_method?)
+    block.method_name.must_equal(:good_method?)
+  end
+
+  def new_block(*args)
+    Veto::ValidateBlock.new(*args)
+  end
+end

data/spec/blocks/validates_block_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Veto::ValidatesBlock do
+  it 'gets attribute_name' do
+    block = new_block(:first_name, :presence => true, :if => true)
+    block.attribute_name.must_equal(:first_name)
+  end
+
+  it 'can build nested check structure' do
+    block = build_block(:first_name, :presence => true, :format => /[a-z]/, :if => true)
+    block.children.size.must_equal(2)
+    block.children[0].must_be_instance_of(Veto::ValidatesBlock::CheckBlock)
+  end
+
+  def new_block(*args)
+    Veto::ValidatesBlock.new(*args)
+  end
+
+  def build_block(*args)
+    Veto::ValidatesBlock.build(*args)
+  end
+end

data/spec/checks/exact_length_check_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Veto::ExactLengthCheck do
+  context 'when value is exact length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcde')
+      errors = new_errors
+      check = new_check(:name, :with => 5)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is not exact length' do
+    it 'assigns errors' do
+      entity = stub(:name => 'abcde')
+      errors = new_errors
+      check = new_check(:name, :with => 4)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(['is not 4 characters'])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::ExactLengthCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/format_validator_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Veto::FormatCheck do
+  context 'when value matches format' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcde')
+      errors = new_errors
+      check = new_check(:name, :with => /^[a-z]+$/)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value does not match format' do
+    it 'assigns errors' do
+      entity = stub(:name => 'abcde1')
+      errors = new_errors
+      check = new_check(:name, :with => /^[a-z]+$/)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is not valid"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::FormatCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/greater_than_check_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Veto::GreaterThanCheck do
+  context 'when value is greater than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 24)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is equal' do
+    it 'assigns no errors' do
+      entity = stub(:name => 23)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["must be greater than 23"])
+    end
+  end
+
+  context 'when value is less than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 22)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["must be greater than 23"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::GreaterThanCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/greater_than_or_equal_to_check_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Veto::GreaterThanOrEqualToCheck do
+  context 'when value is equal' do
+    it 'assigns no errors' do
+      entity = stub(:name => 23)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is greater than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 24)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is less than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 22)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["must be greater than or equal to 23"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::GreaterThanOrEqualToCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/inclusion_check_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Veto::InclusionCheck do
+  context 'when value is included' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'cat')
+      errors = new_errors
+      check = new_check(:name, :in => %w(cat dog mouse))
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is not included' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'cat')
+      errors = new_errors
+      check = new_check(:name, :in => %w(dog mouse))
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is not in set: [\"dog\", \"mouse\"]"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::InclusionCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/integer_check_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Veto::IntegerCheck do
+  context 'when value is an integer' do
+    it 'assigns no errors' do
+      entity = stub(:name => 23)
+      errors = new_errors
+      check = new_check(:name)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is not an integer' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abc')
+      errors = new_errors
+      check = new_check(:name)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is not a number"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::IntegerCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/length_range_check_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Veto::LengthRangeCheck do
+  context 'when value in length range' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcdef')
+      errors = new_errors
+      check = new_check(:name, :in => 1..10)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value not in length range' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcdef')
+      errors = new_errors
+      check = new_check(:name, :in => 99..199)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is too short or too long"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::LengthRangeCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/less_than_check_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Veto::LessThanCheck do
+  context 'when value is less than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 22)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is equal' do
+    it 'assigns no errors' do
+      entity = stub(:name => 23)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["must be less than 23"])
+    end
+  end
+
+  context 'when value is greater than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 24)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["must be less than 23"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::LessThanCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/less_than_or_equal_to_check_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Veto::LessThanOrEqualToCheck do
+  context 'when value is equal' do
+    it 'assigns no errors' do
+      entity = stub(:name => 23)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is less than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 22)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is greater than' do
+    it 'assigns no errors' do
+      entity = stub(:name => 24)
+      errors = new_errors
+      check = new_check(:name, :with => 23)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["must be less than or equal to 23"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::LessThanOrEqualToCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/max_length_check_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Veto::MaxLengthCheck do
+  context 'when value is less than max length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcdefgh')
+      errors = new_errors
+      check = new_check(:name, :with => 99)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value equals max length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcde')
+      errors = new_errors
+      check = new_check(:name, :with => 5)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is greater than max length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcdefgh')
+      errors = new_errors
+      check = new_check(:name, :with => 5)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is longer than 5 characters"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::MaxLengthCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/method_check_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Veto::MethodCheck do
+  it 'delegates to method call on context' do
+    check = Veto::MethodCheck.new(:name)
+    entity = stub
+    context = stub(:name => true)
+    cco = stub(:entity => entity, :context => context)
+    
+    context.expects(:name).with(entity).once
+    check.call(cco)
+  end
+end

data/spec/checks/min_length_check_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Veto::MinLengthCheck do
+  context 'when value is greater than min length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcdefgh')
+      errors = new_errors
+      check = new_check(:name, :with => 5)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value equals min length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcde')
+      errors = new_errors
+      check = new_check(:name, :with => 5)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is less than min length' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcdefgh')
+      errors = new_errors
+      check = new_check(:name, :with => 99)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is shorter than 99 characters"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::MinLengthCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end

data/spec/checks/not_null_check_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Veto::NotNullCheck do
+  context 'when value is not null' do
+    it 'assigns no errors' do
+      entity = stub(:name => 'abcde')
+      errors = new_errors
+      check = new_check(:name)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_be_nil
+    end
+  end
+
+  context 'when value is null' do
+    it 'assigns no errors' do
+      entity = stub(:name => nil)
+      errors = new_errors
+      check = new_check(:name)
+
+      check.call(new_cto(entity, errors))
+      errors[:name].must_equal(["is not present"])
+    end
+  end
+
+  def new_cto(entity, errors)
+    stub(:entity => entity, :errors => errors)
+  end
+
+  def new_check(*args)
+    Veto::NotNullCheck.new(*args)
+  end
+
+  def new_errors
+    Veto::Errors.new
+  end
+end