opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-mocks/upstream/lib/rspec/mocks/proxy.rb

@@ -2,29 +2,51 @@ module RSpec
   module Mocks
     # @private
     class Proxy
+      # @private
       SpecificMessage = Struct.new(:object, :message, :args) do
         def ==(expectation)
           expectation.orig_object == object && expectation.matches?(message, *args)
         end
       end
 
+      unless defined?(Mutex)
+        Support.require_rspec_support 'mutex'
+        Mutex = Support::Mutex
+      end
+
       # @private
       def ensure_implemented(*_args)
         # noop for basic proxies, see VerifyingProxy for behaviour.
       end
 
       # @private
-      def initialize(object, order_group, name=nil, options={})
+      def initialize(object, order_group, options={})
+        ensure_can_be_proxied!(object)
+
         @object = object
         @order_group = order_group
-        @name = name
-        @error_generator = ErrorGenerator.new(object, name)
+        @error_generator = ErrorGenerator.new(object)
         @messages_received = []
+        @messages_received_mutex = Mutex.new
         @options = options
         @null_object = false
         @method_doubles = Hash.new { |h, k| h[k] = MethodDouble.new(@object, k, self) }
       end
 
+      # @private
+      def ensure_can_be_proxied!(object)
+        return unless object.is_a?(Symbol) || object.frozen?
+        return if object.nil?
+
+        msg = "Cannot proxy frozen objects"
+        if Symbol === object
+          msg << ". Symbols such as #{object} cannot be mocked or stubbed."
+        else
+          msg << ", rspec-mocks relies on proxies for method stubbing and expectations."
+        end
+        raise ArgumentError, msg
+      end
+
       # @private
       attr_reader :object
 
@@ -46,8 +68,10 @@ module RSpec
         nil
       end
 
+      DEFAULT_MESSAGE_EXPECTATION_OPTS = {}.freeze
+
       # @private
-      def add_message_expectation(method_name, opts={}, &block)
+      def add_message_expectation(method_name, opts=DEFAULT_MESSAGE_EXPECTATION_OPTS, &block)
         location = opts.fetch(:expected_from) { CallerFilter.first_non_rspec_line }
         meth_double = method_double_for(method_name)
 
@@ -88,20 +112,30 @@ module RSpec
           @error_generator.raise_expectation_on_unstubbed_method(expected_method_name)
         end
 
-        @messages_received.each do |(actual_method_name, args, _)|
-          next unless expectation.matches?(actual_method_name, *args)
+        @messages_received_mutex.synchronize do
+          @messages_received.each do |(actual_method_name, args, received_block)|
+            next unless expectation.matches?(actual_method_name, *args)
 
-          expectation.safe_invoke(nil)
-          block.call(*args) if block
+            expectation.safe_invoke(nil)
+            block.call(*args, &received_block) if block
+          end
         end
       end
 
       # @private
       def check_for_unexpected_arguments(expectation)
-        @messages_received.each do |(method_name, args, _)|
-          next unless expectation.matches_name_but_not_args(method_name, *args)
+        @messages_received_mutex.synchronize do
+          return if @messages_received.empty?
+
+          return if @messages_received.any? { |method_name, args, _| expectation.matches?(method_name, *args) }
+
+          name_but_not_args, others = @messages_received.partition do |(method_name, args, _)|
+            expectation.matches_name_but_not_args(method_name, *args)
+          end
+
+          return if name_but_not_args.empty? && !others.empty?
 
-          raise_unexpected_message_args_error(expectation, *args)
+          expectation.raise_unexpected_message_args_error(name_but_not_args.map { |args| args[1] })
         end
       end
 
@@ -133,12 +167,23 @@ module RSpec
 
       # @private
       def reset
-        @messages_received.clear
+        @messages_received_mutex.synchronize do
+          @messages_received.clear
+        end
       end
 
       # @private
       def received_message?(method_name, *args, &block)
-        @messages_received.any? { |array| array == [method_name, args, block] }
+        @messages_received_mutex.synchronize do
+          @messages_received.any? { |array| array == [method_name, args, block] }
+        end
+      end
+
+      # @private
+      def messages_arg_list
+        @messages_received_mutex.synchronize do
+          @messages_received.map { |_, args, _| args }
+        end
       end
 
       # @private
