ward 0.1.0

data/spec/ward/matchers/match_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Match do
+
+  it 'should be registered with :matches' do
+    matcher = Ward::Matchers.matchers[:matches]
+    matcher.should == Ward::Matchers::Match
+  end
+
+  it 'should be registered with :match' do
+    matcher = Ward::Matchers.matchers[:match]
+    matcher.should == Ward::Matchers::Match
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/match_matcher.feature
+
+end

data/spec/ward/matchers/matcher_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Matcher do
+  subject { Ward::Matchers::Matcher }
+
+  it { should have_public_method_defined(:extra_args) }
+
+  #
+  # initialize
+  #
+
+  describe '#initialize' do
+    it 'should not require an argument' do
+      lambda { Ward::Matchers::Matcher.new }.should_not raise_exception
+    end
+
+    it 'should store extra arguments' do
+      Ward::Matchers::Matcher.new(1, 2, 3).extra_args.should == [2, 3]
+    end
+  end
+
+  #
+  # expected
+  #
+
+  it { should have_public_method_defined(:expected) }
+
+  describe '#expected' do
+    before(:each) do
+      @matcher = Ward::Matchers::Matcher.new(1)
+    end
+
+    it 'should return the expected value' do
+      @matcher.expected.should == 1
+    end
+  end
+
+  #
+  # matches?
+  #
+
+  it { should have_public_method_defined(:matches?) }
+
+  describe '#matches?' do
+    before(:each) do
+      @matcher = Ward::Matchers::Matcher.new(1)
+    end
+
+    it 'should pass' do
+      @matcher.matches?(nil).should be_true
+    end
+  end
+
+end

data/spec/ward/matchers/nil_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Nil do
+
+  it 'should be registered with :nil' do
+    matcher = Ward::Matchers.matchers[:nil]
+    matcher.should == Ward::Matchers::Nil
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/nil_matcher.feature
+
+end

data/spec/ward/matchers/predicate_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Predicate do
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/present_matcher.feature
+
+  describe '#matches?' do
+    it "should raise an error if the actual value doesn't respond to the method" do
+      matcher = Ward::Matchers::Predicate.new(:important?)
+      running = lambda { matcher.matches?(nil) }
+      running.should raise_error(ArgumentError, /does not respond/)
+    end
+  end
+
+end

data/spec/ward/matchers/present_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Present do
+
+  it 'should be registered with :present' do
+    matcher = Ward::Matchers.matchers[:present]
+    matcher.should == Ward::Matchers::Present
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/present_matcher.feature
+
+end

data/spec/ward/matchers/satisfy_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Satisfy do
+
+  it 'should be registered with :satisfies' do
+    matcher = Ward::Matchers.matchers[:satisfies]
+    matcher.should == Ward::Matchers::Satisfy
+  end
+
+  it 'should be registered with :satisfy' do
+    matcher = Ward::Matchers.matchers[:satisfy]
+    matcher.should == Ward::Matchers::Satisfy
+  end
+
+  #
+  # block arguments
+  #
+
+  describe 'when the given block accepts no arguments' do
+    it 'should supply nothing to to the block' do
+      running = lambda { Ward::Matchers::Satisfy.new {}.matches?('nil') }
+      running.should_not raise_error
+    end
+  end
+
+  describe 'when the given block accepts one argument' do
+    it 'should supply the attribute value to to the block' do
+      Ward::Matchers::Satisfy.new do |value|
+        value.should == 'Rincewind'
+      end.matches?('Rincewind')
+    end
+  end
+
+  describe 'when the given block accepts two arguments' do
+    it 'should supply the attribute value to to the block' do
+      Ward::Matchers::Satisfy.new do |value, record|
+        value.should == 'Rincewind'
+      end.matches?('Rincewind')
+    end
+
+    it 'should supply the record instance to to the block' do
+      Ward::Matchers::Satisfy.new do |value, record|
+        record.should == 'Discworld'
+      end.matches?('Rincewind', 'Discworld')
+    end
+  end
+
+  describe 'when the given block accepts a splat argument' do
+    it 'should supply the attribute value to the block' do
+      Ward::Matchers::Satisfy.new do |*args|
+        args.first.should == 'Rincewind'
+      end.matches?('Rincewind', 'Discworld')
+    end
+
+    it 'should supply the record instance to the block' do
+      Ward::Matchers::Satisfy.new do |*args|
+        args.last.should == 'Discworld'
+      end.matches?('Rincewind', 'Discworld')
+    end
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/satisfy_matcher.feature
+
+end

