rspec-mocks 2.11.3 → 2.12.0

data/lib/rspec/mocks/proxy.rb

@@ -170,18 +170,29 @@ module RSpec
       end
 
       def find_matching_expectation(method_name, *args)
-        (method_double[method_name].expectations.find {|expectation| expectation.matches?(method_name, *args) && !expectation.called_max_times?}) || 
-          method_double[method_name].expectations.find {|expectation| expectation.matches?(method_name, *args)}
+        find_best_matching_expectation_for(method_name) do |expectation|
+          expectation.matches?(method_name, *args)
+        end
       end
 
       def find_almost_matching_expectation(method_name, *args)
-        method_double[method_name].expectations.find do |expectation|
-          expectation.matches_name_but_not_args(method_name, *args) && !expectation.called_max_times?
-        end || method_double[method_name].expectations.find do |expectation|
+        find_best_matching_expectation_for(method_name) do |expectation|
           expectation.matches_name_but_not_args(method_name, *args)
         end
       end
 
+      def find_best_matching_expectation_for(method_name)
+        first_match = nil
+
+        method_double[method_name].expectations.each do |expectation|
+          next unless yield expectation
+          return expectation unless expectation.called_max_times?
+          first_match ||= expectation
+        end
+
+        first_match
+      end
+
       def find_matching_method_stub(method_name, *args)
         method_double[method_name].stubs.find {|stub| stub.matches?(method_name, *args)}
       end

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module Version
-      STRING = '2.11.3'
+      STRING = '2.12.0'
     end
   end
 end

data/spec/rspec/mocks/and_call_original_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe "and_call_original" do
+  context "on a partial mock object" do
+    let(:klass) do
+      Class.new do
+        def meth_1
+          :original
+        end
+
+        def meth_2(x)
+          yield x, :additional_yielded_arg
+        end
+
+        def self.new_instance
+          new
+        end
+      end
+    end
+
+    let(:instance) { klass.new }
+
+    it 'passes the received message through to the original method' do
+      instance.should_receive(:meth_1).and_call_original
+      expect(instance.meth_1).to eq(:original)
+    end
+
+    it 'passes args and blocks through to the original method' do
+      instance.should_receive(:meth_2).and_call_original
+      value = instance.meth_2(:submitted_arg) { |a, b| [a, b] }
+      expect(value).to eq([:submitted_arg, :additional_yielded_arg])
+    end
+
+    it 'works for singleton methods' do
+      def instance.foo; :bar; end
+      instance.should_receive(:foo).and_call_original
+      expect(instance.foo).to eq(:bar)
+    end
+
+    if RUBY_VERSION.to_f > 1.8
+      it 'works for class methods defined on a superclass' do
+        subclass = Class.new(klass)
+        subclass.should_receive(:new_instance).and_call_original
+        expect(subclass.new_instance).to be_a(subclass)
+      end
+
+      it 'works for class methods defined on a grandparent class' do
+        sub_subclass = Class.new(Class.new(klass))
+        sub_subclass.should_receive(:new_instance).and_call_original
+        expect(sub_subclass.new_instance).to be_a(sub_subclass)
+      end
+    else
+      it 'attempts to work for class methods defined on a superclass but ' +
+         'executes the method with `self` as the superclass' do
+        ::Kernel.stub(:warn)
+        subclass = Class.new(klass)
+        subclass.should_receive(:new_instance).and_call_original
+        expect(subclass.new_instance).to be_an_instance_of(klass)
+       end
+
+      it 'prints a warning to notify users that `self` will not be correct' do
+        subclass = Class.new(klass)
+        ::Kernel.should_receive(:warn).with(/may not work correctly/)
+        subclass.should_receive(:new_instance).and_call_original
+        subclass.new_instance
+      end
+    end
+
+    it 'works for class methods defined on the Class class' do
+      klass.should_receive(:new).and_call_original
+      expect(klass.new).to be_an_instance_of(klass)
+    end
+
+    it "works for instance methods defined on the object's class's superclass" do
+      subclass = Class.new(klass)
+      inst = subclass.new
+      inst.should_receive(:meth_1).and_call_original
+      expect(inst.meth_1).to eq(:original)
+    end
+
+    context 'on an object that defines method_missing' do
+      before do
+        klass.class_eval do
+          private
+
+          def method_missing(name, *args)
+            if name.to_s == "greet_jack"
+              "Hello, jack"
+            else
+              super
+            end
+          end
+        end
+      end
+
+      it 'works when the method_missing definition handles the message' do
+        instance.should_receive(:greet_jack).and_call_original
+        expect(instance.greet_jack).to eq("Hello, jack")
+      end
+
+      it 'raises an error on invocation if method_missing does not handle the message' do
+        instance.should_receive(:not_a_handled_message).and_call_original
+
+        # Note: it should raise a NoMethodError (and usually does), but
+        # due to a weird rspec-expectations issue (see #183) it sometimes
+        # raises a `NameError` when a `be_xxx` predicate matcher has been
+        # recently used. `NameError` is the superclass of `NoMethodError`
+        # so this example will pass regardless.
+        # If/when we solve the rspec-expectations issue, this can (and should)
+        # be changed to `NoMethodError`.
+        expect {
+          instance.not_a_handled_message
+        }.to raise_error(NameError, /not_a_handled_message/)
+      end
+    end
+  end
+
+  context "on a partial mock object that overrides #method" do
+    let(:request_klass) do
+      Struct.new(:method, :url) do
+        def perform
+          :the_response
+        end
+
+        def self.method
+          :some_method
+        end
+      end
+    end
+
+    let(:request) { request_klass.new(:get, "http://foo.com/bar") }
+
+    it 'still works even though #method has been overriden' do
+      request.should_receive(:perform).and_call_original
+      expect(request.perform).to eq(:the_response)
+    end
+
+    it 'works for a singleton method' do
+      def request.perform
+        :a_response
+      end
+
+      request.should_receive(:perform).and_call_original
+      expect(request.perform).to eq(:a_response)
+    end
+  end
+
+  context "on a pure mock object" do
+    let(:instance) { double }
+
+    it 'raises an error even if the mock object responds to the message' do
+      expect(instance.to_s).to be_a(String)
+      mock_expectation = instance.should_receive(:to_s)
+      instance.to_s # to satisfy the expectation
+
+      expect {
+        mock_expectation.and_call_original
+      }.to raise_error(/and_call_original.*partial mock/i)
+    end
+  end
+end
+

