rspec-mocks 2.9.0 → 2.10.0

data/lib/rspec/mocks/methods.rb

@@ -125,7 +125,7 @@ module RSpec
 
       def __mock_proxy
         @mock_proxy ||= begin
-          mp = if Mock === self
+          mp = if TestDouble === self
             Proxy.new(self, @name, @options)
           else
             Proxy.new(self)

data/lib/rspec/mocks/mock.rb

@@ -1,81 +1,7 @@
 module RSpec
   module Mocks
     class Mock
-      include Methods
-
-      # Creates a new test double with a `name` (that will be used in error
-      # messages only)
-      def initialize(name=nil, stubs_and_options={})
-        if name.is_a?(Hash) && stubs_and_options.empty?
-          stubs_and_options = name
-          @name = nil
-        else
-          @name = name
-        end
-        @options = extract_options(stubs_and_options)
-        assign_stubs(stubs_and_options)
-      end
-
-      # This allows for comparing the mock to other objects that proxy such as
-      # ActiveRecords belongs_to proxy objects. By making the other object run
-      # the comparison, we're sure the call gets delegated to the proxy
-      # target.
-      def ==(other)
-        other == __mock_proxy
-      end
-
-      # @private
-      def inspect
-        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
-      end
-
-      # @private
-      def to_s
-        inspect.gsub('<','[').gsub('>',']')
-      end
-
-      alias_method :to_str, :to_s
-
-      # @private
-      def respond_to?(message, incl_private=false)
-        __mock_proxy.null_object? && message != :to_ary ? true : super
-      end
-
-    private
-
-      def method_missing(message, *args, &block)
-          raise NoMethodError if message == :to_ary
-        __mock_proxy.record_message_received(message, *args, &block)
-        begin
-          __mock_proxy.null_object? ? self : super
-        rescue NameError
-          __mock_proxy.raise_unexpected_message_error(message, *args)
-        end
-      end
-
-      def extract_options(stubs_and_options)
-        if stubs_and_options[:null_object]
-          @null_object = stubs_and_options.delete(:null_object)
-          RSpec.deprecate(%Q["double('name', :null_object => true)"], %Q["double('name').as_null_object"])
-        end
-        options = {}
-        extract_option(stubs_and_options, options, :__declared_as, 'Mock')
-        options
-      end
-
-      def extract_option(source, target, key, default=nil)
-        if source[key]
-          target[key] = source.delete(key)
-        elsif default
-          target[key] = default
-        end
-      end
-
-      def assign_stubs(stubs)
-        stubs.each_pair do |message, response|
-          stub(message).and_return(response)
-        end
-      end
+      include TestDouble
     end
   end
 end

data/lib/rspec/mocks/proxy.rb

@@ -149,9 +149,7 @@ module RSpec
       private
 
       def method_double
-        @method_double ||= Hash.new {|h,k|
-          h[k] = MethodDouble.new(@object, k, self)
-        }
+        @method_double ||= Hash.new {|h,k| h[k] = MethodDouble.new(@object, k, self) }
       end
 
       def method_doubles

data/lib/rspec/mocks/test_double.rb

