rspec-expectations 2.9.1 → 2.10.0

data/lib/rspec/matchers/built_in.rb

@@ -24,8 +24,14 @@ module RSpec
       autoload :MatchArray,     'rspec/matchers/built_in/match_array'
       autoload :RaiseError,     'rspec/matchers/built_in/raise_error'
       autoload :RespondTo,      'rspec/matchers/built_in/respond_to'
+      autoload :StartWith,      'rspec/matchers/built_in/start_and_end_with'
+      autoload :EndWith,        'rspec/matchers/built_in/start_and_end_with'
       autoload :Satisfy,        'rspec/matchers/built_in/satisfy'
       autoload :ThrowSymbol,    'rspec/matchers/built_in/throw_symbol'
+      autoload :YieldControl,   'rspec/matchers/built_in/yield'
+      autoload :YieldWithArgs,  'rspec/matchers/built_in/yield'
+      autoload :YieldWithNoArgs, 'rspec/matchers/built_in/yield'
+      autoload :YieldSuccessiveArgs, 'rspec/matchers/built_in/yield'
     end
   end
 end

data/lib/rspec/matchers/built_in/base_matcher.rb

@@ -24,13 +24,14 @@ module RSpec
           @actual = actual
         end
 
-        def match_unless_raises(exception=Exception)
+        def match_unless_raises(*exceptions)
+          exceptions.unshift Exception if exceptions.empty?
           begin
             yield
-            true
-          rescue exception => @rescued_exception
-            false
+          rescue *exceptions => @rescued_exception
+            return false
           end
+          true
         end
 
         def failure_message_for_should

data/lib/rspec/matchers/built_in/be_within.rb

@@ -14,7 +14,7 @@ module RSpec
           unless defined?(@expected)
             raise ArgumentError.new("You must set an expected value using #of: be_within(#{delta}).of(expected_value)")
           end
-          (super(actual) - expected).abs < delta
+          (super(actual) - expected).abs <= delta
         end
 
         def of(expected)

data/lib/rspec/matchers/built_in/start_and_end_with.rb

@@ -0,0 +1,50 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class StartAndEndWith
+        include BaseMatcher
+
+        def initialize(*expected)
+          @expected = expected.length == 1 ? expected.first : expected
+        end
+
+        def matches?(actual)
+          @actual = actual.respond_to?(:[]) ? actual : (raise ArgumentError.new("#{actual.inspect} does not respond to :[]"))
+          begin
+            @expected.respond_to?(:length) ? subset_matches?(@expected, @actual) : element_matches?(@expected, @actual)
+          rescue ArgumentError
+            raise ArgumentError.new("#{actual.inspect} does not have ordered elements")
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual.inspect} not to #{self.class.name.split('::').last.sub(/With/,'').downcase} with #{@expected.inspect}"
+        end
+      end
+
+      class StartWith < StartAndEndWith
+        def subset_matches?(expected, actual)
+          actual[0, expected.length] == expected
+        end
+
+        def element_matches?(expected, actual)
+          @actual[0] == @expected
+        end
+      end
+
+      class EndWith < StartAndEndWith
+        def subset_matches?(expected, actual)
+          actual[-expected.length, expected.length] == expected
+        end
+
+        def element_matches?(expected, actual)
+          actual[-1] == expected
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/yield.rb

