rspec-mocks 3.0.4 → 3.12.6

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

@@ -3,7 +3,6 @@ module RSpec
     module AnyInstance
       # @private
       class StubChain < Chain
-
         # @private
         def expectation_fulfilled?
           true
@@ -26,20 +25,25 @@ module RSpec
           stub
         end
 
-        def invocation_order
-          @invocation_order ||= {
-            :with => [nil],
+        InvocationOrder =
+          {
             :and_return => [:with, nil],
             :and_raise => [:with, nil],
-            :and_yield => [:with, nil],
-            :and_call_original => [: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
+          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

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

@@ -15,11 +15,7 @@ module RSpec
         end
 
         def invocation_order
-          @invocation_order ||= {
-            :and_return => [nil],
-            :and_raise => [nil],
-            :and_yield => [nil]
-          }
+          EmptyInvocationOrder
         end
       end
     end

data/lib/rspec/mocks/any_instance.rb

@@ -1,5 +1,6 @@
 %w[
   any_instance/chain
+  any_instance/error_generator
   any_instance/stub_chain
   any_instance/stub_chain_chain
   any_instance/expect_chain_chain

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -44,29 +44,74 @@ module RSpec
       # @see #args_match?
       def initialize(*expected_args)
         @expected_args = expected_args
-
-        @matchers = case expected_args.first
-          when ArgumentMatchers::AnyArgsMatcher then Array
-          when ArgumentMatchers::NoArgsMatcher  then []
-          else expected_args
-        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)
-        Support::FuzzyMatcher.values_match?(@matchers, args)
+      def args_match?(*actual_args)
+        expected_args = resolve_expected_args_based_on(actual_args)
+
+        return false if expected_args.size != actual_args.size
+
+        if RUBY_VERSION >= "3"
+          # If the expectation was set with keywords, while the actual method was called with a positional hash argument, they don't match.
+          # If the expectation was set without keywords, e.g., with({a: 1}), then it fine to call it with either foo(a: 1) or foo({a: 1}).
+          # This corresponds to Ruby semantics, as if the method was def foo(options).
+          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
+
+        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
+
+        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
+
+    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 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.new)
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher::INSTANCE)
     end
   end
 end

data/lib/rspec/mocks/argument_matchers.rb

@@ -1,6 +1,10 @@
+# This cannot take advantage of our relative requires, since this file is a
+# dependency of `rspec/mocks/argument_list_matcher.rb`. See comment there for
+# details.
+require 'rspec/support/matcher_definition'
+
 module RSpec
   module Mocks
-
     # ArgumentMatchers are placeholders that you can include in message
     # expectations to match arguments against a broader check than simple
     # equality.
@@ -10,38 +14,38 @@ module RSpec
     #
     # @see ArgumentListMatcher
     module ArgumentMatchers
-      # Matches any args at all. Supports a more explicit variation of
-      # `expect(object).to receive(:message)`
+      # Acts like an arg splat, matching any number of args at any point in an arg list.
       #
       # @example
+      #   expect(object).to receive(:message).with(1, 2, any_args)
       #
-      #   expect(object).to receive(:message).with(any_args)
+      #   # matches any of these:
+      #   object.message(1, 2)
+      #   object.message(1, 2, 3)
+      #   object.message(1, 2, 3, 4)
       def any_args
-        AnyArgsMatcher.new
+        AnyArgsMatcher::INSTANCE
       end
 
       # Matches any argument at all.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(anything)
       def anything
-        AnyArgMatcher.new
+        AnyArgMatcher::INSTANCE
       end
 
       # Matches no arguments.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(no_args)
       def no_args
-        NoArgsMatcher.new
+        NoArgsMatcher::INSTANCE
       end
 
       # Matches if the actual argument responds to the specified messages.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(duck_type(:hello))
       #   expect(object).to receive(:message).with(duck_type(:hello, :goodbye))
       def duck_type(*args)
@@ -51,17 +55,15 @@ module RSpec
       # Matches a boolean value.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(boolean())
       def boolean
-        BooleanMatcher.new
+        BooleanMatcher::INSTANCE
       end
 
       # Matches a hash that includes the specified key(s) or key/value pairs.
       # Ignores any additional keys.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(hash_including(:key => val))
       #   expect(object).to receive(:message).with(hash_including(:key))
       #   expect(object).to receive(:message).with(hash_including(:key, :key2 => val2))
@@ -73,7 +75,6 @@ module RSpec
       # Ignores duplicates and additional values
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(array_including(1,2,3))
       #   expect(object).to receive(:message).with(array_including([1,2,3]))
       def array_including(*args)
@@ -84,7 +85,6 @@ module RSpec
       # Matches a hash that doesn't include the specified key(s) or key/value.
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(hash_excluding(:key => val))
       #   expect(object).to receive(:message).with(hash_excluding(:key))
       #   expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2))
@@ -97,7 +97,6 @@ module RSpec
       # Matches if `arg.instance_of?(klass)`
       #
       # @example
-      #
       #   expect(object).to receive(:message).with(instance_of(Thing))
       def instance_of(klass)
         InstanceOf.new(klass)
@@ -106,8 +105,8 @@ module RSpec
       alias_method :an_instance_of, :instance_of
 
       # Matches if `arg.kind_of?(klass)`
-      # @example
       #
+      # @example
       #   expect(object).to receive(:message).with(kind_of(Thing))
       def kind_of(klass)
         KindOf.new(klass)
@@ -117,21 +116,38 @@ module RSpec
 
       # @private
       def self.anythingize_lonely_keys(*args)
-        hash = args.last.class == Hash ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = AnyArgMatcher.new }
+        hash = Hash === args.last ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = AnyArgMatcher::INSTANCE }
         hash
       end
 
