mocha 0.10.5 → 1.13.0

data/lib/mocha/mockery.rb

@@ -1,181 +1,179 @@
+require 'mocha/ruby_version'
 require 'mocha/central'
 require 'mocha/mock'
 require 'mocha/names'
+require 'mocha/receivers'
 require 'mocha/state_machine'
 require 'mocha/logger'
 require 'mocha/configuration'
 require 'mocha/stubbing_error'
+require 'mocha/not_initialized_error'
+require 'mocha/expectation_error_factory'
 
 module Mocha
-  
   class Mockery
-    
+    class Null < self
+      def add_mock(*)
+        raise_not_initialized_error
+      end
+
+      def add_state_machine(*)
+        raise_not_initialized_error
+      end
+
+      def stubba
+        Central::Null.new(&method(:raise_not_initialized_error))
+      end
+
+      private
+
+      def raise_not_initialized_error
+        message = 'Mocha methods cannot be used outside the context of a test'
+        raise NotInitializedError.new(message, caller)
+      end
+    end
+
     class << self
-      
       def instance
-        @instance ||= new
+        @instances.last || Null.new
+      end
+
+      def setup
+        @instances ||= []
+        mockery = new
+        mockery.logger = instance.logger unless @instances.empty?
+        @instances.push(mockery)
+      end
+
+      def verify(*args)
+        instance.verify(*args)
       end
-      
-      def reset_instance
-        @instance = nil
+
+      def teardown
+        instance.teardown
+      ensure
+        @instances.pop
       end
-      
     end
-    
-    def named_mock(name, &block)
-      add_mock(Mock.new(self, Name.new(name), &block))
+
+    def named_mock(name)
+      add_mock(Mock.new(self, Name.new(name)))
     end
-    
-    def unnamed_mock(&block)
-      add_mock(Mock.new(self, &block))
+
+    def unnamed_mock
+      add_mock(Mock.new(self))
     end
-    
-    def mock_impersonating(object, &block)
-      add_mock(Mock.new(self, ImpersonatingName.new(object), &block))
+
+    def mock_impersonating(object)
+      add_mock(Mock.new(self, ImpersonatingName.new(object), ObjectReceiver.new(object)))
     end
-    
-    def mock_impersonating_any_instance_of(klass, &block)
-      add_mock(Mock.new(self, ImpersonatingAnyInstanceName.new(klass), &block))
+
+    def mock_impersonating_any_instance_of(klass)
+      add_mock(Mock.new(self, ImpersonatingAnyInstanceName.new(klass), AnyInstanceReceiver.new(klass)))
     end
-    
+
     def new_state_machine(name)
       add_state_machine(StateMachine.new(name))
     end
-    
+
     def verify(assertion_counter = nil)
       unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
         message = "not all expectations were satisfied\n#{mocha_inspect}"
-        if unsatisfied_expectations.empty?
-          backtrace = caller
-        else
-          backtrace = unsatisfied_expectations[0].backtrace
-        end
-        raise ExpectationError.new(message, backtrace)
+        backtrace = if unsatisfied_expectations.empty?
+                      caller
+                    else
+                      unsatisfied_expectations[0].backtrace
+                    end
+        raise ExpectationErrorFactory.build(message, backtrace)
       end
-      expectations.each do |e|
-        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-          unless e.used?
-            on_stubbing_method_unnecessarily(e)
-          end
-        end
+      expectations.reject(&:used?).each do |expectation|
+        signature_proc = lambda { expectation.method_signature }
+        check(:stubbing_method_unnecessarily, 'method unnecessarily', signature_proc, expectation.backtrace)
       end
     end
-    
+
     def teardown
       stubba.unstub_all
+      mocks.each(&:__expire__)
       reset
     end
-    
+
     def stubba
       @stubba ||= Central.new
     end
-    
+
     def mocks
       @mocks ||= []
     end
-    
+
     def state_machines
       @state_machines ||= []
     end
-    
+
     def mocha_inspect