@@ -0,0 +1,102 @@
+module RSpec
+  module Mocks
+    # Implements the methods needed for a pure test double.  RSpec::Mocks::Mock
+    # includes this module, and it is provided for cases where you want a
+    # pure test double without subclassing RSpec::Mocks::Mock.
+    module TestDouble
+      include Methods
+
+      # Extends the TestDouble module onto the given object and
+      # initializes it as a test double.
+      #
+      # @example
+      #
+      #   module = Module.new
+      #   RSpec::Mocks::TestDouble.extend_onto(module, "MyMixin", :foo => "bar")
+      #   module.foo  #=> "bar"
+      def self.extend_onto(object, name=nil, stubs_and_options={})
+        object.extend self
+        object.send(:__initialize_as_test_double, name, stubs_and_options)
+      end
+
+      # Creates a new test double with a `name` (that will be used in error
+      # messages only)
+      def initialize(name=nil, stubs_and_options={})
+        __initialize_as_test_double(name, stubs_and_options)
+      end
+
+      # This allows for comparing the mock to other objects that proxy such as
+      # ActiveRecords belongs_to proxy objects. By making the other object run
+      # the comparison, we're sure the call gets delegated to the proxy
+      # target.
+      def ==(other)
+        other == __mock_proxy
+      end
+
+      # @private
+      def inspect
+        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+      end
+
+      # @private
+      def to_s
+        inspect.gsub('<','[').gsub('>',']')
+      end
+
+      alias_method :to_str, :to_s
+
+      # @private
+      def respond_to?(message, incl_private=false)
+        __mock_proxy.null_object? && message != :to_ary ? true : super
+      end
+
+    private
+
+      def __initialize_as_test_double(name=nil, stubs_and_options={})
+        if name.is_a?(Hash) && stubs_and_options.empty?
+          stubs_and_options = name
+          @name = nil
+        else
+          @name = name
+        end
+        @options = extract_options(stubs_and_options)
+        assign_stubs(stubs_and_options)
+      end
+
+      def method_missing(message, *args, &block)
+          raise NoMethodError if message == :to_ary
+        __mock_proxy.record_message_received(message, *args, &block)
+        begin
+          __mock_proxy.null_object? ? self : super
+        rescue NameError
+          __mock_proxy.raise_unexpected_message_error(message, *args)
+        end
+      end
+
+      def extract_options(stubs_and_options)
+        if stubs_and_options[:null_object]
+          @null_object = stubs_and_options.delete(:null_object)
+          RSpec.deprecate(%Q["double('name', :null_object => true)"], %Q["double('name').as_null_object"])
+        end
+        options = {}
+        extract_option(stubs_and_options, options, :__declared_as, 'Mock')
+        options
+      end
+
+      def extract_option(source, target, key, default=nil)
+        if source[key]
+          target[key] = source.delete(key)
+        elsif default
+          target[key] = default
+        end
+      end
+
+      def assign_stubs(stubs)
+        stubs.each_pair do |message, response|
+          stub(message).and_return(response)
+        end
+      end
+    end
+  end
+end
+

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module Version
-      STRING = '2.9.0'
+      STRING = '2.10.0'
     end
   end
 end

data/spec/rspec/mocks/at_most_spec.rb

@@ -4,95 +4,86 @@ module RSpec
   module Mocks
     describe "at_most" do
       before(:each) do
-        @mock = RSpec::Mocks::Mock.new("test mock")
+        @double = double
       end
 
-      it "fails when at most n times method is called n plus 1 times" do
-        @mock.should_receive(:random_call).at_most(4).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      it "passes when at_most(n) is called exactly n times" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.do_something
+        @double.do_something
+        @double.rspec_verify
       end
 
-      it "fails when at most once method is called twice" do
-        @mock.should_receive(:random_call).at_most(:once)
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      it "passes when at_most(n) is called less than n times" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.do_something
+        @double.rspec_verify
       end
 
-      it "fails when at most twice method is called three times" do
-        @mock.should_receive(:random_call).at_most(:twice)
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        lambda do
-          @mock.rspec_verify
-        end.should raise_error(RSpec::Mocks::MockExpectationError)
+      it "passes when at_most(n) is never called" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.rspec_verify
       end
 
-      it "passes when at most n times method is called exactly n times" do
-        @mock.should_receive(:random_call).at_most(4).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
+      it "passes when at_most(:once) is called once" do
+        @double.should_receive(:do_something).at_most(:once)
+        @double.do_something
+        @double.rspec_verify
       end
 
-      it "passes when at most n times method is called less than n times" do
-        @mock.should_receive(:random_call).at_most(4).times
-        @mock.random_call
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
+      it "passes when at_most(:once) is never called" do
+        @double.should_receive(:do_something).at_most(:once)
+        @double.rspec_verify
       end
 
