rspec-mocks 2.6.0 → 2.7.0

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

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

@@ -138,48 +138,41 @@ module RSpec
         end
       end
 
-      # :call-seq:
-      #   object.should_receive(:message).with(any_args())
-      #
       # Passes if object receives :message with any args at all. This is
       # really a more explicit variation of object.should_receive(:message)
+      #
+      # == Examples
+      #   object.should_receive(:message).with(any_args())
       def any_args
         AnyArgsMatcher.new
       end
       
-      # :call-seq:
-      #   object.should_receive(:message).with(anything())
-      #
       # Passes as long as there is an argument.
+      #
+      # == Examples
+      #   object.should_receive(:message).with(anything())
       def anything
         AnyArgMatcher.new(nil)
       end
       
-      # :call-seq:
-      #   object.should_receive(:message).with(no_args)
-      #
       # Passes if no arguments are passed along with the message
+      #
+      # == Examples
+      #   object.should_receive(:message).with(no_args)
       def no_args
         NoArgsMatcher.new
       end
       
-      # :call-seq:
-      #   object.should_receive(:message).with(duck_type(:hello))
-      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
-      #
       # Passes if the argument responds to the specified messages.
       #
       # == Examples
-      #
-      #   array = []
-      #   display = double('display')
-      #   display.should_receive(:present_names).with(duck_type(:length, :each))
-      #   => passes
+      #   object.should_receive(:message).with(duck_type(:hello))
+      #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
       def duck_type(*args)
         DuckTypeMatcher.new(*args)
       end
 
-      # :call-seq:
+      # == Examples
       #   object.should_receive(:message).with(boolean())
       #
       # Passes if the argument is boolean.
@@ -187,22 +180,23 @@ module RSpec
         BooleanMatcher.new(nil)
       end
       
-      # :call-seq:
+      # Passes if the argument is a hash that includes the specified key(s) or key/value
+      # pairs. If the hash includes other keys, it will still pass.
+      #
+      # == Examples
       #   object.should_receive(:message).with(hash_including(:key => val))
       #   object.should_receive(:message).with(hash_including(:key))
       #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
-      # Passes if the argument is a hash that includes the specified key(s) or key/value
-      # pairs. If the hash includes other keys, it will still pass.
       def hash_including(*args)
         HashIncludingMatcher.new(anythingize_lonely_keys(*args))
       end
       
-      # :call-seq:
+      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      #
+      # == Examples
       #   object.should_receive(:message).with(hash_not_including(:key => val))
       #   object.should_receive(:message).with(hash_not_including(:key))
       #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
-      #
-      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
       def hash_not_including(*args)
         HashNotIncludingMatcher.new(anythingize_lonely_keys(*args))
       end

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

@@ -63,10 +63,8 @@ module RSpec
         @return_block = block_given? ? return_block : lambda { value }
       end
       
-      # :call-seq:
-      #   and_raise()
-      #   and_raise(Exception) #any exception class
-      #   and_raise(exception) #any exception object
+      # Tells the mock or stub to raise an exception when the message
+      # is received.
       #
       # == Warning
       #
@@ -74,6 +72,11 @@ module RSpec
       # raise an instance of it, creating it with +new+. If the exception
       # class initializer requires any parameters, you must pass in an
       # instance and not the class.
+      #
+      # == Examples
+      #   and_raise()
+      #   and_raise(Exception) #any exception class
+      #   and_raise(exception) #any exception object
       def and_raise(exception=Exception)
         @exception_to_raise = exception
       end

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
@@ -24,15 +24,13 @@ module RSpec
       alias_method :stub!, :stub
       alias_method :unstub!, :unstub
       
-      # :call-seq:
-      #   double.stub_chain("foo.bar") { :baz }
-      #   double.stub_chain(:foo, :bar) { :baz }
-      #
       # Stubs a chain of methods. Especially useful with fluent and/or
       # composable interfaces.
       #
       # == Examples
       #
+      #   double.stub_chain("foo.bar") { :baz }
+      #   double.stub_chain(:foo, :bar) { :baz }
       #   Article.stub_chain("recent.published") { [Article.new] }
       def stub_chain(*chain, &blk)
         chain, blk = format_chain(*chain, &blk)
