mocha 1.10.0 → 1.11.2

data/lib/mocha/block_matcher.rb

@@ -0,0 +1,31 @@
+module Mocha
+  module BlockMatchers
+    class OptionalBlock
+      def match?(_actual_block)
+        true
+      end
+
+      def mocha_inspect; end
+    end
+
+    class BlockGiven
+      def match?(actual_block)
+        !actual_block.nil?
+      end
+
+      def mocha_inspect
+        'with block given'
+      end
+    end
+
+    class NoBlockGiven
+      def match?(actual_block)
+        actual_block.nil?
+      end
+
+      def mocha_inspect
+        'with no block given'
+      end
+    end
+  end
+end

data/lib/mocha/configuration.rb

@@ -42,7 +42,8 @@ module Mocha
       :stubbing_non_existent_method => :allow,
       :stubbing_non_public_method => :allow,
       :stubbing_method_on_nil => :prevent,
-      :display_matching_invocations_on_failure => false
+      :display_matching_invocations_on_failure => false,
+      :reinstate_undocumented_behaviour_from_v1_9 => true
     }.freeze
 
     attr_reader :options
@@ -247,6 +248,61 @@ module Mocha
       @options[:display_matching_invocations_on_failure]
     end
 
+    # Reinstate undocumented behaviour from v1.9
+    #
+    # Previously when {API#mock}, {API#stub}, or {API#stub_everything} were called with the first argument being a symbol, they built an *unnamed* mock object *and* expected or stubbed the method identified by the symbol argument; subsequent arguments were ignored.
+    # Now these methods build a *named* mock with the name specified by the symbol argument; *no* methods are expected or stubbed and subsequent arguments *are* taken into account.
+    #
+    # Previously if {Expectation#yields} or {Expectation#multiple_yields} was called on an expectation, but no block was given when the method was invoked, the instruction to yield was ignored.
+    # Now a +LocalJumpError+ is raised.
+    #
+    # Enabling this configuration option reinstates the previous behaviour, but displays a deprecation warning.
+    #
+    # @param [Boolean] value +true+ to reinstate undocumented behaviour; enabled by default.
+    #
+    # @example Reinstate undocumented behaviour for {API#mock}
+    #   Mocha.configure do |c|
+    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   end
+    #
+    #   foo = mock(:bar)
+    #   foo.inspect # => #<Mock>
+    #
+    #   not all expectations were satisfied
+    #   unsatisfied expectations:
+    #   - expected exactly once, invoked never: #<Mock>.foo
+    #
+    # @example Reinstate undocumented behaviour for {API#stub}
+    #   Mocha.configure do |c|
+    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   end
+    #
+    #   foo = stub(:bar)
+    #   foo.inspect # => #<Mock>
+    #   foo.bar # => nil
+    #
+    # @example Reinstate undocumented behaviour for {Expectation#yields}
+    #   foo = mock('foo')
+    #   foo.stubs(:my_method).yields(1, 2)
+    #   foo.my_method # => raises LocalJumpError when no block is supplied
+    #
+    #   Mocha.configure do |c|
+    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   end
+    #
+    #   foo = mock('foo')
+    #   foo.stubs(:my_method).yields(1, 2)
+    #   foo.my_method # => does *not* raise LocalJumpError when no block is supplied
+    #
+    def reinstate_undocumented_behaviour_from_v1_9=(value)
+      @options[:reinstate_undocumented_behaviour_from_v1_9] = value
+    end
+
+    # @private
+    def reinstate_undocumented_behaviour_from_v1_9?
+      @options[:reinstate_undocumented_behaviour_from_v1_9]
+    end
+
     class << self
       # Allow the specified +action+.
       #

data/lib/mocha/deprecation.rb

@@ -5,7 +5,8 @@ module Mocha
     class << self
       attr_accessor :mode, :messages
 
-      def warning(message)
+      def warning(*messages)
+        message = messages.join
         @messages << message
         return if mode == :disabled
         filter = BacktraceFilter.new

data/lib/mocha/expectation.rb

@@ -10,6 +10,7 @@ require 'mocha/in_state_ordering_constraint'
 require 'mocha/change_state_side_effect'
 require 'mocha/cardinality'
 require 'mocha/configuration'
+require 'mocha/block_matcher'
 
 module Mocha
   # Methods on expectations returned from {Mock#expects}, {Mock#stubs}, {ObjectMethods#expects} and {ObjectMethods#stubs}.
@@ -224,6 +225,44 @@ module Mocha
       self
     end
 