+      # Intended to be subclassed by stateless, immutable argument matchers.
+      # Provides a `<klass name>::INSTANCE` constant for accessing a global
+      # singleton instance of the matcher. There is no need to construct
+      # multiple instance since there is no state. It also facilities the
+      # special case logic we need for some of these matchers, by making it
+      # easy to do comparisons like: `[klass::INSTANCE] == args` rather than
+      # `args.count == 1 && klass === args.first`.
+      #
+      # @private
+      class SingletonMatcher
+        private_class_method :new
+
+        def self.inherited(subklass)
+          subklass.const_set(:INSTANCE, subklass.send(:new))
+        end
+      end
+
       # @private
-      class AnyArgsMatcher
+      class AnyArgsMatcher < SingletonMatcher
         def description
-          "any args"
+          "*(any args)"
         end
       end
 
       # @private
-      class AnyArgMatcher
-        def ===(other)
+      class AnyArgMatcher < SingletonMatcher
+        def ===(_other)
           true
         end
 
@@ -141,14 +157,14 @@ module RSpec
       end
 
       # @private
-      class NoArgsMatcher
+      class NoArgsMatcher < SingletonMatcher
         def description
           "no args"
         end
       end
 
       # @private
-      class BooleanMatcher
+      class BooleanMatcher < SingletonMatcher
         def ===(value)
           true == value || false == value
         end
@@ -166,14 +182,27 @@ module RSpec
 
         def ===(predicate, actual)
           @expected.__send__(predicate) do |k, v|
-            actual.has_key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
+            actual.key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
           end
         rescue NoMethodError
           false
         end
 
         def description(name)
-          "#{name}(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+          "#{name}(#{formatted_expected_hash.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
+        end
+
+      private
+
+        def formatted_expected_hash
+          Hash[
+            @expected.map do |k, v|
+              k = RSpec::Support.rspec_description_for_object(k)
+              v = RSpec::Support.rspec_description_for_object(v)
+
+              [k, v]
+            end
+          ]
         end
       end
 
@@ -206,11 +235,26 @@ module RSpec
         end
 
         def ===(actual)
-          Set.new(actual).superset?(Set.new(@expected))
+          actual = actual.uniq
+          @expected.uniq.all? do |expected_element|
+            actual.any? do |actual_element|
+              RSpec::Support::FuzzyMatcher.values_match?(expected_element, actual_element)
+            end
+          end
+        rescue NoMethodError
+          false
         end
 
         def description
-          "array_including(#{@expected.join(", ")})"
+          "array_including(#{formatted_expected_values})"
+        end
+
+      private
+
+        def formatted_expected_values
+          @expected.map do |x|
+            RSpec::Support.rspec_description_for_object(x)
+          end.join(", ")
         end
       end
 
@@ -221,7 +265,7 @@ module RSpec
         end
 
         def ===(value)
-          @methods_to_respond_to.all? {|message| value.respond_to?(message)}
+          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
         end
 
         def description
@@ -259,6 +303,20 @@ module RSpec
         end
       end
 
+      matcher_namespace = name + '::'
+      ::RSpec::Support.register_matcher_definition do |object|
+        # This is the best we have for now. We should tag all of our matchers
+        # with a module or something so we can test for it directly.
+        #
+        # (Note Module#parent in ActiveSupport is defined in a similar way.)
+        begin
+          object.class.name.include?(matcher_namespace)
+        rescue NoMethodError
+          # Some objects, like BasicObject, don't implemented standard
+          # reflection methods.
+          false
+        end
+      end
     end
   end
 end

data/lib/rspec/mocks/configuration.rb

@@ -2,14 +2,32 @@ module RSpec
   module Mocks
     # Provides configuration options for rspec-mocks.
     class Configuration
-
       def initialize
