mocha 1.9.0 → 1.10.0

data/lib/mocha/detection/test_unit.rb

@@ -14,10 +14,8 @@ module Mocha
         if testcase
           begin
             require 'test/unit/version'
-          # rubocop:disable Lint/HandleExceptions
-          rescue LoadError
+          rescue LoadError # rubocop:disable Lint/HandleExceptions
           end
-          # rubocop:enable Lint/HandleExceptions
           if defined?(::Test::Unit::VERSION)
             version = ::Test::Unit::VERSION
           end

data/lib/mocha/exception_raiser.rb

@@ -5,7 +5,8 @@ module Mocha
       @message = message
     end
 
-    def evaluate
+    def evaluate(invocation)
+      invocation.raised(@exception)
       raise @exception, @exception.to_s if @exception.is_a?(Module) && (@exception < Interrupt)
       raise @exception, @message if @message
       raise @exception

data/lib/mocha/expectation.rb

@@ -9,6 +9,7 @@ require 'mocha/is_a'
 require 'mocha/in_state_ordering_constraint'
 require 'mocha/change_state_side_effect'
 require 'mocha/cardinality'
+require 'mocha/configuration'
 
 module Mocha
   # Methods on expectations returned from {Mock#expects}, {Mock#stubs}, {ObjectMethods#expects} and {ObjectMethods#stubs}.
@@ -223,7 +224,7 @@ module Mocha
       self
     end
 
-    # Modifies expectation so that when the expected method is called, it yields with the specified +parameters+.
+    # Modifies expectation so that when the expected method is called, it yields with the specified +parameters+ (even if no block is provided, in which case yielding will result in a +LocalJumpError+).
     #
     # May be called multiple times on the same expectation for consecutive invocations.
     #
@@ -231,49 +232,56 @@ module Mocha
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     # @see #then
     #
+    # @example Yield when expected method is invoked.
+    #   benchmark = mock()
+    #   benchmark.expects(:measure).yields.then.returns('0.350000   0.400000   0.750000 (  0.835234)')
+    #   yielded = false
+    #   returned_value = benchmark.measure { yielded = true }
+    #   yielded # => true
+    #   returned_value # => '0.350000   0.400000   0.750000 (  0.835234)'
+    #
     # @example Yield parameters when expected method is invoked.
-    #   object = mock()
-    #   object.expects(:expected_method).yields('result')
-    #   yielded_value = nil
-    #   object.expected_method { |value| yielded_value = value }
-    #   yielded_value # => 'result'
+    #   fibonacci = mock()
+    #   fibonacci.expects(:next_pair).yields(0, 1)
+    #   sum = 0
+    #   fibonacci.next_pair { |first, second| sum = first + second }
+    #   sum # => 1
     #
     # @example Yield different parameters on different invocations of the expected method.
-    #   object = mock()
-    #   object.stubs(:expected_method).yields(1).then.yields(2)
-    #   yielded_values_from_first_invocation = []
-    #   yielded_values_from_second_invocation = []
-    #   object.expected_method { |value| yielded_values_from_first_invocation << value } # first invocation
-    #   object.expected_method { |value| yielded_values_from_second_invocation << value } # second invocation
-    #   yielded_values_from_first_invocation # => [1]
-    #   yielded_values_from_second_invocation # => [2]
+    #   fibonacci = mock()
+    #   fibonacci.expects(:next_pair).yields(0, 1).then.yields(1, 1)
+    #   sum = 0
+    #   fibonacci.next_pair { |first, second| sum = first + second }
+    #   sum # => 1
+    #   fibonacci.next_pair { |first, second| sum = first + second }
+    #   sum # => 2
     def yields(*parameters)
       @yield_parameters.add(*parameters)
       self
     end
 
-    # Modifies expectation so that when the expected method is called, it yields multiple times per invocation with the specified +parameter_groups+.
+    # Modifies expectation so that when the expected method is called, it yields multiple times per invocation with the specified +parameter_groups+ (even if no block is provided, in which case yielding will result in a +LocalJumpError+).
     #
     # @param [*Array<Array>] parameter_groups each element of +parameter_groups+ should iself be an +Array+ representing the parameters to be passed to the block for a single yield.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     # @see #then
     #
