rspec-mocks 2.99.4 → 3.0.0.beta1

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

@@ -12,11 +12,16 @@ module RSpec
         private
 
         def create_message_expectation_on(instance)
-          super do |proxy, expected_from|
-            stub = proxy.add_stub(expected_from, *@expectation_args, &@expectation_block)
-            @recorder.stubs[stub.message] << stub
-            stub
+          proxy = ::RSpec::Mocks.proxy_for(instance)
+          expected_from = IGNORED_BACKTRACE_LINE
+          stub = proxy.add_stub(expected_from, *@expectation_args, &@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
 
         def invocation_order

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -23,6 +23,8 @@ 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
@@ -69,7 +71,7 @@ module RSpec
 
       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::RegexpMatcher.new(arg)  if Regexp === arg
         return ArgumentMatchers::EqualityProxy.new(arg)
       end
 
@@ -92,6 +94,11 @@ module RSpec
       def match_any_args?
         @match_any_args
       end
+
+      # Value that will match all argument lists.
+      #
+      # @private
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher.new)
     end
   end
 end

data/lib/rspec/mocks/argument_matchers.rb

@@ -83,6 +83,20 @@ module RSpec
         end
       end
 
+      class ArrayIncludingMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          Set.new(actual).superset?(Set.new(@expected))
+        end
+
+        def description
+          "array_including(#{@expected.join(",")})"
+        end
+      end
+
       class DuckTypeMatcher
         def initialize(*methods_to_respond_to)
           @methods_to_respond_to = methods_to_respond_to
@@ -109,18 +123,6 @@ module RSpec
         end
 
         def ==(expected)
-          if defined?(DateTime) && DateTime === expected
-            RSpec.warn_deprecation <<-WARN.gsub(/^\s*\|/,'')
-              |In RSpec 3.0.0 matchers use `#===` (the match operator) to perform
-              |comparision between expected and actual arguments. Due to strange
-              |behaviour with `DateTime#===` (which ignores the time of the object
-              |when performing a comparison) this may result in undesired
-              |behaviour. We recommend you switch to a `Date` or `Time` object
-              |instead.
-              |
-              |Called from: #{RSpec::CallerFilter.first_non_rspec_line}
-            WARN
-          end
           @given == expected
         end
       end
@@ -204,6 +206,18 @@ module RSpec
         HashIncludingMatcher.new(anythingize_lonely_keys(*args))
       end
 
+      # Matches an array that includes the specified items at least once.
+      # Ignores duplicates and additional values
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(array_including(1,2,3))
+      #   object.should_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

data/lib/rspec/mocks/arity_calculator.rb

@@ -0,0 +1,66 @@
+module RSpec
+  module Mocks
+
+    # Figures out the valid arity range for a method. Surprisingly non-trivial.
+    class ArityCalculator
+
+      def initialize(method)
+        @method = method
+      end
+
+      # @api private
+      def within_range?(actual)
+        min_arity <= actual && actual <= max_arity
+      end
+
+      # @api private
+      def range_description
+        return min_arity.to_s if min_arity == max_arity
+        return "#{min_arity} or more" if max_arity == INFINITY
+        "#{min_arity} to #{max_arity}"
+      end
+
+      private
+
+      def method
+        @method
+      end
+
+      # @api private
+      def self.supports_optional_and_splat_args?
+        Method.method_defined?(:parameters)
+      end
+
+      def min_arity
+        return method.arity if method.arity >= 0
+        # `~` inverts the one's complement and gives us the number of
+        # required arguments.
+        ~method.arity
+      end
+
+      if supports_optional_and_splat_args?
+        def max_arity
+          params = method.parameters
+          if params.any? {|(type, _)| type == :rest }
+            # Method takes a splat argument
+            return INFINITY
+          else
+            params.count {|(type, _)| type != :block }
+          end
+        end
+      else
+        def max_arity
+          # On 1.8, Method#parameters does not exist.  There is no way to
+          # distinguish between default and splat args, so there is no way to
+          # have it work correctly for both default and splat args, as far as I
+          # can tell. The best we can do is consider it INFINITY (to be
+          # tolerant of splat args).
+          method.arity < 0 ? INFINITY : method.arity
+        end
+      end
+
+      INFINITY = 1/0.0
+    end
+  end
+end
+

data/lib/rspec/mocks/configuration.rb

@@ -4,9 +4,10 @@ module RSpec
     class Configuration
 
       def initialize
