rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

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

@@ -0,0 +1,35 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      class ExpectChainChain < StubChain
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
+        end
+
+        def expectation_fulfilled?
+          @expectation_fulfilled
+        end
+
+        def playback!(instance)
+          super.tap { @expectation_fulfilled = true }
+        end
+
+        private
+
+        def create_message_expectation_on(instance)
+          ::RSpec::Mocks::ExpectChain.expect_chain_on(instance, *@expectation_args, &@expectation_block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :and_return => [nil],
+            :and_raise => [nil],
+            :and_yield => [nil]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module RSpec
         private
 
         def create_message_expectation_on(instance)
-          proxy = ::RSpec::Mocks.proxy_for(instance)
+          proxy = ::RSpec::Mocks.space.proxy_for(instance)
           expected_from = IGNORED_BACKTRACE_LINE
           me = proxy.add_message_expectation(expected_from, *@expectation_args, &@expectation_block)
           if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
@@ -44,4 +44,3 @@ module RSpec
     end
   end
 end
-

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

@@ -49,6 +49,15 @@ module RSpec
           end
         end
 
+        # @api 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.
@@ -73,7 +82,7 @@ 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|
+          ::RSpec::Mocks.space.proxies_of(@klass).each do |proxy|
             stubs[method_name].each { |stub| proxy.remove_single_stub(method_name, stub) }
           end
           stubs[method_name].clear
@@ -116,10 +125,38 @@ module RSpec
         end
 
         def already_observing?(method_name)
-          @observed_methods.include?(method_name)
+          @observed_methods.include?(method_name) || super_class_observing?(method_name)
+        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
+      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}
@@ -141,11 +178,13 @@ module RSpec
         end
 
         def restore_original_method!(method_name)
-          alias_method_name = build_alias_method_name(method_name)
-          @klass.class_exec do
-            remove_method method_name
-            alias_method  method_name, alias_method_name
-            remove_method alias_method_name
+          if @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
+              remove_method alias_method_name
+            end
           end
         end
 
@@ -163,12 +202,7 @@ 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)
@@ -180,8 +214,8 @@ module RSpec
           @observed_methods << 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
-            ::RSpec::Mocks.any_instance_recorder_for(klass).playback!(self, method_name)
+            klass = ::RSpec::Support.method_handle_for(self, method_name).owner
+            ::RSpec::Mocks.space.any_instance_recorder_for(klass).playback!(self, method_name)
             self.__send__(method_name, *args, &blk)
           end
         end
@@ -189,8 +223,8 @@ module RSpec
         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)
+            klass = ::RSpec::Support.method_handle_for(self, method_name).owner
+            invoked_instance = ::RSpec::Mocks.space.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}"
           end
         end

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

@@ -12,7 +12,7 @@ module RSpec
         private
 
         def create_message_expectation_on(instance)
-          proxy = ::RSpec::Mocks.proxy_for(instance)
+          proxy = ::RSpec::Mocks.space.proxy_for(instance)
           expected_from = IGNORED_BACKTRACE_LINE
           stub = proxy.add_stub(expected_from, *@expectation_args, &@expectation_block)
           @recorder.stubs[stub.message] << stub

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

@@ -3,6 +3,10 @@ module RSpec
     module AnyInstance
       # @private
       class StubChainChain < StubChain
