opal-rspec 0.4.3 → 0.5.0.beta1

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/any_instance/recorder.rb

@@ -15,7 +15,7 @@ module RSpec
 
         def initialize(klass)
           @message_chains = MessageChains.new
-          @stubs = Hash.new { |hash,key| hash[key] = [] }
+          @stubs = Hash.new { |hash, key| hash[key] = [] }
           @observed_methods = []
           @played_methods = {}
           @klass = klass
@@ -26,15 +26,9 @@ module RSpec
         # instance of this object that invokes the submitted method.
         #
         # @see Methods#stub
-        def stub(method_name_or_method_map, &block)
-          if Hash === method_name_or_method_map
-            method_name_or_method_map.each do |method_name, return_value|
-              stub(method_name).and_return(return_value)
-            end
-          else
-            observe!(method_name_or_method_map)
-            message_chains.add(method_name_or_method_map, StubChain.new(self, method_name_or_method_map, &block))
-          end
+        def stub(method_name, &block)
+          observe!(method_name)
+          message_chains.add(method_name, StubChain.new(self, method_name, &block))
         end
 
         # Initializes the recording a stub chain to be played back against any
@@ -49,6 +43,15 @@ module RSpec
           end
         end
 
+        # @private
+        def expect_chain(*method_names_and_optional_return_values, &block)
+          @expectation_set = true
+          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
+            observe!(method_name)
+            message_chains.add(method_name, ExpectChainChain.new(self, *args, &block))
+          end
+        end
+
         # Initializes the recording a message expectation to be played back
         # against any instance of this object that invokes the submitted
         # method.
@@ -60,6 +63,9 @@ module RSpec
           message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
         end
 
+        # The opposite of `should_receive`
+        #
+        # @see Methods#should_not_receive
         def should_not_receive(method_name, &block)
           should_receive(method_name, &block).never
         end
@@ -73,9 +79,6 @@ module RSpec
             raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
           end
           message_chains.remove_stub_chains_for!(method_name)
-          ::RSpec::Mocks.proxies_of(@klass).each do |proxy|
-            stubs[method_name].each { |stub| proxy.remove_single_stub(method_name, stub) }
-          end
           stubs[method_name].clear
           stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
         end
@@ -85,17 +88,17 @@ module RSpec
         # Used internally to verify that message expectations have been
         # fulfilled.
         def verify
-          if @expectation_set && !message_chains.all_expectations_fulfilled?
-            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
-          end
-        ensure
-          stop_all_observation!
-          ::RSpec::Mocks.space.remove_any_instance_recorder_for(@klass)
+          return unless @expectation_set
+          return if message_chains.all_expectations_fulfilled?
+
+          raise RSpec::Mocks::MockExpectationError,
+                "Exactly one instance should have received the following " \
+                "message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
         end
 
         # @private
         def stop_all_observation!
-          @observed_methods.each {|method_name| restore_method!(method_name)}
+          @observed_methods.each { |method_name| restore_method!(method_name) }
         end
 
         # @private
@@ -111,18 +114,63 @@ module RSpec
           @played_methods[method_name]
         end
 
+        # @private
         def build_alias_method_name(method_name)
           "__#{method_name}_without_any_instance__"
         end
 
+        # @private
         def already_observing?(method_name)
-          @observed_methods.include?(method_name)
+          @observed_methods.include?(method_name) || super_class_observing?(method_name)
         end
 
-        private
+        # @private
+        def notify_received_message(_object, message, args, _blk)
+          has_expectation = false
+
+          message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
+            has_expectation = true
+            expectation.expectation_fulfilled!
+          end
+
+          return unless has_expectation
+
+          restore_method!(message)
+          mark_invoked!(message)
+        end
+
+      protected
+
+        def stop_observing!(method_name)
+          restore_method!(method_name)
+          @observed_methods.delete(method_name)
+          super_class_observers_for(method_name).each do |ancestor|
+            ::RSpec::Mocks.space.
+              any_instance_recorder_for(ancestor).stop_observing!(method_name)
+          end
+        end
+
+      private
+
+        def ancestor_is_an_observer?(method_name)
+          lambda do |ancestor|
+            unless ancestor == @klass
+              ::RSpec::Mocks.space.
+                any_instance_recorder_for(ancestor).already_observing?(method_name)
+            end
+          end
+        end
+
+        def super_class_observers_for(method_name)
+          @klass.ancestors.select(&ancestor_is_an_observer?(method_name))
+        end
+
+        def super_class_observing?(method_name)
+          @klass.ancestors.any?(&ancestor_is_an_observer?(method_name))
+        end
 
         def normalize_chain(*args)
