rspec-mocks 2.6.0 → 2.7.0.rc1

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

@@ -0,0 +1,49 @@
+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
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      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_fulfilled?
+          @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
+        end
+
+        private
+        def verify_invocation_order(rspec_method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class MessageChains < Hash
+        def add(method_name, chain)
+          (self[method_name] ||= []) << chain
+        end
+        
+        def remove_stub_chains_for!(method_name)
+          chains = self[method_name]
+          chains.reject! { |chain| chain.is_a?(StubChain) || chain.is_a?(StubChainChain) }
+        end
+        
+        def has_expectation?(method_name)
+          !!self[method_name].find{|chain| chain.is_a?(ExpectationChain)}
+        end
+        
+        def each_expectation_fulfilled?
+          self.all? do |method_name, chains|
+            chains.all? { |chain| chain.expectation_fulfilled? }
+          end
+        end
+
+        def unfulfilled_expectations
+          self.map do |method_name, chains|
+            method_name.to_s if chains.last.is_a?(ExpectationChain) unless chains.last.expectation_fulfilled?
+          end.compact
+        end
+
+        def received_expected_message!(method_name)
+          self[method_name].each do |chain|
+            chain.expectation_fulfilled!
+          end
+        end
+        
+        def playback!(instance, method_name)
+          self[method_name].each do |chain|
+            @instance_with_expectation = instance if instance.is_a?(ExpectationChain) && !@instance_with_expectation
+            if instance.is_a?(ExpectationChain) && !@instance_with_expectation.equal?(instance)
+              raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{unfulfilled_expectations.sort.join(', ')}"
+            end
+            chain.playback!(instance)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class Recorder
+        attr_reader :message_chains
+        def initialize(klass)
+          @message_chains = MessageChains.new
+          @observed_methods = []
+          @played_methods = {}
+          @klass = klass
+          @expectation_set = false
+        end
+        
+        def unstub(method_name)
+          unless @observed_methods.include?(method_name.to_sym)
+            raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
+          end
+          message_chains.remove_stub_chains_for!(method_name)
+          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
+        end
+        
+        def stub(method_name_or_method_map, *args, &block)
+          if method_name_or_method_map.is_a?(Hash)
+            method_map = method_name_or_method_map
+            method_map.each do |method_name, return_value| 
+              observe!(method_name)
+              message_chains.add(method_name, chain = StubChain.new(method_name))
+              chain.and_return(return_value)
+            end
+            method_map
+          else
+            method_name = method_name_or_method_map
+            observe!(method_name)
+            message_chains.add(method_name, chain = StubChain.new(method_name, *args, &block))
+            chain
+          end
+        end
+
+        def stub_chain(method_name_or_string_chain, *args, &block)
+          if period_separated_method_chain?(method_name_or_string_chain)
+            first_method_name = method_name_or_string_chain.split('.').first.to_sym
+          else
+            first_method_name = method_name_or_string_chain
+          end
+          observe!(first_method_name)
+          message_chains.add(first_method_name, chain = StubChainChain.new(method_name_or_string_chain, *args, &block))
+          chain
+        end
+        
+        def should_receive(method_name, *args, &block)
+          observe!(method_name)
+          @expectation_set = true
+          message_chains.add(method_name, chain = ExpectationChain.new(method_name, *args, &block))
+          chain
+        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.playback!(instance, method_name)
+          @played_methods[method_name] = instance
+          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
+        end
+
+        def instance_that_received(method_name)
+          @played_methods[method_name]
+        end
+
+        def verify
+          if @expectation_set && !message_chains.each_expectation_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
+        end
+
+        private
+        def period_separated_method_chain?(method_name)
+          method_name.is_a?(String) && method_name.include?('.')
+        end
+        
+        def received_expected_message!(method_name)
+          message_chains.received_expected_message!(method_name)
+          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
+            remove_method method_name
+            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
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      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_fulfilled?
+          true
+        end
+        
+        def expectation_fulfilled!
+        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
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      class StubChainChain < Chain
+        def initialize(*args, &block)
+          record(:stub_chain, *args, &block)
+        end
+
+        def invocation_order
+          @invocation_order ||= {
+            :stub_chain => [nil],
+            :and_return => [:stub_chain],
+            :and_raise => [:stub_chain],
+            :and_yield => [:stub_chain]
+          }
+        end
+
+        def expectation_fulfilled?
+          true
+        end
+        
+        def expectation_fulfilled!
+        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
+    end
+  end
+end

data/lib/rspec/mocks/argument_expectation.rb

@@ -26,7 +26,7 @@ module RSpec
       end
       
       def is_matcher?(obj)
-        !null_object?(obj) & obj.respond_to?(:matches?) & obj.respond_to?(:description)
+        !null_object?(obj) & obj.respond_to?(:matches?) & [:failure_message_for_should, :failure_message].any? { |m| obj.respond_to?(m) }
       end
 
       def args_match?(*args)

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

@@ -7,7 +7,7 @@ module Marshal
       mp = object.instance_variable_get(:@mock_proxy)
       return dump_without_mocks(*args.unshift(object)) unless mp.is_a?(::RSpec::Mocks::Proxy)
 
-      object.send(:remove_instance_variable, :@mock_proxy)
+      object.__send__(:remove_instance_variable, :@mock_proxy)
 
       begin
         dump_without_mocks(*args.unshift(object.dup))

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

@@ -7,7 +7,7 @@ if defined?(Psych) && Psych.respond_to?(:dump)
         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)
