ward 0.1.0

data/spec/ward/context_chain_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Ward::ContextChain do
+  subject { Ward::ContextChain }
+
+  #
+  # attribute
+  #
+
+  it { should have_public_method_defined(:attribute) }
+
+  describe '#attribute' do
+    before(:all) do
+      @chain = Ward::ContextChain.new
+      @chain.push(Ward::Context.new(:name))
+      @chain.push(Ward::Context.new(:length))
+    end
+
+    it 'should return a symbol' do
+      @chain.attribute.should be_a(Symbol)
+    end
+
+    it "should return the first Context's attribute" do
+      @chain.attribute.should == :name
+    end
+
+    it 'should return :base when there are no contexts contained' do
+      Ward::ContextChain.new.attribute.should == :base
+    end
+  end
+
+  #
+  # to_a
+  #
+
+  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 a context to the end of the chain' do
+      chain = Ward::ContextChain.new
+      new_context = Ward::Context.new(:length)
+      chain.to_a.should be_empty
+      chain.push(new_context)
+      chain.to_a.should eql([new_context])
+    end
+  end
+
+  #
+  # natural name
+  #
+
+  it { should have_public_method_defined(:natural_name) }
+
+  describe '#natural_name' do
+    describe 'when the chain contains no contexts' do
+      it 'should return a blank string' do
+        Ward::ContextChain.new.natural_name.should eql('')
+      end
+    end
+
+    describe 'when the chain contains a single context' do
+      before(:all) do
+        @chain =  Ward::ContextChain.new
+        @chain << Ward::Context.new(:length)
+      end
+
+      it 'should return the context natural name' do
+        @chain.natural_name.should eql('length')
+      end
+    end
+
+    describe 'when the chain contains a two (or more) contexts' do
+      before(:all) do
+        @chain =  Ward::ContextChain.new
+        @chain << Ward::Context.new(:post)
+        @chain << Ward::Context.new(:name)
+      end
+
+      it 'should join the natural names of each context' do
+        @chain.natural_name.should eql('post name')
+      end
+    end
+  end
+
+  #
+  # value
+  #
+
+  it { should have_public_method_defined(:value) }
+
+  describe '#value' do
+    describe 'when the chain contains no context' do
+      before(:all) do
+        @chain = Ward::ContextChain.new
+      end
+
+      it 'should return the given object' do
+        @chain.value('this').should == 'this'
+      end
+    end
+
+    describe 'when the chain contains a single context' do
+      before(:all) do
+        @chain =  Ward::ContextChain.new
+        @chain << Ward::Context.new(:length)
+      end
+
+      it 'should retrieve the value when set' do
+        @chain.value('abc').should eql(3)
+      end
+
+      it 'should retrieve a nil value without an error' do
+        @chain.value(Struct.new(:length).new(nil)).should be_nil
+      end
+    end # when the chain contains a single context
+
+    describe 'when the chain contains two contexts' do
+      before(:all) do
+        @chain =  Ward::ContextChain.new
+        @chain << Ward::Context.new(:post)
+        @chain << Ward::Context.new(:name)
+      end
+
+      it 'should retrieve the value when set' do
+        target = Struct.new(:post).new(Struct.new(:name).new('Hello!'))
+        @chain.value(target).should eql('Hello!')
+      end
+
+      it 'should raise an error if the first context value is nil' do
+        lambda { @chain.value(nil) }.should raise_error
+      end
+
+      it 'should not raise an error if the second context value is nil' do
+        target = Struct.new(:post).new(Struct.new(:name).new(nil))
+        @chain.value(target).should be_nil
+      end
+    end # when the chain contains two contexts
+
+    describe 'when the chain contains three (or more) contexts' do
+      before(:all) do
+        @chain =  Ward::ContextChain.new
+        @chain << Ward::Context.new(:post)
+        @chain << Ward::Context.new(:name)
+        @chain << Ward::Context.new(:length)
+      end
+
+      it 'should retrieve the value when set' do
+        target = Struct.new(:post).new(Struct.new(:name).new('abc'))
+        @chain.value(target).should eql(3)
+      end
+
+      it 'should raise an error if the first context value is nil' do
+        lambda { @chain.value(nil) }.should raise_error
+      end
+
+      it 'should raise an error if the second context value is nil' do
+        target = Struct.new(:post).new(Struct.new(:name).new(nil))
+        lambda { @chain.value(target) }.should raise_error
+      end
+
+      it 'should not raise an error if the second context value is nil' do
+        target = Struct.new(:post).new(
+          Struct.new(:name).new(Struct.new(:length).new(nil))
+        )
+
+        @chain.value(target).should be_nil
+      end
+    end # when the chain contains three (or more) contexts
+  end # value
+
+end

