rspec-expectations 2.0.0.beta.22 → 2.6.0

data/lib/rspec/matchers/throw_symbol.rb

@@ -19,42 +19,45 @@ module RSpec
                 throw :proc_did_not_throw_anything, :nothing_thrown
               end
             end
-            @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown
+
+            if @caught_arg == :nothing_thrown
+              @caught_arg = nil
+            else
+              @caught_symbol = @expected_symbol
+            end
           end
 
         # Ruby 1.8 uses NameError with `symbol'
         # Ruby 1.9 uses ArgumentError with :symbol
         rescue NameError, ArgumentError => e
-          raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+          unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+            other_exception = e
+            raise
+          end
           @caught_symbol = $2.to_sym
-
+        rescue => other_exception
+          raise
         ensure
-          if @expected_symbol.nil?
-            return !@caught_symbol.nil?
-          else
-            if @expected_arg.nil?
-              return @caught_symbol == @expected_symbol
+          unless other_exception
+            if @expected_symbol.nil?
+              return !@caught_symbol.nil?
             else
-              return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+              if @expected_arg.nil?
+                return @caught_symbol == @expected_symbol
+              else
+                return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
+              end
             end
           end
         end
       end
 
       def failure_message_for_should
-        if @caught_symbol
-          "expected #{expected}, got #{@caught_symbol.inspect}"
-        else
-          "expected #{expected} but nothing was thrown"
-        end
+        "expected #{expected} to be thrown, got #{caught}"
       end
       
       def failure_message_for_should_not
-        if @expected_symbol
-          "expected #{expected} not to be thrown"
-        else
-          "expected no Symbol, got :#{@caught_symbol}"
-        end
+        "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
       end
       
       def description
@@ -62,15 +65,29 @@ module RSpec
       end
       
       private
-      
-        def expected
-          @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
+
+        def expected(symbol_desc = 'a Symbol')
+          throw_description(@expected_symbol || symbol_desc, @expected_arg)
         end
-        
-        def args
-          @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
+
+        def caught
+          throw_description(@caught_symbol || 'nothing', @caught_arg)
         end
-      
+
+        def throw_description(symbol, arg)
+          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
+
+          arg_description = if arg
+            " with #{arg.inspect}"
+          elsif @expected_arg && @caught_symbol == @expected_symbol
+            " with no argument"
+          else
+            ""
+          end
+
+          symbol_description + arg_description
+        end
+
     end
  
     # :call-seq:

data/lib/rspec/matchers.rb

@@ -16,7 +16,7 @@ module RSpec
   #
   # In addition to those Expression Matchers that are defined explicitly, RSpec will
   # create custom Matchers on the fly for any arbitrary predicate, giving your specs
-  # a much more natural language feel. 
+  # a much more natural language feel.
   #
   # A Ruby predicate is a method that ends with a "?" and returns true or false.
   # Common examples are +empty?+, +nil?+, and +instance_of?+.
@@ -155,8 +155,17 @@ module RSpec
   #   end
   #
   module Matchers
-    if RSpec.respond_to?(:configure)
-      RSpec.configure {|c| c.include self}
+    # Include Matchers for other test frameworks.
+    # Note that MiniTest _must_ come before TU because on ruby 1.9,
+    # T::U::TC is a subclass of MT::U::TC and a 1.9 bug can lead
+    # to infinite recursion from the `super` call in our method_missing
+    # hook.  See this gist for more info:
+    #   https://gist.github.com/845896
+    if defined?(MiniTest::Unit::TestCase)
+      MiniTest::Unit::TestCase.send(:include, self)
+    end
+    if defined?(Test::Unit::TestCase)
+      Test::Unit::TestCase.send(:include, self)
     end
   end
 end
@@ -169,7 +178,10 @@ require 'rspec/matchers/be'
 require 'rspec/matchers/be_close'
 require 'rspec/matchers/be_instance_of'
 require 'rspec/matchers/be_kind_of'