+        @allow_message_expectations_on_nil = nil
         @yield_receiver_to_any_instance_implementation_blocks = true
         @verify_doubled_constant_names = false
         @transfer_nested_constants = false
         @verify_partial_doubles = false
+        @temporarily_suppress_partial_double_verification = false
+        @color = false
       end
 
+      # Sets whether RSpec will warn, ignore, or fail a test when
+      # expectations are set on nil.
+      # By default, when this flag is not set, warning messages are issued when
+      # expectations are set on nil. This is to prevent false-positives and to
+      # catch potential bugs early on.
+      # When set to `true`, warning messages are suppressed.
+      # When set to `false`, it will raise an error.
+      #
+      # @example
+      #   RSpec.configure do |config|
+      #     config.mock_with :rspec do |mocks|
+      #       mocks.allow_message_expectations_on_nil = false
+      #     end
+      #   end
+      attr_accessor :allow_message_expectations_on_nil
+
       def yield_receiver_to_any_instance_implementation_blocks?
         @yield_receiver_to_any_instance_implementation_blocks
       end
@@ -20,15 +38,12 @@ module RSpec
       # Defaults to `true`.
       #
       # @example
-      #
       #   RSpec.configure do |rspec|
       #     rspec.mock_with :rspec do |mocks|
       #       mocks.yield_receiver_to_any_instance_implementation_blocks = false
       #     end
       #   end
-      def yield_receiver_to_any_instance_implementation_blocks=(arg)
-        @yield_receiver_to_any_instance_implementation_blocks = arg
-      end
+      attr_writer :yield_receiver_to_any_instance_implementation_blocks
 
       # Adds `stub` and `should_receive` to the given
       # modules or classes. This is usually only necessary
@@ -38,7 +53,6 @@ module RSpec
       # the process.
       #
       # @example
-      #
       #   RSpec.configure do |rspec|
       #     rspec.mock_with :rspec do |mocks|
       #       mocks.add_stub_and_should_receive_to Delegator
@@ -58,7 +72,6 @@ module RSpec
       # disable `expect` syntax.
       #
       # @example
-      #
       #   RSpec.configure do |rspec|
       #     rspec.mock_with :rspec do |mocks|
       #       mocks.syntax = [:expect, :should]
@@ -84,7 +97,6 @@ module RSpec
       # that are enabled.
       #
       # @example
-      #
       #   unless RSpec::Mocks.configuration.syntax.include?(:expect)
       #     raise "this RSpec extension gem requires the rspec-mocks `:expect` syntax"
       #   end
@@ -105,8 +117,23 @@ module RSpec
       # constant. You probably only want to set this when running your entire
       # test suite, with all production code loaded. Setting this for an
       # isolated unit test will prevent you from being able to isolate it!
-      def verify_doubled_constant_names=(val)
-        @verify_doubled_constant_names = val
+      attr_writer :verify_doubled_constant_names
+
+      # Provides a way to perform customisations when verifying doubles.
+      #
+      # @example
+      #  RSpec::Mocks.configuration.before_verifying_doubles do |ref|
+      #    ref.some_method!
+      #  end
+      def before_verifying_doubles(&block)
+        verifying_double_callbacks << block
+      end
+      alias :when_declaring_verifying_double :before_verifying_doubles
+
+      # @api private
+      # Returns an array of blocks to call when verifying doubles
+      def verifying_double_callbacks
+        @verifying_double_callbacks ||= []
       end
 
       def transfer_nested_constants?
@@ -115,9 +142,7 @@ module RSpec
 
       # Sets the default for the `transfer_nested_constants` option when
       # stubbing constants.
-      def transfer_nested_constants=(val)
-        @transfer_nested_constants = val
-      end
+      attr_writer :transfer_nested_constants
 
       # When set to true, partial mocks will be verified the same as object
       # doubles. Any stubs will have their arguments checked against the original
@@ -130,6 +155,29 @@ module RSpec
         @verify_partial_doubles
       end
 
+      # @private
+      # Used to track wether we are temporarily suppressing verifying partial
+      # doubles with `without_partial_double_verification { ... }`
+      attr_accessor :temporarily_suppress_partial_double_verification
+
+      if ::RSpec.respond_to?(:configuration)
+        def color?
+          ::RSpec.configuration.color_enabled?
+        end
+      else
+        # Indicates whether or not diffs should be colored.
+        # Delegates to rspec-core's color option if rspec-core
+        # is loaded; otherwise you can set it here.
+        attr_writer :color
+
+        # Indicates whether or not diffs should be colored.
+        # Delegates to rspec-core's color option if rspec-core
+        # is loaded; otherwise you can set it here.
+        def color?
+          @color
+        end
+      end
+
       # Monkey-patch `Marshal.dump` to enable dumping of mocked or stubbed
       # objects. By default this will not work since RSpec mocks works by
       # adding singleton methods that cannot be serialized. This patch removes