rspec-mocks 2.13.1 → 2.14.0.rc1

data/lib/rspec/mocks/any_instance/stub_chain.rb

@@ -4,11 +4,6 @@ module RSpec
       # @private
       class StubChain < Chain
 
-        # @private
-        def initialize(*args, &block)
-          record(:stub, *args, &block)
-        end
-
         # @private
         def expectation_fulfilled?
           true
@@ -16,13 +11,18 @@ module RSpec
 
         private
 
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.proxy_for(instance)
+          expected_from = IGNORED_BACKTRACE_LINE
+          proxy.add_stub(expected_from, *@expectation_args, &@expectation_block)
+        end
+
         def invocation_order
           @invocation_order ||= {
-            :stub => [nil],
-            :with => [:stub],
-            :and_return => [:with, :stub],
-            :and_raise => [:with, :stub],
-            :and_yield => [:with, :stub]
+            :with => [nil],
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil],
+            :and_yield => [:with, nil]
           }
         end
 
@@ -34,4 +34,4 @@ module RSpec
       end
     end
   end
-end
+end

data/lib/rspec/mocks/any_instance/stub_chain_chain.rb

@@ -4,22 +4,20 @@ module RSpec
       # @private
       class StubChainChain < StubChain
 
-        # @private
-        def initialize(*args, &block)
-          record(:stub_chain, *args, &block)
-        end
-
         private
 
+        def create_message_expectation_on(instance)
+          ::RSpec::Mocks::StubChain.stub_chain_on(instance, *@expectation_args, &@expectation_block)
+        end
+
         def invocation_order
           @invocation_order ||= {
-            :stub_chain => [nil],
-            :and_return => [:stub_chain],
-            :and_raise => [:stub_chain],
-            :and_yield => [:stub_chain]
+            :and_return => [nil],
+            :and_raise => [nil],
+            :and_yield => [nil]
           }
         end
       end
     end
   end
-end
+end

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -30,7 +30,7 @@ module RSpec
 
       # @api public
       # @param [Array] *expected_args a list of expected literals and/or argument matchers
-      # @param [Block] block a block with arity matching the expected 
+      # @param [Block] block a block with arity matching the expected
       #
       # Initializes an `ArgumentListMatcher` with a collection of literal
       # values and/or argument matchers, or a block that handles the evaluation
@@ -73,8 +73,12 @@ module RSpec
         return ArgumentMatchers::EqualityProxy.new(arg)
       end
 
-      def is_matcher?(obj)
-        !obj.null_object? & obj.respond_to?(:matches?) & [:failure_message_for_should, :failure_message].any? { |m| obj.respond_to?(m) }
+      def is_matcher?(object)
+        return false if object.respond_to?(:i_respond_to_everything_so_im_not_really_a_matcher)
+
+        [:failure_message_for_should, :failure_message].any? do |msg|
+          object.respond_to?(msg)
+        end && object.respond_to?(:matches?)
       end
 
       def block_passes?(*args)

data/lib/rspec/mocks/configuration.rb

@@ -19,10 +19,37 @@ module RSpec
       #
       def add_stub_and_should_receive_to(*modules)
         modules.each do |mod|
-          mod.__send__(:include, RSpec::Mocks::Methods)
+          Syntax.enable_should(mod)
         end
       end
+
+      def syntax=(values)
+        if Array(values).include?(:expect)
+          Syntax.enable_expect
+        else
+          Syntax.disable_expect
+        end
+
+        if Array(values).include?(:should)
+          Syntax.enable_should
+        else
+          Syntax.disable_should
+        end
+      end
+
+      def syntax
+        syntaxes = []
+        syntaxes << :should  if Syntax.should_enabled?
+        syntaxes << :expect if Syntax.expect_enabled?
+        syntaxes
+      end
     end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    configuration.syntax = [:should, :expect]
   end
 end
 

data/lib/rspec/mocks/deprecation.rb

