rspec-mocks 2.11.3 → 3.11.1

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,228 +14,308 @@ module RSpec
     #
     # @see ArgumentListMatcher
     module ArgumentMatchers
+      # 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)
+      #
+      #   # matches any of these:
+      #   object.message(1, 2)
+      #   object.message(1, 2, 3)
+      #   object.message(1, 2, 3, 4)
+      def any_args
+        AnyArgsMatcher::INSTANCE
+      end
 
-      class AnyArgsMatcher
-        def description
-          "any args"
-        end
+      # Matches any argument at all.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(anything)
+      def anything
+        AnyArgMatcher::INSTANCE
       end
 
-      class AnyArgMatcher
-        def initialize(ignore)
-        end
+      # Matches no arguments.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(no_args)
+      def no_args
+        NoArgsMatcher::INSTANCE
+      end
 
-        def ==(other)
-          true
+      # 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)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # Matches a boolean value.
+      #
+      # @example
+      #   expect(object).to receive(:message).with(boolean())
+      def boolean
+        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))
+      def hash_including(*args)
+        HashIncludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
+      end
+
+      # Matches an array that includes the specified items at least once.
+      # 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)
+        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
+        ArrayIncludingMatcher.new(actually_an_array)
+      end
+
+      # 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))
+      def hash_excluding(*args)
+        HashExcludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
+      end
+
+      alias_method :hash_not_including, :hash_excluding
+
+      # Matches if `arg.instance_of?(klass)`
+      #
+      # @example
+      #   expect(object).to receive(:message).with(instance_of(Thing))
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+
+      alias_method :an_instance_of, :instance_of
+
+      # Matches if `arg.kind_of?(klass)`
+      #
+      # @example
+      #   expect(object).to receive(:message).with(kind_of(Thing))
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+
+      alias_method :a_kind_of, :kind_of
+
+      # @private
+      def self.anythingize_lonely_keys(*args)
+        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
 
-      class NoArgsMatcher
+      # @private
+      class AnyArgsMatcher < SingletonMatcher
         def description
-          "no args"
+          "*(any args)"
         end
       end
 
-      class RegexpMatcher
-        def initialize(regexp)
-          @regexp = regexp
+      # @private
+      class AnyArgMatcher < SingletonMatcher
+        def ===(_other)
+          true
+        end
+
+        def description
+          "anything"
         end
+      end
 
-        def ==(value)
-          Regexp === value ? value == @regexp : value =~ @regexp
+      # @private
+      class NoArgsMatcher < SingletonMatcher
+        def description
+          "no args"
         end
       end
 
-      class BooleanMatcher
-        def initialize(ignore)
+      # @private
+      class BooleanMatcher < SingletonMatcher
+        def ===(value)
+          true == value || false == value
         end
 
-        def ==(value)
-          [true,false].include?(value)
+        def description
+          "boolean"
         end
       end
 
-      class HashIncludingMatcher
+      # @private
+      class BaseHashMatcher
         def initialize(expected)
           @expected = expected
         end
 
-        def ==(actual)
-          @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
+        def ===(predicate, actual)
+          @expected.__send__(predicate) do |k, v|
+            actual.key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
+          end
         rescue NoMethodError
           false
         end
 
+        def description(name)
+          "#{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
+
+      # @private
+      class HashIncludingMatcher < BaseHashMatcher
+        def ===(actual)
+          super(:all?, actual)
+        end
+
+        def description
+          super("hash_including")
+        end
+      end
+
+      # @private
+      class HashExcludingMatcher < BaseHashMatcher
+        def ===(actual)
+          super(:none?, actual)
+        end
+
         def description
-          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+          super("hash_not_including")
         end
       end
 
-      class HashExcludingMatcher
+      # @private
+      class ArrayIncludingMatcher
         def initialize(expected)
           @expected = expected
         end
 
-        def ==(actual)
-          @expected.none? {|k,v| actual.has_key?(k) && v == actual[k]}
+        def ===(actual)
+          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
-          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+          "array_including(#{formatted_expected_values})"
         end
-      end
 
-      class DuckTypeMatcher
-        def initialize(*methods_to_respond_to)
-          @methods_to_respond_to = methods_to_respond_to
-        end
+      private
 
-        def ==(value)
-          @methods_to_respond_to.all? {|message| value.respond_to?(message)}
+        def formatted_expected_values
+          @expected.map do |x|
+            RSpec::Support.rspec_description_for_object(x)
+          end.join(", ")
         end
       end
 
-      class MatcherMatcher
-        def initialize(matcher)
-          @matcher = matcher
-        end
-
-        def ==(value)
-          @matcher.matches?(value)
+      # @private
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
         end
-      end
 
-      class EqualityProxy
-        def initialize(given)
-          @given = given
+        def ===(value)
+          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
         end
 
-        def ==(expected)
-          @given == expected
+        def description
+          "duck_type(#{@methods_to_respond_to.map(&:inspect).join(', ')})"
         end
       end
 
+      # @private
       class InstanceOf
         def initialize(klass)
           @klass = klass
         end
 
-        def ==(actual)
+        def ===(actual)
           actual.instance_of?(@klass)
         end
+
+        def description
+          "an_instance_of(#{@klass.name})"
+        end
       end
 
+      # @private
       class KindOf
         def initialize(klass)
           @klass = klass
         end
 
-        def ==(actual)
+        def ===(actual)
           actual.kind_of?(@klass)
         end
-      end
 