-        @yield_receiver_to_any_instance_implementation_blocks = false
-        @should_warn_about_any_instance_blocks = true
-        @marshal_patched = false
+        @yield_receiver_to_any_instance_implementation_blocks = true
+        @verify_doubled_constant_names = false
+        @transfer_nested_constants = false
+        @verify_partial_doubles = false
       end
 
       def yield_receiver_to_any_instance_implementation_blocks?
@@ -14,14 +15,9 @@ module RSpec
       end
 
       def yield_receiver_to_any_instance_implementation_blocks=(arg)
-        @should_warn_about_any_instance_blocks = false
         @yield_receiver_to_any_instance_implementation_blocks = arg
       end
 
-      def should_warn_about_any_instance_blocks?
-        @should_warn_about_any_instance_blocks
-      end
-
       # Adds `stub` and `should_receive` to the given
       # modules or classes. This is usually only necessary
       # if you application uses some proxy classes that
@@ -64,12 +60,45 @@ module RSpec
         syntaxes
       end
 
-      def patch_marshal_to_support_partial_doubles=(val)
-        @marshal_patched = val
+      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!
+      def verify_doubled_constant_names=(val)
+        @verify_doubled_constant_names = val
       end
 
-      def marshal_patched?
-        @marshal_patched
+      def transfer_nested_constants?
+        !!@transfer_nested_constants
+      end
+
+      # Sets the default for the `transfer_nested_constants` option when
+      # stubbing constants.
+      def transfer_nested_constants=(val)
+        @transfer_nested_constants = val
+      end
+
+      # When set to true, partial mocks will be verified the same as object
+      # doubles. Any stubs will have their arity 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
+
+      # @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
 
@@ -77,7 +106,6 @@ module RSpec
       @configuration ||= Configuration.new
     end
 
-    configuration.syntax = [:should, :expect]
+    configuration.reset_syntaxes_to_default
   end
 end
-

data/lib/rspec/mocks/error_generator.rb

@@ -4,8 +4,7 @@ module RSpec
     class ErrorGenerator
       attr_writer :opts
 
-      def initialize(target, name, options={})
-        @declared_as = options[:__declared_as] || 'Mock'
+      def initialize(target, name)
         @target = target
         @name = name
       end
@@ -48,6 +47,22 @@ module RSpec
         __raise "(#{intro}).#{message}#{format_args(*args)}\n    #{expected_part}\n    #{received_part}"
       end
 
+      # @private
+      def raise_unimplemented_error(doubled_module, method_name)
+        __raise "%s does not implement:\n  %s" % [
+          doubled_module.description,
+          method_name
+        ]
+      end
+
+      # @private
+      def raise_arity_error(calculator, actual)
+        __raise "Wrong number of arguments. Expected %s, got %s." % [
+          calculator.range_description,
+          actual
+        ]
+      end
+
       # @private
       def received_part_of_expectation_error(actual_received_count, *args)
         "received: #{count_message(actual_received_count)}" +
@@ -62,11 +77,14 @@ module RSpec
 
       # @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
+        case args.first
+          when ArgumentMatchers::AnyArgsMatcher
+            return " with any arguments"
+          when ArgumentMatchers::NoArgsMatcher
+            return " with no arguments"
+        end
+
+        if args.length > 0
           " with arguments: #{args.inspect.gsub(/\A\[(.+)\]\z/, '(\1)')}"
         else
           ""
@@ -127,9 +145,9 @@ module RSpec
 
       def intro
         if @name
-          "#{@declared_as} #{@name.inspect}"
+          "Double #{@name.inspect}"
         elsif TestDouble === @target
-          @declared_as
+          "Double"
         elsif Class === @target
           "<#{@target.inspect} (class)>"
         elsif @target
@@ -153,7 +171,13 @@ module RSpec
       end
 
       def arg_list(*args)
-        args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
+        args.collect {|arg| arg_has_valid_description(arg) ? arg.description : arg.inspect }.join(", ")
+      end
+
+      def arg_has_valid_description(arg)
+        return false unless arg.respond_to?(:description)
+
+        !arg.description.nil? && !arg.description.empty?
       end
 
       def format_received_args(*args)

data/lib/rspec/mocks/example_methods.rb

@@ -1,3 +1,5 @@
+require 'rspec/mocks/object_reference'
+
 module RSpec
   module Mocks
     module ExampleMethods
