rspec-mocks 2.10.1 → 2.11.0

data/lib/rspec/mocks/methods.rb

@@ -135,6 +135,10 @@ module RSpec
           mp
         end
       end
+      
+      def __remove_mock_proxy
+        @mock_proxy = nil
+      end
 
       def format_chain(*chain, &blk)
         if Hash === chain.last

data/lib/rspec/mocks/proxy.rb

@@ -65,6 +65,7 @@ module RSpec
 
       # @private
       def add_message_expectation(location, method_name, opts={}, &block)        
+        block ||= Proc.new { @object } if null_object?
         method_double[method_name].add_expectation @error_generator, @expectation_ordering, location, opts, &block
       end
 
@@ -128,7 +129,7 @@ module RSpec
           raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(message) or null_object?)
         elsif stub = find_almost_matching_stub(message, *args)
           stub.advise(*args)
-          raise_unexpected_message_args_error(stub, *args)
+          raise_missing_default_stub_error(stub, *args)
         elsif @object.is_a?(Class)
           @object.superclass.__send__(message, *args, &block)
         else
@@ -136,14 +137,19 @@ module RSpec
         end
       end
 
+      # @private
+      def raise_unexpected_message_error(method_name, *args)
+        @error_generator.raise_unexpected_message_error method_name, *args
+      end
+
       # @private
       def raise_unexpected_message_args_error(expectation, *args)
         @error_generator.raise_unexpected_message_args_error(expectation, *args)
       end
 
       # @private
-      def raise_unexpected_message_error(method_name, *args)
-        @error_generator.raise_unexpected_message_error method_name, *args
+      def raise_missing_default_stub_error(expectation, *args)
+        @error_generator.raise_missing_default_stub_error(expectation, *args)
       end
 
       private
@@ -157,7 +163,7 @@ 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) && !expectation.called_max_times?}) || 
           method_double[method_name].expectations.find {|expectation| expectation.matches?(method_name, *args)}
       end
 

data/lib/rspec/mocks/stub_const.rb