-      it "passes when at most n times method is never called" do
-        @mock.should_receive(:random_call).at_most(4).times
-        @mock.rspec_verify
+      it "passes when at_most(:twice) is called once" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.do_something
+        @double.rspec_verify
       end
 
-      it "passes when at most once method is called once" do
-        @mock.should_receive(:random_call).at_most(:once)
-        @mock.random_call
-        @mock.rspec_verify
+      it "passes when at_most(:twice) is called twice" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.do_something
+        @double.do_something
+        @double.rspec_verify
       end
 
-      it "passes when at most once method is never called" do
-        @mock.should_receive(:random_call).at_most(:once)
-        @mock.rspec_verify
+      it "passes when at_most(:twice) is never called" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.rspec_verify
       end
 
-      it "passes when at most twice method is called once" do
-        @mock.should_receive(:random_call).at_most(:twice)
-        @mock.random_call
-        @mock.rspec_verify
+      it "returns the value given by a block when at_most(:once) method is called" do
+        @double.should_receive(:to_s).at_most(:once) { "testing" }
+        @double.to_s.should eq "testing"
+        @double.rspec_verify
       end
 
-      it "passes when at most twice method is called twice" do
-        @mock.should_receive(:random_call).at_most(:twice)
-        @mock.random_call
-        @mock.random_call
-        @mock.rspec_verify
+      it "fails fast when at_most(n) times method is called n plus 1 times" do
+        @double.should_receive(:do_something).at_most(2).times
+        @double.do_something
+        @double.do_something
+        lambda do
+          @double.do_something
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "passes when at most twice method is never called" do
-        @mock.should_receive(:random_call).at_most(:twice)
-        @mock.rspec_verify
+      it "fails fast when at_most(:once) and is called twice" do
+        @double.should_receive(:do_something).at_most(:once)
+        @double.do_something
+        lambda do
+          @double.do_something
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
 
-      it "returns the value given by a block when the at most once method is called" do
-        @mock.should_receive(:to_s).at_most(:once) { "testing" }
-        @mock.to_s.should eq "testing"
-        @mock.rspec_verify
+      it "fails fast when at_most(:twice) and is called three times" do
+        @double.should_receive(:do_something).at_most(:twice)
+        @double.do_something
+        @double.do_something
+        lambda do
+          @double.do_something
+        end.should raise_error(RSpec::Mocks::MockExpectationError)
       end
     end
   end

data/spec/rspec/mocks/mock_spec.rb

@@ -171,7 +171,7 @@ module RSpec
         @mock.should_receive(:something) {| bool | bool.should be_true}
         expect {
           @mock.something false
-        }.to raise_error(RSpec::Mocks::MockExpectationError, /Double \"test double\" received :something but passed block failed with: expected false to be true/)
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
       end
 
       it "passes proc to expectation block without an argument", :ruby => '> 1.8.6' do
@@ -217,6 +217,14 @@ module RSpec
         }.should raise_error(RuntimeError, "error message")
       end
 
+      it "raises instance of submitted ArgumentError" do
+        error = ArgumentError.new("error message")
+        @mock.should_receive(:something).and_raise(error)
+        lambda {
+          @mock.something
+        }.should raise_error(ArgumentError, "error message")
+      end
+
       it "fails with helpful message if submitted Exception requires constructor arguments" do
         class ErrorWithNonZeroArgConstructor < RuntimeError
           def initialize(i_take_an_argument)
@@ -250,14 +258,6 @@ module RSpec
         }.should throw_symbol(:blech)
       end
 
-      it "raises when explicit return and block constrained" do
-        lambda {
-          @mock.should_receive(:fruit) do |colour|
-            :strawberry
-          end.and_return :apple
-        }.should raise_error(RSpec::Mocks::AmbiguousReturnError)
-      end
-
       it "ignores args on any args" do
         @mock.should_receive(:something).at_least(:once).with(any_args)
         @mock.something