-          args.shift.to_s.split('.').map {|s| s.to_sym}.reverse.each {|a| args.unshift a}
+          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
           yield args.first, args
         end
 
@@ -141,10 +189,12 @@ module RSpec
         end
 
         def restore_original_method!(method_name)
+          return unless @klass.instance_method(method_name).owner == @klass
+
           alias_method_name = build_alias_method_name(method_name)
           @klass.class_exec do
             remove_method method_name
-            alias_method  method_name, alias_method_name
+            alias_method method_name, alias_method_name
             remove_method alias_method_name
           end
         end
@@ -163,35 +213,52 @@ module RSpec
         end
 
         def public_protected_or_private_method_defined?(method_name)
-          @klass.method_defined?(method_name) || @klass.private_method_defined?(method_name)
-        end
-
-        def stop_observing!(method_name)
-          restore_method!(method_name)
-          @observed_methods.delete(method_name)
+          MethodReference.method_defined_at_any_visibility?(@klass, method_name)
         end
 
         def observe!(method_name)
+          allow_no_prepended_module_definition_of(method_name)
+
           if RSpec::Mocks.configuration.verify_partial_doubles?
-            raise MockExpectationError unless @klass.method_defined?(method_name)
+            unless public_protected_or_private_method_defined?(method_name)
+              raise MockExpectationError,
+                    "#{@klass} does not implement ##{method_name}"
+            end
           end
 
           stop_observing!(method_name) if already_observing?(method_name)
           @observed_methods << method_name
           backup_method!(method_name)
+          recorder = self
           @klass.__send__(:define_method, method_name) do |*args, &blk|
-            klass = ::RSpec::Mocks.method_handle_for(self, method_name).owner
-            ::RSpec::Mocks.any_instance_recorder_for(klass).playback!(self, method_name)
-            self.__send__(method_name, *args, &blk)
+            recorder.playback!(self, method_name)
+            __send__(method_name, *args, &blk)
           end
         end
 
         def mark_invoked!(method_name)
           backup_method!(method_name)
-          @klass.__send__(:define_method, method_name) do |*args, &blk|
-            klass = ::RSpec::Mocks.method_handle_for(self, method_name).owner
-            invoked_instance = ::RSpec::Mocks.any_instance_recorder_for(klass).instance_that_received(method_name)
-            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{self.inspect} but has already been received by #{invoked_instance}"
+          recorder = self
+          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
+            invoked_instance = recorder.instance_that_received(method_name)
+            inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
+            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{inspect} but has already been received by #{invoked_instance}"
+          end
+        end
+
+        if Support::RubyFeatures.module_prepends_supported?
+          def allow_no_prepended_module_definition_of(method_name)
+            prepended_modules = RSpec::Mocks::Proxy.prepended_modules_of(@klass)
+            problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
+            return unless problem_mod
+
+            raise RSpec::Mocks::MockExpectationError,
+                  "Using `any_instance` to stub a method (#{method_name}) that has been " \
+                  "defined on a prepended module (#{problem_mod}) is not supported."
+          end
+        else
+          def allow_no_prepended_module_definition_of(_method_name)
+            # nothing to do; prepends aren't supported on this version of ruby
           end
         end
       end

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/any_instance/stub_chain.rb

@@ -3,18 +3,19 @@ module RSpec
     module AnyInstance
       # @private
       class StubChain < Chain
-
         # @private
         def expectation_fulfilled?
           true
         end
 
-        private
+      private
 
         def create_message_expectation_on(instance)
-          proxy = ::RSpec::Mocks.proxy_for(instance)
-          expected_from = IGNORED_BACKTRACE_LINE
-          stub = proxy.add_stub(expected_from, *@expectation_args, &@expectation_block)
+          proxy = ::RSpec::Mocks.space.proxy_for(instance)
+          method_name, opts = @expectation_args
+          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
+
+          stub = proxy.add_stub(method_name, opts, &@expectation_block)
           @recorder.stubs[stub.message] << stub
 
           if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
@@ -34,10 +35,9 @@ module RSpec
           }
         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[rspec_method_name].include?(last_message)
+          raise NoMethodError, "Undefined method #{rspec_method_name}"
         end
       end
     end

data/{vendor_lib → rspec-mocks/lib}/rspec/mocks/any_instance/stub_chain_chain.rb

@@ -3,8 +3,12 @@ module RSpec
     module AnyInstance
       # @private
       class StubChainChain < StubChain
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
+        end
 