-    # @example When the +expected_method+ is called, the stub will invoke the block twice, the first time it passes +'result_1'+, +'result_2'+ as the parameters, and the second time it passes 'result_3' as the parameters.
-    #   object = mock()
-    #   object.expects(:expected_method).multiple_yields(['result_1', 'result_2'], ['result_3'])
-    #   yielded_values = []
-    #   object.expected_method { |*values| yielded_values << values }
-    #   yielded_values # => [['result_1', 'result_2'], ['result_3]]
-    #
-    # @example Yield different groups of parameters on different invocations of the expected method.
-    #   object = mock()
-    #   object.stubs(:expected_method).multiple_yields([1, 2], [3]).then.multiple_yields([4], [5, 6])
-    #   yielded_values_from_first_invocation = []
-    #   yielded_values_from_second_invocation = []
-    #   object.expected_method { |*values| yielded_values_from_first_invocation << values } # first invocation
-    #   object.expected_method { |*values| yielded_values_from_second_invocation << values } # second invocation
-    #   yielded_values_from_first_invocation # => [[1, 2], [3]]
-    #   yielded_values_from_second_invocation # => [[4], [5, 6]]
+    # @example When +foreach+ is called, the stub will invoke the block twice, the first time it passes ['row1_col1', 'row1_col2'] as the parameters, and the second time it passes ['row2_col1', ''] as the parameters.
+    #   csv = mock()
+    #   csv.expects(:foreach).with("path/to/file.csv").multiple_yields(['row1_col1', 'row1_col2'], ['row2_col1', ''])
+    #   rows = []
+    #   csv.foreach { |row| rows << row }
+    #   rows # => [['row1_col1', 'row1_col2'], ['row2_col1', '']]
+    #
+    # @example Yield different groups of parameters on different invocations of the expected method. Simulating a situation where the CSV file at 'path/to/file.csv' has been modified between the two calls to +foreach+.
+    #   csv = mock()
+    #   csv.stubs(:foreach).with("path/to/file.csv").multiple_yields(['old_row1_col1', 'old_row1_col2'], ['old_row2_col1', '']).then.multiple_yields(['new_row1_col1', ''], ['new_row2_col1', 'new_row2_col2'])
+    #   rows_from_first_invocation = []
+    #   rows_from_second_invocation = []
+    #   csv.foreach { |row| rows_from_first_invocation << row } # first invocation
+    #   csv.foreach { |row| rows_from_second_invocation << row } # second invocation
+    #   rows_from_first_invocation # => [['old_row1_col1', 'old_row1_col2'], ['old_row2_col1', '']]
+    #   rows_from_second_invocation # => [['new_row1_col1', ''], ['new_row2_col1', 'new_row2_col2']]
     def multiple_yields(*parameter_groups)
       @yield_parameters.multiple_add(*parameter_groups)
       self
@@ -477,7 +485,8 @@ module Mocha
     #
     # An expected method can appear in multiple sequences.
     #
-    # @param [*Array<Sequence>] sequences sequences in which expected method should appear.
+    # @param [Sequence] sequence sequence in which expected method should appear.
+    # @param [*Array<Sequence>] sequences more sequences in which expected method should appear.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
     # @see API#sequence
@@ -489,8 +498,8 @@ module Mocha
     #   egg.expects(:crack).in_sequence(breakfast)
     #   egg.expects(:fry).in_sequence(breakfast)
     #   egg.expects(:eat).in_sequence(breakfast)
-    def in_sequence(*sequences)
-      sequences.each { |sequence| add_in_sequence_ordering_constraint(sequence) }
+    def in_sequence(sequence, *sequences)
+      sequences.unshift(sequence).each { |seq| add_in_sequence_ordering_constraint(seq) }
       self
     end
 
@@ -505,7 +514,6 @@ module Mocha
       @ordering_constraints = []
       @side_effects = []
       @cardinality = Cardinality.exactly(1)
-      @invocation_count = 0
       @return_values = ReturnValues.new
       @yield_parameters = YieldParameters.new
       @backtrace = backtrace || caller
@@ -542,41 +550,36 @@ module Mocha
     end
 
     # @private
-    def match?(actual_method_name, *actual_parameters)
-      @method_matcher.match?(actual_method_name) && @parameters_matcher.match?(actual_parameters) && in_correct_order?
+    def match?(invocation)
+      @method_matcher.match?(invocation.method_name) && @parameters_matcher.match?(invocation.arguments) && in_correct_order?
     end
 
     # @private
     def invocations_allowed?
-      @cardinality.invocations_allowed?(@invocation_count)
+      @cardinality.invocations_allowed?
     end
 
     # @private
     def satisfied?
-      @cardinality.satisfied?(@invocation_count)
+      @cardinality.satisfied?
     end
 
     # @private
-    def invoke
-      @invocation_count += 1
+    def invoke(invocation)
       perform_side_effects
