rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

data/lib/rspec/mocks/targets.rb

@@ -1,8 +1,5 @@
 module RSpec
   module Mocks
-    UnsupportedMatcherError  = Class.new(StandardError)
-    NegationUnsupportedError = Class.new(StandardError)
-
     class TargetBase
       def initialize(target)
         @target = target
@@ -10,7 +7,7 @@ module RSpec
 
       def self.delegate_to(matcher_method)
         define_method(:to) do |matcher, &block|
-          unless Matchers::Receive === matcher || Matchers::ReceiveMessages === matcher
+          unless matcher_allowed?(matcher)
             raise_unsupported_matcher(:to, matcher)
           end
           define_matcher(matcher, matcher_method, &block)
@@ -21,8 +18,10 @@ module RSpec
         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)
+          when Matchers::Receive
+            define_matcher(matcher, matcher_method, &block)
+          when Matchers::ReceiveMessages, Matchers::ReceiveMessageChain
+            raise_negation_unsupported(method_name, matcher)
           else
             raise_unsupported_matcher(method_name, matcher)
           end
@@ -37,6 +36,17 @@ module RSpec
 
     private
 
+      def matcher_allowed?(matcher)
+        ALLOWED_MATCHERS.include?(matcher.class)
+      end
+
+      #@api private
+      ALLOWED_MATCHERS = [
+        Matchers::Receive,
+        Matchers::ReceiveMessages,
+        Matchers::ReceiveMessageChain,
+      ]
+
       def define_matcher(matcher, name, &block)
         matcher.__send__(name, @target, &block)
       end
@@ -87,4 +97,3 @@ module RSpec
     end
   end
 end
-

data/lib/rspec/mocks/test_double.rb

@@ -1,8 +1,8 @@
 module RSpec
   module Mocks
-    # Implements the methods needed for a pure test double.  RSpec::Mocks::Mock
+    # Implements the methods needed for a pure test double.  RSpec::Mocks::Double
     # includes this module, and it is provided for cases where you want a
-    # pure test double without subclassing RSpec::Mocks::Mock.
+    # pure test double without subclassing RSpec::Mocks::Double.
     module TestDouble
       # Extends the TestDouble module onto the given object and
       # initializes it as a test double.
@@ -53,8 +53,6 @@ module RSpec
         inspect.gsub('<','[').gsub('>',']')
       end
 
-      alias_method :to_str, :to_s
-
       # @private
       def respond_to?(message, incl_private=false)
         __mock_proxy.null_object? ? true : super
@@ -62,12 +60,17 @@ module RSpec
 
       # @private
       def __build_mock_proxy(order_group)
-        Proxy.new(self, order_group, @name)
+        __raise_expired_error or TestDoubleProxy.new(self, order_group, @name)
+      end
+
+      def __disallow_further_usage!
+        @__expired = true
       end
 
     private
 
       def __initialize_as_test_double(name=nil, stubs={})
+        @__expired = false
         if Hash === name && stubs.empty?
           stubs = name
           @name = nil
@@ -78,21 +81,33 @@ module RSpec
       end
 
       def method_missing(message, *args, &block)
-        if __mock_proxy.null_object?
+        proxy = __mock_proxy
+        proxy.record_message_received(message, *args, &block)
+
+        if proxy.null_object?
           case message
           when :to_int        then return 0
           when :to_a, :to_ary then return nil
+          else return self
           end
         end
-        __mock_proxy.record_message_received(message, *args, &block)
-
-        begin
-          __mock_proxy.null_object? ? self : super
-        rescue NameError
-          # Required wrapping doubles in an Array on Ruby 1.9.2
-          raise NoMethodError if [:to_a, :to_ary].include? message
-          __mock_proxy.raise_unexpected_message_error(message, *args)
+
+        # Defined private and protected methods will still trigger `method_missing`
+        # when called publicly. We want ruby's method visibility error to get raised,
+        # so we simply delegate to `super` in that case.
+        # ...well, we would delegate to `super`, but there's a JRuby
+        # bug, so we raise our own visibility error instead:
+        # https://github.com/jruby/jruby/issues/1398
+        visibility = proxy.visibility_for(message)
+        if visibility == :private || visibility == :protected
+          ErrorGenerator.new(self, @name).raise_non_public_error(
+            message, visibility
+          )
         end
+
+        # Required wrapping doubles in an Array on Ruby 1.9.2
+        raise NoMethodError if [:to_a, :to_ary].include? message
+        proxy.raise_unexpected_message_error(message, *args)
       end
 
       def assign_stubs(stubs)
@@ -102,8 +117,19 @@ module RSpec
       end
 
       def __mock_proxy