-        private
+      private
 
         def create_message_expectation_on(instance)
           ::RSpec::Mocks::StubChain.stub_chain_on(instance, *@expectation_args, &@expectation_block)

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

@@ -0,0 +1,10 @@
+%w[
+  any_instance/chain
+  any_instance/stub_chain
+  any_instance/stub_chain_chain
+  any_instance/expect_chain_chain
+  any_instance/expectation_chain
+  any_instance/message_chains
+  any_instance/recorder
+  any_instance/proxy
+].each { |f| RSpec::Support.require_rspec_mocks(f) }

data/rspec-mocks/lib/rspec/mocks/argument_list_matcher.rb

@@ -0,0 +1,72 @@
+# We intentionally do not use the `RSpec::Support.require...` methods
+# here so that this file can be loaded individually, as documented
+# below.
+require 'rspec/mocks/argument_matchers'
+require 'rspec/support/fuzzy_matcher'
+
+module RSpec
+  module Mocks
+    # Wrapper for matching arguments against a list of expected values. Used by
+    # the `with` method on a `MessageExpectation`:
+    #
+    #     expect(object).to receive(:message).with(:a, 'b', 3)
+    #     object.message(:a, 'b', 3)
+    #
+    # Values passed to `with` can be literal values or argument matchers that
+    # match against the real objects .e.g.
+    #
+    #     expect(object).to receive(:message).with(hash_including(:a => 'b'))
+    #
+    # Can also be used directly to match the contents of any `Array`. This
+    # enables 3rd party mocking libs to take advantage of rspec's argument
+    # matching without using the rest of rspec-mocks.
+    #
+    #     require 'rspec/mocks/argument_list_matcher'
+    #     include RSpec::Mocks::ArgumentMatchers
+    #
+    #     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
+      attr_reader :expected_args
+
+      # @api public
+      # @param [Array] expected_args a list of expected literals and/or argument matchers
+      #
+      # Initializes an `ArgumentListMatcher` with a collection of literal
+      # values and/or argument matchers.
+      #
+      # @see ArgumentMatchers
+      # @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
+      end
+
+      # @api public
+      # @param [Array] 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)
+      end
+
+      # Value that will match all argument lists.
+      #
+      # @private
+      MATCH_ALL = new(ArgumentMatchers::AnyArgsMatcher.new)
+    end
+  end
+end

data/rspec-mocks/lib/rspec/mocks/argument_matchers.rb

@@ -0,0 +1,282 @@
+# 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.
+    #
+    # With the exception of `any_args` and `no_args`, they all match against
+    # the arg in same position in the argument list.
+    #
+    # @see ArgumentListMatcher
+    module ArgumentMatchers
+      # Matches any args at all. Supports a more explicit variation of
+      # `expect(object).to receive(:message)`
+      #
+      # @example
+      #
+      #   expect(object).to receive(:message).with(any_args)
+      def any_args
+        AnyArgsMatcher.new
+      end
+
+      # Matches any argument at all.
+      #
+      # @example
+      #
+      #   expect(object).to receive(:message).with(anything)
+      def anything
+        AnyArgMatcher.new
+      end
+
+      # Matches no arguments.
+      #
+      # @example
+      #
+      #   expect(object).to receive(:message).with(no_args)
+      def no_args
+        NoArgsMatcher.new
+      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)
+        DuckTypeMatcher.new(*args)
+      end
+
+      # Matches a boolean value.
+      #
+      # @example
+      #
+      #   expect(object).to receive(:message).with(boolean())
+      def boolean
+        BooleanMatcher.new
+      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 = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = AnyArgMatcher.new }
+        hash
+      end
+
+      # @private
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      # @private
+      class AnyArgMatcher
+        def ===(_other)
+          true
+        end
+
+        def description
+          "anything"
+        end
+      end
+
+      # @private
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      # @private
+      class BooleanMatcher
+        def ===(value)
+          true == value || false == value
+        end
+
+        def description
+          "boolean"
+        end
+      end
+
+      # @private
+      class BaseHashMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        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}(#{@expected.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
+        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
+          super("hash_not_including")
+        end
+      end
+
+      # @private
+      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
+
+      # @private
+      class DuckTypeMatcher
+        def initialize(*methods_to_respond_to)
+          @methods_to_respond_to = methods_to_respond_to
+        end
+
+        def ===(value)
+          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
+        end
+
+        def description
+          "duck_type(#{@methods_to_respond_to.map(&:inspect).join(', ')})"
+        end
+      end
+
+      # @private
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        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)
+          actual.kind_of?(@klass)
+        end
+
+        def description
+          "kind of #{@klass.name}"
+        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