+        def initialize(*args)
+          super
+          @expectation_fulfilled = false
+        end
 
         private
 

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -1,17 +1,18 @@
 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`:
     #
-    #     object.should_receive(:message).with(:a, 'b', 3)
+    #     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.
     #
-    #     object.should_receive(:message).with(hash_including(:a => 'b'))
+    #     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
@@ -35,24 +36,17 @@ module RSpec
       # @param [Block] block a block with arity matching the expected
       #
       # Initializes an `ArgumentListMatcher` with a collection of literal
-      # values and/or argument matchers, or a block that handles the evaluation
-      # for you.
+      # values and/or argument matchers.
       #
       # @see ArgumentMatchers
       # @see #args_match?
-      def initialize(*expected_args, &block)
+      def initialize(*expected_args)
         @expected_args = expected_args
-        @block = expected_args.empty? ? block : nil
-        @match_any_args = false
-        @matchers = nil
 
-        case expected_args.first
-        when ArgumentMatchers::AnyArgsMatcher
-          @match_any_args = true
-        when ArgumentMatchers::NoArgsMatcher
-          @matchers = []
-        else
-          @matchers = expected_args.collect {|arg| matcher_for(arg)}
+        @matchers = case expected_args.first
+          when ArgumentMatchers::AnyArgsMatcher then Array
+          when ArgumentMatchers::NoArgsMatcher  then []
+          else expected_args
         end
       end
 
@@ -64,35 +58,7 @@ module RSpec
       #
       # @see #initialize
       def args_match?(*args)
-        match_any_args? || block_passes?(*args) || matchers_match?(*args)
-      end
-
-      private
-
-      def matcher_for(arg)
-        return ArgumentMatchers::MatcherMatcher.new(arg) if is_matcher?(arg)
-        return ArgumentMatchers::RegexpMatcher.new(arg)  if Regexp === arg
-        return ArgumentMatchers::EqualityProxy.new(arg)
-      end
-
-      def is_matcher?(object)
-        return false if object.respond_to?(:i_respond_to_everything_so_im_not_really_a_matcher)
-
-        [:failure_message_for_should, :failure_message].any? do |msg|
-          object.respond_to?(msg)
-        end && object.respond_to?(:matches?)
-      end
-
-      def block_passes?(*args)
-        @block.call(*args) if @block
-      end
-
-      def matchers_match?(*args)
-        @matchers == args
-      end
-
-      def match_any_args?
-        @match_any_args
+        Support::FuzzyMatcher.values_match?(@matchers, args)
       end
 
       # Value that will match all argument lists.

data/lib/rspec/mocks/argument_matchers.rb

@@ -10,149 +10,12 @@ module RSpec
     #
     # @see ArgumentListMatcher
     module ArgumentMatchers
-
-      class AnyArgsMatcher
-        def description
-          "any args"
-        end
-      end
-
-      class AnyArgMatcher
-        def initialize(ignore)
-        end
-
-        def ==(other)
-          true
-        end
-      end
-
-      class NoArgsMatcher
-        def description
-          "no args"
-        end
-      end
-
-      class RegexpMatcher
-        def initialize(regexp)
-          @regexp = regexp
-        end
-
-        def ==(value)
-          Regexp === value ? value == @regexp : value =~ @regexp
-        end
-      end
-
-      class BooleanMatcher
-        def initialize(ignore)
-        end
-
-        def ==(value)
-          [true,false].include?(value)
-        end
-      end
-
-      class HashIncludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ==(actual)
-          @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
-        rescue NoMethodError
-          false
-        end
-
-        def description
-          "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
-        end
-      end
-
-      class HashExcludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ==(actual)
-          @expected.none? {|k,v| actual.has_key?(k) && v == actual[k]}
-        rescue NoMethodError
-          false
-        end
-
-        def description
-          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
-        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
-        end
-
-        def ==(value)
-          @methods_to_respond_to.all? {|message| value.respond_to?(message)}
-        end
-      end
-
-      class MatcherMatcher
-        def initialize(matcher)
-          @matcher = matcher
-        end
-
-        def ==(value)
-          @matcher.matches?(value)
-        end
-      end
-
-      class EqualityProxy
-        def initialize(given)
-          @given = given
-        end
-
-        def ==(expected)
-          @given == expected
-        end
-      end
-
-      class InstanceOf
-        def initialize(klass)
-          @klass = klass
-        end
-
-        def ==(actual)
-          actual.instance_of?(@klass)
-        end
-      end
-
-      class KindOf
-        def initialize(klass)
-          @klass = klass
-        end
-
-        def ==(actual)
-          actual.kind_of?(@klass)
-        end
-      end
-
       # Matches any args at all. Supports a more explicit variation of
-      # `object.should_receive(:message)`
+      # `expect(object).to receive(:message)`
       #
       # @example
       #
-      #   object.should_receive(:message).with(any_args)
+      #   expect(object).to receive(:message).with(any_args)
       def any_args
         AnyArgsMatcher.new
       end
@@ -161,16 +24,16 @@ module RSpec
       #
       # @example
       #
-      #   object.should_receive(:message).with(anything)
+      #   expect(object).to receive(:message).with(anything)
       def anything
-        AnyArgMatcher.new(nil)
+        AnyArgMatcher.new
       end
 
       # Matches no arguments.
       #
       # @example
       #
-      #   object.should_receive(:message).with(no_args)
+      #   expect(object).to receive(:message).with(no_args)
       def no_args
         NoArgsMatcher.new
       end
@@ -179,8 +42,8 @@ module RSpec
       #
       # @example
       #
-      #   object.should_receive(:message).with(duck_type(:hello))
-      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
+      #   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
@@ -189,9 +52,9 @@ module RSpec
       #
       # @example
       #
-      #   object.should_receive(:message).with(boolean())
+      #   expect(object).to receive(:message).with(boolean())
       def boolean
-        BooleanMatcher.new(nil)
+        BooleanMatcher.new
       end
 
       # Matches a hash that includes the specified key(s) or key/value pairs.
@@ -199,11 +62,11 @@ module RSpec
       #
       # @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))
+      #   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(anythingize_lonely_keys(*args))
+        HashIncludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
       end
 
       # Matches an array that includes the specified items at least once.
@@ -211,8 +74,8 @@ module RSpec
       #
       # @example
       #
-      #   object.should_receive(:message).with(array_including(1,2,3))
-      #   object.should_receive(:message).with(array_including([1,2,3]))
+      #   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)
@@ -222,11 +85,11 @@ module RSpec
       #
       # @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))
+      #   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(anythingize_lonely_keys(*args))
+        HashExcludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
       end
 
       alias_method :hash_not_including, :hash_excluding
@@ -235,7 +98,7 @@ module RSpec
       #
       # @example
       #
-      #   object.should_receive(:message).with(instance_of(Thing))
+      #   expect(object).to receive(:message).with(instance_of(Thing))
       def instance_of(klass)
         InstanceOf.new(klass)
       end
@@ -245,20 +108,126 @@ module RSpec
       # Matches if `arg.kind_of?(klass)`
       # @example
       #
-      #   object.should_receive(:message).with(kind_of(Thing))
+      #   expect(object).to receive(:message).with(kind_of(Thing))
       def kind_of(klass)
-        KindOf.new(klass)
+        klass
       end
 
       alias_method :a_kind_of, :kind_of
 
-      private
-
-      def anythingize_lonely_keys(*args)
+      # @api private
+      def self.anythingize_lonely_keys(*args)
         hash = args.last.class == Hash ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = anything }
+        args.each { | arg | hash[arg] = AnyArgMatcher.new }
         hash
       end
+
+      # @api private
+      class AnyArgsMatcher
+        def description
+          "any args"
+        end
+      end
+
+      # @api private
+      class AnyArgMatcher
+        def ===(other)
+          true
+        end
+      end
+
+      # @api private
+      class NoArgsMatcher
+        def description
+          "no args"
+        end
+      end
+
+      # @api private
+      class BooleanMatcher
+        def ===(value)
+          true == value || false == value
+        end
+      end
+
+      # @api private
+      class BaseHashMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ===(predicate, actual)
+          @expected.__send__(predicate) do |k, v|
+            actual.has_key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
+          end
+        rescue NoMethodError
+          false
+        end
+
+        def description(name)
+          "#{name}(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+
+      # @api private
+      class HashIncludingMatcher < BaseHashMatcher
+        def ===(actual)
+          super(:all?, actual)
+        end
+
+        def description
+          super("hash_including")
+        end
+      end
+
+      # @api private
+      class HashExcludingMatcher < BaseHashMatcher
+        def ===(actual)
+          super(:none?, actual)
+        end
+
+        def description
+          super("hash_not_including")
+        end
+      end
+
+      # @api 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
+
+      # @api 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
+      end
+
+      # @api private
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ===(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+
     end
   end
 end