@@ -149,7 +194,9 @@ module RSpec
       # @private
       def record_message_received(message, *args, &block)
         @order_group.invoked SpecificMessage.new(object, message, args)
-        @messages_received << [message, args, block]
+        @messages_received_mutex.synchronize do
+          @messages_received << [message, args, block]
+        end
       end
 
       # @private
@@ -166,36 +213,33 @@ module RSpec
           end
           stub.invoke(nil, *args, &block)
         elsif expectation
+          expectation.unadvise(messages_arg_list)
           expectation.invoke(stub, *args, &block)
         elsif (expectation = find_almost_matching_expectation(message, *args))
           expectation.advise(*args) if null_object? unless expectation.expected_messages_received?
 
           if null_object? || !has_negative_expectation?(message)
-            raise_unexpected_message_args_error(expectation, *args)
+            expectation.raise_unexpected_message_args_error([args])
           end
         elsif (stub = find_almost_matching_stub(message, *args))
           stub.advise(*args)
-          raise_missing_default_stub_error(stub, *args)
+          raise_missing_default_stub_error(stub, [args])
         elsif Class === @object
           @object.superclass.__send__(message, *args, &block)
         else
           @object.__send__(:method_missing, message, *args, &block)
         end
       end
+      ruby2_keywords :message_received if respond_to?(:ruby2_keywords, true)
 
       # @private
-      def raise_unexpected_message_error(method_name, *args)
-        @error_generator.raise_unexpected_message_error method_name, *args
+      def raise_unexpected_message_error(method_name, args)
+        @error_generator.raise_unexpected_message_error method_name, args
       end
 
       # @private
-      def raise_unexpected_message_args_error(expectation, *args)
-        @error_generator.raise_unexpected_message_args_error(expectation, *args)
-      end
-
-      # @private
-      def raise_missing_default_stub_error(expectation, *args)
-        @error_generator.raise_missing_default_stub_error(expectation, *args)
+      def raise_missing_default_stub_error(expectation, args_for_multiple_calls)
+        @error_generator.raise_missing_default_stub_error(expectation, args_for_multiple_calls)
       end
 
       # @private
@@ -220,6 +264,11 @@ module RSpec
         end
       end
 
+      # @private
+      def method_double_if_exists_for_message(message)
+        method_double_for(message) if @method_doubles.key?(message.to_sym)
+      end
+
     private
 
       def method_double_for(message)
@@ -231,12 +280,14 @@ module RSpec
           expectation.matches?(method_name, *args)
         end
       end
+      ruby2_keywords :find_matching_expectation if respond_to?(:ruby2_keywords, true)
 
       def find_almost_matching_expectation(method_name, *args)
         find_best_matching_expectation_for(method_name) do |expectation|
           expectation.matches_name_but_not_args(method_name, *args)
         end
       end
+      ruby2_keywords :find_almost_matching_expectation if respond_to?(:ruby2_keywords, true)
 
       def find_best_matching_expectation_for(method_name)
         first_match = nil
@@ -253,10 +304,12 @@ module RSpec
       def find_matching_method_stub(method_name, *args)
         method_double_for(method_name).stubs.find { |stub| stub.matches?(method_name, *args) }
       end
+      ruby2_keywords :find_matching_method_stub if respond_to?(:ruby2_keywords, true)
 
       def find_almost_matching_stub(method_name, *args)
         method_double_for(method_name).stubs.find { |stub| stub.matches_name_but_not_args(method_name, *args) }
       end
+      ruby2_keywords :find_almost_matching_stub if respond_to?(:ruby2_keywords, true)
     end
 
     # @private
@@ -312,6 +365,7 @@ module RSpec
         end
         super
       end
+      ruby2_keywords :message_received if respond_to?(:ruby2_keywords, true)
 
     private
 
@@ -363,27 +417,43 @@ module RSpec
 
         return super unless unbound_method
         unbound_method.bind(object)
+        # :nocov:
+      rescue TypeError
+        if RUBY_VERSION == '1.8.7'
+          # In MRI 1.8.7, a singleton method on a class cannot be rebound to its subclass
+          if unbound_method && unbound_method.owner.ancestors.first != unbound_method.owner
+            # This is a singleton method; we can't do anything with it
+            # But we can work around this using a different implementation
+            double = method_double_from_ancestor_for(message)
+            return object.method(double.method_stasher.stashed_method_name)
+          end
+        end
+        raise
+        # :nocov:
       end
 
     protected
 
       def original_unbound_method_handle_from_ancestor_for(message)