@@ -484,8 +484,8 @@ module RSpec
 
       it "raises an error when a previously stubbed method has a negative expectation" do
         @mock.stub(:msg).and_return(:stub_value)
-        @mock.should_not_receive(:msg).and_return(:mock_value)
-        lambda {@mock.msg(:arg)}.should raise_error(RSpec::Mocks::MockExpectationError)
+        @mock.should_not_receive(:msg)
+        expect { @mock.msg(:arg) }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       it "temporarily replaces a method stub on a non-mock" do

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -2,187 +2,118 @@ require 'spec_helper'
 
 module RSpec
   module Mocks
-    describe "a Mock expectation with multiple return values and no specified count" do
+    describe "a message expectation with multiple return values and no specified count" do
       before(:each) do
-        @mock = RSpec::Mocks::Mock.new("mock")
-        @return_values = ["1",2,Object.new]
-        @mock.should_receive(:message).and_return(@return_values[0],@return_values[1],@return_values[2])
+        @double = double
+        @return_values = [1,2,3]
+        @double.should_receive(:do_something).and_return(@return_values[0],@return_values[1],@return_values[2])
       end
 
-      it "returns values in order to consecutive calls" do
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        @mock.message.should eq @return_values[2]
-        @mock.rspec_verify
+      it "returns values in order" do
+        @double.do_something.should eq @return_values[0]
+        @double.do_something.should eq @return_values[1]
+        @double.do_something.should eq @return_values[2]
+        @double.rspec_verify
       end
 
-      it "complains when there are too few calls" do
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
-        )
+      it "falls back to a previously stubbed value" do
+        @double.stub :do_something => :stub_result
+        @double.do_something.should eq @return_values[0]
+        @double.do_something.should eq @return_values[1]
+        @double.do_something.should eq @return_values[2]
+        @double.do_something.should eq :stub_result
       end
 
-      it "complains when there are too many calls" do
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        @mock.message.should eq @return_values[2]
-        @mock.message.should eq @return_values[2]
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
-        )
+      it "fails when there are too few calls (if there is no stub)" do
+        @double.do_something
+        @double.do_something
+        expect { @double.rspec_verify }.to raise_error
       end
 
-      it "doesn't complain when there are too many calls but method is stubbed too" do
-        @mock.stub(:message).and_return :stub_result
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        @mock.message.should eq @return_values[2]
-        @mock.message.should eq :stub_result
-        expect { @mock.rspec_verify }.to_not raise_error(RSpec::Mocks::MockExpectationError)
+      it "fails when there are too many calls (if there is no stub)" do
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        expect { @double.rspec_verify }.to raise_error
       end
     end
 
-    describe "a Mock expectation with multiple return values with a specified count equal to the number of values" do
+    describe "a message expectation with multiple return values with a specified count equal to the number of values" do
       before(:each) do
-        @mock = RSpec::Mocks::Mock.new("mock")
-        @return_values = ["1",2,Object.new]
-        @mock.should_receive(:message).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
+        @double = double
+        @return_values = [1,2,3]
+        @double.should_receive(:do_something).exactly(3).times.and_return(@return_values[0],@return_values[1],@return_values[2])
       end
 
       it "returns values in order to consecutive calls" do
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        @mock.message.should eq @return_values[2]
-        @mock.rspec_verify
-      end
-
-      it "complains when there are too few calls" do
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 2 times|
-        )
-      end
-
-      it "complains when there are too many calls" do
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        @mock.message.should eq @return_values[2]
-        @mock.message.should eq @return_values[2]
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
-        )
-      end
-
-      it "complains when there are too many calls and method is stubbed too" do
-        @mock.stub(:message).and_return :stub_result
-        @mock.message.should eq @return_values[0]
-        @mock.message.should eq @return_values[1]
-        @mock.message.should eq @return_values[2]
-        @mock.message.should eq :stub_result
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
-        )
+        @double.do_something.should eq @return_values[0]
+        @double.do_something.should eq @return_values[1]
+        @double.do_something.should eq @return_values[2]
+        @double.rspec_verify
       end
     end
 
