rspec-mocks 2.11.3 → 3.11.1

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

@@ -3,35 +3,49 @@ module RSpec
     module AnyInstance
       # @private
       class StubChain < Chain
-
-        # @private
-        def initialize(*args, &block)
-          record(:stub, *args, &block)
-        end
-
         # @private
         def expectation_fulfilled?
           true
         end
 
-        private
+      private
+
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.space.proxy_for(instance)
+          method_name, opts = @expectation_args
+          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
+
+          stub = proxy.add_stub(method_name, opts, &@expectation_block)
+          @recorder.stubs[stub.message] << stub
+
+          if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
+            stub.and_yield_receiver_to_implementation
+          end
+
+          stub
+        end
+
+        InvocationOrder =
+          {
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil],
+            :and_yield => [:with, :and_yield, nil],
+            :and_throw => [:with, nil],
+            :and_call_original => [:with, nil],
+            :and_wrap_original => [:with, nil]
+          }.freeze
+
+        EmptyInvocationOrder = {}.freeze
 
         def invocation_order
-          @invocation_order ||= {
-            :stub => [nil],
-            :with => [:stub],
-            :and_return => [:with, :stub],
-            :and_raise => [:with, :stub],
-            :and_yield => [:with, :stub]
-          }
+          InvocationOrder
         end
 
-        def verify_invocation_order(rspec_method_name, *args, &block)
-          unless invocation_order[rspec_method_name].include?(last_message)
-            raise(NoMethodError, "Undefined method #{rspec_method_name}")
-          end
+        def verify_invocation_order(rspec_method_name, *_args, &_block)
+          return if invocation_order.fetch(rspec_method_name, [nil]).include?(last_message)
+          raise NoMethodError, "Undefined method #{rspec_method_name}"
         end
       end
     end
   end
-end
+end

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

@@ -3,23 +3,21 @@ module RSpec
     module AnyInstance
       # @private
       class StubChainChain < StubChain
-
-        # @private
-        def initialize(*args, &block)
-          record(:stub_chain, *args, &block)
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
         end
 
-        private
+      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]
-          }
+          EmptyInvocationOrder
         end
       end
     end
   end
-end
+end

data/lib/rspec/mocks/any_instance.rb

@@ -1,81 +1,11 @@
-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'
-
-module RSpec
-  module Mocks
-    module AnyInstance
-      # Used to set stubs and message expectations on any instance of a given
-      # class. Returns a [Recorder](Recorder), which records messages like
-      # `stub` and `should_receive` for later playback on instances of the
-      # class.
-      #
-      # @example
-      #
-      #     Car.any_instance.should_receive(:go)
-      #     race = Race.new
-      #     race.cars << Car.new
-      #     race.go # assuming this delegates to all of its cars
-      #             # this example would pass
-      #
-      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
-      #     Account.new.balance # => Money.new(:USD, 25))
-      #
-      # @return [Recorder]
-      def any_instance
-        RSpec::Mocks::space.add(self)
-        modify_dup_to_remove_mock_proxy_when_invoked
-        __recorder
-      end
-      
-      # @private
-      def rspec_verify
-        __recorder.verify
-        super
-      ensure
-        __recorder.stop_all_observation!
-        restore_dup
-        @__recorder = nil
-      end
-      
-      # @private
-      def rspec_reset
-        restore_dup
-        __mock_proxy.reset
-      end
-      
-      # @private
-      def __recorder
-        @__recorder ||= AnyInstance::Recorder.new(self)
-      end
-      
-      private
-      def modify_dup_to_remove_mock_proxy_when_invoked
-        if self.method_defined?(:dup) and !self.method_defined?(:__rspec_original_dup)
-          self.class_eval do
-            def __rspec_dup
-              __remove_mock_proxy
-              __rspec_original_dup
-            end
-            
-            alias_method  :__rspec_original_dup, :dup
-            alias_method  :dup, :__rspec_dup
-          end
-        end
-      end
-      
-      def restore_dup
-        if self.method_defined?(:__rspec_original_dup)
-          self.class_eval do
-            alias_method  :dup, :__rspec_original_dup
-            remove_method :__rspec_original_dup
-            remove_method :__rspec_dup
-          end
-        end
-      end
-    end
-  end
-end
+%w[
+  any_instance/chain
+  any_instance/error_generator
+  any_instance/stub_chain
+  any_instance/stub_chain_chain
+  any_instance/expect_chain_chain
+  any_instance/expectation_chain
+  any_instance/message_chains
+  any_instance/recorder
+  any_instance/proxy
+].each { |f| RSpec::Support.require_rspec_mocks(f) }

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -1,17 +1,21 @@
+# We intentionally do not use the `RSpec::Support.require...` methods
+# here so that this file can be loaded individually, as documented
+# below.
 require 'rspec/mocks/argument_matchers'
+require 'rspec/support/fuzzy_matcher'
 
 module RSpec
   module Mocks
     # Wrapper for matching arguments against a list of expected values. Used by
     # the `with` method on a `MessageExpectation`:
     #