@@ -0,0 +1,280 @@
+module RSpec
+  module Mocks
+    # Provides recursive constant lookup methods useful for
+    # constant stubbing.
+    # @api private
+    module RecursiveConstMethods
+      def recursive_const_get(name)
+        name.split('::').inject(Object) { |mod, name| mod.const_get name }
+      end
+
+      def recursive_const_defined?(name)
+        name.split('::').inject([Object, '']) do |(mod, full_name), name|
+          yield(full_name, name) if block_given? && !mod.is_a?(Module)
+          return false unless mod.const_defined?(name)
+          [mod.const_get(name), [mod, name].join('::')]
+        end
+      end
+    end
+
+    # Provides information about constants that may (or may not)
+    # have been stubbed by rspec-mocks.
+    class Constant
+      extend RecursiveConstMethods
+
+      # @api private
+      def initialize(name)
+        @name = name
+      end
+
+      # @return [String] The fully qualified name of the constant.
+      attr_reader :name
+
+      # @return [Object, nil] The original value (e.g. before it
+      #   was stubbed by rspec-mocks) of the constant, or
+      #   nil if the constant was not previously defined.
+      attr_accessor :original_value
+
+      # @api private
+      attr_writer :previously_defined, :stubbed
+
+      # @return [Boolean] Whether or not the constant was defined
+      #   before the current example.
+      def previously_defined?
+        @previously_defined
+      end
+
+      # @return [Boolean] Whether or not rspec-mocks has stubbed
+      #   this constant.
+      def stubbed?
+        @stubbed
+      end
+
+      def to_s
+        "#<#{self.class.name} #{name}>"
+      end
+      alias inspect to_s
+
+      # @api private
+      def self.unstubbed(name)
+        const = new(name)
+        const.previously_defined = recursive_const_defined?(name)
+        const.stubbed = false
+        const.original_value = recursive_const_get(name) if const.previously_defined?
+
+        const
+      end
+      private_class_method :unstubbed
+
+      # Queries rspec-mocks to find out information about the named constant.
+      #
+      # @param [String] name the name of the constant
+      # @return [Constant] an object contaning information about the named
+      #   constant.
+      def self.original(name)
+        stubber = ConstantStubber.find(name)
+        stubber ? stubber.to_constant : unstubbed(name)
+      end
+    end
+
+    # Provides a means to stub constants.
+    class ConstantStubber
+      extend RecursiveConstMethods
+
+      # Stubs a constant.
+      #
+      # @param (see ExampleMethods#stub_const)
+      # @option (see ExampleMethods#stub_const)
+      # @return (see ExampleMethods#stub_const)
+      #
+      # @see ExampleMethods#stub_const
+      # @note It's recommended that you use `stub_const` in your
+      #  examples. This is an alternate public API that is provided
+      #  so you can stub constants in other contexts (e.g. helper
+      #  classes).
+      def self.stub(constant_name, value, options = {})
+        stubber = if recursive_const_defined?(constant_name, &raise_on_invalid_const)
+          DefinedConstantReplacer
+        else
+          UndefinedConstantSetter
+        end
+
+        stubber = stubber.new(constant_name, value, options[:transfer_nested_constants])
+        stubbers << stubber
+
+        stubber.stub
+        ensure_registered_with_mocks_space
+        value
+      end
+
+      # Contains common functionality used by both of the constant stubbers.
+      #
+      # @api private
+      class BaseStubber
+        include RecursiveConstMethods
+
+        attr_reader :original_value, :full_constant_name
+
+        def initialize(full_constant_name, stubbed_value, transfer_nested_constants)
+          @full_constant_name        = full_constant_name
+          @stubbed_value             = stubbed_value
+          @transfer_nested_constants = transfer_nested_constants
+          @context_parts             = @full_constant_name.split('::')
+          @const_name                = @context_parts.pop
+        end
+
+        def to_constant
+          const = Constant.new(full_constant_name)
+          const.stubbed = true
+          const.previously_defined = previously_defined?
+          const.original_value = original_value
+
+          const
+        end
+      end
+
+      # Replaces a defined constant for the duration of an example.
+      #
+      # @api private
+      class DefinedConstantReplacer < BaseStubber
+        def stub
+          @context = recursive_const_get(@context_parts.join('::'))
+          @original_value = @context.const_get(@const_name)
+
+          constants_to_transfer = verify_constants_to_transfer!
+
+          @context.send(:remove_const, @const_name)
+          @context.const_set(@const_name, @stubbed_value)
+
+          transfer_nested_constants(constants_to_transfer)
+        end
+
+        def previously_defined?
+          true
+        end
+
+        def rspec_reset
+          @context.send(:remove_const, @const_name)
+          @context.const_set(@const_name, @original_value)
+        end
+
+        def transfer_nested_constants(constants)
+          constants.each do |const|
+            @stubbed_value.const_set(const, original_value.const_get(const))
+          end
+        end
+
+        def verify_constants_to_transfer!
+          return [] unless @transfer_nested_constants
+
+          { @original_value => "the original value", @stubbed_value => "the stubbed value" }.each do |value, description|
+            unless value.respond_to?(:constants)
+              raise ArgumentError,
+                "Cannot transfer nested constants for #{@full_constant_name} " +
+                "since #{description} is not a class or module and only classes " +
+                "and modules support nested constants."
+            end
+          end
+
+          if @transfer_nested_constants.is_a?(Array)
+            @transfer_nested_constants = @transfer_nested_constants.map(&:to_s) if RUBY_VERSION == '1.8.7'
+            undefined_constants = @transfer_nested_constants - @original_value.constants
+
+            if undefined_constants.any?
+              available_constants = @original_value.constants - @transfer_nested_constants
+              raise ArgumentError,
+                "Cannot transfer nested constant(s) #{undefined_constants.join(' and ')} " +
+                "for #{@full_constant_name} since they are not defined. Did you mean " +
+                "#{available_constants.join(' or ')}?"
+            end
+
+            @transfer_nested_constants
+          else
+            @original_value.constants
+          end
+        end
+      end
+
+      # Sets an undefined constant for the duration of an example.
+      #
+      # @api private
+      class UndefinedConstantSetter < BaseStubber
+        def stub
+          remaining_parts = @context_parts.dup
+          @deepest_defined_const = @context_parts.inject(Object) do |klass, name|
+            break klass unless klass.const_defined?(name)
+            remaining_parts.shift
+            klass.const_get(name)
+          end
+
+          context = remaining_parts.inject(@deepest_defined_const) do |klass, name|
+            klass.const_set(name, Module.new)
+          end
+
+          @const_to_remove = remaining_parts.first || @const_name
+          context.const_set(@const_name, @stubbed_value)
+        end
+
+        def previously_defined?
+          false
+        end
+
+        def rspec_reset
+          @deepest_defined_const.send(:remove_const, @const_to_remove)
+        end
+      end
+
+      # Ensures the constant stubbing is registered with
+      # rspec-mocks space so that stubbed constants can
+      # be restored when examples finish.
+      #
+      # @api private
+      def self.ensure_registered_with_mocks_space
+        return if @registered_with_mocks_space
+        ::RSpec::Mocks.space.add(self)
+        @registered_with_mocks_space = true
+      end
+
+      # Resets all stubbed constants. This is called automatically
+      # by rspec-mocks when an example finishes.
+      #
+      # @api private
+      def self.rspec_reset
+        @registered_with_mocks_space = false
+
+        # We use reverse order so that if the same constant
+        # was stubbed multiple times, the original value gets
+        # properly restored.
+        stubbers.reverse.each { |s| s.rspec_reset }
+
+        stubbers.clear
+      end
+
+      # The list of constant stubbers that have been used for
+      # the current example.
+      #
+      # @api private
+      def self.stubbers
+        @stubbers ||= []
+      end
+
+      def self.find(name)
+        stubbers.find { |s| s.full_constant_name == name }
+      end
+
+      # Used internally by the constant stubbing to raise a helpful
+      # error when a constant like "A::B::C" is stubbed and A::B is
+      # not a module (and thus, it's impossible to define "A::B::C"
+      # since only modules can have nested constants).
+      #
+      # @api private
+      def self.raise_on_invalid_const
+        lambda do |const_name, failed_name|
+          raise "Cannot stub constant #{failed_name} on #{const_name} " +
+                "since #{const_name} is not a module."
+        end
+      end
+    end
+  end
+end
+