@@ -50,15 +48,15 @@ module RSpec
         end
       end
       
-      def received_message?(sym, *args, &block) #:nodoc:
+      def received_message?(sym, *args, &block)
         __mock_proxy.received_message?(sym.to_sym, *args, &block)
       end
       
-      def rspec_verify #:nodoc:
+      def rspec_verify
         __mock_proxy.verify
       end
 
-      def rspec_reset #:nodoc:
+      def rspec_reset
         __mock_proxy.reset
       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

@@ -45,11 +45,11 @@ module RSpec
         @object
       end
 
-      def already_proxied_respond_to # :nodoc:
+      def already_proxied_respond_to
         @already_proxied_respond_to = true
       end
 
-      def already_proxied_respond_to? # :nodoc:
+      def already_proxied_respond_to?
         @already_proxied_respond_to
       end
 
@@ -69,7 +69,7 @@ module RSpec
         method_double[method_name].remove_stub
       end
       
-      def verify #:nodoc:
+      def verify
         method_doubles.each {|d| d.verify}
       ensure
         reset
@@ -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'
+module RSpec
+  module Mocks
+    module Version
+      STRING = '2.7.0'
     end
   end
 end

data/lib/rspec/mocks.rb

@@ -17,7 +17,7 @@ module RSpec
   #
   #   book = double("book")
   #   double.stub(:title) { "The RSpec Book" }
-  #   double.title => "The RSpec Book"
+  #   double.title # => "The RSpec Book"
   #
   # When we declare a stub, we say we are "stubbing" a method.
   #
@@ -37,9 +37,9 @@ module RSpec
   # == Mock Objects and Test Stubs
   #
   # The names Mock Object and Test Stub suggest specialized Test Doubles.  i.e.
-  # Test Stub evokes Test Double that only supports method stubs, and a Mock
-  # Object evokes a Test Double that only supports message expectations, or
-  # sometimes supports message expectations in addition to method stubs.
+  # a Test Stub is a Test Double that only supports method stubs, and a Mock
+  # Object is a Test Double that supports message expectations and method
+  # stubs.
   #
   # There is a lot of overlapping nomenclature here, and there are many
   # variations of these patterns (fakes, spies, etc). Keep in mind that most of
@@ -60,7 +60,7 @@ module RSpec
   #
   # In this case we're instrumenting Person to return the person object we've
   # defined whenever it receives the +find+ message. We can do this with any
-  # object in a system because RSpec adds the +stub+ and +should_receive+
+  # object in a system because rspec-mocks adds the +stub+ and +should_receive+
   # methods to every object. When we use either, RSpec replaces the method
   # we're stubbing or mocking with it's own test-double-like method. At the
   # end of the example, RSpec verifies any message expectations, and then
@@ -73,15 +73,14 @@ module RSpec
   #
   # == Argument Matchers
   #
-  # Arguments that are passed to #with are compared with actual arguments received
-  # using == by default. In cases in which you want to specify things about the arguments
-  # rather than the arguments themselves, you can use any of RSpec's Expression Matchers.
-  # They don't all make syntactic sense (they were primarily designed for use with
-  # RSpec::Expectations), but you are free to create your own custom RSpec::Matchers.
+  # Arguments that are passed to +with+ are compared with actual arguments
+  # received using ==. In cases in which you want to specify things about the
+  # arguments rather than the arguments themselves, you can use any of the
+  # matchers that ship with rspec-expectations. They don't all make syntactic
+  # sense (they were primarily designed for use with RSpec::Expectations), but
+  # you are free to create your own custom RSpec::Matchers.
   #
-  # RSpec::Mocks does provide one additional Matcher method named #ducktype.
-  #
-  # In addition, RSpec::Mocks adds some keyword Symbols that you can use to
+  # rspec-mocks also adds some keyword Symbols that you can use to
   # specify certain kinds of arguments:
   #
   #   double.should_receive(:msg).with(no_args())
@@ -152,7 +151,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/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