-      # Matches any args at all. Supports a more explicit variation of
-      # `object.should_receive(:message)`
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(any_args)
-      def any_args
-        AnyArgsMatcher.new
-      end
-
-      # Matches any argument at all.
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(anything)
-      def anything
-        AnyArgMatcher.new(nil)
-      end
-
-      # Matches no arguments.
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(no_args)
-      def no_args
-        NoArgsMatcher.new
-      end
-
-      # Matches if the actual argument responds to the specified messages.
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(duck_type(:hello))
-      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
-      def duck_type(*args)
-        DuckTypeMatcher.new(*args)
-      end
-
-      # Matches a boolean value.
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(boolean())
-      def boolean
-        BooleanMatcher.new(nil)
-      end
-
-      # Matches a hash that includes the specified key(s) or key/value pairs.
-      # Ignores any additional keys.
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(hash_including(:key => val))
-      #   object.should_receive(:message).with(hash_including(:key))
-      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
-      def hash_including(*args)
-        HashIncludingMatcher.new(anythingize_lonely_keys(*args))
-      end
-
-      # Matches a hash that doesn't include the specified key(s) or key/value.
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(hash_excluding(:key => val))
-      #   object.should_receive(:message).with(hash_excluding(:key))
-      #   object.should_receive(:message).with(hash_excluding(:key, :key2 => :val2))
-      def hash_excluding(*args)
-        HashExcludingMatcher.new(anythingize_lonely_keys(*args))
-      end
-
-      alias_method :hash_not_including, :hash_excluding
-
-      # Matches if `arg.instance_of?(klass)`
-      #
-      # @example
-      #
-      #   object.should_receive(:message).with(instance_of(Thing))
-      def instance_of(klass)
-        InstanceOf.new(klass)
-      end
-
-      alias_method :an_instance_of, :instance_of
-
-      # Matches if `arg.kind_of?(klass)`
-      # @example
-      #
-      #   object.should_receive(:message).with(kind_of(Thing))
-      def kind_of(klass)
-        KindOf.new(klass)
+        def description
+          "kind of #{@klass.name}"
+        end
       end
 
-      alias_method :a_kind_of, :kind_of
-
-      private
-
-      def anythingize_lonely_keys(*args)
-        hash = args.last.class == Hash ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = anything }
-        hash
+      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

data/lib/rspec/mocks/configuration.rb

@@ -0,0 +1,212 @@
+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
+
+      # Sets whether or not RSpec will yield the receiving instance of a
+      # message to blocks that are used for any_instance stub implementations.
+      # When set, the first yielded argument will be the receiving instance.
+      # 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
+      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
+      # if you application uses some proxy classes that
+      # "strip themselves down" to a bare minimum set of
+      # methods and remove `stub` and `should_receive` in
+      # the process.
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.add_stub_and_should_receive_to Delegator
+      #     end
+      #   end
+      #
+      def add_stub_and_should_receive_to(*modules)
+        modules.each do |mod|
+          Syntax.enable_should(mod)
+        end
+      end
+
+      # Provides the ability to set either `expect`,
+      # `should` or both syntaxes. RSpec uses `expect`
+      # syntax by default. This is needed if you want to
+      # explicitly enable `should` syntax and/or explicitly
+      # disable `expect` syntax.
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.mock_with :rspec do |mocks|
+      #       mocks.syntax = [:expect, :should]
+      #     end
+      #  end
+      #
+      def syntax=(*values)
+        syntaxes = values.flatten
+        if syntaxes.include?(:expect)
+          Syntax.enable_expect
+        else
+          Syntax.disable_expect
+        end
+
+        if syntaxes.include?(:should)
+          Syntax.enable_should
+        else
+          Syntax.disable_should
+        end
+      end
+
+      # Returns an array with a list of syntaxes
+      # that are enabled.
+      #
+      # @example
+      #   unless RSpec::Mocks.configuration.syntax.include?(:expect)
+      #     raise "this RSpec extension gem requires the rspec-mocks `:expect` syntax"
+      #   end
+      #
+      def syntax
+        syntaxes = []
+        syntaxes << :should  if Syntax.should_enabled?
+        syntaxes << :expect if Syntax.expect_enabled?
+        syntaxes
+      end
+
+      def verify_doubled_constant_names?
+        !!@verify_doubled_constant_names
+      end
+
+      # When this is set to true, an error will be raised when
+      # `instance_double` or `class_double` is given the name of an undefined
+      # 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!
+      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?
+        !!@transfer_nested_constants
+      end
+
+      # Sets the default for the `transfer_nested_constants` option when
+      # stubbing constants.
+      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
+      # method, and methods that do not exist cannot be stubbed.
+      def verify_partial_doubles=(val)
+        @verify_partial_doubles = !!val
+      end
+
+      def verify_partial_doubles?
+        @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
+      # these singleton methods before serialization. Setting to falsey removes
+      # the patch.
+      #
+      # This method is idempotent.
+      def patch_marshal_to_support_partial_doubles=(val)
+        if val
+          RSpec::Mocks::MarshalExtension.patch!
+        else
+          RSpec::Mocks::MarshalExtension.unpatch!
+        end
+      end
+
+      # @api private
+      # Resets the configured syntax to the default.
+      def reset_syntaxes_to_default
+        self.syntax = [:should, :expect]
+        RSpec::Mocks::Syntax.warn_about_should!
+      end
+    end
+
+    # Mocks specific configuration, as distinct from `RSpec.configuration`
+    # which is core RSpec configuration.
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    configuration.reset_syntaxes_to_default
+  end
+end