@@ -0,0 +1,18 @@
+module RSpec
+  module Mocks
+    module Deprecation
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def deprecate(deprecated, options={})
+        message = "DEPRECATION: #{deprecated} is deprecated."
+        message << " Use #{options[:replacement]} instead." if options[:replacement]
+        message << " Called from #{caller(0)[2]}."
+        warn message
+      end
+    end
+  end
+
+  extend(Mocks::Deprecation) unless respond_to?(:deprecate)
+end
+

data/lib/rspec/mocks/error_generator.rb

@@ -23,27 +23,59 @@ module RSpec
       # @private
       def raise_unexpected_message_args_error(expectation, *args)
         expected_args = format_args(*expectation.expected_args)
-        actual_args = format_args(*args)
+        actual_args = format_received_args(*args)
         __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
       end
 
       # @private
       def raise_missing_default_stub_error(expectation, *args)
         expected_args = format_args(*expectation.expected_args)
-        actual_args = format_args(*args)
+        actual_args = format_received_args(*args)
         __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}\n Please stub a default value first if message might be received with other args as well. \n"
       end
 
       # @private
       def raise_similar_message_args_error(expectation, *args_for_multiple_calls)
         expected_args = format_args(*expectation.expected_args)
-        actual_args = args_for_multiple_calls.collect {|a| format_args(*a)}.join(", ")
+        actual_args = args_for_multiple_calls.collect {|a| format_received_args(*a)}.join(", ")
         __raise "#{intro} received #{expectation.message.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
       end
 
       # @private
-      def raise_expectation_error(message, expected_received_count, actual_received_count, *args)
-        __raise "(#{intro}).#{message}#{format_args(*args)}\n    expected: #{count_message(expected_received_count)}\n    received: #{count_message(actual_received_count)}"
+      def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, *args)
+        expected_part = expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        received_part = received_part_of_expectation_error(actual_received_count, *args)
+        __raise "(#{intro}).#{message}#{format_args(*args)}\n    #{expected_part}\n    #{received_part}"
+      end
+
+      # @private
+      def received_part_of_expectation_error(actual_received_count, *args)
+        "received: #{count_message(actual_received_count)}" +
+          method_call_args_description(args)
+      end
+
+      # @private
+      def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher)
+        "expected: #{count_message(expected_received_count, expectation_count_type)}" +
+          method_call_args_description(argument_list_matcher.expected_args)
+      end
+
+      # @private
+      def method_call_args_description(args)
+        if args.first.is_a?(ArgumentMatchers::AnyArgsMatcher)
+          " with any arguments"
+        elsif args.first.is_a?(ArgumentMatchers::NoArgsMatcher)
+          " with no arguments"
+        elsif args.length > 0
+          " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
+        else
+          ""
+        end
+      end
+
+      # @private
+      def describe_expectation(message, expected_received_count, actual_received_count, *args)
+        "have received #{message}#{format_args(*args)} #{count_message(expected_received_count)}"
       end
 
       # @private
@@ -72,6 +104,18 @@ module RSpec
                 "available on a partial mock object."
       end
 
+      # @private
+      def raise_expectation_on_unstubbed_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has not been stubbed."
+      end
+
+      # @private
+      def raise_expectation_on_mocked_method(method)
+        __raise "#{intro} expected to have received #{method}, but that " +
+                "method has been mocked instead of stubbed."
+      end
+
       private
 
       def intro
@@ -105,8 +149,17 @@ module RSpec
         args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
       end
 
-      def count_message(count)
-        return "at least #{pretty_print(count.abs)}" if count < 0
+      def format_received_args(*args)
+        args.empty? ? "(no args)" : "(" + received_arg_list(*args) + ")"
+      end
+
+      def received_arg_list(*args)
+        args.collect(&:inspect).join(", ")
+      end
+
+      def count_message(count, expectation_count_type=nil)
+        return "at least #{pretty_print(count.abs)}" if count < 0 || expectation_count_type == :at_least
+        return "at most #{pretty_print(count)}" if expectation_count_type == :at_most
         return pretty_print(count)
       end
 
@@ -117,4 +170,3 @@ module RSpec
     end
   end
 end
-

data/lib/rspec/mocks/errors.rb