data/spec/ward/matchers_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Ward::Matchers do
+  subject  { Ward::Matchers }
+
+  #
+  # matchers
+  #
+
+  it { should respond_to(:matchers) }
+
+  describe '#matchers' do
+    it 'should return a Hash' do
+      Ward::Matchers.matchers.should be_a(Hash)
+    end
+  end
+
+  #
+  # register
+  #
+
+  it { should respond_to(:register) }
+
+  describe '#register' do
+    before(:all) do
+      class ::TestMatcher < Ward::Matchers::Matcher  ; end
+      class ::TestMatcher2 < Ward::Matchers::Matcher ; end
+    end
+
+    it 'should register the Matcher with the given slug' do
+      Ward::Matchers.matchers.should_not have_key(:__test_matcher__)
+      Ward::Matchers.matchers.should_not have_value(::TestMatcher)
+      Ward::Matchers.register(:__test_matcher__, ::TestMatcher)
+      Ward::Matchers.matchers[:__test_matcher__].should == ::TestMatcher
+    end
+
+    it 'should overwrite an existing registration' do
+      Ward::Matchers.register(:__test_matcher__, ::TestMatcher)
+      Ward::Matchers.register(:__test_matcher__, ::TestMatcher2)
+      Ward::Matchers.matchers[:__test_matcher__].should == ::TestMatcher2
+    end
+
+    it 'should permit registration multiple times with different slugs' do
+      Ward::Matchers.register(:__test_matcher__, ::TestMatcher)
+      Ward::Matchers.register(:__another_test_matcher__, ::TestMatcher)
+      Ward::Matchers.matchers[:__test_matcher__].should == ::TestMatcher
+      Ward::Matchers.matchers[:__another_test_matcher__].should == ::TestMatcher
+    end
+  end
+
+end

data/spec/ward/spec/have_public_method_defined_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe 'have_public_method_defined matcher' do
+  before(:all) do
+    @exception = Spec::Expectations::ExpectationNotMetError
+  end
+
+  describe 'with should' do
+    it 'should pass when the method is defined' do
+      running = lambda { String.should have_public_method_defined(:length) }
+      running.should_not raise_exception(@exception)
+    end
+
+    it 'should fail when the method is not defined' do
+      running = lambda { String.should have_public_method_defined(:__invalid__) }
+      running.should raise_exception(@exception)
+    end
+  end
+
+  describe 'with should_not' do
+    it 'should fail when the method is defined' do
+      running = lambda { String.should_not have_public_method_defined(:length) }
+      running.should raise_exception(@exception)
+    end
+
+    it 'should pass when the method is not defined' do
+      running = lambda { String.should_not have_public_method_defined(:__invalid__) }
+      running.should_not raise_exception(@exception)
+    end
+  end
+end

data/spec/ward/spec/matcher_matcher_spec.rb

