mocha 1.0.0.alpha → 1.10.0.alpha

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,24 +1,20 @@
-require 'mocha/debug'
+require 'mocha/backtrace_filter'
 
 module Mocha
-
   class Deprecation
-
     class << self
-
       attr_accessor :mode, :messages
 
       def warning(message)
         @messages << message
-        $stderr.puts "\n*** Mocha deprecation warning: #{message}\n\n" unless mode == :disabled
-        $stderr.puts caller.join("\n  ") if mode == :debug
+        return if mode == :disabled
+        filter = BacktraceFilter.new
+        location = filter.filtered(caller)[0]
+        warn "Mocha deprecation warning at #{location}: #{message}"
       end
-
     end
 
-    self.mode = Debug::OPTIONS['debug'] ? :debug : :enabled
+    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,7 +14,7 @@ module Mocha
         if testcase
           begin
             require 'test/unit/version'
-          rescue LoadError
+          rescue LoadError # rubocop:disable Lint/HandleExceptions
           end
           if defined?(::Test::Unit::VERSION)
             version = ::Test::Unit::VERSION

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,17 +1,15 @@
 module Mocha
-
   class ExceptionRaiser
-
     def initialize(exception, message)
-      @exception, @message = exception, message
+      @exception = exception
+      @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
     end
-
   end
-
 end

data/lib/mocha/expectation.rb

@@ -9,12 +9,11 @@ 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}.
   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 +183,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
@@ -225,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.
     #
@@ -233,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
@@ -479,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
@@ -491,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
 
@@ -506,7 +513,7 @@ module Mocha
       @parameters_matcher = ParametersMatcher.new
       @ordering_constraints = []
       @side_effects = []
-      @cardinality, @invocation_count = Cardinality.exactly(1), 0
+      @cardinality = Cardinality.exactly(1)
       @return_values = ReturnValues.new
       @yield_parameters = YieldParameters.new
       @backtrace = backtrace || caller
@@ -529,12 +536,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
@@ -543,62 +550,52 @@ 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
-      perform_side_effects()
-      if block_given? then
-        @yield_parameters.next_invocation.each do |yield_parameters|
-          yield(*yield_parameters)
-        end
-      end
-      @return_values.next
+    def invoke(invocation)
+      perform_side_effects
+      @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
     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"
+      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 << ": "
-      message << method_signature
-      message << "; #{@ordering_constraints.map { |oc| oc.mocha_inspect }.join("; ")}" unless @ordering_constraints.empty?
       message
     end
 
@@ -606,7 +603,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,5 @@ module Mocha
   # Authors of test libraries may use +Mocha::ExpectationErrorFactory+ to have Mocha raise a different exception.
   #
   # @see Mocha::ExpectationErrorFactory
-  class ExpectationError < Exception; end
+  class ExpectationError < Exception; end # rubocop:disable Lint/InheritException
 end

data/lib/mocha/expectation_error_factory.rb

@@ -2,7 +2,6 @@ require 'mocha/backtrace_filter'
 require 'mocha/expectation_error'
 
 module Mocha
-
   # This factory determines what class of exception should be raised when Mocha detects a test failure.
   #
   # This class should only be used by authors of test libraries and not by typical "users" of Mocha.

data/lib/mocha/expectation_list.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class ExpectationList
-
     def initialize(expectations = [])
       @expectations = expectations
     end
@@ -19,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 { |e| e.invocations_allowed? }
+    def match_allowing_invocation(invocation)
+      matching_expectations(invocation).detect(&:invocations_allowed?)
     end
 
     def verified?(assertion_counter = nil)
@@ -48,15 +46,13 @@ module Mocha
     end
 
     def +(other)
-      self.class.new(self.to_a + other.to_a)
+      self.class.new(to_a + other.to_a)
     end
 
     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/hooks.rb

@@ -1,7 +1,6 @@
 require 'mocha/mockery'
 
 module Mocha
-
   # Integration hooks for test library authors.
   #
   # The methods in this module should be called from test libraries wishing to integrate with Mocha.
@@ -21,6 +20,7 @@ module Mocha
     #
     # This method should be called before each individual test starts (including before any "setup" code).
     def mocha_setup
+      Mockery.setup
     end
 
     # Verifies that all mock expectations have been met (only for use by authors of test libraries).
@@ -37,8 +37,6 @@ module Mocha
     # This method should be called after each individual test has finished (including after any "teardown" code).
     def mocha_teardown
       Mockery.teardown
-    ensure
-      Mockery.reset_instance
     end
   end
 end

data/lib/mocha/in_state_ordering_constraint.rb

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