mocha 1.4.0 → 1.7.0

data/lib/mocha/cardinality.rb

@@ -1,11 +1,8 @@
 module Mocha
-
   class Cardinality
-
     INFINITY = 1 / 0.0
 
     class << self
-
       def exactly(count)
         new(count, count)
       end
@@ -20,15 +17,15 @@ module Mocha
 
       def times(range_or_count)
         case range_or_count
-          when Range then new(range_or_count.first, range_or_count.last)
-          else new(range_or_count, range_or_count)
+        when Range then new(range_or_count.first, range_or_count.last)
+        else new(range_or_count, range_or_count)
         end
       end
-
     end
 
     def initialize(required, maximum)
-      @required, @maximum = required, maximum
+      @required = required
+      @maximum = maximum
     end
 
     def invocations_allowed?(invocation_count)
@@ -48,28 +45,26 @@ module Mocha
     end
 
     def allowed_any_number_of_times?
-      required == 0 && infinite?(maximum)
+      required.zero? && infinite?(maximum)
     end
 
     def used?(invocation_count)
-      (invocation_count > 0) || (maximum == 0)
+      (invocation_count > 0) || maximum.zero?
     end
 
     def mocha_inspect
       if allowed_any_number_of_times?
-        "allowed any number of times"
+        'allowed any number of times'
+      elsif required.zero? && maximum.zero?
+        'expected never'
+      elsif required == maximum
+        "expected exactly #{times(required)}"
+      elsif infinite?(maximum)
+        "expected at least #{times(required)}"
+      elsif required.zero?
+        "expected at most #{times(maximum)}"
       else
-        if required == 0 && maximum == 0
-          "expected never"
-        elsif required == maximum
-          "expected exactly #{times(required)}"
-        elsif infinite?(maximum)
-          "expected at least #{times(required)}"
-        elsif required == 0
-          "expected at most #{times(maximum)}"
-        else
-          "expected between #{required} and #{times(maximum)}"
-        end
+        "expected between #{required} and #{times(maximum)}"
       end
     end
 
@@ -79,17 +74,15 @@ module Mocha
 
     def times(number)
       case number
-        when 0 then "no times"
-        when 1 then "once"
-        when 2 then "twice"
-        else "#{number} times"
+      when 0 then 'no times'
+      when 1 then 'once'
+      when 2 then 'twice'
+      else "#{number} times"
       end
     end
 
     def infinite?(number)
       number.respond_to?(:infinite?) && number.infinite?
     end
-
   end
-
 end

data/lib/mocha/central.rb

@@ -1,6 +1,19 @@
 module Mocha
-
   class Central
+    class Null < self
+      def initialize(&block)
+        super
+        @raise_not_initialized_error = block
+      end
+
+      def stub(*)
+        @raise_not_initialized_error.call
+      end
+
+      def unstub(*)
+        @raise_not_initialized_error.call
+      end
+    end
 
     attr_accessor :stubba_methods
 
@@ -9,25 +22,21 @@ module Mocha
     end
 
     def stub(method)
-      unless stubba_methods.detect { |m| m.matches?(method) }
-        method.stub
-        stubba_methods.push(method)
-      end
+      return if stubba_methods.detect { |m| m.matches?(method) }
+      method.stub
+      stubba_methods.push(method)
     end
 
     def unstub(method)
-      if existing = stubba_methods.detect { |m| m.matches?(method) }
-        existing.unstub
-        stubba_methods.delete(existing)
-      end
+      return unless (existing = stubba_methods.detect { |m| m.matches?(method) })
+      existing.unstub
+      stubba_methods.delete(existing)
     end
 
     def unstub_all
-      while stubba_methods.any? do
+      while stubba_methods.any?
         unstub(stubba_methods.first)
       end
     end
-
   end
-
 end

data/lib/mocha/change_state_side_effect.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class ChangeStateSideEffect
-
     def initialize(state)
       @state = state
     end
@@ -13,7 +11,5 @@ module Mocha
     def mocha_inspect
       "then #{@state.mocha_inspect}"
     end
-
   end
-
 end

data/lib/mocha/class_method.rb

@@ -2,16 +2,15 @@ require 'mocha/ruby_version'
 require 'metaclass'
 
 module Mocha
-
   class ClassMethod
-
     PrependedModule = Class.new(Module)
 
     attr_reader :stubbee, :method
 
     def initialize(stubbee, method)
       @stubbee = stubbee