-        ::RSpec::Mocks.proxy_for(self)
+        ::RSpec::Mocks.space.proxy_for(self)
+      end
+
+      def __raise_expired_error
+        return false unless @__expired
+        ErrorGenerator.new(self, @name).raise_expired_test_double_error
       end
     end
+
+    # A generic test double object. `double`, `instance_double` and friends
+    # return an instance of this.
+    class Double
+      include TestDouble
+    end
   end
 end

data/lib/rspec/mocks/verifying_double.rb

@@ -1,22 +1,63 @@
-require 'rspec/mocks/mock'
 require 'rspec/mocks/verifying_proxy'
+require 'stringio'
 
 module RSpec
   module Mocks
 
+    # @api private
     module VerifyingDouble
+      def respond_to?(message, include_private=false)
+        return super unless null_object?
+
+        method_ref = __mock_proxy.method_reference[message]
+
+        return case method_ref.visibility
+          when :public    then true
+          when :private   then include_private
+          when :protected then include_private || RUBY_VERSION.to_f < 2.0
+          else !method_ref.unimplemented?
+        end
+      end
+
       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?
+        if null_object?
+          if @__sending_message == message
+            __mock_proxy.ensure_implemented(message)
+          else
+            __mock_proxy.ensure_publicly_implemented(message, self)
+          end
+        end
+
+        super
+      end
+
+      # Redefining `__send__` causes ruby to issue a warning.
+      old, $stderr = $stderr, StringIO.new
+      def __send__(name, *args, &block)
+        @__sending_message = name
         super
+      ensure
+        @__sending_message = nil
+      end
+      $stderr = old
+
+      def send(name, *args, &block)
+        __send__(name, *args, &block)
+      end
+
+      def __initialize_as_test_double(*args)
+        super
+        @__sending_message = nil
       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.
+    # @api private
     class InstanceVerifyingDouble
       include TestDouble
       include VerifyingDouble
@@ -24,7 +65,10 @@ module RSpec
       def initialize(doubled_module, *args)
         @doubled_module = doubled_module
 
-        __initialize_as_test_double(doubled_module, *args)
+        __initialize_as_test_double(
+          "#{doubled_module.description} (instance)",
+          *args
+        )
       end
 
       def __build_mock_proxy(order_group)
@@ -37,6 +81,7 @@ module RSpec
 
     # An awkward module necessary because we cannot otherwise have
     # ClassVerifyingDouble inherit from Module and still share these methods.
+    # @api private
     module ObjectVerifyingDoubleMethods
       include TestDouble
       include VerifyingDouble
@@ -44,7 +89,7 @@ module RSpec
       def initialize(doubled_module, *args)
         @doubled_module = doubled_module
 
-        __initialize_as_test_double(doubled_module, *args)
+        __initialize_as_test_double(doubled_module.description, *args)
       end
 
       def __build_mock_proxy(order_group)
@@ -62,6 +107,7 @@ module RSpec
 
     # Similar to an InstanceVerifyingDouble, except that it verifies against
     # public methods of the given object.
+    # @api private
     class ObjectVerifyingDouble
       include ObjectVerifyingDoubleMethods
     end
@@ -69,6 +115,7 @@ module RSpec
     # 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.
+    # @api private
     class ClassVerifyingDouble < Module
       include ObjectVerifyingDoubleMethods
     end

data/lib/rspec/mocks/verifying_message_expecation.rb

@@ -1,11 +1,12 @@
-require 'rspec/mocks/arity_calculator'
+require 'rspec/mocks/method_signature_verifier'
 
 module RSpec
   module Mocks
 
     # A message expectation that knows about the real implementation of the
     # message being expected, so that it can verify that any expectations
-    # have the correct arity.
+    # have the valid arguments.
+    # @api private
     class VerifyingMessageExpectation < MessageExpectation
 
       # A level of indirection is used here rather than just passing in the
@@ -25,36 +26,35 @@ module RSpec
       # @override
       def with(*args, &block)
         unless ArgumentMatchers::AnyArgsMatcher === args.first
-          expected_arity = if ArgumentMatchers::NoArgsMatcher === args.first
-            0
+          expected_args = if ArgumentMatchers::NoArgsMatcher === args.first
+            []
           elsif args.length > 0
-            args.length
+            args
           else
             # No arguments given, this will raise.
             super
           end
 
-          ensure_arity!(expected_arity)
+          validate_arguments!(expected_args)
         end
         super
       end
 
     private
 
-      def ensure_arity!(actual)
+      def validate_arguments!(actual_args)
         return if method_reference.nil?
 