-    #     object.should_receive(:message).with(:a, 'b', 3)
+    #     expect(object).to receive(:message).with(:a, 'b', 3)
     #     object.message(:a, 'b', 3)
     #
     # Values passed to `with` can be literal values or argument matchers that
     # match against the real objects .e.g.
     #
-    #     object.should_receive(:message).with(hash_including(:a => 'b'))
+    #     expect(object).to receive(:message).with(hash_including(:a => 'b'))
     #
     # Can also be used directly to match the contents of any `Array`. This
     # enables 3rd party mocking libs to take advantage of rspec's argument
@@ -23,71 +27,89 @@ module RSpec
     #     arg_list_matcher = RSpec::Mocks::ArgumentListMatcher.new(123, hash_including(:a => 'b'))
     #     arg_list_matcher.args_match?(123, :a => 'b')
     #
+    # This class is immutable.
+    #
     # @see ArgumentMatchers
     class ArgumentListMatcher
       # @private
       attr_reader :expected_args
 
       # @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 [Array] expected_args a list of expected literals and/or argument matchers
       #
       # Initializes an `ArgumentListMatcher` with a collection of literal
-      # values and/or argument matchers, or a block that handles the evaluation
-      # for you.
+      # values and/or argument matchers.
       #
       # @see ArgumentMatchers
       # @see #args_match?
-      def initialize(*expected_args, &block)
+      def initialize(*expected_args)
         @expected_args = expected_args
-        @block = expected_args.empty? ? block : nil
-        @match_any_args = false
-        @matchers = nil
-
-        case expected_args.first
-        when ArgumentMatchers::AnyArgsMatcher
-          @match_any_args = true
-        when ArgumentMatchers::NoArgsMatcher
-          @matchers = []
-        else
-          @matchers = expected_args.collect {|arg| matcher_for(arg)}
-        end
+        ensure_expected_args_valid!
       end
+      ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
       # @api public
-      # @param [Array] *args
+      # @param [Array] actual_args
       #
       # Matches each element in the `expected_args` against the element in the same
       # position of the arguments passed to `new`.
       #
       # @see #initialize
-      def args_match?(*args)
-        match_any_args? || block_passes?(*args) || matchers_match?(*args)
-      end
+      def args_match?(*actual_args)
+        expected_args = resolve_expected_args_based_on(actual_args)
 
-      private
+        return false if expected_args.size != actual_args.size
 
-      def matcher_for(arg)
-        return ArgumentMatchers::MatcherMatcher.new(arg) if is_matcher?(arg)
-        return ArgumentMatchers::RegexpMatcher.new(arg)  if arg.is_a?(Regexp)
-        return ArgumentMatchers::EqualityProxy.new(arg)
-      end
+        if RUBY_VERSION >= "3"
+          # if both arguments end with Hashes, and if one is a keyword hash and the other is not, they don't match
+          if Hash === expected_args.last && Hash === actual_args.last
+            if !Hash.ruby2_keywords_hash?(actual_args.last) && Hash.ruby2_keywords_hash?(expected_args.last)
+              return false
+            end
+          end
+        end
 
-      def is_matcher?(obj)
-        !obj.null_object? & obj.respond_to?(:matches?) & [:failure_message_for_should, :failure_message].any? { |m| obj.respond_to?(m) }
+        Support::FuzzyMatcher.values_match?(expected_args, actual_args)
       end
+      ruby2_keywords :args_match? if respond_to?(:ruby2_keywords, true)
+
+      # @private
+      # Resolves abstract arg placeholders like `no_args` and `any_args` into
+      # a more concrete arg list based on the provided `actual_args`.
+      def resolve_expected_args_based_on(actual_args)
+        return [] if [ArgumentMatchers::NoArgsMatcher::INSTANCE] == expected_args
 
-      def block_passes?(*args)
-        @block.call(*args) if @block
+        any_args_index = expected_args.index { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a }
+        return expected_args unless any_args_index
+
+        replace_any_args_with_splat_of_anything(any_args_index, actual_args.count)
       end
 
-      def matchers_match?(*args)
-        @matchers == args
+    private
+
+      def replace_any_args_with_splat_of_anything(before_count, actual_args_count)
+        any_args_count  = actual_args_count   - expected_args.count + 1
+        after_count     = expected_args.count - before_count        - 1
+
+        any_args = 1.upto(any_args_count).map { ArgumentMatchers::AnyArgMatcher::INSTANCE }
+        expected_args.first(before_count) + any_args + expected_args.last(after_count)
       end
 
-      def match_any_args?
-        @match_any_args
+      def ensure_expected_args_valid!
+        if expected_args.count { |a| ArgumentMatchers::AnyArgsMatcher::INSTANCE == a } > 1
+          raise ArgumentError, "`any_args` can only be passed to " \
+                "`with` once but you have passed it multiple times."
+        elsif expected_args.count > 1 && expected_args.any? { |a| ArgumentMatchers::NoArgsMatcher::INSTANCE == a }
+          raise ArgumentError, "`no_args` can only be passed as a " \
+                "singleton argument to `with` (i.e. `with(no_args)`), " \
+                "but you have passed additional arguments."
+        end
       end
+
+      # Value that will match all argument lists.
+      #
+      # @private
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher::INSTANCE)
     end
   end
 end