-      @original_method, @original_visibility = nil, nil
+      @original_method = nil
+      @original_visibility = nil
       @method = PRE_RUBY_V19 ? method.to_s : method.to_sym
     end
 
@@ -24,9 +23,8 @@ module Mocha
       remove_new_method
       restore_original_method
       mock.unstub(method.to_sym)
-      unless mock.any_expectations?
-        reset_mocha
-      end
+      return if mock.any_expectations?
+      reset_mocha
     end
 
     def mock
@@ -38,21 +36,22 @@ module Mocha
     end
 
     def hide_original_method
-      if @original_visibility = method_visibility(method)
-        begin
-          if RUBY_V2_PLUS
-            @definition_target = PrependedModule.new
-            stubbee.__metaclass__.__send__ :prepend, @definition_target
-          else
-            @original_method = stubbee._method(method)
-            if @original_method && @original_method.owner == stubbee.__metaclass__
-              stubbee.__metaclass__.send(:remove_method, method)
-            end
+      return unless (@original_visibility = method_visibility(method))
+      begin
+        if RUBY_V2_PLUS
+          @definition_target = PrependedModule.new
+          stubbee.__metaclass__.__send__ :prepend, @definition_target
+        else
+          @original_method = stubbee._method(method)
+          if @original_method && @original_method.owner == stubbee.__metaclass__
+            stubbee.__metaclass__.send(:remove_method, method)
           end
-        rescue NameError
-          # deal with nasties like ActiveRecord::Associations::AssociationProxy
         end
+      # rubocop:disable Lint/HandleExceptions
+      rescue NameError
+        # deal with nasties like ActiveRecord::Associations::AssociationProxy
       end
+      # rubocop:enable Lint/HandleExceptions
     end
 
     def define_new_method