+    # Modifies expectation so that the expected method must be called with a block.
+    #
+    # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
+    #
+    # @example Expected method must be called with a block.
+    #   object = mock()
+    #   object.expects(:expected_method).with_block_given
+    #   object.expected_method { 1 + 1 }
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).with_block_given
+    #   object.expected_method
+    #   # => verify fails
+    def with_block_given
+      @block_matcher = BlockMatchers::BlockGiven.new
+      self
+    end
+
+    # Modifies expectation so that the expected method must be called without a block.
+    #
+    # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
+    #
+    # @example Expected method must be called without a block.
+    #   object = mock()
+    #   object.expects(:expected_method).with_no_block_given
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).with_block_given
+    #   object.expected_method { 1 + 1 }
+    #   # => verify fails
+    def with_no_block_given
+      @block_matcher = BlockMatchers::NoBlockGiven.new
+      self
+    end
+
     # 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.
@@ -256,13 +295,12 @@ module Mocha
     #   fibonacci.next_pair { |first, second| sum = first + second }
     #   sum # => 2
     def yields(*parameters)
-      @yield_parameters.add(*parameters)
-      self
+      multiple_yields(parameters)
     end
 
     # 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.
+    # @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. Any element of +parameter_groups+ that is not an +Array+ is wrapped in an +Array+.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     # @see #then
     #
@@ -283,7 +321,7 @@ module Mocha
     #   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)
+      @yield_parameters.add(*parameter_groups)
       self
     end
 
@@ -511,6 +549,7 @@ module Mocha
       @mock = mock
       @method_matcher = MethodMatcher.new(expected_method_name.to_sym)
       @parameters_matcher = ParametersMatcher.new
+      @block_matcher = BlockMatchers::OptionalBlock.new
       @ordering_constraints = []
       @side_effects = []
       @cardinality = Cardinality.exactly(1)
@@ -551,7 +590,7 @@ module Mocha
 
     # @private
     def match?(invocation)
-      @method_matcher.match?(invocation.method_name) && @parameters_matcher.match?(invocation.arguments) && in_correct_order?
+      @method_matcher.match?(invocation.method_name) && @parameters_matcher.match?(invocation.arguments) && @block_matcher.match?(invocation.block) && in_correct_order?
     end
 
     # @private
@@ -568,7 +607,7 @@ module Mocha
     def invoke(invocation)
       perform_side_effects
       @cardinality << invocation
-      invocation.call(@yield_parameters, @return_values) { |*yield_args| yield(*yield_args) }
+      invocation.call(@yield_parameters, @return_values)
     end
 
     # @private
@@ -601,7 +640,9 @@ module Mocha
 
     # @private
     def method_signature
-      "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
+      signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
+      signature << " #{@block_matcher.mocha_inspect}" if @block_matcher.mocha_inspect
+      signature
     end
   end
 end

data/lib/mocha/invocation.rb

@@ -3,15 +3,18 @@ require 'mocha/raised_exception'
 require 'mocha/return_values'
 require 'mocha/thrown_object'
 require 'mocha/yield_parameters'
+require 'mocha/configuration'
+require 'mocha/deprecation'
 
 module Mocha
   class Invocation
-    attr_reader :method_name
+    attr_reader :method_name, :block
 
-    def initialize(mock, method_name, *arguments)
+    def initialize(mock, method_name, *arguments, &block)
       @mock = mock
       @method_name = method_name
       @arguments = arguments
+      @block = block
       @yields = []
       @result = nil
     end
@@ -19,7 +22,18 @@ module Mocha
     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)
+        if @block
+          @block.call(*yield_args)
+        else
+          raise LocalJumpError unless Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+          yield_args_description = ParametersMatcher.new(yield_args).mocha_inspect
+          Deprecation.warning(
+            "Stubbed method was instructed to yield #{yield_args_description}, but no block was given by invocation: #{call_description}.",
+            ' This will raise a LocalJumpError in the future.',
+            ' Use Expectation#with_block_given to constrain this expectation to match invocations supplying a block.',
+            ' And, if necessary, add another expectation to match invocations not supplying a block.'
+          )
+        end
       end
       return_values.next(self)
     end
@@ -41,7 +55,9 @@ module Mocha
     end
 
     def call_description
-      "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description << ' { ... }' unless @block.nil?
+      description
     end
 
     def short_call_description

data/lib/mocha/mock.rb

@@ -275,6 +275,7 @@ module Mocha
       @everything_stubbed = false
       @responder = nil
       @unexpected_invocation = nil
+      @expired = false
     end
 
     # @private
@@ -305,26 +306,16 @@ module Mocha
     end
 
     # @private
-    # rubocop:disable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-    def method_missing(symbol, *arguments, &block)
-      if @responder && !@responder.respond_to?(symbol)
-        raise NoMethodError, "undefined method `#{symbol}' for #{mocha_inspect} which responds like #{@responder.mocha_inspect}"
-      end
-      invocation = Invocation.new(self, symbol, *arguments)
+    def method_missing(symbol, *arguments, &block) # rubocop:disable Style/MethodMissingSuper
+      check_expiry
+      check_responder_responds_to(symbol)
+      invocation = Invocation.new(self, symbol, *arguments, &block)
       if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(invocation))
