rspec-mocks 2.5.0 → 2.6.0.rc2

data/features/method_stubs/to_ary.feature

@@ -0,0 +1,45 @@
+Feature: double handling to_ary
+
+  Ruby implicitly sends to_ary to any objects in an Array when the array
+  receives `flatten`:
+
+      [obj].flatten # => obj.to_ary
+
+  To support this, an RSpec double will raise a NoMethodError when it receives
+  `to_ary`, unless that method is explicitly stubbed.
+
+  Scenario: double receiving to_ary
+    Given a file named "example.rb" with:
+      """
+      describe "a double receiving 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)
+          end
+
+          it "can be overridden with a stub" do
+            obj.stub(:to_ary) { :non_nil_value }
+            obj.to_ary.should be(:non_nil_value)
+          end
+
+          it "supports Array#flatten" do
+            obj = double('foo')
+            [obj].flatten.should eq([obj])
+          end
+        end
+
+        context "double as_null_object" do
+          let(:obj) { double('obj').as_null_object }
+          include_examples "to_ary"
+        end
+
+        context "double without as_null_object" do
+          let(:obj) { double('obj') }
+          include_examples "to_ary"
+        end
+      end
+     """
+    When I run `rspec example.rb`
+    Then the examples should all pass

data/features/outside_rspec/configuration.feature

@@ -42,7 +42,7 @@ Feature: configure any test framework to use rspec-mocks
       puts example.respond_to?(:stub)
       """
 
-    When I run "ruby foo.rb"
+    When I run `ruby foo.rb`
     Then the output should contain "true"
     But  the output should not contain "false"
 
@@ -60,7 +60,7 @@ Feature: configure any test framework to use rspec-mocks
       puts obj.respond_to?(:stub)
       """
 
-    When I run "ruby foo.rb"
+    When I run `ruby foo.rb`
     Then the output should contain "true"
     But  the output should not contain "false"
 
@@ -76,7 +76,7 @@ Feature: configure any test framework to use rspec-mocks
       puts obj.respond_to?(:stub)
       """
 
-    When I run "ruby foo.rb"
+    When I run `ruby foo.rb`
     Then the output should contain "false"
     But  the output should not contain "true"
 

data/features/outside_rspec/standalone.feature

@@ -13,7 +13,7 @@ Feature: standalone
       greeter.stub(:say_hi) { "Hello!" }
       puts greeter.say_hi
       """
-    When I run "ruby example.rb"
+    When I run `ruby example.rb`
     Then the output should contain "Hello!"
 
   Scenario: message expectation outside rspec
@@ -26,7 +26,7 @@ Feature: standalone
 
       RSpec::Mocks.verify
       """
-    When I run "ruby example.rb"
+    When I run `ruby example.rb`
     Then the output should contain "say_hi(any args) (RSpec::Mocks::MockExpectationError)"
     Then the output should contain "expected: 1 time"
     Then the output should contain "received: 0 times"

data/features/step_definitions/additional_cli_steps.rb

@@ -0,0 +1,4 @@
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  Then %q{the output should contain "0 failures"}
+  Then %q{the exit status should be 0}
+end

data/features/support/env.rb

@@ -1,2 +1,6 @@
-require 'aruba'
+require 'aruba/cucumber'
 require 'rspec/expectations'
+
+Before do
+  @aruba_timeout_seconds = 3
+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/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,246 @@
+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_observing!
+          @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 observe!(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_observing!
+        @__recorder = nil
+      end
+
+      def __recorder
+        @__recorder ||= AnyInstance::Recorder.new(self)
+      end
+    end
+  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