data/spec/rspec/mocks/any_instance_spec.rb

@@ -273,37 +273,37 @@ module RSpec
           end.should raise_error(RSpec::Mocks::MockExpectationError, 'The method `existing_method` was not stubbed or was already unstubbed')
         end
       end
-      
+
       context "with #should_not_receive" do
         it "fails if the method is called" do
           klass.any_instance.should_not_receive(:existing_method)
           lambda { klass.new.existing_method }.should raise_error(RSpec::Mocks::MockExpectationError)
         end
-        
+
         it "passes if no method is called" do
           lambda { klass.any_instance.should_not_receive(:existing_method) }.should_not raise_error
         end
-        
+
         it "passes if only a different method is called" do
           klass.any_instance.should_not_receive(:existing_method)
           lambda { klass.new.another_existing_method }.should_not raise_error
         end
-        
+
         context "with constraints" do
           it "fails if the method is called with the specified parameters" do
             klass.any_instance.should_not_receive(:existing_method_with_arguments).with(:argument_one, :argument_two)
             lambda do
-              klass.new.existing_method_with_arguments(:argument_one, :argument_two) 
+              klass.new.existing_method_with_arguments(:argument_one, :argument_two)
             end.should raise_error(RSpec::Mocks::MockExpectationError)
           end
-          
+
           it "passes if the method is called with different parameters" do
             klass.any_instance.should_not_receive(:existing_method_with_arguments).with(:argument_one, :argument_two)
             lambda { klass.new.existing_method_with_arguments(:argument_three, :argument_four) }.should_not raise_error
           end
         end
       end