+require 'rspec/matchers/be_within'
+require 'rspec/matchers/block_aliases'
 require 'rspec/matchers/change'
+require 'rspec/matchers/cover' if (1..2).respond_to? :cover?
 require 'rspec/matchers/eq'
 require 'rspec/matchers/eql'
 require 'rspec/matchers/equal'

data/rspec-expectations.gemspec

@@ -18,14 +18,10 @@ Gem::Specification.new do |s|
   s.files            = `git ls-files`.split("\n")
   s.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
   s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.extra_rdoc_files = [ "README.markdown" ]
+  s.extra_rdoc_files = [ "README.md" ]
   s.rdoc_options     = ["--charset=UTF-8"]
   s.require_path     = "lib"
 
-  s.add_runtime_dependency     'diff-lcs',    '>= 1.1.2'
-  s.add_development_dependency 'cucumber',    ">= 0.6.2"
-  s.add_development_dependency 'aruba',       ">= 0.1.1"
-  s.add_development_dependency 'rspec-core',  ">= #{RSpec::Expectations::Version::STRING}"
-  s.add_development_dependency 'rspec-mocks', ">= #{RSpec::Expectations::Version::STRING}"
+  s.add_runtime_dependency     'diff-lcs',    '~> 1.1.2'
 end
 

data/spec/rspec/matchers/be_close_spec.rb

@@ -1,49 +1,21 @@
 require 'spec_helper'
+
 module RSpec
   module Matchers
     describe "[actual.should] be_close(expected, delta)" do
-      it "matches when actual == expected" do
-        be_close(5.0, 0.5).matches?(5.0).should be_true
-      end
-      it "matches when actual < (expected + delta)" do
-        be_close(5.0, 0.5).matches?(5.49).should be_true
-      end
-      it "matches when actual > (expected - delta)" do
-        be_close(5.0, 0.5).matches?(4.51).should be_true
-      end
-      it "does not match when actual == (expected - delta)" do
-        be_close(5.0, 0.5).matches?(4.5).should be_false
-      end
-      it "does not match when actual < (expected - delta)" do
-        be_close(5.0, 0.5).matches?(4.49).should be_false
-      end
-      it "does not match when actual == (expected + delta)" do
-        be_close(5.0, 0.5).matches?(5.5).should be_false
-      end
-      it "does not match when actual > (expected + delta)" do
-        be_close(5.0, 0.5).matches?(5.51).should be_false
-      end
-      it "provides a failure message for should" do
-        #given
-          matcher = be_close(5.0, 0.5)
-        #when
-          matcher.matches?(5.51)
-        #then
-          matcher.failure_message_for_should.should == "expected 5.0 +/- (< 0.5), got 5.51"
+      before(:each) do
+        RSpec.stub(:warn)
       end
 
-      it "provides a failure message for should tno" do
-        #given
-          matcher = be_close(5.0, 0.5)
-        #when
-          matcher.matches?(5.49)
-        #then
-          matcher.failure_message_for_should_not.should == "expected 5.0 +/- (< 0.5), got 5.49"
+      it "delegates to be_within(delta).of(expected)" do
+        should_receive(:be_within).with(0.5).and_return( be_within_matcher = stub )
+        be_within_matcher.should_receive(:of).with(3.0)
+        be_close(3.0, 0.5)
       end
-      it "provides a description" do
-        matcher = be_close(5.0, 0.5)
-        matcher.matches?(5.1)
-        matcher.description.should == "be close to 5.0 (within +- 0.5)"
+
+      it "prints a deprecation warning" do
+        RSpec.should_receive(:warn).with(/please use be_within.*instead/)
+        be_close(3.0, 0.5)
       end
     end
   end

data/spec/rspec/matchers/be_spec.rb

@@ -265,7 +265,7 @@ describe "should be_nil" do
   it "fails when actual is not nil" do
     lambda {
       :not_nil.should be_nil
-    }.should fail_with("expected nil, got :not_nil")
+    }.should fail_with(/^expected: nil/)
   end
 end
 