@@ -0,0 +1,222 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class YieldProbe
+        def self.probe(block)
+          probe = new
+          assert_valid_expect_block!(block)
+          block.call(probe)
+          probe.assert_used!
+          probe
+        end
+
+        attr_accessor :num_yields, :yielded_args
+
+        def initialize
+          @used = false
+          self.num_yields, self.yielded_args = 0, []
+        end
+
+        def to_proc
+          @used = true
+
+          probe = self
+          Proc.new do |*args|
+            probe.num_yields += 1
+            probe.yielded_args << args
+          end
+        end
+
+        def single_yield_args
+          yielded_args.first
+        end
+
+        def yielded_once?(matcher_name)
+          case num_yields
+          when 1 then true
+          when 0 then false
+          else
+            raise "The #{matcher_name} matcher is not designed to be used with a " +
+                  "method that yields multiple times. Use the yield_successive_args " +
+                  "matcher for that case."
+          end
+        end
+
+        def successive_yield_args
+          yielded_args.map do |arg_array|
+            arg_array.size == 1 ? arg_array.first : arg_array
+          end
+        end
+
+        def assert_used!
+          return if @used
+          raise "You must pass the argument yielded to your expect block on " +
+                "to the method-under-test as a block. It acts as a probe that " +
+                "allows the matcher to detect whether or not the method-under-test " +
+                "yields, and, if so, how many times, and what the yielded arguments " +
+                "are."
+        end
+
+        def self.assert_valid_expect_block!(block)
+          return if block.arity == 1
+          raise "Your expect block must accept an argument to be used with this " +
+                "matcher. Pass the argument as a block on to the method you are testing."
+        end
+      end
+
+      class YieldControl
+        include BaseMatcher
+
+        def matches?(block)
+          probe = YieldProbe.probe(block)
+          probe.yielded_once?(:yield_control)
+        end
+
+        def failure_message_for_should
+          "expected given block to yield control"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield control"
+        end
+      end
+
+      class YieldWithNoArgs
+        include BaseMatcher
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @probe.yielded_once?(:yield_with_no_args) && @probe.single_yield_args.none?
+        end
+
+        def failure_message_for_should
+          "expected given block to yield with no arguments, but #{failure_reason}"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield with no arguments, but did"
+        end
+
+      private
+
+        def failure_reason
+          if @probe.num_yields.zero?
+            "did not yield"
+          else
+            "yielded with arguments: #{@probe.single_yield_args.inspect}"
+          end
+        end
+      end
+
+      class YieldWithArgs
+        def initialize(*args)
+          @expected = args
+        end
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @actual = @probe.single_yield_args
+          @probe.yielded_once?(:yield_with_args) && args_match?
+        end
+
+        def failure_message_for_should
+          "expected given block to yield with arguments, but #{positive_failure_reason}"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield with arguments, but #{negative_failure_reason}"
+        end
+
+        def description
+          desc = "yield with args"
+          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")" if @expected.any?
+          desc
+        end
+
+      private
+
+        def positive_failure_reason
+          if @probe.num_yields.zero?
+            "did not yield"
+          else
+            @positive_args_failure
+          end
+        end
+
+        def negative_failure_reason
+          if all_args_match?
+            "yielded with expected arguments" +
+              "\nexpected not: #{@expected.inspect}" +
+              "\n         got: #{@actual.inspect} (compared using === and ==)"
+          else
+            "did"
+          end
+        end
+
+        def args_match?
+          if @expected.none? # expect {...}.to yield_with_args
+            @positive_args_failure = "yielded with no arguments" if @actual.none?
+            return @actual.any?
+          end
+
+          unless match = all_args_match?
+            @positive_args_failure = "yielded with unexpected arguments" +
+              "\nexpected: #{@expected.inspect}" +
+              "\n     got: #{@actual.inspect} (compared using === and ==)"
+          end
+
+          match
+        end
+
+        def all_args_match?
+          return false if @expected.size != @actual.size
+
+          @expected.zip(@actual).all? do |expected, actual|
+            expected === actual || actual == expected
+          end
+        end
+      end
+
+      class YieldSuccessiveArgs
+        def initialize(*args)
+          @expected = args
+        end
+
+        def matches?(block)
+          @probe = YieldProbe.probe(block)
+          @actual = @probe.successive_yield_args
+          args_match?
+        end
+
+        def failure_message_for_should
+          "expected given block to yield successively with arguments, but yielded with unexpected arguments" +
+            "\nexpected: #{@expected.inspect}" +
+            "\n     got: #{@actual.inspect} (compared using === and ==)"
+        end
+
+        def failure_message_for_should_not
+          "expected given block not to yield successively with arguments, but yielded with expected arguments" +
+              "\nexpected not: #{@expected.inspect}" +
+              "\n         got: #{@actual.inspect} (compared using === and ==)"
+        end
+
+        def description
+          desc = "yield successive args"
+          desc << "(" + @expected.map { |e| e.inspect }.join(", ") + ")"
+          desc
+        end
+
+      private
+
+        def args_match?
+          return false if @expected.size != @actual.size
+
+          @expected.zip(@actual).all? do |expected, actual|
+            expected === actual || actual == expected
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rspec/matchers/dsl.rb

@@ -7,7 +7,7 @@ module RSpec
         matcher_template = RSpec::Matchers::DSL::Matcher.new(name, &declarations)
         define_method name do |*expected|
           matcher = matcher_template.for_expected(*expected)
-          matcher.matcher_execution_context = @matcher_execution_context || self
+          matcher.matcher_execution_context = @matcher_execution_context ||= self
           matcher
         end
       end

data/lib/rspec/matchers/matcher.rb

@@ -223,14 +223,14 @@ module RSpec
         end
 
         def respond_to?(method, include_private=false)
-          super || @matcher_execution_context.respond_to?(method, include_private)
+          super || matcher_execution_context.respond_to?(method, include_private)
         end
 
         private
 
         def method_missing(method, *args, &block)