data/lib/rspec/mocks/test_double.rb

@@ -64,8 +64,10 @@ module RSpec
       end
 
       def method_missing(message, *args, &block)
-          raise NoMethodError if message == :to_ary
+        raise NoMethodError if message == :to_ary
+        return 0 if message == :to_int && __mock_proxy.null_object?
         __mock_proxy.record_message_received(message, *args, &block)
+
         begin
           __mock_proxy.null_object? ? self : super
         rescue NameError
@@ -99,4 +101,3 @@ module RSpec
     end
   end
 end
-

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module Version
-      STRING = '2.10.1'
+      STRING = '2.11.0'
     end
   end
 end

data/spec/rspec/mocks/any_instance/message_chains_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe RSpec::Mocks::AnyInstance::MessageChains do
   let(:chains) { RSpec::Mocks::AnyInstance::MessageChains.new }
   let(:stub_chain) { RSpec::Mocks::AnyInstance::StubChain.new }
-  let(:expectation_chain) { RSpec::Mocks::AnyInstance::ExpectationChain.new }
+  let(:expectation_chain) { RSpec::Mocks::AnyInstance::PositiveExpectationChain.new }
 
   it "knows if a method does not have an expectation set on it" do
     chains.add(:method_name, stub_chain)

data/spec/rspec/mocks/any_instance_spec.rb

@@ -34,13 +34,13 @@ module RSpec
             lambda{ klass.any_instance.stub(:foo).and_yield(1).with("1") }.should raise_error(NoMethodError)
           end
         end
-        
+
         context "#stub_chain" do
           it "raises an error if 'stub_chain' follows 'any_instance'" do
             lambda{ klass.any_instance.and_return("1").stub_chain(:foo, :bar) }.should raise_error(NoMethodError)
           end
         end
-        
+
         context "#should_receive" do
           it "raises an error if 'should_receive' follows 'with'" do
             lambda{ klass.any_instance.with("1").should_receive(:foo) }.should raise_error(NoMethodError)
@@ -57,13 +57,13 @@ module RSpec
           end
         end
       end
-      
+
       context "with #stub" do
         it "does not suppress an exception when a method that doesn't exist is invoked" do
           klass.any_instance.stub(:foo)
           lambda{ klass.new.bar }.should raise_error(NoMethodError)
         end
-        
+
         context 'multiple methods' do
           it "allows multiple methods to be stubbed in a single invocation" do
             klass.any_instance.stub(:foo => 'foo', :bar => 'bar')
@@ -71,12 +71,12 @@ module RSpec
             instance.foo.should eq('foo')
             instance.bar.should eq('bar')
           end
-          
+
           it "adheres to the contract of multiple method stubbing withou any instance" do
             Object.new.stub(:foo => 'foo', :bar => 'bar').should eq(:foo => 'foo', :bar => 'bar')
             klass.any_instance.stub(:foo => 'foo', :bar => 'bar').should eq(:foo => 'foo', :bar => 'bar')
           end
-          
+
           context "allows a chain of methods to be stubbed using #stub_chain" do
             it "given symbols representing the methods" do
               klass.any_instance.stub_chain(:one, :two, :three).and_return(:four)