-        method_reference.when_defined do |method|
-          calculator = ArityCalculator.new(method)
-          unless calculator.within_range?(actual)
+        method_reference.with_signature do |signature|
+          verifier = MethodSignatureVerifier.new(signature, actual_args)
+          unless verifier.valid?
             # Fail fast is required, otherwise the message expecation will fail
             # as well ("expected method not called") and clobber this one.
             @failed_fast = true
-            @error_generator.raise_arity_error(calculator, actual)
+            @error_generator.raise_invalid_arguments_error(verifier)
           end
         end
       end
     end
   end
 end
-

data/lib/rspec/mocks/verifying_proxy.rb

@@ -4,6 +4,7 @@ require 'rspec/mocks/method_reference'
 module RSpec
   module Mocks
 
+    # @api private
     module VerifyingProxyMethods
       def add_stub(location, method_name, opts={}, &implementation)
         ensure_implemented(method_name)
@@ -21,21 +22,28 @@ module RSpec
       end
 
       def ensure_implemented(method_name)
-        return unless @doubled_module.defined?
-
-        method_reference[method_name].when_unimplemented do
+        if method_reference[method_name].unimplemented?
           @error_generator.raise_unimplemented_error(
             @doubled_module,
             method_name
           )
         end
       end
+
+      def ensure_publicly_implemented(method_name, object)
+        ensure_implemented(method_name)
+        visibility = method_reference[method_name].visibility
+
+        unless visibility == :public
+          @error_generator.raise_non_public_error(method_name, visibility)
+        end
+      end
     end
 
     # A verifying proxy mostly acts like a normal proxy, except that it
     # contains extra logic to try and determine the validity of any expectation
     # set on it. This includes whether or not methods have been defined and the
-    # arity of method calls.
+    # validatiy of arguments on method calls.
     #
     # In all other ways this behaves like a normal proxy. It only adds the
     # verification behaviour to specific methods then delegates to the parent
@@ -56,7 +64,7 @@ module RSpec
         @method_reference_class = method_reference_class
 
         # A custom method double is required to pass through a way to lookup
-        # methods to determine their arity. This is only relevant if the doubled
+        # methods to determine their parameters. This is only relevant if the doubled
         # class is loaded.
         @method_doubles = Hash.new do |h, k|
           h[k] = VerifyingMethodDouble.new(@object, k, self, method_reference[k])
@@ -68,9 +76,14 @@ module RSpec
           h[k] = @method_reference_class.new(@doubled_module, k)
         end
       end
+
+      def visibility_for(method_name)
+        method_reference[method_name].visibility
+      end
     end
 
-    class VerifyingPartialMockProxy < PartialMockProxy
+    # @api private
+    class VerifyingPartialDoubleProxy < PartialDoubleProxy
       include VerifyingProxyMethods
 
       def initialize(object, expectation_ordering)
@@ -78,7 +91,7 @@ module RSpec
         @doubled_module = DirectObjectReference.new(object)
 
         # A custom method double is required to pass through a way to lookup
-        # methods to determine their arity.
+        # methods to determine their parameters.
         @method_doubles = Hash.new do |h, k|
           h[k] = VerifyingExistingMethodDouble.new(object, k, self)
         end
@@ -105,29 +118,29 @@ module RSpec
       end
 
       def proxy_method_invoked(obj, *args, &block)
-        ensure_arity!(args.length)
+        validate_arguments!(args)
         super
       end
 
     private
 
-      def ensure_arity!(arity)
-        @method_reference.when_defined do |method|
-          calculator = ArityCalculator.new(method)
-          unless calculator.within_range?(arity)
-            raise ArgumentError, "wrong number of arguments (#{arity} for #{method.arity})"
+      def validate_arguments!(actual_args)
+        @method_reference.with_signature do |signature|
+          verifier = MethodSignatureVerifier.new(signature, actual_args)
+          unless verifier.valid?
+            raise ArgumentError, verifier.error_message
           end
         end
       end
     end
 
-    # @api private
-    #
     # A VerifyingMethodDouble fetches the method to verify against from the
     # original object, using a MethodReference. This works for pure doubles,
     # but when the original object is itself the one being modified we need to
     # collapse the reference and the method double into a single object so that
     # we can access the original pristine method definition.
+    #
+    # @api private
     class VerifyingExistingMethodDouble < VerifyingMethodDouble
       def initialize(object, method_name, proxy)
         super(object, method_name, proxy, self)
@@ -139,12 +152,12 @@ module RSpec
         save_original_method!
       end
 
-      def when_defined
-        yield original_method
+      def with_signature
+        yield MethodSignature.new(original_method)
       end
 
-      def when_unimplemented
-        yield unless @valid_method
+      def unimplemented?
+        !@valid_method
       end
     end
   end