-        method_double = @method_doubles.fetch(message) do
+        double = method_double_from_ancestor_for(message)
+        double && double.original_method.unbind
+      end
+
+      def method_double_from_ancestor_for(message)
+        @method_doubles.fetch(message) do
           # The fact that there is no method double for this message indicates
           # that it has not been redefined by rspec-mocks. We need to continue
           # looking up the ancestor chain.
           return superclass_proxy &&
-            superclass_proxy.original_unbound_method_handle_from_ancestor_for(message)
+            superclass_proxy.method_double_from_ancestor_for(message)
         end
-
-        method_double.original_method.unbind
       end
 
       def superclass_proxy
         return @superclass_proxy if defined?(@superclass_proxy)
 
         if (superclass = object.superclass)
-          @superclass_proxy = @source_space.proxy_for(superclass)
+          @superclass_proxy = @source_space.superclass_proxy_for(superclass)
         else
           @superclass_proxy = nil
         end
@@ -398,33 +468,57 @@ module RSpec
     # @private
     class ProxyForNil < PartialDoubleProxy
       def initialize(order_group)
-        @warn_about_expectations = true
+        set_expectation_behavior
         super(nil, order_group)
       end
 
+      attr_accessor :disallow_expectations
       attr_accessor :warn_about_expectations
-      alias warn_about_expectations? warn_about_expectations
 
       def add_message_expectation(method_name, opts={}, &block)
-        warn(method_name) if warn_about_expectations?
-        super
-      end
-
-      def add_negative_message_expectation(location, method_name, &implementation)
-        warn(method_name) if warn_about_expectations?
+        warn_or_raise!(method_name)
         super
       end
 
       def add_stub(method_name, opts={}, &implementation)
-        warn(method_name) if warn_about_expectations?
+        warn_or_raise!(method_name)
         super
       end
 
     private
 
+      def set_expectation_behavior
+        case RSpec::Mocks.configuration.allow_message_expectations_on_nil
+        when false
+          @warn_about_expectations = false
+          @disallow_expectations = true
+        when true
+          @warn_about_expectations = false
+          @disallow_expectations = false
+        else
+          @warn_about_expectations = true
+          @disallow_expectations = false
+        end
+      end
+
+      def warn_or_raise!(method_name)
+        # This method intentionally swallows the message when
+        # neither disallow_expectations nor warn_about_expectations
+        # are set to true.
+        if disallow_expectations
+          raise_error(method_name)
+        elsif warn_about_expectations
+          warn(method_name)
+        end
+      end
+
       def warn(method_name)
-        source = CallerFilter.first_non_rspec_line
-        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{source}. Use allow_message_expectations_on_nil to disable warnings.")
+        warning_msg = @error_generator.expectation_on_nil_message(method_name)
+        RSpec.warning(warning_msg)
+      end
+
+      def raise_error(method_name)
+        @error_generator.raise_expectation_on_nil_error(method_name)
       end
     end
   end

data/rspec-mocks/upstream/lib/rspec/mocks/space.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_support 'reentrant_mutex'
+
 module RSpec
   module Mocks
     # @private
@@ -35,6 +37,10 @@ module RSpec
         false
       end
 
+      def superclass_proxy_for(*_args)
+        raise_lifecycle_message
+      end
+
       def new_scope
         Space.new
       end
@@ -109,6 +115,13 @@ module RSpec
         end
       end
 
+      def superclass_proxy_for(klass)
+        proxy_mutex.synchronize do
+          id = id_for(klass)
+          proxies.fetch(id) { superclass_proxy_not_found_for(id, klass) }
+        end
+      end
+
       alias ensure_registered proxy_for
 
       def registered?(object)
@@ -131,18 +144,8 @@ module RSpec
 
     private
 
-      # We don't want to depend on the stdlib ourselves, but if the user is
-      # using threads then a Mutex will be available to us. If not, we don't
-      # need to synchronize anyway.
       def new_mutex
-        defined?(::Mutex) ? ::Mutex.new : FakeMutex
-      end
-
-      # @private
-      module FakeMutex
-        def self.synchronize
-          yield
-        end
+        Support::ReentrantMutex.new
       end
 
       def proxy_not_found_for(id, object)