@@ -0,0 +1,217 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Ward RSpec matcher" do
+
+  before(:each) do
+    @exception = Spec::Expectations::ExpectationNotMetError
+    @matcher   = Object.new
+    @matcher.stub!(:expected).and_return('')
+  end
+
+  describe 'pass_matcher_with' do
+    describe 'with "should"' do
+      it 'should pass when the matcher returns true' do
+        @matcher.should_receive(:matches?).and_return(true)
+
+        running = lambda { @matcher.should pass_matcher_with('') }
+        running.should_not raise_exception(@exception)
+      end
+
+      it 'should pass when the matcher returns an arbitrary object' do
+        @matcher.should_receive(:matches?).and_return(Object.new)
+
+        running = lambda { @matcher.should pass_matcher_with('') }
+        running.should_not raise_exception(@exception)
+      end
+
+      it 'should fail when the matcher returns false' do
+        @matcher.should_receive(:matches?).and_return(false)
+
+        running = lambda { @matcher.should pass_matcher_with('') }
+        running.should raise_exception(@exception)
+      end
+
+      it 'should fail when the matcher returns [false, ...]' do
+        @matcher.should_receive(:matches?).and_return([false])
+
+        running = lambda { @matcher.should pass_matcher_with('') }
+        running.should raise_exception(@exception)
+      end
+
+      it 'should fail when the matcher returns nil' do
+        @matcher.should_receive(:matches?).and_return(nil)
+
+        running = lambda { @matcher.should pass_matcher_with('') }
+        running.should raise_exception(@exception)
+      end
+
+      it 'should fail when the matcher returns [nil, ...]' do
+        @matcher.should_receive(:matches?).and_return([nil])
+
+        running = lambda { @matcher.should pass_matcher_with('') }
+        running.should raise_exception(@exception)
+      end
+
+    end # with "should"
+
+    describe 'with "should_not"' do
+      it 'should fail when the matcher returns true' do
+        @matcher.should_receive(:matches?).and_return(true)
+
+        running = lambda { @matcher.should_not pass_matcher_with('') }
+        running.should raise_exception(@exception)
+      end
+
+      it 'should fail when the matcher returns an arbitrary object' do
+        @matcher.should_receive(:matches?).and_return(Object.new)
+
+        running = lambda { @matcher.should_not pass_matcher_with('') }
+        running.should raise_exception(@exception)
+      end
+
+      it 'should pass when the matcher returns false' do
+        @matcher.should_receive(:matches?).and_return(false)
+
+        running = lambda { @matcher.should_not pass_matcher_with('') }
+        running.should_not raise_exception(@exception)
+      end
+
+      it 'should pass when the matcher returns [false, ...]' do
+        @matcher.should_receive(:matches?).and_return([false])
+
+        running = lambda { @matcher.should_not pass_matcher_with('') }
+        running.should_not raise_exception(@exception)
+      end
+
+      it 'should pass when the matcher returns nil' do
+        @matcher.should_receive(:matches?).and_return(nil)
+
+        running = lambda { @matcher.should_not pass_matcher_with('') }
+        running.should_not raise_exception(@exception)
+      end
+
+      it 'should pass when the matcher returns [nil, ...]' do
+        @matcher.should_receive(:matches?).and_return([nil])
+
+        running = lambda { @matcher.should_not pass_matcher_with('') }
+        running.should_not raise_exception(@exception)
+      end
+
+    end # with "should_not"
+  end # pass_matcher_with
+
+  describe 'fail_matcher_with' do
+    describe 'with no error expectation' do
+      describe 'with "should"' do
+        it 'should fail when the matcher returns true' do
+          @matcher.should_receive(:matches?).and_return(true)
+
+          running = lambda { @matcher.should fail_matcher_with('') }
+          running.should raise_exception(@exception)
+        end
+
+        it 'should fail when the matcher returns an arbitrary object' do
+          @matcher.should_receive(:matches?).and_return(Object.new)
+
+          running = lambda { @matcher.should fail_matcher_with('') }
+          running.should raise_exception(@exception)
+        end
+
+        it 'should pass when the matcher returns false' do
+          @matcher.should_receive(:matches?).and_return(false)
+
+          running = lambda { @matcher.should fail_matcher_with('') }
+          running.should_not raise_exception(@exception)
+        end
+
+        it 'should pass when the matcher returns [false, ...]' do
+          @matcher.should_receive(:matches?).and_return([false])
+
+          running = lambda { @matcher.should fail_matcher_with('') }
+          running.should_not raise_exception(@exception)
+        end
+
+        it 'should pass when the matcher returns nil' do
+          @matcher.should_receive(:matches?).and_return([nil])
+
+          running = lambda { @matcher.should fail_matcher_with('') }
+          running.should_not raise_exception(@exception)
+        end
+
+        it 'should pass when the matcher returns [nil, ...]' do
+          @matcher.should_receive(:matches?).and_return([nil])
+
+          running = lambda { @matcher.should fail_matcher_with('') }
+          running.should_not raise_exception(@exception)
+        end
+      end # with "should"
+
+      describe 'with "should_not"' do
+        it 'should pass when the matcher returns true' do
+          @matcher.should_receive(:matches?).and_return(true)
+
+          running = lambda { @matcher.should_not fail_matcher_with('') }
+          running.should_not raise_exception(@exception)
+        end
+
+        it 'should pass when the matcher returns an arbitrary object' do
+          @matcher.should_receive(:matches?).and_return(Object.new)
+
+          running = lambda { @matcher.should_not fail_matcher_with('') }
+          running.should_not raise_exception(@exception)
+        end
+
+        it 'should fail when the matcher returns false' do
+          @matcher.should_receive(:matches?).and_return(false)
+
+          running = lambda { @matcher.should_not fail_matcher_with('') }
+          running.should raise_exception(@exception)
+        end
+
+        it 'should fail when the matcher returns [false, ...]' do
+          @matcher.should_receive(:matches?).and_return([false])
+
+          running = lambda { @matcher.should_not fail_matcher_with('') }
+          running.should raise_exception(@exception)
+        end
+
+        it 'should fail when the matcher returns nil' do
+          @matcher.should_receive(:matches?).and_return(nil)
+
+          running = lambda { @matcher.should_not fail_matcher_with('') }
+          running.should raise_exception(@exception)
+        end
+
+        it 'should fail when the matcher returns [nil, ...]' do
+          @matcher.should_receive(:matches?).and_return([nil])
+
+          running = lambda { @matcher.should_not fail_matcher_with('') }
+          running.should raise_exception(@exception)
+        end
+      end # with "should_not"
+    end # with no error expectation
+
+    describe 'with an error expectation' do
+      it 'should pass when the actual error matches the expected error' do
+        @matcher.should_receive(:matches?).and_return([false, :e])
+
+        running = lambda {
+          @matcher.should fail_matcher_with('').with_error(:e)
+        }
+
+        running.should_not raise_exception(@exception)
+      end
+
+      it 'should fail when the actual error does not match the expected error' do
+        @matcher.should_receive(:matches?).and_return([false, :e])
+
+        running = lambda {
+          @matcher.should fail_matcher_with('').with_error(:whoops)
+        }
+
+        running.should raise_exception(@exception)
+      end
+    end # with an error expectation
+  end # fail_matcher_with
+
+end