-      if block_given?
-        @yield_parameters.next_invocation.each do |yield_parameters|
-          yield(*yield_parameters)
-        end
-      end
-      @return_values.next
+      @cardinality << invocation
+      invocation.call(@yield_parameters, @return_values) { |*yield_args| yield(*yield_args) }
     end
 
     # @private
     def verified?(assertion_counter = nil)
       assertion_counter.increment if assertion_counter && @cardinality.needs_verifying?
-      @cardinality.verified?(@invocation_count)
+      @cardinality.verified?
     end
 
     # @private
     def used?
-      @cardinality.used?(@invocation_count)
+      @cardinality.used?
     end
 
     # @private
@@ -588,16 +591,11 @@ module Mocha
 
     # @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 << ': '
-      message << method_signature
+      message = "#{@cardinality.anticipated_times}, #{@cardinality.invoked_times}: #{method_signature}"
       message << "; #{@ordering_constraints.map(&:mocha_inspect).join('; ')}" unless @ordering_constraints.empty?
+      if Mocha.configuration.display_matching_invocations_on_failure?
+        message << @cardinality.actual_invocations
+      end
       message
     end
 

data/lib/mocha/expectation_error.rb

@@ -4,7 +4,5 @@ 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
+  class ExpectationError < Exception; end # rubocop:disable Lint/InheritException
 end

data/lib/mocha/expectation_list.rb

@@ -17,12 +17,12 @@ module Mocha
       @expectations.any? { |expectation| expectation.matches_method?(method_name) }
     end
 
-    def match(method_name, *arguments)
-      matching_expectations(method_name, *arguments).first
+    def match(invocation)
+      matching_expectations(invocation).first
     end
 
-    def match_allowing_invocation(method_name, *arguments)
-      matching_expectations(method_name, *arguments).detect(&:invocations_allowed?)
+    def match_allowing_invocation(invocation)
+      matching_expectations(invocation).detect(&:invocations_allowed?)
     end
 
     def verified?(assertion_counter = nil)
@@ -51,8 +51,8 @@ module Mocha
 
     private
 
-    def matching_expectations(method_name, *arguments)
-      @expectations.select { |e| e.match?(method_name, *arguments) }
+    def matching_expectations(invocation)
+      @expectations.select { |e| e.match?(invocation) }
     end
   end
 end

data/lib/mocha/inspect.rb

@@ -1,55 +1,57 @@
 require 'date'
 
 module Mocha
-  module ObjectMethods
-    def mocha_inspect
-      address = __id__ * 2
-      address += 0x100000000 if address < 0
-      inspect =~ /#</ ? "#<#{self.class}:0x#{Kernel.format('%x', address)}>" : inspect
+  module Inspect
+    module ObjectMethods
+      def mocha_inspect
+        address = __id__ * 2
+        address += 0x100000000 if address < 0
+        inspect =~ /#</ ? "#<#{self.class}:0x#{Kernel.format('%x', address)}>" : inspect
+      end
     end
-  end
 
-  module ArrayMethods
-    def mocha_inspect
-      "[#{collect(&:mocha_inspect).join(', ')}]"
+    module ArrayMethods
+      def mocha_inspect
+        "[#{collect(&:mocha_inspect).join(', ')}]"
+      end
     end
-  end
 
-  module HashMethods
-    def mocha_inspect
-      "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+    module HashMethods
+      def mocha_inspect
+        "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+      end
     end
-  end
 
-  module TimeMethods
-    def mocha_inspect
-      "#{inspect} (#{to_f} secs)"
+    module TimeMethods
+      def mocha_inspect
+        "#{inspect} (#{to_f} secs)"
+      end
     end
-  end
 
-  module DateMethods
-    def mocha_inspect
-      to_s
+    module DateMethods
+      def mocha_inspect
+        to_s
+      end
     end
   end
 end
 
 class Object
-  include Mocha::ObjectMethods
+  include Mocha::Inspect::ObjectMethods
 end
 
 class Array
-  include Mocha::ArrayMethods
+  include Mocha::Inspect::ArrayMethods
 end
 
 class Hash
-  include Mocha::HashMethods
+  include Mocha::Inspect::HashMethods
 end
 
 class Time
-  include Mocha::TimeMethods
+  include Mocha::Inspect::TimeMethods
 end
 
 class Date
-  include Mocha::DateMethods
+  include Mocha::Inspect::DateMethods
 end

data/lib/mocha/instance_method.rb

@@ -1,6 +1,23 @@
-require 'mocha/class_method'
+require 'mocha/stubbed_method'
 
 module Mocha
