rspec-mocks 2.6.0 → 2.7.0.rc1

data/features/method_stubs/any_instance.feature

@@ -6,7 +6,7 @@ Feature: stub on any instance of a class
 
   Messages can be stubbed on any class, including those in Ruby's core library.
 
-  Scenario: simple any_instance stub with a single return value
+  Scenario: any_instance stub with a single return value
     Given a file named "example_spec.rb" with:
       """
       describe "any_instance.stub" do
@@ -20,4 +20,114 @@ Feature: stub on any instance of a class
       """
     When I run `rspec example_spec.rb`
     Then the examples should all pass
+    
+  Scenario: any_instance stub with a hash
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.stub" do
+        context "with a hash" do
+          it "returns the hash values on any instance of the class" do
+            Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
+
+            o = Object.new
+            o.foo.should eq('foo')
+            o.bar.should eq('bar')
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass  
+    
+  Scenario: any_instance stub with specific arguments matchers
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.stub" do
+        context "with arguments" do
+          it "returns the stubbed value when arguments match" do
+            Object.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
+            Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
+          
+            o = Object.new
+            o.foo(:param_one, :param_two).should eq(:result_one)
+            o.foo(:param_three, :param_four).should eq(:result_two)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+  
+  Scenario: any_instance unstub
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.unstub" do
+        it "unstubs a stubbed method" do
+          class Object
+            def foo
+              :foo
+            end
+          end
+          
+          Object.any_instance.stub(:foo)
+          Object.any_instance.unstub(:foo)
+
+          Object.new.foo.should eq(:foo)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass  
+  
+  Scenario: any_instance unstub
+    Given a file named "example_spec.rb" with:
+      """
+      describe "any_instance.unstub" do
+        context "with both an expectation and a stub already set" do
+          it "only removes the stub" do
+            class Object
+              def foo
+                :foo
+              end
+            end
+            Object.any_instance.should_receive(:foo).and_return(:bar)
+            Object.any_instance.stub(:foo)
+            Object.any_instance.unstub(:foo)
+            
+            Object.new.foo.should eq(:bar)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+    
+  Scenario: stub a chain of methods an any instance
+    Given a file named "stub_chain_spec.rb" with:
+      """
+      describe "stubbing a chain of methods" do
+        context "given symbols representing methods" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain(:one, :two, :three).and_return(:four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+
+        context "given a hash at the end" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain(:one, :two, :three => :four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
 
+        context "given a string of methods separated by dots" do
+          it "returns the correct value" do
+            Object.any_instance.stub_chain("one.two.three").and_return(:four)
+            Object.new.one.two.three.should eq(:four)
+          end
+        end
+      end
+      """
+    When I run `rspec stub_chain_spec.rb`
+    Then the examples should all pass
+    

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.rb

@@ -152,7 +152,7 @@ module RSpec
   #
   #   double.should_receive(:msg) do |arg|
   #     arg.should be_an_istance_of(Array)
-  #     arg.length.should == 7
+  #     arg.length.should eq 7
   #   end
   #
   # == Combining Expectation Details

data/lib/rspec/mocks/any_instance.rb

@@ -1,245 +1,18 @@
+require 'rspec/mocks/any_instance/chain'
+require 'rspec/mocks/any_instance/stub_chain'
+require 'rspec/mocks/any_instance/stub_chain_chain'
+require 'rspec/mocks/any_instance/expectation_chain'
+require 'rspec/mocks/any_instance/message_chains'
+require 'rspec/mocks/any_instance/recorder'
+
 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