@@ -61,9 +60,8 @@ module Mocha
           mocha.method_missing(:#{method}, *args, &block)
         end
       CODE
-      if @original_visibility
-        Module.instance_method(@original_visibility).bind(definition_target).call(method)
-      end
+      return unless @original_visibility
+      Module.instance_method(@original_visibility).bind(definition_target).call(method)
     end
 
     def remove_new_method
@@ -71,26 +69,24 @@ module Mocha
     end
 
     def restore_original_method
-      unless RUBY_V2_PLUS
-        if @original_method && @original_method.owner == stubbee.__metaclass__
-          if PRE_RUBY_V19
-            original_method = @original_method
-            stubbee.__metaclass__.send(:define_method, method) do |*args, &block|
-              original_method.call(*args, &block)
-            end
-          else
-            stubbee.__metaclass__.send(:define_method, method, @original_method)
+      return if RUBY_V2_PLUS
+      if @original_method && @original_method.owner == stubbee.__metaclass__
+        if PRE_RUBY_V19
+          original_method = @original_method
+          stubbee.__metaclass__.send(:define_method, method) do |*args, &block|
+            original_method.call(*args, &block)
           end
-        end
-        if @original_visibility
-          Module.instance_method(@original_visibility).bind(stubbee.__metaclass__).call(method)
+        else
+          stubbee.__metaclass__.send(:define_method, method, @original_method)
         end
       end
+      return unless @original_visibility
+      Module.instance_method(@original_visibility).bind(stubbee.__metaclass__).call(method)
     end
 
     def matches?(other)
-      return false unless (other.class == self.class)
-      (stubbee.object_id == other.stubbee.object_id) and (method == other.method)
+      return false unless other.class == self.class
+      (stubbee.object_id == other.stubbee.object_id) && (method == other.method)
     end
 
     alias_method :==, :eql?
@@ -113,7 +109,5 @@ module Mocha
     def definition_target
       @definition_target ||= stubbee.__metaclass__
     end
-
   end
-
 end

data/lib/mocha/class_methods.rb

@@ -3,10 +3,8 @@ require 'mocha/class_method'
 require 'mocha/any_instance_method'
 
 module Mocha
-
   # Methods added to all classes to allow mocking and stubbing on real (i.e. non-mock) objects.
   module ClassMethods
-
     # @private
     def stubba_method
       Mocha::ClassMethod
@@ -14,33 +12,33 @@ module Mocha
 
     # @private
     class AnyInstance
-
       def initialize(klass)
         @stubba_object = klass
       end
 
-      def mocha
-        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+      def mocha(instantiate = true)
+        if instantiate
+          @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+        else
+          defined?(@mocha) ? @mocha : nil
+        end
       end
 
       def stubba_method
         Mocha::AnyInstanceMethod
       end
 
-      def stubba_object
-        @stubba_object
-      end
+      attr_reader :stubba_object
 
       def method_exists?(method, include_public_methods = true)
         if include_public_methods
-          return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
+          return true if @stubba_object.public_instance_methods(true).include?(method)
           return true if @stubba_object.allocate.respond_to?(method.to_sym)
         end
-        return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
-        return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
-        return false
+        return true if @stubba_object.protected_instance_methods(true).include?(method)
+        return true if @stubba_object.private_instance_methods(true).include?(method)
+        false
       end
-
     end
 
     # @return [Mock] a mock object which will detect calls to any instance of this class.
@@ -58,7 +56,5 @@ module Mocha
       end
       @any_instance ||= AnyInstance.new(self)
     end
-
   end
-
 end

data/lib/mocha/configuration.rb

@@ -1,18 +1,80 @@
 module Mocha
-
-  # Configuration settings.
+  # This class allows you to determine what should happen under certain circumstances. In each scenario, Mocha can be configured to {.allow do nothing}, {.warn_when display a warning message}, or {.prevent raise an exception}. The relevant scenario is identified using one of the following symbols:
+  #
+  # * +:stubbing_method_unnecessarily+ This is useful for identifying unused stubs. Unused stubs are often accidentally introduced when code is {http://martinfowler.com/bliki/DefinitionOfRefactoring.html refactored}. Allowed by default.
+  # * +:stubbing_non_existent_method+ - This is useful if you want to ensure that methods you're mocking really exist. A common criticism of unit tests with mock objects is that such a test may (incorrectly) pass when an equivalent non-mocking test would (correctly) fail. While you should always have some integration tests, particularly for critical business functionality, this Mocha configuration setting should catch scenarios when mocked methods and real methods have become misaligned. Allowed by default.
+  # * +:stubbing_non_public_method+ - Many people think that it's good practice only to mock public methods. This is one way to prevent your tests being too tightly coupled to the internal implementation of a class. Such tests tend to be very brittle and not much use when refactoring. Allowed by default.
+  # * +:stubbing_method_on_non_mock_object+ - If you like the idea of {http://www.jmock.org/oopsla2004.pdf mocking roles not objects} and {http://www.mockobjects.com/2007/04/test-smell-mocking-concrete-classes.html you don't like stubbing concrete classes}, this is the setting for you. However, while this restriction makes a lot of sense in Java with its {http://java.sun.com/docs/books/tutorial/java/concepts/interface.html explicit interfaces}, it may be moot in Ruby where roles are probably best represented as Modules. Allowed by default.
+  # * +:stubbing_method_on_nil+ - This is usually done accidentally, but there might be rare cases where it is intended. Prevented by default.
+  #
+  # @example Preventing unnecessary stubbing of a method
+  #   Mocha::Configuration.prevent(:stubbing_method_unnecessarily)
+  #
+  #   example = mock('example')
+  #   example.stubs(:unused_stub)
+  #   # => Mocha::StubbingError: stubbing method unnecessarily:
+  #   # =>   #<Mock:example>.unused_stub(any_parameters)
+  #
+  # @example Preventing stubbing of a method on a non-mock object
+  #   Mocha::Configuration.prevent(:stubbing_method_on_non_mock_object)
+  #
+  #   class Example
+  #     def example_method; end
+  #   end
+  #
+  #   example = Example.new
+  #   example.stubs(:example_method)
+  #   # => Mocha::StubbingError: stubbing method on non-mock object:
+  #   # =>   #<Example:0x593620>.example_method
+  #
+  # @example Preventing stubbing of a non-existent method
+  #
+  #   Mocha::Configuration.prevent(:stubbing_non_existent_method)
+  #
+  #   class Example
+  #   end
+  #
+  #   example = Example.new
+  #   example.stubs(:method_that_doesnt_exist)
+  #   # => Mocha::StubbingError: stubbing non-existent method:
+  #   # =>   #<Example:0x593760>.method_that_doesnt_exist
+  #
+  # @example Preventing stubbing of a non-public method
+  #   Mocha::Configuration.prevent(:stubbing_non_public_method)
+  #
+  #   class Example
+  #     def internal_method; end
+  #     private :internal_method
+  #   end
+  #
+  #   example = Example.new
+  #   example.stubs(:internal_method)
+  #   # => Mocha::StubbingError: stubbing non-public method:
+  #   # =>   #<Example:0x593530>.internal_method
+  #
+  # Typically the configuration would be set globally in a +test_helper.rb+ or +spec_helper.rb+ file. However, it can also be temporarily overridden locally using the block syntax of the relevant method. In the latter case, the original configuration settings are restored when the block is exited.
+  #
+  # @example Temporarily allowing stubbing of a non-existent method
+  #   Mocha::Configuration.prevent(:stubbing_non_public_method)
+  #
+  #   class Example
+  #   end
+  #
+  #   Mocha::Configuration.allow(:stubbing_non_existent_method) do
+  #     example = Example.new
+  #     example.stubs(:method_that_doesnt_exist)
+  #     # => no exception raised
+  #   end
   class Configuration
-
     DEFAULTS = {
       :stubbing_method_unnecessarily => :allow,
       :stubbing_method_on_non_mock_object => :allow,
       :stubbing_non_existent_method => :allow,
       :stubbing_non_public_method => :allow,
-      :stubbing_method_on_nil => :prevent,
-    }
+      :stubbing_method_on_nil => :prevent
+    }.freeze
 
     class << self