@@ -3,7 +3,7 @@ module RSpec
     # @private
     class MockExpectationError < Exception
     end
-    
+
     # @private
     class AmbiguousReturnError < StandardError
     end

data/lib/rspec/mocks/example_methods.rb

@@ -31,13 +31,15 @@ module RSpec
         declare_double('Double', *args)
       end
 
-      # Effectively an alias for [double](#double-instance_method).
+      # Deprecated: Use [double](#double-instance_method).
       def mock(*args)
+        RSpec.deprecate "mock", :replacement => "double"
         declare_double('Mock', *args)
       end
 
-      # Effectively an alias for [double](#double-instance_method).
+      # Deprecated: Use [double](#double-instance_method).
       def stub(*args)
+        RSpec.deprecate "stub", :replacement => "double"
         declare_double('Stub', *args)
       end
 
@@ -47,7 +49,7 @@ module RSpec
       # nil.  This is to prevent false-positives and to catch potential bugs
       # early on.
       def allow_message_expectations_on_nil
-        Proxy.allow_message_expectations_on_nil
+        RSpec::Mocks.space.proxy_for(nil).warn_about_expectations = false
       end
 
       # Stubs the named constant with the given value.
@@ -107,6 +109,36 @@ module RSpec
         ConstantMutator.hide(constant_name)
       end
 
+      # Verifies that the given object received the expected message during the
+      # course of the test. The method must have previously been stubbed in
+      # order for messages to be verified.
+      #
+      # Stubbing and verifying messages received in this way implements the
+      # Test Spy pattern.
+      #
+      # @param method_name [Symbol] name of the method expected to have been
+      #   called.
+      #
+      # @example
+      #
+      #   invitation = double('invitation', accept: true)
+      #   user.accept_invitation(invitation)
+      #   expect(invitation).to have_received(:accept)
+      #
+      #   # You can also use most message expectations:
+      #   expect(invitation).to have_received(:accept).with(mailer).once
+      def have_received(method_name)
+        Matchers::HaveReceived.new(method_name)
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          # This gets mixed in so that if `RSpec::Matchers` is included in
+          # `klass` later, it's definition of `expect` will take precedence.
+          include ExpectHost unless method_defined?(:expect)
+        end
+      end
+
     private
 
       def declare_double(declared_as, *args)
@@ -115,6 +147,10 @@ module RSpec
         RSpec::Mocks::Mock.new(*args)
       end
 
+      # This module exists to host the `expect` method for cases where
+      # rspec-mocks is used w/o rspec-expectations.
+      module ExpectHost
+      end
     end
   end
 end

data/lib/rspec/mocks/extensions/marshal.rb

@@ -2,18 +2,12 @@ module Marshal
   class << self
     def dump_with_mocks(*args)
       object = args.shift
-      return dump_without_mocks(*args.unshift(object)) unless object.instance_variable_defined?(:@mock_proxy)
 
-      mp = object.instance_variable_get(:@mock_proxy)
-      return dump_without_mocks(*args.unshift(object)) unless mp.is_a?(::RSpec::Mocks::Proxy)
-
-      object.__send__(:remove_instance_variable, :@mock_proxy)
-
-      begin
-        dump_without_mocks(*args.unshift(object.dup))
-      ensure
-        object.instance_variable_set(:@mock_proxy,mp)
+      if ( ::RSpec::Mocks.space && !::RSpec::Mocks.space.registered?(object) ) || NilClass === object
+        return dump_without_mocks(*args.unshift(object))
       end
+
+      dump_without_mocks(*args.unshift(object.dup))
     end
 
     alias_method :dump_without_mocks, :dump

data/lib/rspec/mocks/framework.rb

@@ -2,13 +2,14 @@
 # supports wrapping rspec's mocking functionality without invading every
 # object in the system.
 
-require 'rspec/mocks/configuration'
+require 'rspec/mocks/deprecation'
 require 'rspec/mocks/extensions/instance_exec'
 require 'rspec/mocks/instance_method_stasher'
 require 'rspec/mocks/method_double'
-require 'rspec/mocks/methods'
 require 'rspec/mocks/argument_matchers'
