ward 0.1.0

data/spec/ward/validator_set_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+# @todo
+#   Replace all cases of ValidatorSet.new with the DSL.
+
+describe Ward::ValidatorSet do
+  subject { Ward::ValidatorSet }
+
+  #
+  # .build
+  #
+
+  describe '.build' do
+    describe 'when no initial set is provided' do
+      it 'should add the validators to the set' do
+        dsl = Ward::ValidatorSet.build do |object|
+          object.name.matches(/abc/)
+          object.name.length.is.equal_to(3)
+        end
+
+        # ValidatorSet doesn't have a size method, but does implement Enumerable
+        dsl.inject(0) { |c, *| c += 1 }.should == 2
+      end
+    end # when no initial set is provided
+
+    describe 'when an initial set is provided' do
+      before(:all) do
+        @initial = Ward::ValidatorSet.build do |object|
+          object.name.matches(/abc/)
+          object.name.length.is.equal_to(3)
+        end
+
+        @set = Ward::ValidatorSet.build(@initial) do |object|
+          object.name.present
+        end
+      end
+
+      it 'should add the new validators to a copy of the initial set' do
+        # ValidatorSet doesn't have a size method, but does implement Enumerable
+        @set.inject(0) { |c, *| c += 1 }.should == 3
+      end
+
+      it 'should return a copy of the initial set' do
+        @set.should_not == @initial
+        @initial.inject(0) { |c, *| c += 1 }.should == 2
+      end
+    end # when an initial set is provided
+  end # .build
+
+  #
+  # enumeration
+  #
+
+  it 'should be enumerable' do
+    Ward::ValidatorSet.ancestors.should include(Enumerable)
+  end
+
+  it { should have_public_method_defined(:each) }
+  it { should have_public_method_defined(:to_a) }
+
+  #
+  # push
+  #
+
+  it { should have_public_method_defined(:push) }
+  it { should have_public_method_defined(:<<) }
+
+  describe '#push' do
+    it 'should add validator to the set' do
+      set = Ward::ValidatorSet.new
+      new_validator = Ward::Validator.new(nil, nil)
+      set.to_a.should be_empty
+      set.push(new_validator)
+      set.should include(new_validator)
+    end
+  end
+
+  #
+  # valid?
+  #
+
+  it { should have_public_method_defined(:valid?) }
+
+  describe '#valid?' do
+    describe 'with two validators, both of which pass' do
+      it 'should return true' do
+        set = Ward::ValidatorSet.build do |object|
+          object.length.is.equal_to(1)
+          object.length.is.present
+        end
+
+        set.valid?('a').should be_true
+      end
+    end
+
+    describe 'with two validators, both of which fail' do
+      before(:each) do
+        @set = Ward::ValidatorSet.build do |object|
+          object.length.is.equal_to(1)
+          object.length.is.equal_to(2)
+        end
+      end
+
+      it 'should return false' do
+        @set.valid?('').should be_false
+      end
+
+      it 'should run all the validators' do
+        @set.each do |validator|
+          validator.should_receive(:validate).and_return([false])
+        end
+
+        lambda { @set.valid?('') }.should_not raise_exception
+      end
+    end
+
+    describe 'with two validators, one of which fails' do
+      before(:each) do
+        @set = Ward::ValidatorSet.build do |object|
+          object.length.is.equal_to(1) # false
+          object.length.is.equal_to(2) # true
+        end
+      end
+
+      it 'should return false' do
+        @set.valid?('ab').should be_false
+      end
+
+      it 'should run all the validators' do
+        @set.to_a[0].should_receive(:validate).and_return([false])
+        @set.to_a[1].should_receive(:validate).and_return([true])
+
+        lambda { @set.valid?('ab') }.should_not raise_exception
+      end
+    end
+  end # valid?
+
+  #
+  # merge!
+  #
+
+  it { should have_public_method_defined(:merge!) }
+
+  describe '#merge!' do
+    before(:each) do
+      @set = Ward::ValidatorSet.build do |object|
+        object.length.is.equal_to(1)
+      end
+    end
+
+    it 'should return self' do
+      @set.merge!(Ward::ValidatorSet.new).should == @set
+    end
+
+    it "should add the argument's validators to the receiver" do
+      other = Ward::ValidatorSet.new
+      other << Ward::Validator.new(nil, nil)
+      running = lambda { @set.merge!(other) }
+
+      # select is used here since ValidatorSet doesn't have a size method, but
+      # does implement Enumerable.
+      running.should change { @set.select { |*| true }.size }.by(1)
+    end
+
+    it 'should not merge validators already contained in the set' do
+      pending do
+        other = Ward::ValidatorSet.new
+        other << @set.to_a.first.dup
+        running = lambda { @set.merge!(other) }
+
+        # select is used here since ValidatorSet doesn't have a size method, but
+        # does implement Enumerable.
+        running.should_not change { @set.select { |*| true }.size }
+      end
+    end
+  end
+
+end