-      
+
       context "with #should_receive" do
         let(:foo_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: foo' }
         let(:existing_method_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: existing_method' }
@@ -825,6 +825,17 @@ module RSpec
           end
           klass.any_instance
         end
+
+        it "doesn't fail when dup accepts parameters" do
+          klass = Class.new do
+            def dup(funky_option)
+            end
+          end
+
+          klass.any_instance
+
+          lambda { klass.new.dup('Dup dup dup') }.should_not raise_error(ArgumentError)
+        end
       end
 
       context "when directed at a method defined on a superclass" do

data/spec/rspec/mocks/configuration_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Configuration do
+      let(:config) { Configuration.new }
+      let(:mod_1)  { Module.new }
+      let(:mod_2)  { Module.new }
+
+      def instance_methods_of(mod)
+        mod_1.instance_methods.map(&:to_sym)
+      end
+
+      it 'adds stub and should_receive to the given modules' do
+        instance_methods_of(mod_1).should_not include(:stub, :should_receive)
+        instance_methods_of(mod_2).should_not include(:stub, :should_receive)
+
+        config.add_stub_and_should_receive_to(mod_1, mod_2)
+
+        instance_methods_of(mod_1).should include(:stub, :should_receive)
+        instance_methods_of(mod_2).should include(:stub, :should_receive)
+      end
+    end
+  end
+end
+

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -7,7 +7,7 @@ module RSpec
         @double = double("double")
         @reporter = double("reporter").as_null_object
       end
-      
+
       after(:each) do
         @double.rspec_reset
       end
@@ -25,14 +25,14 @@ module RSpec
           @double.random_call("1")
         end.to raise_error(RSpec::Mocks::MockExpectationError)
       end
-      
+
       it "rejects non string" do
         @double.should_receive(:random_call).with(an_instance_of(String))
         expect do
           @double.random_call(123)
         end.to raise_error(RSpec::Mocks::MockExpectationError)
       end
-      
+
       it "rejects goose when expecting a duck" do
         @double.should_receive(:random_call).with(duck_type(:abs, :div))
         expect { @double.random_call("I don't respond to :abs or :div") }.to raise_error(RSpec::Mocks::MockExpectationError)
@@ -42,40 +42,40 @@ module RSpec
         @double.should_receive(:random_call).with(/bcd/)
         expect { @double.random_call("abc") }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
-      
+
       it "fails if regexp does not match submitted regexp" do
         @double.should_receive(:random_call).with(/bcd/)
         expect { @double.random_call(/bcde/) }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
-      
+
       it "fails for a hash w/ wrong values" do
         @double.should_receive(:random_call).with(:a => "b", :c => "d")
         expect do
           @double.random_call(:a => "b", :c => "e")
         end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/)
       end
-      
+
       it "fails for a hash w/ wrong keys" do
         @double.should_receive(:random_call).with(:a => "b", :c => "d")
         expect do
           @double.random_call("a" => "b", "c" => "d")
         end.to raise_error(RSpec::Mocks::MockExpectationError, /Double "double" received :random_call with unexpected arguments\n  expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n       got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/)
       end
-      
+
       it "matches against a Matcher" do
         expect do
           @double.should_receive(:msg).with(equal(3))
           @double.msg(37)
         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
       end
-      
+
       it "fails no_args with one arg" do
         expect do
           @double.should_receive(:msg).with(no_args)
           @double.msg(37)
         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (no args)\n       got: (37)")
       end
-      
+
       it "fails hash_including with missing key" do
          expect do
            @double.should_receive(:msg).with(hash_including(:a => 1))
@@ -89,7 +89,6 @@ module RSpec
           @double.msg :no_msg_for_you
         end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
       end
-            
     end
   end
 end

data/spec/rspec/mocks/instance_method_stasher_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe InstanceMethodStasher do
+      class ExampleClass
+        def hello
+          :hello_defined_on_class
+        end
+      end
+
+      def singleton_class_for(obj)
+        class << obj; self; end
+      end
+
+      it "stashes the current implementation of an instance method so it can be temporarily replaced" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :hello_defined_on_singleton_class
+      end
+
+      it "stashes private instance methods" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+        singleton_class_for(obj).__send__(:private, :hello)
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        stashed_method.restore
+        expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
+      end
+
+      it "only stashes methods directly defined on the given class, not its ancestors" do
+        obj = ExampleClass.new
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end;
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :overridden_hello
+      end
+    end
+  end
+end
+

data/spec/rspec/mocks/mock_spec.rb

@@ -42,11 +42,11 @@ module RSpec
         @double.rspec_verify
       end
 
-      it "passes when not receiving message specified as not to be received with and_return" do
-        # NOTE (DC 2012-05-05) calling `and_return` after `should_not_receive` makes no sense
-        # and should probably be disallowed.
-        @double.should_not_receive(:not_expected).and_return nil
-        @double.rspec_verify
+      it "warns when should_not_receive is followed by and_return" do
+        RSpec.should_receive(:warn_deprecation).
+          with(/`and_return` with `should_not_receive` is deprecated/)
+
+        @double.should_not_receive(:do_something).and_return(1)
       end
 
       it "passes when receiving message specified as not to be received with different args" do
@@ -214,49 +214,49 @@ module RSpec
         )
       end
 
