Fix raise_error to not swallow any non-matching exception in combination with should_not!

* lambda { ... }.should_not raise_error(SomeError)
  should rethrow if any non-matching exception is thrown by the block,
  otherwise the matcher silently swallows it and returns false,
  which #should_not interprets as a success!

Author: eregon

lib/mspec/matchers/raise_error.rb

@@ -9,17 +9,26 @@ def matches?(proc)
     @result = proc.call
     return false
   rescue Exception => @actual
-    return false unless @exception === @actual
+    if matching_exception?(@actual)
+      return true
+    else
+      raise @actual
+    end
+  end
+
+  def matching_exception?(exc)
+    return false unless @exception === exc
     if @message then
       case @message
-      when String then
-        return false if @message != @actual.message
-      when Regexp then
-        return false if @message !~ @actual.message
+      when String
+        return false if @message != exc.message
+      when Regexp
+        return false if @message !~ exc.message
       end
     end
 
-    @block[@actual] if @block
+    # The block has its own expectations and will throw an exception if it fails
+    @block[exc] if @block
 
     return true
   end

spec/matchers/raise_error_spec.rb

@@ -8,7 +8,8 @@ class UnexpectedException < Exception; end
 describe RaiseErrorMatcher do
   it "matches when the proc raises the expected exception" do
     proc = Proc.new { raise ExpectedException }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == true
+    matcher = RaiseErrorMatcher.new(ExpectedException, nil)
+    matcher.matches?(proc).should == true
   end
 
   it "executes it's optional block if matched" do
@@ -25,28 +26,50 @@ class UnexpectedException < Exception; end
 
   it "matches when the proc raises the expected exception with the expected message" do
     proc = Proc.new { raise ExpectedException, "message" }
-    RaiseErrorMatcher.new(ExpectedException, "message").matches?(proc).should == true
+    matcher = RaiseErrorMatcher.new(ExpectedException, "message")
+    matcher.matches?(proc).should == true
+  end
+
+  it "matches when the proc raises the expected exception with a matching message" do
+    proc = Proc.new { raise ExpectedException, "some message" }
+    matcher = RaiseErrorMatcher.new(ExpectedException, /some/)
+    matcher.matches?(proc).should == true
   end
 
   it "does not match when the proc does not raise the expected exception" do
-    proc = Proc.new { raise UnexpectedException }
-    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == false
+    exc = UnexpectedException.new
+    matcher = RaiseErrorMatcher.new(ExpectedException, nil)
+
+    matcher.matching_exception?(exc).should == false
+    lambda {
+      matcher.matches?(Proc.new { raise exc })
+    }.should raise_error(UnexpectedException)
   end
 
   it "does not match when the proc raises the expected exception with an unexpected message" do
-    proc = Proc.new { raise ExpectedException, "unexpected" }
-    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
+    exc = ExpectedException.new("unexpected")
+    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
+
+    matcher.matching_exception?(exc).should == false
+    lambda {
+      matcher.matches?(Proc.new { raise exc })
+    }.should raise_error(ExpectedException)
   end
 
   it "does not match when the proc does not raise an exception" do
     proc = Proc.new {}
-    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
+    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
+    matcher.matches?(proc).should == false
   end
 
   it "provides a useful failure message" do
-    proc = Proc.new { raise UnexpectedException, "unexpected" }
+    exc = UnexpectedException.new("unexpected")
     matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
-    matcher.matches?(proc)
+
+    matcher.matching_exception?(exc).should == false
+    lambda {
+      matcher.matches?(Proc.new { raise exc })
+    }.should raise_error(UnexpectedException)
     matcher.failure_message.should ==
       ["Expected ExpectedException (expected)", "but got UnexpectedException (unexpected)"]
   end