@@ -277,7 +277,7 @@ describe "should_not be_nil" do
   it "fails when actual is nil" do
     lambda {
       nil.should_not be_nil
-    }.should fail_with("expected not nil, got nil")
+    }.should fail_with(/^expected: not nil/)
   end
 end
 
@@ -287,7 +287,7 @@ describe "should be <" do
   end
 
   it "fails when < operator returns false" do
-    lambda { 3.should be < 3 }.should fail_with("expected < 3, got 3")
+    lambda { 3.should be < 3 }.should fail_with("expected: < 3\n     got:   3")
   end
 
   it "describes itself" do
@@ -302,7 +302,7 @@ describe "should be <=" do
   end
 
   it "fails when <= operator returns false" do
-    lambda { 3.should be <= 2 }.should fail_with("expected <= 2, got 3")
+    lambda { 3.should be <= 2 }.should fail_with("expected: <= 2\n     got:    3")
   end
 end
 
@@ -313,7 +313,7 @@ describe "should be >=" do
   end
 
   it "fails when >= operator returns false" do
-    lambda { 3.should be >= 4 }.should fail_with("expected >= 4, got 3")
+    lambda { 3.should be >= 4 }.should fail_with("expected: >= 4\n     got:    3")
   end
 end
 
@@ -323,7 +323,7 @@ describe "should be >" do
   end
 
   it "fails when > operator returns false" do
-    lambda { 3.should be > 4 }.should fail_with("expected > 4, got 3")
+    lambda { 3.should be > 4 }.should fail_with("expected: > 4\n     got:   3")
   end
 end
 
@@ -333,7 +333,7 @@ describe "should be ==" do
   end
 
   it "fails when == operator returns false" do
-    lambda { 3.should be == 4 }.should fail_with("expected == 4, got 3")
+    lambda { 3.should be == 4 }.should fail_with("expected: == 4\n     got:    3")
   end
 end
 
@@ -343,7 +343,7 @@ describe "should be ===" do
   end
 
   it "fails when === operator returns false" do
-    lambda { Hash.should be === "not a hash" }.should fail_with(%[expected === not a hash, got Hash])
+    lambda { Hash.should be === "not a hash" }.should fail_with(%[expected: === "not a hash"\n     got:     Hash])
   end
 end
 

