rspec-mocks 2.99.4 → 3.0.0.beta1

data/lib/rspec/mocks/stub_chain.rb

@@ -19,7 +19,7 @@ module RSpec
             chain.shift
             matching_stub.invoke(nil).stub_chain(*chain, &block)
           else
-            next_in_chain = Double.new
+            next_in_chain = Mock.new
             object.stub(chain.shift) { next_in_chain }
             StubChain.stub_chain_on(next_in_chain, *chain, &block)
           end
@@ -35,7 +35,7 @@ module RSpec
           hash = chain.pop
           hash.each do |k,v|
             chain << k
-            blk = Proc.new { v }
+            blk = lambda { v }
           end
         end
         return chain.join('.').split('.'), blk

data/lib/rspec/mocks/syntax.rb

@@ -5,75 +5,81 @@ module RSpec
     # provided by rspec-mocks.
     module Syntax
       # @api private
-      #
-      # Common stubbing logic for both `stub` and `stub!`. This used to
-      # live in `stub`, and `stub!` delegated to `stub`, but we discovered
-      # that `stub!` was delegating to `RSpec::Mocks::ExampleMethods#stub`
-      # (which declares a test double) when called with an implicit receiver,
-      # which was a regression in 2.14.0.
-      def self.stub_object(object, message_or_hash, opts = {}, &block)
-        if ::Hash === message_or_hash
-          message_or_hash.each {|message, value| stub_object(object, message).and_return value }
-        else
-          opts[:expected_from] = CallerFilter.first_non_rspec_line
-          ::RSpec::Mocks.allow_message(object, message_or_hash, opts, &block)
+      def self.warn_about_should!
+        @warn_about_should = true
+      end
+
+      # @api private
+      def self.warn_unless_should_configured(method_name)
+        if @warn_about_should
+          RSpec.deprecate(
+            "Using `#{method_name}` from rspec-mocks' old `:should` syntax without explicitly enabling the syntax",
+            :replacement => "the new `:expect` syntax or explicitly enable `:should`"
+          )
+
+          @warn_about_should = false
         end
       end
 
       # @api private
       # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
       def self.enable_should(syntax_host = default_should_syntax_host)
+        @warn_about_should = false
         return if should_enabled?(syntax_host)
 
-        syntax_host.class_eval do
+        syntax_host.class_exec do
           def should_receive(message, opts={}, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             opts[:expected_from] ||= CallerFilter.first_non_rspec_line
-            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block)
+            ::RSpec::Mocks.expect_message(self, message, opts, &block)
           end
 
           def should_not_receive(message, &block)
-            opts = { :expected_from => CallerFilter.first_non_rspec_line }
-            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block).never
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            opts = {:expected_from => CallerFilter.first_non_rspec_line}
+            ::RSpec::Mocks.expect_message(self, message, opts, &block).never
           end
 
           def stub(message_or_hash, opts={}, &block)