+        object.__send__(:remove_instance_variable, :@mock_proxy)
 
         begin
           dump_without_mocks(object, *args)

data/lib/rspec/mocks/methods.rb

@@ -11,7 +11,7 @@ module RSpec
       
       def stub(sym_or_hash, opts={}, &block)
         if Hash === sym_or_hash
-          sym_or_hash.each {|method, value| stub!(method).and_return value }
+          sym_or_hash.each {|method, value| stub(method).and_return value }
         else
           __mock_proxy.add_stub(caller(1)[0], sym_or_hash.to_sym, opts, &block)
         end

data/lib/rspec/mocks/mock.rb

@@ -35,7 +35,7 @@ module RSpec
       alias_method :to_str, :to_s
 
       def respond_to?(sym, incl_private=false)
-        __mock_proxy.null_object? ? true : super
+        __mock_proxy.null_object? && sym != :to_ary ? true : super 
       end
 
     private
@@ -70,7 +70,7 @@ module RSpec
 
       def assign_stubs(stubs)
         stubs.each_pair do |message, response|
-          stub!(message).and_return(response)
+          stub(message).and_return(response)
         end
       end
     end

data/lib/rspec/mocks/proxy.rb

@@ -110,7 +110,7 @@ module RSpec
           stub.advise(*args)
           raise_unexpected_message_args_error(stub, *args)
         elsif @object.is_a?(Class)
-          @object.superclass.send(method_name, *args, &block)
+          @object.superclass.__send__(method_name, *args, &block)
         else
           @object.__send__(:method_missing, method_name, *args, &block)
         end

data/lib/rspec/mocks/version.rb

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

data/spec/rspec/mocks/any_instance/message_chains_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe RSpec::Mocks::AnyInstance::MessageChains do
+  let(:chains) { RSpec::Mocks::AnyInstance::MessageChains.new }
+  let(:stub_chain) { RSpec::Mocks::AnyInstance::StubChain.new }
+  let(:expectation_chain) { RSpec::Mocks::AnyInstance::ExpectationChain.new }
+
+  it "knows if a method does not have an expectation set on it" do
+    chains.add(:method_name, stub_chain)
+    chains.has_expectation?(:method_name).should be_false
+  end
+
+  it "knows if a method has an expectation set on it" do
+    chains.add(:method_name, stub_chain)
+    chains.add(:method_name, expectation_chain)
+    chains.has_expectation?(:method_name).should be_true
+  end
+
+  it "can remove all stub chains" do
+    chains.add(:method_name, stub_chain)
+    chains.add(:method_name, expectation_chain)
+    chains.add(:method_name, another_stub_chain = RSpec::Mocks::AnyInstance::StubChain.new)
+
+    chains.remove_stub_chains_for!(:method_name)
+    chains[:method_name].should eq([expectation_chain])
+  end
+  
+  context "creating stub chains" do
+    it "understands how to add a stub chain for a method" do
+      chains.add(:method_name, stub_chain)
+      chains[:method_name].should eq([stub_chain])
+    end
+
+    it "allows multiple stub chains for a method" do
+      chains.add(:method_name, stub_chain)
+      chains.add(:method_name, another_stub_chain = RSpec::Mocks::AnyInstance::StubChain.new)
+      chains[:method_name].should eq([stub_chain, another_stub_chain])
+    end
+  end
+end