-      message = ""
-      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
-      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
-      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
+      message = ''
+      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if unsatisfied_expectations.any?
+      message << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if satisfied_expectations.any?
+      message << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}\n" if state_machines.any?
       message
     end
-    
+
     def on_stubbing(object, method)
-      method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
-      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
-        unless object.method_exists?(method, include_public_methods = true)
-          on_stubbing_non_existent_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
-        if object.method_exists?(method, include_public_methods = false)
-          on_stubbing_non_public_method(object, method)
-        end
+      method = PRE_RUBY_V19 ? method.to_s : method.to_sym
+      signature_proc = lambda { "#{object.mocha_inspect}.#{method}" }
+      check(:stubbing_non_existent_method, 'non-existent method', signature_proc) do
+        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method.to_sym))
       end
-      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
-        on_stubbing_method_on_non_mock_object(object, method)
+      check(:stubbing_non_public_method, 'non-public method', signature_proc) do
+        object.stubba_class.__method_exists__?(method, false)
       end
+      check(:stubbing_method_on_nil, 'method on nil', signature_proc) { object.nil? }
+      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', signature_proc)
     end
-    
-    def on_stubbing_non_existent_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
-        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
-        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
-      end
-    end
-    
-    def on_stubbing_non_public_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
-        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
-        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
-      end
-    end
-    
-    def on_stubbing_method_on_non_mock_object(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
-        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
-        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
-      end
-    end
-    
-    def on_stubbing_method_unnecessarily(expectation)
-      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
-        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
-      end
-    end
-    
+
     attr_writer :logger
-    
+
     def logger
       @logger ||= Logger.new($stderr)
     end
-    
-    
+
     private
-    
+
+    def check(action, description, signature_proc, backtrace = caller)
+      treatment = Mocha.configuration.send(action)
+      return if (treatment == :allow) || (block_given? && !yield)
+      method_signature = signature_proc.call
+      message = "stubbing #{description}: #{method_signature}"
+      raise StubbingError.new(message, backtrace) if treatment == :prevent
+      logger.warn(message) if treatment == :warn
+    end
+
     def expectations
       mocks.map { |mock| mock.__expectations__.to_a }.flatten
     end
-    
+
     def unsatisfied_expectations
-      expectations.reject { |e| e.verified? }
+      expectations.reject(&:verified?)
     end
-    
+
     def satisfied_expectations
-      expectations.select { |e| e.verified? }
+      expectations.select(&:verified?)
     end
-    
+
     def add_mock(mock)
       mocks << mock
       mock
     end
-    
+
     def add_state_machine(state_machine)
       state_machines << state_machine
       state_machine
     end
-    
+
     def reset
       @stubba = nil
       @mocks = nil
       @state_machines = nil
     end
-    
   end
-  
 end

data/lib/mocha/names.rb

@@ -1,53 +1,43 @@
 module Mocha
-  
   class ImpersonatingName
-    
     def initialize(object)
       @object = object
     end
-    
+
     def mocha_inspect
       @object.mocha_inspect
     end
-    
   end
-  
+
   class ImpersonatingAnyInstanceName
-    
     def initialize(klass)
       @klass = klass
     end
-    
+
     def mocha_inspect
       "#<AnyInstance:#{@klass.mocha_inspect}>"
     end
-    
   end
-  
+
   class Name
-    
     def initialize(name)
-      @name = name
+      @name = name.to_s
     end
-    
+
     def mocha_inspect
       "#<Mock:#{@name}>"
     end
-    
   end
-  
+
   class DefaultName
-    
     def initialize(mock)
       @mock = mock
     end
-    
+
     def mocha_inspect
       address = @mock.__id__ * 2
       address += 0x100000000 if address < 0
-      "#<Mock:0x#{'%x' % address}>"
+      "#<Mock:0x#{format('%x', address)}>"
     end
-    
   end
-  
-end
+end

data/lib/mocha/not_initialized_error.rb

@@ -0,0 +1,7 @@
+require 'mocha/error_with_filtered_backtrace'
+
+module Mocha
+  # Exception raised when Mocha has not been initialized, e.g. outside the
+  # context of a test.
+  class NotInitializedError < ErrorWithFilteredBacktrace; end
+end

data/lib/mocha/object_methods.rb

@@ -0,0 +1,169 @@
+require 'mocha/mockery'
+require 'mocha/instance_method'
+require 'mocha/argument_iterator'
+require 'mocha/expectation_error_factory'
+
+module Mocha
+  # Methods added to all objects to allow mocking and stubbing on real (i.e. non-mock) objects.
+  #
+  # Both {#expects} and {#stubs} return an {Expectation} which can be further modified by methods on {Expectation}.
+  module ObjectMethods
+    # @private
+    alias_method :_method, :method
+
+    # @private
+    def mocha(instantiate = true)
+      if instantiate
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+      else
+        defined?(@mocha) ? @mocha : nil
+      end
+    end
+
+    # @private
+    def reset_mocha
+      @mocha = nil
+    end
+
+    # @private
+    def stubba_method
+      Mocha::InstanceMethod
+    end
+
+    # @private
+    def stubba_object
+      self
+    end
+
+    # @private
+    def stubba_class
+      singleton_class
+    end
+
+    # Adds an expectation that the specified method must be called exactly once with any parameters.
+    #
+    # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
+    #
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #
+    # @overload def expects(method_name)
+    #   @param [Symbol,String] method_name name of expected method
+    # @overload def expects(expected_methods_vs_return_values)
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {#expects} were called multiple times.
+    #
+    # @example Setting up an expectation on a non-mock object.
+    #   product = Product.new
+    #   product.expects(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # @example Setting up multiple expectations on a non-mock object.
+    #   product = Product.new
+    #   product.expects(:valid? => true, :save => true)
+    #
+    #   # exactly equivalent to
+    #
+    #   product = Product.new
+    #   product.expects(:valid?).returns(true)
+    #   product.expects(:save).returns(true)
+    #
+    # @see Mock#expects
+    def expects(expected_methods_vs_return_values)
+      if expected_methods_vs_return_values.to_s =~ /the[^a-z]*spanish[^a-z]*inquisition/i
+        raise ExpectationErrorFactory.build('NOBODY EXPECTS THE SPANISH INQUISITION!')
+      end
+      if frozen?
+        raise StubbingError.new("can't stub method on frozen object: #{mocha_inspect}", caller)
+      end
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(expected_methods_vs_return_values)
+      iterator.each do |*args|
+        method_name = args.shift
+        mockery.on_stubbing(self, method_name)
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.stub(method)
+        expectation = mocha.expects(method_name, caller)
+        expectation.returns(args.shift) unless args.empty?
+      end
+      expectation
+    end
+
+    # Adds an expectation that the specified method may be called any number of times with any parameters.
+    #
+    # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
+    #
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #
+    # @overload def stubs(method_name)
+    #   @param [Symbol,String] method_name name of stubbed method
+    # @overload def stubs(stubbed_methods_vs_return_values)
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {#stubs} were called multiple times.
+    #
+    # @example Setting up a stubbed methods on a non-mock object.
+    #   product = Product.new
+    #   product.stubs(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # @example Setting up multiple stubbed methods on a non-mock object.
+    #   product = Product.new
+    #   product.stubs(:valid? => true, :save => true)
+    #
+    #   # exactly equivalent to
+    #
+    #   product = Product.new
+    #   product.stubs(:valid?).returns(true)
+    #   product.stubs(:save).returns(true)
+    #
+    # @see Mock#stubs
+    def stubs(stubbed_methods_vs_return_values)
+      if frozen?
+        raise StubbingError.new("can't stub method on frozen object: #{mocha_inspect}", caller)
+      end
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(stubbed_methods_vs_return_values)
+      iterator.each do |*args|
+        method_name = args.shift
+        mockery.on_stubbing(self, method_name)
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.stub(method)
+        expectation = mocha.stubs(method_name, caller)
+        expectation.returns(args.shift) unless args.empty?
+      end
+      expectation
+    end
+
+    # Removes the specified stubbed methods (added by calls to {#expects} or {#stubs}) and all expectations associated with them.
+    #
+    # Restores the original behaviour of the methods before they were stubbed. This is normally done automatically at the end of each test, but in some circumstances you may want to do it *before* the end of the test.
+    #
+    # WARNING: If you {#unstub} a method which still has unsatisfied expectations, you may be removing the only way those expectations can be satisfied. Use {#unstub} with care.
+    #
+    # @param [Array<Symbol>] method_names names of methods to unstub.
+    #
+    # @example Stubbing and unstubbing a method on a real (non-mock) object.
+    #   multiplier = Multiplier.new
+    #   multiplier.double(2) # => 4
+    #   multiplier.stubs(:double).raises # new behaviour defined
+    #   multiplier.double(2) # => raises exception
+    #   multiplier.unstub(:double) # original behaviour restored
+    #   multiplier.double(2) # => 4
+    #
+    # @example Unstubbing multiple methods on a real (non-mock) object.
+    #   multiplier.unstub(:double, :triple)
+    #
+    #   # exactly equivalent to
+    #
+    #   multiplier.unstub(:double)
+    #   multiplier.unstub(:triple)
+    def unstub(*method_names)
+      mockery = Mocha::Mockery.instance
+      method_names.each do |method_name|
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.unstub(method)
+      end
+    end
+  end
+end

data/lib/mocha/parameter_matchers/all_of.rb

@@ -1,17 +1,21 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
+    # Matches if all +matchers+ match.
+    #
+    # @param [*Array<Base>] matchers parameter matchers.
+    # @return [AllOf] parameter matcher.
+    #
+    # @see Expectation#with
     #
-    # Matches if all +parameter_matchers+ match.
+    # @example All parameter matchers match.
     #   object = mock()
     #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
     #   object.method_1([1, 3])
     #   # no error raised
     #
+    # @example One of the parameter matchers does not match.
     #   object = mock()
     #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
     #   object.method_1([1, 2])
@@ -19,24 +23,24 @@ module Mocha
     def all_of(*matchers)
       AllOf.new(*matchers)
     end
-    
-    class AllOf < Base # :nodoc:
-      
+
+    # Parameter matcher which combines a number of other matchers using a logical AND.
+    class AllOf < Base
+      # @private
       def initialize(*matchers)
         @matchers = matchers
       end
-    
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
         @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
       end
-      
+
+      # @private
       def mocha_inspect
-        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "all_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-      
     end
-    
   end
-  
-end
+end

data/lib/mocha/parameter_matchers/any_of.rb

@@ -1,22 +1,27 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-  
   module ParameterMatchers
-
-    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
+    # Matches if any +matchers+ match.
+    #
+    # @param [*Array<Base>] matchers parameter matchers.
+    # @return [AnyOf] parameter matcher.
+    #
+    # @see Expectation#with
     #
-    # Matches if any +parameter_matchers+ match.
+    # @example One parameter matcher matches.
     #   object = mock()
     #   object.expects(:method_1).with(any_of(1, 3))
     #   object.method_1(1)
     #   # no error raised
     #
+    # @example The other parameter matcher matches.
     #   object = mock()
     #   object.expects(:method_1).with(any_of(1, 3))
     #   object.method_1(3)
     #   # no error raised
     #
+    # @example Neither parameter matcher matches.
     #   object = mock()
     #   object.expects(:method_1).with(any_of(1, 3))
     #   object.method_1(2)
@@ -24,24 +29,24 @@ module Mocha
     def any_of(*matchers)
       AnyOf.new(*matchers)
     end
-    
-    class AnyOf < Base # :nodoc:
-      
+
+    # Parameter matcher which combines a number of other matchers using a logical OR.
+    class AnyOf < Base
+      # @private
       def initialize(*matchers)
         @matchers = matchers
       end
-    
+
+      # @private
       def matches?(available_parameters)
         parameter = available_parameters.shift
         @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
       end
-      
+
+      # @private
       def mocha_inspect
-        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "any_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-      
     end
-    
   end
-  
-end
+end