rspec-mocks 2.6.0 → 2.7.0

data/features/method_stubs/simple_return_value.feature

@@ -1,55 +1,64 @@
 Feature: stub with a simple return value
 
   Use the `stub` method on a test double or a real object to tell the object to
-  return a value (or values) in response to a given message. If the message is
-  never received, nothing happens.
+  return a value (or values) in response to a given message. Nothing happens if
+  the message is never received.
 
-  Scenario: simple stub with no return value
+  Scenario: stub with no return value
     Given a file named "example_spec.rb" with:
       """
-      describe "a simple stub with no return value specified" do
-        let(:receiver) { double("receiver") }
+      describe "a stub with no return value specified" do
+        let(:collaborator) { double("collaborator") }
 
         it "returns nil" do
-          receiver.stub(:message)
-          receiver.message.should be(nil)
-        end
-
-        it "quietly carries on when not called" do
-          receiver.stub(:message)
+          collaborator.stub(:message)
+          collaborator.message.should be(nil)
         end
       end
       """
     When I run `rspec example_spec.rb`
-    Then the output should contain "0 failures"
+    Then the examples should all pass
 
-  Scenario: single return value
+  Scenario: stubs with return values
     Given a file named "example_spec.rb" with:
       """
-      describe "a simple stub with a return value" do
+      describe "a stub with a return value" do
         context "specified in a block" do
           it "returns the specified value" do
-            receiver = double("receiver")
-            receiver.stub(:message) { :return_value }
-            receiver.message.should eq(:return_value)
+            collaborator = double("collaborator")
+            collaborator.stub(:message) { :value }
+            collaborator.message.should eq(:value)
+          end
+        end
+
+        context "specified with #and_return" do
+          it "returns the specified value" do
+            collaborator = double("collaborator")
+            collaborator.stub(:message).and_return(:value)
+            collaborator.message.should eq(:value)
           end
         end
 
-        context "specified in the double declaration" do
+        context "specified with a hash passed to #stub" do
           it "returns the specified value" do
-            receiver = double("receiver", :message => :return_value)
-            receiver.message.should eq(:return_value)
+            collaborator = double("collaborator")
+            collaborator.stub(:message_1 => :value_1, :message_2 => :value_2)
+            collaborator.message_1.should eq(:value_1)
+            collaborator.message_2.should eq(:value_2)
           end
         end
 
-        context "specified with and_return" do
+        context "specified with a hash passed to #double" do
           it "returns the specified value" do
-            receiver = double("receiver")
-            receiver.stub(:message).and_return(:return_value)
-            receiver.message.should eq(:return_value)
+            collaborator = double("collaborator",
+              :message_1 => :value_1,
+              :message_2 => :value_2
+            )
+            collaborator.message_1.should eq(:value_1)
+            collaborator.message_2.should eq(:value_2)
           end
         end
       end
       """
     When I run `rspec example_spec.rb`
-    Then the output should contain "0 failures"
+    Then the examples should all pass

data/features/method_stubs/stub_implementation.feature

@@ -1,7 +1,7 @@
 Feature: stub with substitute implementation
 
   You can stub an implementation of a method (a.k.a. fake) by passing a block
-  to the stub() method.
+  to the `stub` method.
   
   Scenario: stub implementation
     Given a file named "stub_implementation_spec.rb" with:

data/features/method_stubs/to_ary.feature

@@ -1,22 +1,24 @@
 Feature: double handling to_ary
 
-  Ruby implicitly sends to_ary to any objects in an Array when the array
-  receives `flatten`:
+  Ruby implicitly sends `to_ary` to all of the objects in an `Array` when the
+  array receives `flatten`:
 
       [obj].flatten # => obj.to_ary
 
+  If `to_ary` raises a `NoMethodError`, Ruby sees that the object can not be coerced
+  into an array and moves on to the next object.
+
   To support this, an RSpec double will raise a NoMethodError when it receives
-  `to_ary`, unless that method is explicitly stubbed.
+  `to_ary` _even if it is set `as_null_object`_, unless `to_ary` is explicitly
+  stubbed.
 
   Scenario: double receiving to_ary
     Given a file named "example.rb" with:
       """
-      describe "a double receiving to_ary" do
+      describe "#to_ary" do
         shared_examples "to_ary" do
-          it "returns nil" do
-            expect do
-              obj.to_ary.should be_nil
-            end.to raise_error(NoMethodError)
+          it "raises a NoMethodError" do
+            expect { obj.to_ary }.to raise_error(NoMethodError)
           end
 
           it "can be overridden with a stub" do
@@ -30,12 +32,12 @@ Feature: double handling to_ary
           end
         end
 
-        context "double as_null_object" do
+        context "sent to a double as_null_object" do
           let(:obj) { double('obj').as_null_object }
           include_examples "to_ary"
         end
 
-        context "double without as_null_object" do
+        context "sent to a double without as_null_object" do
           let(:obj) { double('obj') }
           include_examples "to_ary"
         end

data/features/support/env.rb

@@ -2,5 +2,5 @@ require 'aruba/cucumber'
 require 'rspec/expectations'
 
 Before do
-  @aruba_timeout_seconds = 3
+  RUBY_PLATFORM =~ /java/ ? @aruba_timeout_seconds = 60 : @aruba_timeout_seconds = 5
 end

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,168 @@
+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!(*)
+          raise "stub! is not supported on any_instance. Use stub instead."
+        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 public_protected_or_private_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
+            alias_method alias_method_name, method_name
+          end if public_protected_or_private_method_defined?(method_name)
+        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)
+        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