data/spec/ward/validator_spec.rb

@@ -0,0 +1,264 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Ward::Validator do
+  subject { Ward::Validator }
+
+  #
+  # initialize
+  #
+
+  describe '#initialize' do
+    describe 'scenarios' do
+      it 'should be [:default] when no scenarios option is given' do
+        Ward::Validator.new(nil, nil).scenarios.should == [:default]
+      end
+
+      it 'should be [:scenario] when the scenarios option is [:scenario]' do
+        validator = Ward::Validator.new(nil, nil, :scenarios => [:scenario])
+        validator.scenarios.should == [:scenario]
+      end
+
+      it 'should be [:scenario] when the scenarios option is :scenario' do
+        validator = Ward::Validator.new(nil, nil, :scenarios => :scenario)
+        validator.scenarios.should == [:scenario]
+      end
+    end
+  end
+
+  #
+  # context
+  #
+
+  it { should have_public_method_defined(:context) }
+
+  describe '#context' do
+    before(:all) do
+      @context = Ward::Validator.new('context', 'matcher').context
+    end
+
+    it 'should return the context' do
+      @context.should == 'context'
+    end
+  end
+
+  #
+  # matcher
+  #
+
+  it { should have_public_method_defined(:matcher) }
+
+  describe '#matcher' do
+    before(:all) do
+      @matcher = Ward::Validator.new('context', 'matcher').matcher
+    end
+
+    it 'should return the matcher' do
+      @matcher.should == 'matcher'
+    end
+  end
+
+  #
+  # validate
+  #
+
+  it { should have_public_method_defined(:validate) }
+
+  describe '#validate' do
+    describe 'when the validator is positive' do
+      before(:all) do
+        @validator = Ward::Validator.new(Ward::Context.new(:name),
+          Ward::Matchers::Nil.new, :negative => false)
+      end
+
+      describe 'when the matcher passes' do
+        it 'should return true' do
+          @validator.validate(mock(:name => nil)).should be_true
+        end
+      end
+
+      describe 'when the matcher fails' do
+        before(:all) do
+          @result = @validator.validate(mock(:name => ''))
+        end
+
+        it 'should return Array[false, ...]' do
+          @result.first.should be_false
+        end
+      end
+
+      describe 'when the matcher fails and return an error' do
+        before(:all) do
+          @validator.matcher.stub(:matches?).and_return([false, :error])
+          @result = @validator.validate(mock(:name => ''))
+        end
+
+        it 'should return Array[false, ...]' do
+          @result.first.should be_false
+        end
+      end
+
+      # Rubinius.
+      describe 'when the matcher returns a non-array which responds to #to_a' do
+        before(:all) do
+          @validator.matcher.stub(:matches?).and_return(mock(:to_a => []))
+          @result = @validator.validate(mock(:name => ''))
+        end
+
+        it 'should return Array[true, ...]' do
+          @result.first.should be_true
+        end
+
+        it 'should return Array[..., nil]' do
+          @result[1].should be_nil
+        end
+      end
+    end # when the matcher is positive
+
+    describe 'when the validator is negative' do
+      before(:all) do
+        @validator = Ward::Validator.new(Ward::Context.new(:name),
+          Ward::Matchers::Nil.new, :negative => true)
+      end
+
+      describe 'when the matcher passes' do
+        it 'should return Array[false, ...]' do
+          @validator.validate(mock(:name => nil)).first.should be_false
+        end
+      end
+
+      describe 'when the matcher fails' do
+        before(:all) do
+          @result = @validator.validate(mock(:name => ''))
+        end
+
+        it 'should return Array[true, ...]' do
+          @result.first.should be_true
+        end
+      end
+
+      describe 'when the matcher fails and return an error' do
+        before(:all) do
+          @validator.matcher.stub(:matches?).and_return([false, :error])
+          @result = @validator.validate(mock(:name => ''))
+        end
+
+        it 'should return Array[true, ...]' do
+          @result.first.should be_true
+        end
+      end
+
+      # Rubinius.
+      describe 'when the matcher returns a non-array which responds to #to_a' do
+        before(:all) do
+          @validator.matcher.stub(:matches?).and_return(mock(:to_a => []))
+          @result = @validator.validate(mock(:name => ''))
+        end
+
+        it 'should return Array[false, ...]' do
+          @result.first.should be_false
+        end
+
+        it 'should return Array[..., an_error]' do
+          @result[1].should_not be_nil
+        end
+      end
+    end # when the matcher is negative
+
+    #
+    # argument counts
+    #
+
+    describe 'when matcher #matches? accepts' do
+      describe 'one argument' do
+        it 'should supply the attribute' do
+          value  = ''
+
+          Ward::Validator.new(Ward::Context.new(:name),
+            Class.new do
+              def matches?(arg1)
+                arg1.should == ''
+              end
+            end.new
+          ).validate(mock(:name => value))
+        end
+      end
+
+      describe 'two arguments' do
+        it 'should supply the attribute and record' do
+          value  = ''
+          record = mock(:name => value)
+
+          Ward::Validator.new(Ward::Context.new(:name),
+            Class.new do
+              include Spec::Matchers
+              def matches?(arg1, arg2)
+                arg1.should == ''
+                arg2.should be_a(Spec::Mocks::Mock)
+              end
+            end.new
+          ).validate(record)
+        end
+      end
+    end # when matcher #matches? accepts (one|two) arguments?
+
+  end # validate
+
+  #
+  # scenarios
+  #
+
+  it { should have_public_method_defined(:scenarios) }
+
+  describe '#scenarios' do
+    before(:all) do
+      @matcher = Ward::Validator.new('context', 'matcher').scenarios
+    end
+
+    it 'should return an array' do
+      @matcher.should be_an(Array)
+    end
+  end
+
+  #
+  # scenario?
+  #
+
+  it { should have_public_method_defined(:scenario?) }
+
+  describe '#scenario?' do
+    it 'should return true when the validator exists in a given scenario' do
+      validator = Ward::Validator.new(nil, nil, :scenarios => [:update])
+      validator.scenario?(:update).should be_true
+    end
+
+    it 'should return true when the validator does not exist in a given scenario' do
+      validator = Ward::Validator.new(nil, nil)
+      validator.scenario?(:update).should be_false
+    end
+  end
+
+  #
+  # negative?
+  #
+
+  it { should have_public_method_defined(:negative?) }
+
+  describe 'negative?' do
+    it 'should return true when the validator requires that the matcher ' \
+       'does not match the actual value' do
+      validator = Ward::Validator.new(nil, nil, :negative => true)
+      validator.should be_negative
+    end
+
+    it 'should return false when the validator requires that the matcher ' \
+       'matches the actual value' do
+      validator = Ward::Validator.new(nil, nil, :negative => false)
+      validator.should_not be_negative
+
+      validator = Ward::Validator.new(nil, nil)
+      validator.should_not be_negative
+    end
+  end
+
+
+end

data/tasks/features.rake

@@ -0,0 +1,15 @@
+begin
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |features|
+    features.cucumber_opts = '--format progress --tag ~@pending'
+  end
+
+  task :features => :check_dependencies
+
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: " \
+          "gem install cucumber"
+  end
+end