-        matching_expectation_allowing_invocation.invoke(invocation, &block)
+        matching_expectation_allowing_invocation.invoke(invocation)
       elsif (matching_expectation = all_expectations.match(invocation)) || (!matching_expectation && !@everything_stubbed)
-        if @unexpected_invocation.nil?
-          @unexpected_invocation = invocation
-          matching_expectation.invoke(invocation, &block) if matching_expectation
-          message = "#{@unexpected_invocation.call_description}\n#{@mockery.mocha_inspect}"
-        else
-          message = @unexpected_invocation.short_call_description
-        end
-        raise ExpectationErrorFactory.build("unexpected invocation: #{message}", caller)
+        raise_unexpected_invocation_error(invocation, matching_expectation)
       end
     end
-    # rubocop:enable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # @private
     def respond_to_missing?(symbol, include_private = false)
@@ -351,6 +342,11 @@ module Mocha
       @expectations.verified?(assertion_counter)
     end
 
+    # @private
+    def __expire__
+      @expired = true
+    end
+
     # @private
     def mocha_inspect
       @name.mocha_inspect
@@ -370,5 +366,35 @@ module Mocha
     def any_expectations?
       @expectations.any?
     end
+
+    private
+
+    def raise_unexpected_invocation_error(invocation, matching_expectation)
+      if @unexpected_invocation.nil?
+        @unexpected_invocation = invocation
+        matching_expectation.invoke(invocation) if matching_expectation
+        message = "#{@unexpected_invocation.call_description}\n#{@mockery.mocha_inspect}"
+      else
+        message = @unexpected_invocation.short_call_description
+      end
+      raise ExpectationErrorFactory.build("unexpected invocation: #{message}", caller)
+    end
+
+    def check_responder_responds_to(symbol)
+      if @responder && !@responder.respond_to?(symbol) # rubocop:disable Style/GuardClause
+        raise NoMethodError, "undefined method `#{symbol}' for #{mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      end
+    end
+
+    def check_expiry
+      if @expired # rubocop:disable Style/GuardClause
+        Deprecation.warning(
+          "#{mocha_inspect} was instantiated in one test but it is receiving invocations within another test.",
+          ' This can lead to unintended interactions between tests and hence unexpected test failures.',
+          ' Ensure that every test correctly cleans up any state that it introduces.',
+          ' A Mocha::StubbingError will be raised in this scenario in the future.'
+        )
+      end
+    end
   end
 end

data/lib/mocha/mockery.rb

@@ -102,6 +102,7 @@ module Mocha
 
     def teardown
       stubba.unstub_all
+      mocks.each(&:__expire__)
       reset
     end
 
@@ -127,19 +128,20 @@ module Mocha
 
     def on_stubbing(object, method)
       method = PRE_RUBY_V19 ? method.to_s : method.to_sym
-      method_signature = "#{object.mocha_inspect}.#{method}"
-      check(:stubbing_non_existent_method, 'non-existent method', method_signature) do
+      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
-      check(:stubbing_non_public_method, 'non-public method', method_signature) do
+      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', method_signature) { object.nil? }
-      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', method_signature)
+      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_method_unnecessarily(expectation)
-      check(:stubbing_method_unnecessarily, 'method unnecessarily', expectation.method_signature, expectation.backtrace)
+      signature_proc = lambda { expectation.method_signature }
+      check(:stubbing_method_unnecessarily, 'method unnecessarily', signature_proc, expectation.backtrace)
     end
 
     attr_writer :logger
@@ -150,15 +152,13 @@ module Mocha
 
     private
 
-    def check(action, description, method_signature, backtrace = caller)
-      return if block_given? && !yield
+    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}"
-      case Mocha.configuration.send(action)
-      when :warn
-        logger.warn(message)
-      when :prevent
-        raise StubbingError.new(message, backtrace)
-      end
+      raise StubbingError.new(message, backtrace) if treatment == :prevent
+      logger.warn(message) if treatment == :warn
     end
 
     def expectations

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -22,11 +22,10 @@ module Mocha
     #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
     #   object.method_1('key_1' => 1, 'key_2' => 99)
     #   # error raised, because method_1 was not called with Hash containing entries: 'key_1' => 1, 'key_2' => 2
-    # rubocop:disable Naming/PredicateName
-    def has_entries(entries)
+    #
+    def has_entries(entries) # rubocop:disable Naming/PredicateName
       HasEntries.new(entries)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains all expected +Hash+ entries.
     class HasEntries < Base

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -39,8 +39,8 @@ module Mocha
     #   object.expects(:method_1).with(has_entry('key_1' => 1))
     #   object.method_1('key_1' => 2, 'key_2' => 1)
     #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
-    # rubocop:disable Naming/PredicateName
-    def has_entry(*options)
+    #
+    def has_entry(*options) # rubocop:disable Naming/PredicateName
       case options.length
       when 1
         case options[0]
@@ -63,7 +63,6 @@ module Mocha
       end
       HasEntry.new(key, value)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains expected +Hash+ entry.
     class HasEntry < Base