@@ -150,11 +153,7 @@ module RSpec
                       when NilClass   then ProxyForNil.new(@expectation_ordering)
                       when TestDouble then object.__build_mock_proxy_unless_expired(@expectation_ordering)
                       when Class
-                        if RSpec::Mocks.configuration.verify_partial_doubles?
-                          VerifyingPartialClassDoubleProxy.new(self, object, @expectation_ordering)
-                        else
-                          PartialClassDoubleProxy.new(self, object, @expectation_ordering)
-                        end
+                        class_proxy_with_callback_verification_strategy(object, CallbackInvocationStrategy.new)
                       else
                         if RSpec::Mocks.configuration.verify_partial_doubles?
                           VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
@@ -164,6 +163,24 @@ module RSpec
                       end
       end
 
+      def superclass_proxy_not_found_for(id, object)
+        raise "superclass_proxy_not_found_for called with something that is not a class" unless Class === object
+        proxies[id] = class_proxy_with_callback_verification_strategy(object, NoCallbackInvocationStrategy.new)
+      end
+
+      def class_proxy_with_callback_verification_strategy(object, strategy)
+        if RSpec::Mocks.configuration.verify_partial_doubles?
+          VerifyingPartialClassDoubleProxy.new(
+            self,
+            object,
+            @expectation_ordering,
+            strategy
+          )
+        else
+          PartialClassDoubleProxy.new(self, object, @expectation_ordering)
+        end
+      end
+
       def any_instance_recorder_not_found_for(id, klass)
         any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
       end

data/rspec-mocks/upstream/lib/rspec/mocks/standalone.rb

@@ -1,3 +1,3 @@
 require 'rspec/mocks'
-include RSpec::Mocks::ExampleMethods
+extend RSpec::Mocks::ExampleMethods
 RSpec::Mocks.setup

data/rspec-mocks/upstream/lib/rspec/mocks/syntax.rb

@@ -48,7 +48,7 @@ module RSpec
           end
 
           def unstub(message)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to_receive(...).and_call_original` or explicitly enable `:should`")
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to receive(...).and_call_original` or explicitly enable `:should`")
             ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
           end
 
@@ -214,11 +214,10 @@ if defined?(BasicObject)
     # the end of the example.
     #
     # @example
-    #
-    #     logger = double('logger')
-    #     thing_that_logs = ThingThatLogs.new(logger)
-    #     logger.should_receive(:log)
-    #     thing_that_logs.do_something_that_logs_a_message
+    #   logger = double('logger')
+    #   thing_that_logs = ThingThatLogs.new(logger)
+    #   logger.should_receive(:log)
+    #   thing_that_logs.do_something_that_logs_a_message
     #
     # @note This is only available when you have enabled the `should` syntax.
     # @see RSpec::Mocks::ExampleMethods#expect
@@ -232,10 +231,9 @@ if defined?(BasicObject)
     # Tells the object to respond to the message with the specified value.
     #
     # @example
-    #
-    #     counter.stub(:count).and_return(37)
-    #     counter.stub(:count => 37)
-    #     counter.stub(:count) { 37 }
+    #   counter.stub(:count).and_return(37)
+    #   counter.stub(:count => 37)
+    #   counter.stub(:count) { 37 }
     #
     # @note This is only available when you have enabled the `should` syntax.
     # @see RSpec::Mocks::ExampleMethods#allow
@@ -269,10 +267,9 @@ if defined?(BasicObject)
     # implementation calls `foo.baz.bar`, the stub will not work.
     #
     # @example
-    #
-    #     double.stub_chain("foo.bar") { :baz }
-    #     double.stub_chain(:foo, :bar => :baz)
-    #     double.stub_chain(:foo, :bar) { :baz }
+    #   double.stub_chain("foo.bar") { :baz }
+    #   double.stub_chain(:foo, :bar => :baz)
+    #   double.stub_chain(:foo, :bar) { :baz }
     #
     #     # Given any of ^^ these three forms ^^:
     #     double.foo.bar # => :baz
@@ -311,15 +308,14 @@ class Class
   # 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
   #
-  #     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))
+  #   Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+  #   Account.new.balance # => Money.new(:USD, 25))
   #
   # @return [Recorder]
   #

data/rspec-mocks/upstream/lib/rspec/mocks/targets.rb