-          if @matcher_execution_context.respond_to?(method)
-            @matcher_execution_context.send method, *args, &block
+          if matcher_execution_context.respond_to?(method)
+            matcher_execution_context.send method, *args, &block
           else
             super(method, *args, &block)
           end

data/spec/rspec/matchers/base_matcher_spec.rb

@@ -15,11 +15,17 @@ module RSpec::Matchers::BuiltIn
         matcher.match_unless_raises { raise }.should be_false
       end
 
-      it "returns false if the submitted error is raised" do
+      it "returns false if the only submitted error is raised" do
         matcher.match_unless_raises(RuntimeError){ raise "foo" }.should be_false
       end
 
-      it "re-raises any error other than the one specified" do
+      it "returns false if any of several errors submitted is raised" do
+        matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise "foo" }.should be_false
+        matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise ArgumentError.new('') }.should be_false
+        matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise NameError.new('') }.should be_false
+      end
+
+      it "re-raises any error other than one of those specified" do
         expect do
           matcher.match_unless_raises(ArgumentError){ raise "foo" }
         end.to raise_error

data/spec/rspec/matchers/be_within_spec.rb

@@ -15,16 +15,16 @@ module RSpec
         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
+      it "matches when actual == (expected - delta)" do
+        be_within(0.5).of(5.0).matches?(4.5).should be_true
       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
+      it "matches when actual == (expected + delta)" do
+        be_within(0.5).of(5.0).matches?(5.5).should be_true
       end
 
       it "does not match when actual > (expected + delta)" do

data/spec/rspec/matchers/have_spec.rb

@@ -386,7 +386,7 @@ EOF
 
   describe "have(n).things on an object which is not a collection nor contains one" do
     it "fails" do