-            ::RSpec::Mocks::Syntax.stub_object(self, message_or_hash, opts, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            if ::Hash === message_or_hash
+              message_or_hash.each {|message, value| stub(message).and_return value }
+            else
+              opts[:expected_from] = CallerFilter.first_non_rspec_line
+              ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
+            end
           end
 
           def unstub(message)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
           end
 
-          def stub!(message_or_hash, opts={}, &block)
-            ::RSpec.deprecate "stub!", :replacement => "stub"
-            ::RSpec::Mocks::Syntax.stub_object(self, message_or_hash, opts, &block)
-          end
-
-          def unstub!(message)
-            ::RSpec.deprecate "unstub!", :replacement => "unstub"
-            unstub(message)
-          end
-
           def stub_chain(*chain, &blk)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
           end
 
           def as_null_object
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             @_null_object = true
             ::RSpec::Mocks.proxy_for(self).as_null_object
           end
 
           def null_object?
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             defined?(@_null_object)
           end
 
           def received_message?(message, *args, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             ::RSpec::Mocks.proxy_for(self).received_message?(message, *args, &block)
           end
 
           unless Class.respond_to? :any_instance
-            Class.class_eval do
+            Class.class_exec do
               def any_instance
+                ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
                 ::RSpec::Mocks.any_instance_recorder_for(self)
               end
             end
@@ -86,20 +92,18 @@ module RSpec
       def self.disable_should(syntax_host = default_should_syntax_host)
         return unless should_enabled?(syntax_host)
 
-        syntax_host.class_eval do
+        syntax_host.class_exec do
           undef should_receive
           undef should_not_receive
           undef stub
           undef unstub
-          undef stub!
-          undef unstub!
           undef stub_chain
           undef as_null_object
           undef null_object?
           undef received_message?
         end
 
-        Class.class_eval do
+        Class.class_exec do
           undef any_instance
         end
       end
@@ -109,11 +113,17 @@ module RSpec
       def self.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
         return if expect_enabled?(syntax_host)
 
-        syntax_host.class_eval do
+        syntax_host.class_exec do
           def receive(method_name, &block)
             Matchers::Receive.new(method_name, block)
           end
 
+          def receive_messages(message_return_value_hash)
+            matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
+            matcher.warn_about_block if block_given?
+            matcher
+          end
+
           def allow(target)
             AllowanceTarget.new(target)
           end
@@ -127,7 +137,7 @@ module RSpec
           end
         end
 
-        RSpec::Mocks::ExampleMethods::ExpectHost.class_eval do
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
           def expect(target)
             ExpectationTarget.new(target)
           end
@@ -139,14 +149,15 @@ module RSpec
       def self.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
         return unless expect_enabled?(syntax_host)
 
-        syntax_host.class_eval do
+        syntax_host.class_exec do
           undef receive
+          undef receive_messages
           undef allow
           undef expect_any_instance_of
           undef allow_any_instance_of
         end
 
-        RSpec::Mocks::ExampleMethods::ExpectHost.class_eval do
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
           undef expect
         end
       end
@@ -343,6 +354,20 @@ module RSpec
       #   expect(obj).to receive(:hello).with("world").exactly(3).times
       #
       # @note This is only available when you have enabled the `expect` syntax.
+      #
+      # @method receive_messages
+      # Shorthand syntax used to setup message(s), and their return value(s),
+      # that you expect or allow an object to receive. The method takes a hash
+      # of messages and their respective return values. Unlike with `receive`,
+      # you cannot apply further customizations using a block or the fluent
+      # interface.
+      #
+      # @example
+      #
+      #   allow(obj).to receive_messages(:speak => "Hello World")
+      #   allow(obj).to receive_messages(:speak => "Hello", :meow => "Meow")
+      #
+      # @note This is only available when you have enabled the `expect` syntax.
     end
   end
 end

data/lib/rspec/mocks/targets.rb

@@ -8,30 +8,51 @@ module RSpec
         @target = target
       end
 
-      def self.delegate_to(matcher_method, options = {})
-        method_name = options.fetch(:from) { :to }
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def #{method_name}(matcher, &block)
-          unless Matchers::Receive === matcher
-            raise UnsupportedMatcherError, "only the `receive` matcher is supported " +
-              "with `\#{expression}(...).\#{#{method_name.inspect}}`, but you have provided: \#{matcher}"
+      def self.delegate_to(matcher_method)
+        define_method(:to) do |matcher, &block|
+          unless Matchers::Receive === matcher || Matchers::ReceiveMessages === matcher
+            raise_unsupported_matcher(:to, matcher)
           end
+          define_matcher(matcher, matcher_method, &block)
+        end
+      end
 
-          matcher.__send__(#{matcher_method.inspect}, @target, &block)
+      def self.delegate_not_to(matcher_method, options = {})
+        method_name = options.fetch(:from)
+        define_method(method_name) do |matcher, &block|
+          case matcher
+          when Matchers::Receive         then define_matcher(matcher, matcher_method, &block)
+          when Matchers::ReceiveMessages then raise_negation_unsupported(method_name, matcher)
+          else
+            raise_unsupported_matcher(method_name, matcher)
+          end
         end
-        RUBY
       end
 
-      def self.disallow_negation(method)
-        define_method method do |*args|
-          raise NegationUnsupportedError,
-            "`#{expression}(...).#{method} receive` is not supported since it " +
-            "doesn't really make sense. What would it even mean?"
+      def self.disallow_negation(method_name)
+        define_method(method_name) do |matcher, *args|
+          raise_negation_unsupported(method_name, matcher)
         end
       end
 
     private
 
+      def define_matcher(matcher, name, &block)
+        matcher.__send__(name, @target, &block)
+      end
+
+      def raise_unsupported_matcher(method_name, matcher)
+        raise UnsupportedMatcherError,
+          "only the `receive` or `receive_messages` matchers are supported " +
+          "with `#{expression}(...).#{method_name}`, but you have provided: #{matcher}"
+      end
+
+      def raise_negation_unsupported(method_name, matcher)
+        raise NegationUnsupportedError,
+          "`#{expression}(...).#{method_name} #{matcher.name}` is not supported since it " +
+          "doesn't really make sense. What would it even mean?"
+      end
+
       def expression
         self.class::EXPRESSION
       end
@@ -47,12 +68,12 @@ module RSpec
     class ExpectationTarget < TargetBase
       EXPRESSION = :expect
       delegate_to :setup_expectation
-      delegate_to :setup_negative_expectation, :from => :not_to
-      delegate_to :setup_negative_expectation, :from => :to_not
+      delegate_not_to :setup_negative_expectation, :from => :not_to
+      delegate_not_to :setup_negative_expectation, :from => :to_not
     end
 
     class AnyInstanceAllowanceTarget < TargetBase
-      EXPRESSION = :expect_any_instance_of
+      EXPRESSION = :allow_any_instance_of
       delegate_to :setup_any_instance_allowance
       disallow_negation :not_to
       disallow_negation :to_not
@@ -61,8 +82,8 @@ module RSpec
     class AnyInstanceExpectationTarget < TargetBase
       EXPRESSION = :expect_any_instance_of
       delegate_to :setup_any_instance_expectation
-      delegate_to :setup_any_instance_negative_expectation, :from => :not_to
-      delegate_to :setup_any_instance_negative_expectation, :from => :to_not
+      delegate_not_to :setup_any_instance_negative_expectation, :from => :not_to
+      delegate_not_to :setup_any_instance_negative_expectation, :from => :to_not
     end
   end
 end

data/lib/rspec/mocks/test_double.rb

@@ -12,16 +12,15 @@ module RSpec
       #   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={})
-        RSpec.deprecate("`RSpec::Mocks::TestDouble.extend_onto(...)`")
+      def self.extend_onto(object, name=nil, stubs={})
         object.extend self
-        object.send(:__initialize_as_test_double, name, stubs_and_options)
+        object.send(:__initialize_as_test_double, name, stubs)
       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)
+      def initialize(name=nil, stubs={})
+        __initialize_as_test_double(name, stubs)
       end
 
       # Tells the object to respond to all messages. If specific stub values
@@ -29,14 +28,11 @@ module RSpec
       # returned.
       def as_null_object
         __mock_proxy.as_null_object
-        @__null_object = true
-        self
       end
 
       # Returns true if this object has received `as_null_object`
       def null_object?
-        __warn_of_expired_use_if_expired
-        @__null_object
+        __mock_proxy.null_object?
       end
 
       # This allows for comparing the mock to other objects that proxy such as
@@ -64,37 +60,21 @@ module RSpec
         __mock_proxy.null_object? ? true : super
       end
 
-      def freeze
-        RSpec.deprecate 'Freezing a test double'
-        super
-      end
-
       # @private
-      def __build_mock_proxy
-        proxy = TestDoubleProxy.new(self, @name, @options || {})
-        __warn_of_expired_use_if_expired
-        proxy.as_null_object if @__null_object
-        proxy
-      end
-
-      def __warn_if_used_further!
-        @__unfrozen_attributes[:expired] = true
+      def __build_mock_proxy(order_group)
+        Proxy.new(self, order_group, @name)
       end
 
     private
 
-      def __initialize_as_test_double(name=nil, stubs_and_options={})
-        @__null_object = false
-        @__unfrozen_attributes = {}
-
-        if name.is_a?(Hash) && stubs_and_options.empty?
-          stubs_and_options = name
+      def __initialize_as_test_double(name=nil, stubs={})
+        if Hash === name && stubs.empty?
+          stubs = name
           @name = nil
         else
           @name = name
         end
-        @options = extract_options(stubs_and_options)
-        assign_stubs(stubs_and_options)
+        assign_stubs(stubs)
       end
 
       def method_missing(message, *args, &block)
@@ -115,33 +95,9 @@ module RSpec
         end
       end
 
-      def extract_options(stubs_and_options)
-        if stubs_and_options[:null_object]
-          @null_object = stubs_and_options.delete(:null_object)
-          RSpec.deprecate("double('name', :null_object => true)", :replacement => "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|
-          Mocks.allow_message(self, message).and_return(response)
-        end
-      end
-
-      def __warn_of_expired_use_if_expired
-        if @__unfrozen_attributes && @__unfrozen_attributes[:expired]
-          RSpec.deprecate "Continuing to use a test double after it has been reset (e.g. in a subsequent example)"
+          __mock_proxy.add_simple_stub(message, response)
         end
       end
 

data/lib/rspec/mocks/verifying_double.rb

@@ -0,0 +1,77 @@
+require 'rspec/mocks/mock'
+require 'rspec/mocks/verifying_proxy'
+
+module RSpec
+  module Mocks
+
+    module VerifyingDouble
+      def method_missing(message, *args, &block)
+        # Null object conditional is an optimization. If not a null object,
+        # validity of method expectations will have been checked at definition
+        # time.
+        __mock_proxy.ensure_implemented(message) if null_object?
+        super
+      end
+    end
+
+    # A mock providing a custom proxy that can verify the validity of any
+    # method stubs or expectations against the public instance methods of the
+    # given class.
+    class InstanceVerifyingDouble
+      include TestDouble
+      include VerifyingDouble
+
+      def initialize(doubled_module, *args)
+        @doubled_module = doubled_module
+
+        __initialize_as_test_double(doubled_module, *args)
+      end
+
+      def __build_mock_proxy(order_group)
+        VerifyingProxy.new(self, order_group,
+          @doubled_module,
+          InstanceMethodReference
+        )
+      end
+    end
+
+    # An awkward module necessary because we cannot otherwise have
+    # ClassVerifyingDouble inherit from Module and still share these methods.
+    module ObjectVerifyingDoubleMethods
+      include TestDouble
+      include VerifyingDouble
+
+      def initialize(doubled_module, *args)
+        @doubled_module = doubled_module
+
+        __initialize_as_test_double(doubled_module, *args)
+      end
+
+      def __build_mock_proxy(order_group)
+        VerifyingProxy.new(self, order_group,
+          @doubled_module,
+          ObjectMethodReference
+        )
+      end
+
+      def as_stubbed_const(options = {})
+        ConstantMutator.stub(@doubled_module.const_to_replace, self, options)
+        self
+      end
+    end
+
+    # Similar to an InstanceVerifyingDouble, except that it verifies against
+    # public methods of the given object.
+    class ObjectVerifyingDouble
+      include ObjectVerifyingDoubleMethods
+    end
+
+    # Effectively the same as an ObjectVerifyingDouble (since a class is a type
+    # of object), except with Module in the inheritance chain so that
+    # transferring nested constants to work.
+    class ClassVerifyingDouble < Module
+      include ObjectVerifyingDoubleMethods
+    end
+
+  end
+end