@@ -9,12 +11,12 @@ module RSpec
       # @overload double(name, stubs)
       # @param name [String/Symbol] (optional) used in
       #   clarify intent
-      # @param stubs (Hash) (optional) hash of method/return-value pairs
+      # @param stubs (Hash) (optional) hash of message/return-value pairs
       # @return (Mock)
       #
       # Constructs an instance of [RSpec::Mocks::Mock](RSpec::Mocks::Mock) configured
       # with an optional name, used for reporting in failure messages, and an optional
-      # hash of method/return-value pairs.
+      # hash of message/return-value pairs.
       #
       # @example
       #
@@ -25,22 +27,53 @@ module RSpec
       #   card.suit  #=> "Spades"
       #   card.rank  #=> "A"
       #
-      # @see #mock
-      # @see #stub
       def double(*args)
-        declare_double('Double', *args)
+        declare_double(Mock, *args)
+      end
+
+      # @overload instance_double(doubled_class)
+      # @overload instance_double(doubled_class, stubs)
+      # @param doubled_class [String, Class]
+      # @param stubs [Hash] (optional) hash of message/return-value pairs
+      # @return InstanceVerifyingDouble
+      #
+      # Constructs a test double against a specific class. If the given class
+      # name has been loaded, only instance methods defined on the class are
+      # allowed to be stubbed. In all other ways it behaves like a
+      # [double](double).
+      def instance_double(doubled_class, *args)
+        ref = ObjectReference.for(doubled_class)
+        declare_verifying_double(InstanceVerifyingDouble, ref, *args)
       end
 
-      # Deprecated: Use [double](#double-instance_method).
-      def mock(*args)
-        RSpec.deprecate "mock", :replacement => "double"
-        declare_double('Mock', *args)
+      # @overload class_double(doubled_class)
+      # @overload class_double(doubled_class, stubs)
+      # @param doubled_class [String, Module]
+      # @param stubs [Hash] (optional) hash of message/return-value pairs
+      # @return ClassVerifyingDouble
+      #
+      # Constructs a test double against a specific class. If the given class
+      # name has been loaded, only class methods defined on the class are
+      # allowed to be stubbed. In all other ways it behaves like a
+      # [double](double).
+      def class_double(doubled_class, *args)
+        ref = ObjectReference.for(doubled_class)
+        declare_verifying_double(ClassVerifyingDouble, ref, *args)
       end
 
-      # Deprecated: Use [double](#double-instance_method).
-      def stub(*args)
-        RSpec.deprecate "stub", :replacement => "double"
-        declare_double('Stub', *args)
+      # @overload object_double(object_or_name)
+      # @overload object_double(object_or_name, stubs)
+      # @param object_or_name [String, Object]
+      # @param stubs [Hash] (optional) hash of message/return-value pairs
+      # @return ObjectVerifyingDouble
+      #
+      # Constructs a test double against a specific object. Only the methods
+      # the object responds to are allowed to be stubbed. If a String argument
+      # is provided, it is assumed to reference a constant object which is used
+      # for verification. In all other ways it behaves like a [double](double).
+      def object_double(object_or_name, *args)
+        ref = ObjectReference.for(object_or_name, :allow_direct_object_refs)
+        declare_verifying_double(ObjectVerifyingDouble, ref, *args)
       end
 
       # Disables warning messages about expectations being set on nil.
@@ -127,12 +160,12 @@ module RSpec
       #
       #   # 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)
+      def have_received(method_name, &block)
+        Matchers::HaveReceived.new(method_name, &block)
       end
 
       def self.included(klass)
-        klass.class_eval do
+        klass.class_exec 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)
@@ -141,10 +174,22 @@ module RSpec
 
     private
 
-      def declare_double(declared_as, *args)
+      def declare_verifying_double(type, ref, *args)
+        if RSpec::Mocks.configuration.verify_doubled_constant_names? &&
+          !ref.defined?
+
+          raise NameError,
+            "#{ref.name} is not a defined constant. " +
+            "Perhaps you misspelt it? " +
+            "Disable check with verify_doubled_constant_names configuration option."
+        end
+
+        declare_double(type, ref, *args)
+      end
+
+      def declare_double(type, *args)
         args << {} unless Hash === args.last
-        args.last[:__declared_as] = declared_as
-        RSpec::Mocks::Double.new(*args)
+        type.new(*args)
       end
 
       # This module exists to host the `expect` method for cases where