rspec-mocks 2.5.0 → 2.6.0

data/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,256 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class Chain
+        [
+          :with, :and_return, :and_raise, :and_yield,
+          :once, :twice, :any_number_of_times,
+          :exactly, :times, :never,
+          :at_least, :at_most
+          ].each do |method_name|
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{method_name}(*args, &block)
+                record(:#{method_name}, *args, &block)
+              end
+            EOM
+        end
+
+        def playback!(instance)
+          messages.inject(instance) do |instance, message|
+            instance.send(*message.first, &message.last)
+          end
+        end
+
+        def constrained_to_any_of?(*constraints)
+          constraints.any? do |constraint|
+            messages.any? do |message|
+              message.first.first == constraint
+            end
+          end
+        end
+
+        private
+        def messages
+          @messages ||= []
+        end
+
+        def last_message
+          messages.last.first.first unless messages.empty?
+        end
+
+        def record(rspec_method_name, *args, &block)
+          verify_invocation_order(rspec_method_name, *args, &block)
+          messages << [args.unshift(rspec_method_name), block]
+          self
+        end
+      end
+
+      class StubChain < Chain
+        def initialize(*args, &block)
+          record(:stub, *args, &block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :stub => [nil],
+            :with => [:stub],
+            :and_return => [:with, :stub],
+            :and_raise => [:with, :stub],
+            :and_yield => [:with, :stub]
+          }
+        end
+
+        def expectation_filfilled?
+          true
+        end
+
+        private
+        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
+        end
+      end
+
+      class ExpectationChain < Chain
+        def initialize(*args, &block)
+          record(:should_receive, *args, &block)
+          @expectation_fulfilled = false
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :should_receive => [nil],
+            :with => [:should_receive],
+            :and_return => [:with, :should_receive],
+            :and_raise => [:with, :should_receive]
+          }
+        end
+
+        def expectation_fulfilled!
+          @expectation_fulfilled = true
+        end
+
+        def expectation_filfilled?
+          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+        end
+
+        private
+        def verify_invocation_order(rspec_method_name, *args, &block)
+        end
+      end
+
+      class Recorder
+        def initialize(klass)
+          @message_chains = {}
+          @observed_methods = []
+          @played_methods = {}
+          @klass = klass
+          @expectation_set = false
+        end
+
+        def stub(method_name, *args, &block)
+          observe!(method_name)
+          @message_chains[method_name] = StubChain.new(method_name, *args, &block)
+        end
+
+        def should_receive(method_name, *args, &block)
+          observe!(method_name)
+          @expectation_set = true
+          @message_chains[method_name] = ExpectationChain.new(method_name, *args, &block)
+        end
+
+        def stop_all_observation!
+          @observed_methods.each do |method_name|
+            restore_method!(method_name)
+          end
+        end
+
+        def playback!(instance, method_name)
+          RSpec::Mocks::space.add(instance)
+          @message_chains[method_name].playback!(instance)
+          @played_methods[method_name] = instance
+          received_expected_message!(method_name) if has_expectation?(method_name)
+        end
+
+        def instance_that_received(method_name)
+          @played_methods[method_name]
+        end
+
+        def verify
+          if @expectation_set && !each_expectation_filfilled?
+            raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+          end
+        end
+
+        private
+        def each_expectation_filfilled?
+          @message_chains.all? do |method_name, chain|
+            chain.expectation_filfilled?
+          end
+        end
+
+        def has_expectation?(method_name)
+          @message_chains[method_name].is_a?(ExpectationChain)
+        end
+
+        def unfulfilled_expectations
+          @message_chains.map do |method_name, chain|
+            method_name.to_s if chain.is_a?(ExpectationChain) unless chain.expectation_filfilled?
+          end.compact
+        end
+
+        def received_expected_message!(method_name)
+          @message_chains[method_name].expectation_fulfilled!
+          restore_method!(method_name)
+          mark_invoked!(method_name)
+        end
+
+        def restore_method!(method_name)
+          if @klass.method_defined?(build_alias_method_name(method_name))
+            restore_original_method!(method_name)
+          else
+            remove_dummy_method!(method_name)
+          end
+        end
+
+        def build_alias_method_name(method_name)
+          "__#{method_name}_without_any_instance__"
+        end
+
+        def restore_original_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_eval do
+            alias_method  method_name, alias_method_name
+            remove_method alias_method_name
+          end
+        end
+
+        def remove_dummy_method!(method_name)
+          @klass.class_eval do
+            remove_method method_name
+          end
+        end
+
+        def backup_method!(method_name)
+          alias_method_name = build_alias_method_name(method_name)
+          @klass.class_eval do
+            if method_defined?(method_name)
+              alias_method alias_method_name, method_name
+            end
+          end
+        end
+
+        def stop_observing!(method_name)
+          restore_method!(method_name)
+          @observed_methods.delete(method_name)
+        end
+
+        def already_observing?(method_name)
+          @observed_methods.include?(method_name)
+        end
+
+        def observe!(method_name)
+          stop_observing!(method_name) if already_observing?(method_name)
+          @observed_methods << method_name
+          backup_method!(method_name)
+          @klass.class_eval(<<-EOM, __FILE__, __LINE__)
+            def #{method_name}(*args, &blk)
+              self.class.__recorder.playback!(self, :#{method_name})
+              self.send(:#{method_name}, *args, &blk)
+            end
+          EOM
+        end
+
+        def mark_invoked!(method_name)
+          backup_method!(method_name)
+          @klass.class_eval(<<-EOM, __FILE__, __LINE__)
+            def #{method_name}(*args, &blk)
+              method_name = :#{method_name}
+              current_instance = self
+              invoked_instance = self.class.__recorder.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
+          EOM
+        end
+      end
+
+      def any_instance
+        RSpec::Mocks::space.add(self)
+        __recorder
+      end
+
+      def rspec_verify
+        __recorder.verify
+        super
+      ensure
+        __recorder.stop_all_observation!
+        @__recorder = nil
+      end
+
+      def __recorder
+        @__recorder ||= AnyInstance::Recorder.new(self)
+      end
+    end
+  end
+end

data/lib/rspec/mocks/argument_expectation.rb

@@ -5,7 +5,7 @@ module RSpec
       
       def initialize(*args, &block)
         @args = args
-        @matchers_block = args.empty? ? block : nil
+        @block = args.empty? ? block : nil
         @match_any_args = false
         @matchers = nil
         
@@ -26,19 +26,20 @@ module RSpec
       end
       
       def is_matcher?(obj)
-        !is_stub_as_null_object?(obj) & obj.respond_to?(:matches?) & obj.respond_to?(:description)
+        !null_object?(obj) & obj.respond_to?(:matches?) & obj.respond_to?(:description)
       end
 
-      def is_stub_as_null_object?(obj)
-        obj.respond_to?(:__rspec_double_acting_as_null_object?) && obj.__rspec_double_acting_as_null_object?
+      def args_match?(*args)
+        match_any_args? || block_passes?(*args) || matchers_match?(*args)
       end
       
-      def args_match?(*args)
-        match_any_args? || matchers_block_matches?(*args) || matchers_match?(*args)
+      private
+      def null_object?(obj)
+        obj.respond_to?(:__rspec_double_acting_as_null_object?) && obj.__rspec_double_acting_as_null_object?
       end
       
-      def matchers_block_matches?(*args)
-        @matchers_block ? @matchers_block.call(*args) : nil
+      def block_passes?(*args)
+        @block.call(*args) if @block
       end
       
       def matchers_match?(*args)

data/lib/rspec/mocks/extensions/marshal.rb

@@ -1,7 +1,5 @@
 module Marshal
-
   class << self
-
     def dump_with_mocks(*args)
       object = args.shift
       return dump_without_mocks(*args.unshift(object)) unless object.instance_variable_defined?(:@mock_proxy)
@@ -21,7 +19,5 @@ module Marshal
     alias_method :dump_without_mocks, :dump
     undef_method :dump
     alias_method :dump, :dump_with_mocks
-
   end
-
 end

data/lib/rspec/mocks/extensions/psych.rb

@@ -0,0 +1,23 @@
+if defined?(Psych) && Psych.respond_to?(:dump)
+  module Psych
+    class << self
+      def dump_with_mocks(object, *args)
+        return dump_without_mocks(object, *args) unless object.instance_variable_defined?(:@mock_proxy)
+
+        mp = object.instance_variable_get(:@mock_proxy)
+        return dump_without_mocks(object, *args) unless mp.is_a?(::RSpec::Mocks::Proxy)
+
+        object.send(:remove_instance_variable, :@mock_proxy)
+
+        begin
+          dump_without_mocks(object, *args)
+        ensure
+          object.instance_variable_set(:@mock_proxy,mp)
+        end
+      end
+
+      alias_method :dump_without_mocks, :dump
+      alias_method :dump, :dump_with_mocks
+    end
+  end
+end

data/lib/rspec/mocks/framework.rb

@@ -15,3 +15,4 @@ require 'rspec/mocks/errors'
 require 'rspec/mocks/error_generator'
 require 'rspec/mocks/space'
 require 'rspec/mocks/serialization'
+require 'rspec/mocks/any_instance'

data/lib/rspec/mocks/message_expectation.rb

@@ -249,22 +249,25 @@ module RSpec
       end
 
       def with(*args, &block)
-        @return_block = block if block_given?
+        @return_block = block if block_given? unless args.empty?
         @args_expectation = ArgumentExpectation.new(*args, &block)
         self
       end
       
-      def exactly(n)
+      def exactly(n, &block)
+        @method_block = block if block
         set_expected_received_count :exactly, n
         self
       end
       
-      def at_least(n)
+      def at_least(n, &block)
+        @method_block = block if block
         set_expected_received_count :at_least, n
         self
       end
       
-      def at_most(n)
+      def at_most(n, &block)
+        @method_block = block if block
         set_expected_received_count :at_most, n
         self
       end

data/lib/rspec/mocks/methods.rb

@@ -39,7 +39,7 @@ module RSpec
         if chain.length > 1
           if matching_stub = __mock_proxy.__send__(:find_matching_method_stub, chain[0].to_sym)
             chain.shift
-            matching_stub.invoke.stub_chain(*chain)
+            matching_stub.invoke.stub_chain(*chain, &blk)
           else
             next_in_chain = Object.new
             stub(chain.shift) { next_in_chain }

data/lib/rspec/mocks/mock.rb

@@ -41,10 +41,10 @@ module RSpec
     private
 
       def method_missing(sym, *args, &block)
+          raise NoMethodError if sym == :to_ary
         __mock_proxy.record_message_received(sym, *args, &block)
         begin
-          return self if __mock_proxy.null_object?
-          super
+          __mock_proxy.null_object? ? self : super
         rescue NameError
           __mock_proxy.raise_unexpected_message_error(sym, *args)
         end

data/lib/rspec/mocks/serialization.rb

@@ -1,4 +1,5 @@
 require 'rspec/mocks/extensions/marshal'
+require 'rspec/mocks/extensions/psych' if defined?(::Psych)
 
 module RSpec
   module Mocks
@@ -8,14 +9,15 @@ module RSpec
       end
 
       module YAML
-        def to_yaml(*a)
-          return super(*a) unless instance_variable_defined?(:@mock_proxy)
+        def to_yaml(options = {})
+          return nil if defined?(::Psych) && options.respond_to?(:[]) && options[:nodump]
+          return super(options) unless instance_variable_defined?(:@mock_proxy)
 
           mp = @mock_proxy
           remove_instance_variable(:@mock_proxy)
 
           begin
-            super(*a)
+            super(options)
           ensure
             @mock_proxy = mp
           end

data/lib/rspec/mocks/space.rb

@@ -10,7 +10,7 @@ module RSpec
           mock.rspec_verify
         end
       end
-      
+
       def reset_all
         mocks.each do |mock|
           mock.rspec_reset

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec # :nodoc:
   module Mocks # :nodoc:
     module Version # :nodoc:
-      STRING = '2.5.0'
+      STRING = '2.6.0'
     end
   end
 end

data/lib/rspec/mocks.rb

@@ -177,7 +177,8 @@ module RSpec
       attr_accessor :space
 
       def setup(includer)
-        Object.class_eval { include RSpec::Mocks::Methods } unless Object < RSpec::Mocks::Methods
+        Object.class_eval { include RSpec::Mocks::Methods }
+        Class.class_eval  { include RSpec::Mocks::AnyInstance }
         (class << includer; self; end).class_eval do
           include RSpec::Mocks::ExampleMethods
         end

data/spec/rspec/mocks/and_yield_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
-def obj
-  @obj ||= mock
-end
 
 describe RSpec::Mocks::Mock do
+
+  let(:obj) { double }
+
   describe "#and_yield" do
     context "with eval context as block argument" do