@@ -1,12 +1,8 @@
 module RSpec
   module Mocks
     # @private
-    class TargetBase
-      def initialize(target)
-        @target = target
-      end
-
-      def self.delegate_to(matcher_method)
+    module TargetDelegationClassMethods
+      def delegate_to(matcher_method)
         define_method(:to) do |matcher, &block|
           unless matcher_allowed?(matcher)
             raise_unsupported_matcher(:to, matcher)
@@ -15,11 +11,11 @@ module RSpec
         end
       end
 
-      def self.delegate_not_to(matcher_method, options={})
+      def delegate_not_to(matcher_method, options={})
         method_name = options.fetch(:from)
         define_method(method_name) do |matcher, &block|
           case matcher
-          when Matchers::Receive
+          when Matchers::Receive, Matchers::HaveReceived
             define_matcher(matcher, matcher_method, &block)
           when Matchers::ReceiveMessages, Matchers::ReceiveMessageChain
             raise_negation_unsupported(method_name, matcher)
@@ -29,25 +25,30 @@ module RSpec
         end
       end
 
-      def self.disallow_negation(method_name)
+      def disallow_negation(method_name)
         define_method(method_name) do |matcher, *_args|
           raise_negation_unsupported(method_name, matcher)
         end
       end
+    end
+
+    # @private
+    module TargetDelegationInstanceMethods
+      attr_reader :target
 
     private
 
       def matcher_allowed?(matcher)
-        matcher.class.name.start_with?("RSpec::Mocks::Matchers".freeze)
+        Matchers::Matcher === matcher
       end
 
       def define_matcher(matcher, name, &block)
-        matcher.__send__(name, @target, &block)
+        matcher.__send__(name, target, &block)
       end
 
       def raise_unsupported_matcher(method_name, matcher)
         raise UnsupportedMatcherError,
-              "only the `receive` or `receive_messages` matchers are supported " \
+              "only the `receive`, `have_received` and `receive_messages` matchers are supported " \
               "with `#{expression}(...).#{method_name}`, but you have provided: #{matcher}"
       end
 
@@ -56,31 +57,54 @@ module RSpec
               "`#{expression}(...).#{method_name} #{matcher.name}` is not supported since it " \
               "doesn't really make sense. What would it even mean?"
       end
+    end
+
+    # @private
+    class TargetBase
+      def initialize(target)
+        @target = target
+      end
+
+      extend TargetDelegationClassMethods
+      include TargetDelegationInstanceMethods
+    end
+
+    # @private
+    module ExpectationTargetMethods
+      extend TargetDelegationClassMethods
+      include TargetDelegationInstanceMethods
+
+      delegate_to :setup_expectation
+      delegate_not_to :setup_negative_expectation, :from => :not_to
+      delegate_not_to :setup_negative_expectation, :from => :to_not
 
       def expression
-        self.class::EXPRESSION
+        :expect
       end
     end
 
+    # @private
+    class ExpectationTarget < TargetBase
+      include ExpectationTargetMethods
+    end
+
     # @private
     class AllowanceTarget < TargetBase
-      EXPRESSION = :allow
+      def expression
+        :allow
+      end
+
       delegate_to :setup_allowance
       disallow_negation :not_to
       disallow_negation :to_not
     end
 
-    # @private
-    class ExpectationTarget < TargetBase
-      EXPRESSION = :expect
-      delegate_to :setup_expectation
-      delegate_not_to :setup_negative_expectation, :from => :not_to
-      delegate_not_to :setup_negative_expectation, :from => :to_not
-    end
-
     # @private
     class AnyInstanceAllowanceTarget < TargetBase
-      EXPRESSION = :allow_any_instance_of
+      def expression
+        :allow_any_instance_of
+      end
+
       delegate_to :setup_any_instance_allowance
       disallow_negation :not_to
       disallow_negation :to_not
@@ -88,7 +112,10 @@ module RSpec
 
     # @private
     class AnyInstanceExpectationTarget < TargetBase
-      EXPRESSION = :expect_any_instance_of
+      def expression
+        :expect_any_instance_of
+      end
+
       delegate_to :setup_any_instance_expectation
       delegate_not_to :setup_any_instance_negative_expectation, :from => :not_to
       delegate_not_to :setup_any_instance_negative_expectation, :from => :to_not