data/spec/ward/context_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Ward::Context do
+  subject { Ward::Context }
+
+  #
+  # attribute
+  #
+
+  it { should have_public_method_defined(:attribute) }
+
+  describe '#attribute' do
+    subject do
+      @attribute = Ward::Context.new('full_name').attribute
+    end
+
+    it { should be_a(Symbol) }
+    it { should eql(:full_name) }
+  end
+
+  #
+  # natural name
+  #
+
+  it { should have_public_method_defined(:natural_name) }
+
+  describe '#natural_name' do
+    subject do
+      @attribute = Ward::Context.new('full_name').natural_name
+    end
+
+    it { should be_a(String) }
+    it { should eql('full name') }
+  end
+
+  #
+  # value
+  #
+
+  it { should have_public_method_defined(:value) }
+
+  describe '#value' do
+    before(:all) do
+      @matcher = Ward::Context.new(:length)
+    end
+
+    it 'should retrieve the target value' do
+      @matcher.value('abc').should == 3
+    end
+
+    it 'should raise an error when the target does not respond to the ' \
+       'target method' do
+      lambda { @matcher.value(nil) }.should raise_exception(NoMethodError)
+    end
+  end # value
+
+end # Ward::Context

data/spec/ward/dsl/validation_block_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::DSL::ValidationBlock do
+
+  #
+  # to_validator_set
+  #
+
+  describe '#to_validator_set' do
+    it 'should return a Ward::ValidatorSet' do
+      set = Ward::DSL::ValidationBlock.new.to_validator_set
+      set.should be_a(Ward::ValidatorSet)
+    end
+    end # to_validator_set
+
+  #
+  # method_missing
+  #
+
+  describe '#method_missing' do
+    it 'should raise an exception when used outside of a run block' do
+      running = lambda { Ward::DSL::ValidationBlock.new.name }
+      running.should raise_error(RuntimeError, /a block/)
+    end
+  end
+
+end

data/spec/ward/dsl/validation_builder_spec.rb