-
       # Allow the specified +action+.
       #
       # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
@@ -74,16 +136,13 @@ module Mocha
       end
 
       # @private
-      def temporarily_change_config(action, new_value, &block)
+      def temporarily_change_config(action, new_value)
         original_value = configuration[action]
         configuration[action] = new_value
         yield
       ensure
         configuration[action] = original_value
       end
-
     end
-
   end
-
 end

data/lib/mocha/debug.rb

@@ -1,11 +1,12 @@
 module Mocha
   module Debug
     OPTIONS = (ENV['MOCHA_OPTIONS'] || '').split(',').inject({}) do |hash, key|
-      hash[key] = true; hash
+      hash[key] = true
+      hash
     end.freeze
 
     def self.puts(message)
-      $stderr.puts(message) if OPTIONS['debug']
+      warn(message) if OPTIONS['debug']
     end
   end
 end

data/lib/mocha/deprecation.rb

@@ -1,27 +1,20 @@
 require 'mocha/backtrace_filter'
 
 module Mocha
-
   class Deprecation
-
     class << self
-
       attr_accessor :mode, :messages
 
       def warning(message)
         @messages << message
-        unless mode == :disabled
-          filter = BacktraceFilter.new
-          location = filter.filtered(caller)[0]
-          $stderr.puts "Mocha deprecation warning at #{location}: #{message}"
-        end
+        return if mode == :disabled
+        filter = BacktraceFilter.new
+        location = filter.filtered(caller)[0]
+        warn "Mocha deprecation warning at #{location}: #{message}"
       end
-
     end
 
     self.mode = :enabled
     self.messages = []
-
   end
-
 end

data/lib/mocha/detection/mini_test.rb

@@ -6,8 +6,6 @@ module Mocha
           ::Minitest::Test
         elsif defined?(::MiniTest::Unit::TestCase)
           ::MiniTest::Unit::TestCase
-        else
-          nil
         end
       end
 

data/lib/mocha/detection/test_unit.rb

@@ -3,11 +3,9 @@ module Mocha
     module TestUnit
       def self.testcase
         if defined?(::Test::Unit::TestCase) &&
-          !(defined?(::MiniTest::Unit::TestCase) && (::Test::Unit::TestCase < ::MiniTest::Unit::TestCase)) &&
-          !(defined?(::MiniTest::Spec) && (::Test::Unit::TestCase < ::MiniTest::Spec))
+           !(defined?(::MiniTest::Unit::TestCase) && (::Test::Unit::TestCase < ::MiniTest::Unit::TestCase)) &&
+           !(defined?(::MiniTest::Spec) && (::Test::Unit::TestCase < ::MiniTest::Spec))
           ::Test::Unit::TestCase
-        else
-          nil
         end
       end
 
@@ -16,8 +14,10 @@ module Mocha
         if testcase
           begin
             require 'test/unit/version'
+          # rubocop:disable Lint/HandleExceptions
           rescue LoadError
           end
+          # rubocop:enable Lint/HandleExceptions
           if defined?(::Test::Unit::VERSION)
             version = ::Test::Unit::VERSION
           end

data/lib/mocha/error_with_filtered_backtrace.rb