-  class InstanceMethod < ClassMethod
+  class InstanceMethod < StubbedMethod
+    private
+
+    def mock_owner
+      stubbee
+    end
+
+    def method_body(method)
+      PRE_RUBY_V19 ? proc { |*args, &block| method.call(*args, &block) } : method
+    end
+
+    def stubbee_method(method_name)
+      stubbee._method(method_name)
+    end
+
+    def original_method_owner
+      stubbee.singleton_class
+    end
   end
 end

data/lib/mocha/integration.rb

@@ -1,4 +1,3 @@
-require 'mocha/deprecation'
 require 'mocha/integration/test_unit'
 require 'mocha/integration/mini_test'
 
@@ -6,8 +5,7 @@ module Mocha
   module Integration
     def self.activate
       return unless [Integration::TestUnit, Integration::MiniTest].map(&:activate).none?
-      Deprecation.warning("Test::Unit or MiniTest must be loaded *before* `require 'mocha/setup'`.")
-      Deprecation.warning("If you're integrating with a test library other than Test::Unit or MiniTest, you should use `require 'mocha/api'` instead of `require 'mocha/setup'`.")
+      raise "Test::Unit or Minitest must be loaded *before* `require 'mocha/setup'`."
     end
   end
 end

data/lib/mocha/integration/mini_test.rb

@@ -14,6 +14,8 @@ require 'mocha/integration/mini_test/version_2110_to_2111'
 require 'mocha/integration/mini_test/version_2112_to_320'
 require 'mocha/integration/mini_test/adapter'
 
+require 'mocha/deprecation'
+
 module Mocha
   module Integration
     module MiniTest
@@ -39,6 +41,11 @@ module Mocha
 
         target = Detection::MiniTest.testcase
         unless target < integration_module
+          unless integration_module == MiniTest::Adapter
+            Deprecation.warning(
+              'Versions of minitest earlier than v3.3.0 will not be supported in future versions of Mocha.'
+            )
+          end
           Debug.puts "Applying #{integration_module.description}"
           target.send(:include, integration_module)
         end

data/lib/mocha/integration/test_unit.rb

@@ -11,6 +11,8 @@ require 'mocha/integration/test_unit/gem_version_203_to_220'
 require 'mocha/integration/test_unit/gem_version_230_to_250'
 require 'mocha/integration/test_unit/adapter'
 
+require 'mocha/deprecation'
+
 module Mocha
   module Integration
     module TestUnit
@@ -34,6 +36,11 @@ module Mocha
         ].detect { |m| m.applicable_to?(test_unit_version, ruby_version) }
 
         unless ::Test::Unit::TestCase < integration_module
+          unless integration_module == TestUnit::Adapter
+            Deprecation.warning(
+              'Versions of test-unit earlier than v2.5.1 will not be supported in future versions of Mocha.'
+            )
+          end
           Debug.puts "Applying #{integration_module.description}"
           ::Test::Unit::TestCase.send(:include, integration_module)
         end

data/lib/mocha/invocation.rb

@@ -0,0 +1,61 @@
+require 'mocha/parameters_matcher'
+require 'mocha/raised_exception'
+require 'mocha/return_values'
+require 'mocha/thrown_object'
+require 'mocha/yield_parameters'
+
+module Mocha
+  class Invocation
+    attr_reader :method_name
+
+    def initialize(mock, method_name, *arguments)
+      @mock = mock
+      @method_name = method_name
+      @arguments = arguments
+      @yields = []
+      @result = nil
+    end
+
+    def call(yield_parameters = YieldParameters.new, return_values = ReturnValues.new)
+      yield_parameters.next_invocation.each do |yield_args|
+        @yields << ParametersMatcher.new(yield_args)
+        yield(*yield_args)
+      end
+      return_values.next(self)
+    end
+
+    def returned(value)
+      @result = value
+    end
+
+    def raised(exception)
+      @result = RaisedException.new(exception)
+    end
+
+    def threw(tag, value)
+      @result = ThrownObject.new(tag, value)
+    end
+
+    def arguments
+      @arguments.dup
+    end
+
+    def call_description
+      "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+    end
+
+    def short_call_description
+      "#{@method_name}(#{@arguments.join(', ')})"
+    end
+
+    def result_description
+      desc = "# => #{@result.mocha_inspect}"
+      desc << " after yielding #{@yields.map(&:mocha_inspect).join(', then ')}" if @yields.any?
+      desc
+    end
+
+    def full_description
+      "\n  - #{call_description} #{result_description}"
+    end
+  end
+end