@@ -87,14 +87,14 @@ module RSpec
               klass.any_instance.stub_chain(:one, :two, :three => :four)
               klass.new.one.two.three.should eq(:four)
             end
-            
+
             it "given a string of '.' separated method names representing the chain" do
               klass.any_instance.stub_chain('one.two.three').and_return(:four)
               klass.new.one.two.three.should eq(:four)
             end
           end
         end
-        
+
         context "behaves as 'every instance'" do
           it "stubs every instance in the spec" do
             klass.any_instance.stub(:foo).and_return(result = Object.new)
@@ -108,13 +108,13 @@ module RSpec
             instance.foo.should eq(result)
           end
         end
-        
+
         context "with argument matching" do
-          before do 
+          before do
             klass.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
             klass.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
           end
-          
+
           it "returns the stubbed value when arguments match" do
             instance = klass.new
             instance.foo(:param_one, :param_two).should eq(:result_one)
@@ -127,11 +127,11 @@ module RSpec
             end.to(raise_error(RSpec::Mocks::MockExpectationError))
           end
         end
-        
+
         context "with multiple stubs" do
-          before do 
-            klass.any_instance.stub(:foo).and_return(1) 
-            klass.any_instance.stub(:bar).and_return(2) 
+          before do
+            klass.any_instance.stub(:foo).and_return(1)
+            klass.any_instance.stub(:bar).and_return(2)
           end
 
           it "stubs a method" do
@@ -196,7 +196,7 @@ module RSpec
             klass.new.foo.should eq(klass.new.foo)
           end
         end
-        
+
         context "core ruby objects" do
           it "works uniformly across *everything*" do
             Object.any_instance.stub(:foo).and_return(1)
@@ -244,7 +244,7 @@ module RSpec
           end.to raise_error(/Use stub instead/)
         end
       end
-      
+
       context "unstub implementation" do
         it "replaces the stubbed method with the original method" do
           klass.any_instance.stub(:existing_method)
@@ -264,7 +264,7 @@ module RSpec
           klass.any_instance.stub(:existing_method_with_arguments).with(1)
           klass.any_instance.stub(:existing_method_with_arguments).with(2)
           klass.any_instance.unstub(:existing_method_with_arguments)
-          klass.new.existing_method_with_arguments(3).should eq :three
+          klass.new.existing_method_with_arguments(3).should eq(:three)
         end
 
         it "raises a MockExpectationError if the method has not been stubbed" do
@@ -273,6 +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) 
+            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' }
@@ -406,11 +437,11 @@ module RSpec
         end
 
         context "with argument matching" do
-          before do 
+          before do
             klass.any_instance.should_receive(:foo).with(:param_one, :param_two).and_return(:result_one)
             klass.any_instance.should_receive(:foo).with(:param_three, :param_four).and_return(:result_two)
           end
-          
+
           it "returns the expected value when arguments match" do
             instance = klass.new
             instance.foo(:param_one, :param_two).should eq(:result_one)
@@ -434,7 +465,7 @@ module RSpec
             instance.foo(:param_one, :param_two).should eq(:result_one)
             instance.foo(:param_three, :param_four).should eq(:result_two)
           end
-          
+
           it "fails when arguments do not match" do
             instance = klass.new
             expect do
@@ -676,21 +707,21 @@ module RSpec
                 klass.new.existing_method.should eq(existing_method_return_value)
               end
             end
-            
+
             context "private methods" do
               before :each do
                 klass.any_instance.stub(:private_method).and_return(:something)
                 space.verify_all
               end
-              
+
               it "cleans up the backed up method" do
                 klass.method_defined?(:__existing_method_without_any_instance__).should be_false
               end
-              
+
               it "restores a stubbed private method after the spec is run" do
                 klass.private_method_defined?(:private_method).should be_true
               end
-              
+
               it "ensures that the restored method behaves as it originally did" do
                 klass.new.send(:private_method).should eq(:private_method_return_value)
               end
@@ -717,7 +748,7 @@ module RSpec
                 klass.new.send(:private_method).should eq(:private_method_return_value)
               end
             end
-            
+
             context "ensures that the subsequent specs do not see expectations set in previous specs" do
               context "when the instance created after the expectation is set" do
                 it "first spec" do
@@ -780,6 +811,15 @@ module RSpec
         end
       end
 
+      context 'when used in conjunction with a `dup`' do
+        it "doesn't cause an infinite loop" do
+          Object.any_instance.stub(:some_method)
+          o = Object.new
+          o.some_method
+          lambda { o.dup.some_method }.should_not raise_error(SystemStackError)
+        end
+      end
+
     end
   end
 end