-    describe "a Mock expectation with multiple return values specifying at_least less than the number of values" do
+    describe "a message expectation with multiple return values specifying at_least less than the number of values" do
       before(:each) do
-        @mock = RSpec::Mocks::Mock.new("mock")
-        @mock.should_receive(:message).at_least(:twice).with(no_args).and_return(11, 22)
+        @double = double
+        @double.should_receive(:do_something).at_least(:twice).with(no_args).and_return(11, 22)
       end
 
       it "uses the last return value for subsequent calls" do
-        @mock.message.should equal(11)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        @mock.rspec_verify
+        @double.do_something.should equal(11)
+        @double.do_something.should equal(22)
+        @double.do_something.should equal(22)
+        @double.rspec_verify
       end
 
       it "fails when called less than the specified number" do
-        @mock.message.should equal(11)
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(no args)\n    expected: 2 times\n    received: 1 time|
-        )
+        @double.do_something.should equal(11)
+        expect { @double.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
       end
 
       context "when method is stubbed too" do
-        before { @mock.stub(:message).and_return :stub_result }
+        before { @double.stub(:do_something).and_return :stub_result }
 
         it "uses the stub return value for subsequent calls" do
-          @mock.message.should equal(11)
-          @mock.message.should equal(22)
-          @mock.message.should equal(:stub_result)
-          @mock.rspec_verify
+          @double.do_something.should equal(11)
+          @double.do_something.should equal(22)
+          @double.do_something.should equal(:stub_result)
+          @double.rspec_verify
         end
 
         it "fails when called less than the specified number" do
-          @mock.message.should equal(11)
-          expect { @mock.rspec_verify }.to raise_error(
-            RSpec::Mocks::MockExpectationError,
-            %Q|(Mock "mock").message(no args)\n    expected: 2 times\n    received: 1 time|
-          )
+          @double.do_something.should equal(11)
+          expect { @double.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
         end
       end
-
     end
 
-    describe "a Mock expectation with multiple return values with a specified count larger than the number of values" do
+    describe "a message expectation with multiple return values with a specified count larger than the number of values" do
       before(:each) do
-        @mock = RSpec::Mocks::Mock.new("mock")
-        @mock.should_receive(:message).exactly(3).times.and_return(11, 22)
+        @double = RSpec::Mocks::Mock.new("double")
+        @double.should_receive(:do_something).exactly(3).times.and_return(11, 22)
       end
 
       it "uses the last return value for subsequent calls" do
-        @mock.message.should equal(11)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        @mock.rspec_verify
+        @double.do_something.should equal(11)
+        @double.do_something.should equal(22)
+        @double.do_something.should equal(22)
+        @double.rspec_verify
       end
 
       it "fails when called less than the specified number" do
-        @mock.message.should equal(11)
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 1 time|
-        )
+        @double.do_something
+        @double.do_something
+        expect { @double.rspec_verify }.to raise_error
       end
 
-      it "fails when called greater than the specified number" do
-        @mock.message.should equal(11)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        @mock.message.should equal(22)
-        expect { @mock.rspec_verify }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
-        )
-      end
-
-      context "when method is stubbed too" do
-        before { @mock.stub(:message).and_return :stub_result }
-
-        it "fails when called greater than the specified number" do
-          @mock.message.should equal(11)
-          @mock.message.should equal(22)
-          @mock.message.should equal(22)
-          @mock.message.should equal(:stub_result)
-          expect { @mock.rspec_verify }.to raise_error(
-            RSpec::Mocks::MockExpectationError,
-            %Q|(Mock "mock").message(any args)\n    expected: 3 times\n    received: 4 times|
-          )
-        end
-
+      it "fails fast when called greater than the specified number" do
+        @double.do_something
+        @double.do_something
+        @double.do_something
+        expect { @double.do_something }.to raise_error
       end
     end
   end
 end
-