@@ -0,0 +1,212 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::DSL::ValidationBuilder do
+  subject { Ward::DSL::ValidationBuilder }
+
+  #
+  # when setting a matcher
+  #
+
+  describe 'when setting a matcher' do
+    before(:each) do
+      @builder = Ward::DSL::ValidationBuilder.new
+    end
+
+    it "should set an Acceptance matcher when calling #accepted" do
+      validator = @builder.is.accepted.to_validator
+      validator.matcher.should be_a(Ward::Matchers::Acceptance)
+    end
+
+    it "should set a CloseTo matcher when calling #close_to" do
+      validator = @builder.is.close_to(1, 1).to_validator
+      validator.matcher.should be_a(Ward::Matchers::CloseTo)
+    end
+
+    it "should set an EqualTo matcher when calling #equal_to" do
+      validator = @builder.is.equal_to(1).to_validator
+      validator.matcher.should be_a(Ward::Matchers::EqualTo)
+    end
+
+    it "should set a Has matcher when calling #has" do
+      validator = @builder.has.to_validator
+      validator.matcher.should be_a(Ward::Matchers::Has)
+    end
+
+    it "should set a Has matcher when calling #have" do
+      validator = @builder.have(1, 1).to_validator
+      validator.matcher.should be_a(Ward::Matchers::Has)
+    end
+
+    it "should set an Include matcher when calling #included_in" do
+      validator = @builder.is.included_in([]).to_validator
+      validator.matcher.should be_a(Ward::Matchers::Include)
+    end
+
+    it "should set a Match matcher when calling #matches" do
+      validator = @builder.matches(//).to_validator
+      validator.matcher.should be_a(Ward::Matchers::Match)
+    end
+
+    it "should set a Match matcher when calling #match" do
+      validator = @builder.match(//).to_validator
+      validator.matcher.should be_a(Ward::Matchers::Match)
+    end
+
+    it "should set a Nil matcher when calling #nil" do
+      validator = @builder.is.nil.to_validator
+      validator.matcher.should be_a(Ward::Matchers::Nil)
+    end
+
+    it "should set a Present matcher when calling #present" do
+      validator = @builder.is.present.to_validator
+      validator.matcher.should be_a(Ward::Matchers::Present)
+    end
+
+    it "should set a Satisfy matcher when calling #satisfies" do
+      validator = @builder.satisfies.to_validator
+      validator.matcher.should be_a(Ward::Matchers::Satisfy)
+    end
+
+    it "should set a Satisfy matcher when calling #satisfy" do
+      validator = @builder.satisfy.to_validator
+      validator.matcher.should be_a(Ward::Matchers::Satisfy)
+    end
+  end
+
+  #
+  # customising a matcher
+  #
+
+  describe 'calling a missing method when a matcher is set' do
+    it 'should call methods on the matcher' do
+      builder = Ward::DSL::ValidationBuilder.new.has
+      builder.to_validator.matcher.expected.should == 1 # default
+      builder.at_least(5)
+      builder.to_validator.matcher.expected.should == 5
+    end
+  end
+
+  #
+  # when setting a context name
+  #
+
+  describe '#attribute' do
+    before(:each) do
+      @builder = Ward::DSL::ValidationBuilder.new
+    end
+
+    it 'should return the builder' do
+      @builder.attribute(:name).should be(@builder)
+    end
+  end
+
+  #
+  # when setting a message
+  #
+
+  describe '#message' do
+    before(:each) do
+      @builder = Ward::DSL::ValidationBuilder.new.is.present
+    end
+
+    it 'should return the builder' do
+      @builder.message('A validation error message').should be(@builder)
+    end
+
+    it 'should set the validation message' do
+      validator = @builder.message('A validation error message').to_validator
+      validator.message.should == 'A validation error message'
+    end
+  end
+
+  describe 'with no message' do
+    before(:each) do
+      @builder = Ward::DSL::ValidationBuilder.new.is.present
+    end
+
+    it 'should set the validation message' do
+      validator = @builder.to_validator
+      validator.message.should be_nil
+    end
+  end
+
+  #
+  # when setting a scenario
+  #
+
+  describe '#scenario' do
+    before(:each) do
+      @builder = Ward::DSL::ValidationBuilder.new.is.present
+    end
+
+    it 'should return the builder' do
+      @builder.scenario(:scenario).should be(@builder)
+    end
+
+    it 'should set the validation scenario' do
+      validator = @builder.scenario(:scenario).to_validator
+      validator.scenarios.should == [:scenario]
+    end
+  end
+
+  describe '#scenarios' do
+    before(:each) do
+      @builder = Ward::DSL::ValidationBuilder.new.is.present
+    end
+
+    it 'should return the builder' do
+      @builder.scenarios([:scenario]).should be(@builder)
+    end
+
+    it 'should set multiple scenarios when given an array' do
+      validator = @builder.scenarios([:one, :two]).to_validator
+      validator.scenarios.should == [:one, :two]
+    end
+
+    it 'should set multiple scenarios when given a multiple arguments' do
+      validator = @builder.scenarios(:one, :two).to_validator
+      validator.scenarios.should == [:one, :two]
+    end
+  end
+
+  #
+  # to_validator
+  #
+
+  it { should have_public_method_defined(:to_validator) }
+
+  describe '#to_validator' do
+    describe 'when no matcher is defined' do
+      it 'should raise an IncompleteValidator exception' do
+        running = lambda { Ward::DSL::ValidationBuilder.new.to_validator }
+        running.should raise_exception(Ward::IncompleteValidator)
+      end
+    end
+
+    describe 'when a matcher is defined' do
+      before(:all) do
+        builder = Ward::DSL::ValidationBuilder.new.author.name
+        builder.is.equal_to(1)
+        @validator = builder.to_validator
+      end
+
+      it 'should return a Ward::Validator' do
+        @validator.should be_a(Ward::Validator)
+      end
+
+      it 'should set the matcher' do
+        @validator.matcher.should be_a(Ward::Matchers::Matcher)
+      end
+
+      it 'should set the matcher expectation' do
+        @validator.matcher.expected.should == 1
+      end
+
+      it 'should set the context' do
+        attributes = @validator.context.to_a.map { |c| c.attribute }
+        attributes.should == [:author, :name]
+      end
+    end
+  end
+
+end