-      lambda { Object.new.should have(2).things }.should raise_error(NoMethodError, /undefined method `things' for #<Object:/)
+      lambda { Object.new.should have(2).things }.should raise_error(NoMethodError) {|e| e.name.should eq :things }
     end
   end
 

data/spec/rspec/matchers/raise_error_spec.rb

@@ -43,8 +43,8 @@ describe "should_not raise_error" do
   
   it "fails if anything is raised" do
     lambda {
-      lambda {raise}.should_not raise_error
-    }.should fail_with("expected no Exception, got RuntimeError")
+      lambda { raise RuntimeError, "example message" }.should_not raise_error
+    }.should fail_with("expected no Exception, got #<RuntimeError: example message>")
   end
 end
 
@@ -102,8 +102,8 @@ describe "should raise_error(NamedError)" do
   
   it "fails if another error is raised (NameError)" do
     lambda {
-      lambda { raise }.should raise_error(NameError)
-    }.should fail_with("expected NameError, got RuntimeError")
+      lambda { raise RuntimeError, "example message" }.should raise_error(NameError)
+    }.should fail_with("expected NameError, got #<RuntimeError: example message>")
   end
   
   it "fails if another error is raised (NameError)" do
@@ -142,8 +142,8 @@ describe "should raise_error(NamedError, error_message) with String" do
   
   it "fails if incorrect error is raised" do
     lambda {
-      lambda { raise }.should raise_error(NameError, "example message")
-    }.should fail_with("expected NameError with \"example message\", got RuntimeError")
+      lambda { raise RuntimeError, "example message" }.should raise_error(NameError, "example message")
+    }.should fail_with("expected NameError with \"example message\", got #<RuntimeError: example message>")
   end
   
   it "fails if correct error is raised with incorrect message" do
@@ -307,8 +307,8 @@ describe "should raise_error(NamedError, error_message) with Regexp" do
   
   it "fails if incorrect error is raised" do
     lambda {
-      lambda { raise }.should raise_error(NameError, /ample mess/)
-    }.should fail_with("expected NameError with message matching /ample mess/, got RuntimeError")
+      lambda { raise RuntimeError, "example message" }.should raise_error(NameError, /ample mess/)
+    }.should fail_with("expected NameError with message matching /ample mess/, got #<RuntimeError: example message>")
   end
   
   it "fails if correct error is raised with incorrect message" do

data/spec/rspec/matchers/start_with_end_with_spec.rb

@@ -0,0 +1,174 @@
+require "spec_helper"
+
+describe "should start_with" do
+  context "with a string" do
+    it "passes if it matches the start of the actual string" do
+      "this string".should start_with "this str"
+    end
+
+    it "fails if it does not match the start of the actual string" do
+      expect {
+        "this string".should start_with "that str"
+      }.to fail_with("expected \"this string\" to start with \"that str\"")
+    end
+  end
+
+  context "with an array" do
+    it "passes if it is the first element of the array" do
+      [0, 1, 2].should start_with 0
+    end
+
+    it "passes if the first elements of the array match" do
+      [0, 1, 2].should start_with 0, 1
+    end
+
+    it "fails if it does not match the first element of the array" do
+      expect {
+        [0, 1, 2].should start_with 2
+      }.to fail_with("expected [0, 1, 2] to start with 2")
+    end
+
+    it "fails if it the first elements of the array do not match" do
+      expect {
+        [0, 1, 2].should start_with 1, 2
+      }.to fail_with("expected [0, 1, 2] to start with [1, 2]")
+    end
+  end
+
+  context "with an object that does not respond to :[]" do
+    it "raises an ArgumentError" do
+      expect { Object.new.should start_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
+    end
+  end
+
+  context "with a hash" do
+    it "raises an ArgumentError if trying to match more than one element" do
+      expect{
+        {:a => 'b', :b => 'b', :c => 'c'}.should start_with({:a => 'b', :b => 'b'})
+      }.to raise_error(ArgumentError, /does not have ordered elements/)
+    end
+  end
+end
+
+describe "should_not start_with" do
+  context "with a string" do
+    it "passes if it does not match the start of the actual string" do
+      "this string".should_not start_with "that str"
+    end
+
+    it "fails if it does match the start of the actual string" do
+      expect {
+        "this string".should_not start_with "this str"
+      }.to fail_with("expected \"this string\" not to start with \"this str\"")
+    end
+  end
+
+  context "with an array" do
+    it "passes if it is not the first element of the array" do
+      [0, 1, 2].should_not start_with 2
+    end
+
+    it "passes if the first elements of the array do not match" do
+      [0, 1, 2].should_not start_with 1, 2
+    end
+
+    it "fails if it matches the first element of the array" do
+      expect {
+        [0, 1, 2].should_not start_with 0
+      }.to fail_with("expected [0, 1, 2] not to start with 0")
+    end
+
+    it "fails if it the first elements of the array match" do
+      expect {
+        [0, 1, 2].should_not start_with 0, 1
+      }.to fail_with("expected [0, 1, 2] not to start with [0, 1]")
+    end
+  end
+end
+
+describe "should end_with" do
+  context "with a string" do
+    it "passes if it matches the end of the actual string" do
+      "this string".should end_with "is string"
+    end
+
+    it "fails if it does not match the end of the actual string" do
+      expect {
+        "this string".should end_with "is stringy"
+      }.to fail_with("expected \"this string\" to end with \"is stringy\"")
+    end
+  end
+
+  context "with an array" do
+    it "passes if it is the last element of the array" do
+      [0, 1, 2].should end_with 2
+    end
+
+    it "passes if the last elements of the array match" do
+      [0, 1, 2].should end_with [1, 2]
+    end
+
+    it "fails if it does not match the last element of the array" do
+      expect {
+        [0, 1, 2].should end_with 1
+      }.to fail_with("expected [0, 1, 2] to end with 1")
+    end
+
+    it "fails if it the last elements of the array do not match" do
+      expect {
+        [0, 1, 2].should end_with [0, 1]
+      }.to fail_with("expected [0, 1, 2] to end with [0, 1]")
+    end
+  end
+
+  context "with an object that does not respond to :[]" do
+    it "should raise an error if expected value can't be indexed'" do
+      expect { Object.new.should end_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
+    end
+  end
+
+  context "with a hash" do
+    it "raises an ArgumentError if trying to match more than one element" do
+      expect{
+        {:a => 'b', :b => 'b', :c => 'c'}.should end_with({:a => 'b', :b =>'b'})
+      }.to raise_error(ArgumentError, /does not have ordered elements/)
+    end
+  end
+
+end
+
+describe "should_not end_with" do
+  context "with a sting" do
+    it "passes if it does not match the end of the actual string" do
+      "this string".should_not end_with "stringy"
+    end
+
+    it "fails if it matches the end of the actual string" do
+      expect {
+        "this string".should_not end_with "string"
+      }.to fail_with("expected \"this string\" not to end with \"string\"")
+    end
+  end
+
+  context "an array" do
+    it "passes if it is not the last element of the array" do
+      [0, 1, 2].should_not end_with 1
+    end
+
+    it "passes if the last elements of the array do not match" do
+      [0, 1, 2].should_not end_with [0, 1]
+    end
+
+    it "fails if it matches the last element of the array" do
+      expect {
+        [0, 1, 2].should_not end_with 2
+      }.to fail_with("expected [0, 1, 2] not to end with 2")
+    end
+
+    it "fails if it the last elements of the array match" do
+      expect {
+        [0, 1, 2].should_not end_with [1, 2]
+      }.to fail_with("expected [0, 1, 2] not to end with [1, 2]")
+    end
+  end
+end