-      it "raises when told to" do
-        @double.should_receive(:something).and_raise(StandardError)
-        expect { @double.something }.to raise_error(StandardError)
-      end
-
       it "raises RuntimeError by default" do
         @double.should_receive(:something).and_raise
         expect { @double.something }.to raise_error(RuntimeError)
       end
 
-      it "raises instance of submitted Exception" do
-        error = RuntimeError.new("error message")
-        @double.should_receive(:something).and_raise(error)
-        lambda {
-          @double.something
-        }.should raise_error(RuntimeError, "error message")
+      it "raises RuntimeError with a message by default" do
+        @double.should_receive(:something).and_raise("error message")
+        expect { @double.something }.to raise_error(RuntimeError, "error message")
       end
 
-      it "raises instance of submitted ArgumentError" do
-        error = ArgumentError.new("error message")
-        @double.should_receive(:something).and_raise(error)
-        lambda {
-          @double.something
-        }.should raise_error(ArgumentError, "error message")
+      it "raises an exception of a given type without an error message" do
+        @double.should_receive(:something).and_raise(StandardError)
+        expect { @double.something }.to raise_error(StandardError)
       end
 
-      it "fails with helpful message if submitted Exception requires constructor arguments" do
-        class ErrorWithNonZeroArgConstructor < RuntimeError
-          def initialize(i_take_an_argument)
-          end
-        end
+      it "raises an exception of a given type with a message" do
+        @double.should_receive(:something).and_raise(RuntimeError, "error message")
+        expect { @double.something }.to raise_error(RuntimeError, "error message")
+      end
 
-        @double.stub(:something).and_raise(ErrorWithNonZeroArgConstructor)
-        lambda {
-          @double.something
-        }.should raise_error(ArgumentError, /^'and_raise' can only accept an Exception class if an instance/)
+      it "raises a given instance of an exception" do
+        @double.should_receive(:something).and_raise(RuntimeError.new("error message"))
+        expect { @double.something }.to raise_error(RuntimeError, "error message")
       end
 
-      it "raises RuntimeError with submitted message" do
-        @double.should_receive(:something).and_raise("error message")
-        lambda {
+      class OutOfGas < StandardError
+        attr_reader :amount, :units
+        def initialize(amount, units)
+          @amount = amount
+          @units  = units
+        end
+      end
+
+      it "raises a given instance of an exception with arguments other than the standard 'message'" do
+        @double.should_receive(:something).and_raise(OutOfGas.new(2, :oz))
+
+        begin
           @double.something
-        }.should raise_error(RuntimeError, "error message")
+          fail "OutOfGas was not raised"
+        rescue OutOfGas => e
+          e.amount.should == 2
+          e.units.should  == :oz
+        end
       end
 
       it "does not raise when told to if args dont match" do