+require 'rspec/mocks/example_methods'
 require 'rspec/mocks/proxy'
+require 'rspec/mocks/proxy_for_nil'
 require 'rspec/mocks/test_double'
 require 'rspec/mocks/mock'
 require 'rspec/mocks/argument_list_matcher'
@@ -17,6 +18,17 @@ require 'rspec/mocks/order_group'
 require 'rspec/mocks/errors'
 require 'rspec/mocks/error_generator'
 require 'rspec/mocks/space'
-require 'rspec/mocks/serialization'
-require 'rspec/mocks/any_instance'
+require 'rspec/mocks/extensions/marshal'
+require 'rspec/mocks/any_instance/chain'
+require 'rspec/mocks/any_instance/stub_chain'
+require 'rspec/mocks/any_instance/stub_chain_chain'
+require 'rspec/mocks/any_instance/expectation_chain'
+require 'rspec/mocks/any_instance/message_chains'
+require 'rspec/mocks/any_instance/recorder'
 require 'rspec/mocks/mutate_const'
+require 'rspec/mocks/matchers/have_received'
+require 'rspec/mocks/matchers/receive'
+require 'rspec/mocks/stub_chain'
+require 'rspec/mocks/targets'
+require 'rspec/mocks/syntax'
+require 'rspec/mocks/configuration'

data/lib/rspec/mocks/instance_method_stasher.rb

@@ -75,6 +75,9 @@ module RSpec
       def restore
         return unless @method_is_stashed
 
+        if @klass.__send__(:method_defined?, @method)
+          @klass.__send__(:undef_method, @method)
+        end
         @klass.__send__(:alias_method, @method, stashed_method_name)
         @klass.__send__(:remove_method, stashed_method_name)
         @method_is_stashed = false

data/lib/rspec/mocks/matchers/have_received.rb

@@ -0,0 +1,93 @@
+module RSpec
+  module Mocks
+    module Matchers
+      class HaveReceived
+        COUNT_CONSTRAINTS = %w(exactly at_least at_most times once twice)
+        ARGS_CONSTRAINTS = %w(with)
+        CONSTRAINTS = COUNT_CONSTRAINTS + ARGS_CONSTRAINTS
+
+        def initialize(method_name)
+          @method_name = method_name
+          @constraints = []
+          @subject = nil
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @expectation = expect
+          expected_messages_received?
+        end
+
+        def does_not_match?(subject)
+          @subject = subject
+          ensure_count_unconstrained
+          @expectation = expect.never
+          expected_messages_received?
+        end
+
+        def failure_message
+          generate_failure_message
+        end
+
+        def negative_failure_message
+          generate_failure_message
+        end
+
+        def description
+          expect.description
+        end
+
+        CONSTRAINTS.each do |expectation|
+          define_method expectation do |*args|
+            @constraints << [expectation, *args]
+            self
+          end
+        end
+
+        private
+
+        def expect
+          expectation = mock_proxy.build_expectation(@method_name)
+          apply_constraints_to expectation
+          expectation
+        end
+
+        def apply_constraints_to(expectation)
+          @constraints.each do |constraint|
+            expectation.send(*constraint)
+          end
+        end
+
+        def ensure_count_unconstrained
+          if count_constraint
+            raise RSpec::Mocks::MockExpectationError,
+              "can't use #{count_constraint} when negative"
+          end
+        end
+
+        def count_constraint
+          @constraints.map(&:first).detect do |constraint|
+            COUNT_CONSTRAINTS.include?(constraint)
+          end
+        end
+
+        def generate_failure_message
+          mock_proxy.check_for_unexpected_arguments(@expectation)
+          @expectation.generate_error
+        rescue RSpec::Mocks::MockExpectationError => error
+          error.message
+        end
+
+        def expected_messages_received?
+          mock_proxy.replay_received_message_on @expectation
+          @expectation.expected_messages_received?
+        end
+
+        def mock_proxy
+          RSpec::Mocks.proxy_for(@subject)
+        end
+      end
+    end
+  end
+end
+