@@ -0,0 +1,13 @@
+require 'mocha/backtrace_filter'
+
+module Mocha
+  # @private
+  class ErrorWithFilteredBacktrace < StandardError
+    # @private
+    def initialize(message = nil, backtrace = [])
+      super(message)
+      filter = BacktraceFilter.new
+      set_backtrace(filter.filtered(backtrace))
+    end
+  end
+end

data/lib/mocha/exception_raiser.rb

@@ -1,9 +1,8 @@
 module Mocha
-
   class ExceptionRaiser
-
     def initialize(exception, message)
-      @exception, @message = exception, message
+      @exception = exception
+      @message = message
     end
 
     def evaluate
@@ -11,7 +10,5 @@ module Mocha
       raise @exception, @message if @message
       raise @exception
     end
-
   end
-
 end

data/lib/mocha/expectation.rb

@@ -11,10 +11,8 @@ require 'mocha/change_state_side_effect'
 require 'mocha/cardinality'
 
 module Mocha
-
   # Methods on expectations returned from {Mock#expects}, {Mock#stubs}, {ObjectMethods#expects} and {ObjectMethods#stubs}.
   class Expectation
-
     # Modifies expectation so that the number of calls to the expected method must be within a specific +range+.
     #
     # @param [Range,Integer] range specifies the allowable range in the number of expected invocations.
@@ -184,7 +182,7 @@ module Mocha
     #   object = mock()
     #   object.expects(:expected_method).at_most_once
     #   2.times { object.expected_method } # => unexpected invocation
-    def at_most_once()
+    def at_most_once
       at_most(1)
       self
     end
@@ -506,7 +504,8 @@ module Mocha
       @parameters_matcher = ParametersMatcher.new
       @ordering_constraints = []
       @side_effects = []
-      @cardinality, @invocation_count = Cardinality.exactly(1), 0
+      @cardinality = Cardinality.exactly(1)
+      @invocation_count = 0
       @return_values = ReturnValues.new
       @yield_parameters = YieldParameters.new
       @backtrace = backtrace || caller
@@ -529,12 +528,12 @@ module Mocha
 
     # @private
     def perform_side_effects
-      @side_effects.each { |side_effect| side_effect.perform }
+      @side_effects.each(&:perform)
     end
 
     # @private
     def in_correct_order?
-      @ordering_constraints.all? { |ordering_constraint| ordering_constraint.allows_invocation_now? }
+      @ordering_constraints.all?(&:allows_invocation_now?)
     end
 
     # @private
@@ -560,8 +559,8 @@ module Mocha
     # @private
     def invoke
       @invocation_count += 1
-      perform_side_effects()
-      if block_given? then
+      perform_side_effects
+      if block_given?
         @yield_parameters.next_invocation.each do |yield_parameters|
           yield(*yield_parameters)
         end
@@ -584,21 +583,21 @@ module Mocha
     def inspect
       address = __id__ * 2
       address += 0x100000000 if address < 0
-      "#<Expectation:0x#{'%x' % address} #{mocha_inspect} >"
+      "#<Expectation:0x#{format('%x', address)} #{mocha_inspect} >"
     end
 
     # @private
     def mocha_inspect
       message = "#{@cardinality.mocha_inspect}, "
       message << case @invocation_count
-        when 0 then "not yet invoked"
-        when 1 then "invoked once"
-        when 2 then "invoked twice"
-        else "invoked #{@invocation_count} times"
-      end
-      message << ": "
+                 when 0 then 'not yet invoked'
+                 when 1 then 'invoked once'
+                 when 2 then 'invoked twice'
+                 else "invoked #{@invocation_count} times"
+                 end
+      message << ': '
       message << method_signature
-      message << "; #{@ordering_constraints.map { |oc| oc.mocha_inspect }.join("; ")}" unless @ordering_constraints.empty?
+      message << "; #{@ordering_constraints.map(&:mocha_inspect).join('; ')}" unless @ordering_constraints.empty?
       message
     end
 
@@ -606,7 +605,5 @@ module Mocha
     def method_signature
       "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
     end
-
   end
-
 end

data/lib/mocha/expectation_error.rb

@@ -4,5 +4,7 @@ module Mocha
   # Authors of test libraries may use +Mocha::ExpectationErrorFactory+ to have Mocha raise a different exception.
   #
   # @see Mocha::ExpectationErrorFactory
+  # rubocop:disable Lint/InheritException
   class ExpectationError < Exception; end
+  # rubocop:enable Lint/InheritException
 end