data/spec/rspec/matchers/be_within_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    describe "[actual.should] be_within(delta).of(expected)" do
+      it "matches when actual == expected" do
+        be_within(0.5).of(5.0).matches?(5.0).should be_true
+      end
+
+      it "matches when actual < (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.49).should be_true
+      end
+
+      it "matches when actual > (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.51).should be_true
+      end
+
+      it "does not match when actual == (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.5).should be_false
+      end
+
+      it "does not match when actual < (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.49).should be_false
+      end
+
+      it "does not match when actual == (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.5).should be_false
+      end
+
+      it "does not match when actual > (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.51).should be_false
+      end
+
+      it "provides a failure message for should" do
+        #given
+          matcher = be_within(0.5).of(5.0)
+        #when
+          matcher.matches?(5.51)
+        #then
+          matcher.failure_message_for_should.should == "expected 5.51 to be within 0.5 of 5.0"
+      end
+
+      it "provides a failure message for should not" do
+        #given
+          matcher = be_within(0.5).of(5.0)
+        #when
+          matcher.matches?(5.49)
+        #then
+          matcher.failure_message_for_should_not.should == "expected 5.49 not to be within 0.5 of 5.0"
+      end
+
+      it "provides a description" do
+        matcher = be_within(0.5).of(5.0)
+        matcher.matches?(5.1)
+        matcher.description.should == "be within 0.5 of 5.0"
+      end
+
+      it "raises an error if no expected value is given" do
+        matcher = be_within(0.5)
+        expect { matcher.matches?(5.1) }.to raise_error(ArgumentError, /must set an expected value using #of/)
+      end
+    end
+  end
+end

data/spec/rspec/matchers/change_spec.rb

@@ -14,7 +14,7 @@ describe "should change(actual, message)" do
     end
 
     it "passes when actual is modified by the block" do
-      expect {@instance.some_value = 6}.to change(@instance, :some_value)
+      expect {@instance.some_value = 6.0}.to change(@instance, :some_value)
     end
 
     it "fails when actual is not modified by the block" do
@@ -44,6 +44,57 @@ describe "should change(actual, message)" do
       end.to fail_with("some_value should have changed, but is still true")
     end
   end
+
+  context "with nil value" do
+    before(:each) do
+      @instance = SomethingExpected.new
+      @instance.some_value = nil
+    end
+
+    it "passes when actual is modified by the block" do
+      expect {@instance.some_value = false}.to change(@instance, :some_value)
+    end
+
+    it "fails when actual is not modified by the block" do
+      expect do
+        expect {}.to change(@instance, :some_value)
+      end.to fail_with("some_value should have changed, but is still nil")
+    end
+  end
+
+  context "with an array" do
+    before(:each) do
+      @instance = SomethingExpected.new
+      @instance.some_value = []
+    end
+
+    it "passes when actual is modified by the block" do
+      expect {@instance.some_value << 1}.to change(@instance, :some_value)
+    end
+
+    it "fails when actual is not modified by the block" do
+      expect do
+        expect {}.to change(@instance, :some_value)
+      end.to fail_with("some_value should have changed, but is still []")
+    end
+  end
+
+  context "with a hash" do
+    before(:each) do
+      @instance = SomethingExpected.new
+      @instance.some_value = {:a => 'a'}
+    end
+
+    it "passes when actual is modified by the block" do
+      expect {@instance.some_value[:a] = 'A'}.to change(@instance, :some_value)
+    end
+
+    it "fails when actual is not modified by the block" do
+      expect do
+        expect {}.to change(@instance, :some_value)
+      end.to fail
+    end
+  end
 end
 
 describe "should_not change(actual, message)" do
@@ -123,6 +174,10 @@ describe "should change(actual, message).by(expected)" do
     expect { @instance.some_value += 1 }.to change(@instance, :some_value).by(1)
   end
 
+  it "passes when attribute is not changed and expected amount is 0" do
+    expect { @instance.some_value += 0 }.to change(@instance, :some_value).by(0)
+  end
+
   it "fails when the attribute is changed by unexpected amount" do
     expect do
       expect { @instance.some_value += 2 }.to change(@instance, :some_value).by(1)
@@ -269,11 +324,17 @@ describe "should change(actual, message).from(old)" do
       @instance.some_value = 'string'
     end
 
-    it "passes when attribute is == to expected value before executing block" do
+    it "passes when attribute is === to expected value before executing block" do
       expect { @instance.some_value = "astring" }.to change(@instance, :some_value).from("string")
     end
 
-    it "fails when attribute is not == to expected value before executing block" do
+    it "compares the expected and actual values with ===" do
+      expected = "string"
+      expected.should_receive(:===).and_return true
+      expect { @instance.some_value = "astring" }.to change(@instance, :some_value).from(expected)
+    end
+
+    it "fails when attribute is not === to expected value before executing block" do
       expect do
         expect { @instance.some_value = "knot" }.to change(@instance, :some_value).from("cat")
       end.to fail_with("some_value should have initially been \"cat\", but was \"string\"")
@@ -287,11 +348,17 @@ describe "should change{ block }.from(old)" do
     @instance.some_value = 'string'
   end
 
-  it "passes when attribute is == to expected value before executing block" do
+  it "passes when attribute is === to expected value before executing block" do
     expect { @instance.some_value = "astring" }.to change{@instance.some_value}.from("string")
   end
 
-  it "fails when attribute is not == to expected value before executing block" do
+  it "compares the expected and actual values with ===" do
+    expected = "string"
+    expected.should_receive(:===).and_return true
+    expect { @instance.some_value = "astring" }.to change{@instance.some_value}.from(expected)
+  end
+
+  it "fails when attribute is not === to expected value before executing block" do
     expect do
       expect { @instance.some_value = "knot" }.to change{@instance.some_value}.from("cat")
     end.to fail_with("result should have initially been \"cat\", but was \"string\"")
@@ -321,11 +388,17 @@ describe "should change(actual, message).to(new)" do
       @instance.some_value = 'string'
     end
     
-    it "passes when attribute is == to expected value after executing block" do
+    it "passes when attribute is === to expected value after executing block" do
       expect { @instance.some_value = "cat" }.to change(@instance, :some_value).to("cat")
     end
 
-    it "fails when attribute is not == to expected value after executing block" do
+    it "compares the expected and actual values with ===" do
+      expected = "cat"
+      expected.should_receive(:===).and_return true
+      expect { @instance.some_value = "cat" }.to change(@instance, :some_value).to(expected)
+    end
+
+    it "fails when attribute is not === to expected value after executing block" do
       expect do
         expect { @instance.some_value = "cat" }.to change(@instance, :some_value).from("string").to("dog")
       end.to fail_with("some_value should have been changed to \"dog\", but is now \"cat\"")
@@ -339,11 +412,17 @@ describe "should change{ block }.to(new)" do
     @instance.some_value = 'string'
   end
   
-  it "passes when attribute is == to expected value after executing block" do
+  it "passes when attribute is === to expected value after executing block" do
     expect { @instance.some_value = "cat" }.to change{@instance.some_value}.to("cat")
   end
 
-  it "fails when attribute is not == to expected value after executing block" do
+  it "compares the expected and actual values with ===" do
+    expected = "cat"
+    expected.should_receive(:===).and_return true
+    expect { @instance.some_value = "cat" }.to change{@instance.some_value}.to(expected)
+  end
+
+  it "fails when attribute is not === to expected value after executing block" do
     expect do
       expect { @instance.some_value = "cat" }.to change{@instance.some_value}.from("string").to("dog")
     end.to fail_with("result should have been changed to \"dog\", but is now \"cat\"")

data/spec/rspec/matchers/cover_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe "should cover(expected)", :if => RSpec::Matchers.respond_to?(:cover) do
+  context "for a range target" do
+    it "passes if target covers expected" do
+      (1..10).should cover(5)
+    end
+
+    it "fails if target does not cover expected" do
+      lambda {
+        (1..10).should cover(11)
+      }.should fail_with("expected 1..10 to cover 11")
+    end
+  end
+end
+
+describe "should cover(with, multiple, args)", :if => RSpec::Matchers.respond_to?(:cover) do
+  context "for a range target" do
+    it "passes if target covers all items" do
+      (1..10).should cover(4, 6)
+    end
+
+    it "fails if target does not cover any one of the items" do
+      lambda {
+        (1..10).should cover(4, 6, 11)
+      }.should fail_with("expected 1..10 to cover 4, 6, and 11")
+    end
+  end
+end
+
+describe "should_not cover(expected)", :if => RSpec::Matchers.respond_to?(:cover) do
+  context "for a range target" do
+    it "passes if target does not cover expected" do
+      (1..10).should_not cover(11)
+    end
+
+    it "fails if target covers expected" do
+      lambda {
+        (1..10).should_not cover(5)
+      }.should fail_with("expected 1..10 not to cover 5")
+    end
+  end
+end
+
+describe "should_not cover(with, multiple, args)", :if => RSpec::Matchers.respond_to?(:cover) do
+  context "for a range target" do
+    it "passes if the target does not cover any of the expected" do
+      (1..10).should_not include(11, 12, 13)
+    end
+
+    it "fails if the target covers all of the expected" do
+      expect {
+        (1..10).should_not include(4, 6)
+      }.to fail_with("expected 1..10 not to include 4 and 6")
+    end
+
+    it "fails if the target covers some (but not all) of the expected" do
+      expect {
+        (1..10).should_not include(5, 11)
+      }.to fail_with("expected 1..10 not to include 5 and 11")
+    end
+  end
+end
+
+