mocha 1.10.2 → 1.11.0

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
@@ -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

@@ -8,7 +8,7 @@ require 'mocha/deprecation'
 
 module Mocha
   class Invocation
-    attr_reader :method_name
+    attr_reader :method_name, :block
 
     def initialize(mock, method_name, *arguments, &block)
       @mock = mock
@@ -27,10 +27,12 @@ module Mocha
         else
           raise LocalJumpError unless Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
           yield_args_description = ParametersMatcher.new(yield_args).mocha_inspect
-          Deprecation.warning([
+          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.'
-          ].join(' '))
+            ' 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)
@@ -53,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/version.rb

@@ -1,3 +1,3 @@
 module Mocha
-  VERSION = '1.10.2'.freeze
+  VERSION = '1.11.0'.freeze
 end

data/lib/mocha/yield_parameters.rb

@@ -1,7 +1,3 @@
-require 'mocha/no_yields'
-require 'mocha/single_yield'
-require 'mocha/multiple_yields'
-
 module Mocha
   class YieldParameters
     def initialize
@@ -10,18 +6,16 @@ module Mocha
 
     def next_invocation
       case @parameter_groups.length
-      when 0 then NoYields.new
+      when 0 then []
       when 1 then @parameter_groups.first
       else @parameter_groups.shift
       end
     end
 
-    def add(*parameters)
-      @parameter_groups << SingleYield.new(*parameters)
-    end
-
-    def multiple_add(*parameter_groups)
-      @parameter_groups << MultipleYields.new(*parameter_groups)
+    def add(*parameter_groups)
+      @parameter_groups << parameter_groups.map do |pg|
+        pg.is_a?(Array) ? pg : [pg]
+      end
     end
   end
 end

data/test/acceptance/acceptance_test_helper.rb

@@ -1,6 +1,7 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'test_runner'
 require 'mocha/configuration'
+require 'mocha/mockery'
 require 'introspection'
 
 if Mocha::Detection::MiniTest.testcase && (ENV['MOCHA_RUN_INTEGRATION_TESTS'] != 'test-unit')

data/test/acceptance/display_matching_invocations_alongside_expectations_test.rb

@@ -31,7 +31,7 @@ class DisplayMatchingInvocationsAlongsideExpectationsTest < Mocha::TestCase
     test_result = run_as_test do
       foo = mock('foo')
       foo.expects(:bar).with(1).returns('a')
-      foo.stubs(:bar).with(any_parameters).multiple_yields(%w[b c], %w[d e]).returns('f').raises(StandardError).throws(:tag, 'value')
+      foo.stubs(:bar).with(any_parameters).multiple_yields('bc', %w[d e]).returns('f').raises(StandardError).throws(:tag, 'value')
 
       foo.bar(1, 2) { |_ignored| }
       assert_raises(StandardError) { foo.bar(3, 4) { |_ignored| } }
@@ -40,9 +40,9 @@ class DisplayMatchingInvocationsAlongsideExpectationsTest < Mocha::TestCase
     assert_invocations(
       test_result,
       '- allowed any number of times, invoked 3 times: #<Mock:foo>.bar(any_parameters)',
-      '  - #<Mock:foo>.bar(1, 2) # => "f" after yielding ("b", "c"), then ("d", "e")',
-      '  - #<Mock:foo>.bar(3, 4) # => raised StandardError after yielding ("b", "c"), then ("d", "e")',
-      '  - #<Mock:foo>.bar(5, 6) # => threw (:tag, "value") after yielding ("b", "c"), then ("d", "e")'
+      '  - #<Mock:foo>.bar(1, 2) { ... } # => "f" after yielding ("bc"), then ("d", "e")',
+      '  - #<Mock:foo>.bar(3, 4) { ... } # => raised StandardError after yielding ("bc"), then ("d", "e")',
+      '  - #<Mock:foo>.bar(5, 6) { ... } # => threw (:tag, "value") after yielding ("bc"), then ("d", "e")'
     )
   end
 
@@ -57,7 +57,7 @@ class DisplayMatchingInvocationsAlongsideExpectationsTest < Mocha::TestCase
     assert_invocations(
       test_result,
       '- allowed any number of times, invoked once: #<Mock:foo>.bar(any_parameters)',
-      '  - #<Mock:foo>.bar(1, 2) # => nil after yielding ()'
+      '  - #<Mock:foo>.bar(1, 2) { ... } # => nil after yielding ()'
     )
   end
 

data/test/acceptance/failure_messages_test.rb

@@ -58,4 +58,20 @@ class FailureMessagesTest < Mocha::TestCase
     end
     assert_match Regexp.new(%("Foo")), test_result.failures[0].message
   end
+
+  def test_should_display_that_block_was_expected
+    test_result = run_as_test do
+      foo = mock
+      foo.expects(:bar).with_block_given
+    end
+    assert_match Regexp.new(' with block given$'), test_result.failures[0].message
+  end
+
+  def test_should_display_that_block_was_not_expected
+    test_result = run_as_test do
+      foo = mock
+      foo.expects(:bar).with_no_block_given
+    end
+    assert_match Regexp.new(' with no block given$'), test_result.failures[0].message
+  end
 end

data/test/acceptance/multiple_yielding_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../acceptance_test_helper', __FILE__)
+
+class MultipleYieldingTest < Mocha::TestCase
+  include AcceptanceTest
+
+  def setup
+    setup_acceptance_test
+  end
+
+  def teardown
+    teardown_acceptance_test
+  end
+
+  def test_yields_values_multiple_times_when_stubbed_method_is_invoked
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).multiple_yields([1], [2, 3])
+      yielded = []
+      m.foo { |*args| yielded << args }
+      assert_equal [[1], [2, 3]], yielded
+    end
+    assert_passed(test_result)
+  end
+
+  def test_yields_values_multiple_times_when_multiple_yields_arguments_are_not_arrays
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).multiple_yields(1, { :b => 2 }, '3')
+      yielded = []
+      m.foo { |*args| yielded << args }
+      assert_equal [[1], [{ :b => 2 }], ['3']], yielded
+    end
+    assert_passed(test_result)
+  end
+
+  def test_raises_local_jump_error_if_instructed_to_multiple_yield_but_no_block_given
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).multiple_yields([])
+      assert_raises(LocalJumpError) { m.foo }
+    end
+    assert_passed(test_result)
+  end
+
+  def test_yields_different_values_on_consecutive_invocations
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).multiple_yields([0], [1, 2]).then.multiple_yields([3], [4, 5])
+      yielded = []
+      m.foo { |*args| yielded << args }
+      m.foo { |*args| yielded << args }
+      assert_equal [[0], [1, 2], [3], [4, 5]], yielded
+    end
+    assert_passed(test_result)
+  end
+end

data/test/acceptance/yielding_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../acceptance_test_helper', __FILE__)
+
+class YieldingTest < Mocha::TestCase
+  include AcceptanceTest
+
+  def setup
+    setup_acceptance_test
+  end
+
+  def teardown
+    teardown_acceptance_test
+  end
+
+  def test_yields_when_stubbed_method_is_invoked
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).yields
+      yielded = false
+      m.foo { yielded = true }
+      assert yielded
+    end
+    assert_passed(test_result)
+  end
+
+  def test_raises_local_jump_error_if_instructed_to_yield_but_no_block_given
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).yields
+      assert_raises(LocalJumpError) { m.foo }
+    end
+    assert_passed(test_result)
+  end
+
+  def test_yields_when_block_expected_and_block_given
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).with_block_given.yields
+      m.stubs(:foo).with_no_block_given.returns(:bar)
+      yielded = false
+      m.foo { yielded = true }
+      assert yielded
+    end
+    assert_passed(test_result)
+  end
+
+  def test_returns_when_no_block_expected_and_no_block_given
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).with_block_given.yields
+      m.stubs(:foo).with_no_block_given.returns(:bar)
+      assert_equal :bar, m.foo
+    end
+    assert_passed(test_result)
+  end
+
+  def test_yields_values_when_stubbed_method_is_invoked
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).yields(0, 1)
+      yielded = []
+      m.foo { |*args| yielded << args }
+      assert_equal [[0, 1]], yielded
+    end
+    assert_passed(test_result)
+  end
+
+  def test_yields_different_values_on_consecutive_invocations
+    test_result = run_as_test do
+      m = mock('m')
+      m.stubs(:foo).yields(0, 1).then.yields(2, 3)
+      yielded = []
+      m.foo { |*args| yielded << args }
+      m.foo { |*args| yielded << args }
+      assert_equal [[0, 1], [2, 3]], yielded
+    end
+    assert_passed(test_result)
+  end
+end

data/test/unit/expectation_test.rb

@@ -8,6 +8,7 @@ require 'execution_point'
 require 'simple_counter'
 require 'deprecation_disabler'
 
+# rubocop:disable  Metrics/ClassLength
 class ExpectationTest < Mocha::TestCase
   include Mocha
 
@@ -119,7 +120,7 @@ class ExpectationTest < Mocha::TestCase
     assert_raises(LocalJumpError) { invoke(new_expectation.yields(:foo)) }
   end
 
-  def test_yield_should_display_warning_when_caller_does_not_provide_block_and_behaviour_from_v1_9_retained
+  def test_yields_should_display_warning_when_caller_does_not_provide_block_and_behaviour_from_v1_9_retained
     Mocha::Configuration.override(:reinstate_undocumented_behaviour_from_v1_9 => true) do
       DeprecationDisabler.disable_deprecations do
         invoke(new_expectation.yields(:foo, 1, [2, 3]))
@@ -131,6 +132,18 @@ class ExpectationTest < Mocha::TestCase
     assert message.include?('This will raise a LocalJumpError in the future.')
   end
 
+  def test_multiple_yields_should_display_warning_when_caller_does_not_provide_block_and_behaviour_from_v1_9_retained
+    Mocha::Configuration.override(:reinstate_undocumented_behaviour_from_v1_9 => true) do
+      DeprecationDisabler.disable_deprecations do
+        invoke(new_expectation.multiple_yields(:foo, 1, [2, 3]))
+      end
+    end
+    assert message = Deprecation.messages.last
+    assert message.include?('Stubbed method was instructed to yield (2, 3)')
+    assert message.include?('but no block was given by invocation: :irrelevant.expected_method()')
+    assert message.include?('This will raise a LocalJumpError in the future.')
+  end
+
   def test_should_yield_with_specified_parameters
     yielded_parameters = nil
     invoke(new_expectation.yields(1, 2, 3)) { |*parameters| yielded_parameters = parameters }
@@ -490,3 +503,4 @@ class ExpectationTest < Mocha::TestCase
     assert expectation.inspect.include?(expectation.mocha_inspect)
   end
 end
+# rubocop:enable  Metrics/ClassLength

data/test/unit/yield_parameters_test.rb

@@ -1,91 +1,73 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 require 'mocha/yield_parameters'
-require 'mocha/no_yields'
-require 'mocha/single_yield'
-require 'mocha/multiple_yields'
 
 class YieldParametersTest < Mocha::TestCase
   include Mocha
 
   def test_should_return_null_yield_parameter_group_by_default
-    yield_parameters = YieldParameters.new
-    assert yield_parameters.next_invocation.is_a?(NoYields)
+    assert_next_invocation_yields(YieldParameters.new, [])
   end
 
   def test_should_return_single_yield_parameter_group
     yield_parameters = YieldParameters.new
-    yield_parameters.add(1, 2, 3)
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(SingleYield)
-    assert_equal [1, 2, 3], parameter_group.parameters
+    yield_parameters.add([1, 2, 3])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3]])
   end
 
   def test_should_keep_returning_single_yield_parameter_group
     yield_parameters = YieldParameters.new
-    yield_parameters.add(1, 2, 3)
-    yield_parameters.next_invocation
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(SingleYield)
-    assert_equal [1, 2, 3], parameter_group.parameters
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(SingleYield)
-    assert_equal [1, 2, 3], parameter_group.parameters
+    yield_parameters.add([1, 2, 3])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3]])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3]])
   end
 
   def test_should_return_consecutive_single_yield_parameter_groups
     yield_parameters = YieldParameters.new
-    yield_parameters.add(1, 2, 3)
-    yield_parameters.add(4, 5)
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(SingleYield)
-    assert_equal [1, 2, 3], parameter_group.parameters
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(SingleYield)
-    assert_equal [4, 5], parameter_group.parameters
+    yield_parameters.add([1, 2, 3])
+    yield_parameters.add([4, 5])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3]])
+    assert_next_invocation_yields(yield_parameters, [[4, 5]])
   end
 
   def test_should_return_multiple_yield_parameter_group
     yield_parameters = YieldParameters.new
-    yield_parameters.multiple_add([1, 2, 3], [4, 5])
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(MultipleYields)
-    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+    yield_parameters.add([1, 2, 3], [4, 5])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3], [4, 5]])
+  end
+
+  def test_should_return_multiple_yield_parameter_group_when_arguments_are_not_arrays
+    yield_parameters = YieldParameters.new
+    yield_parameters.add(1, { :b => 2 }, 3)
+    assert_next_invocation_yields(yield_parameters, [[1], [{ :b => 2 }], [3]])
   end
 
   def test_should_keep_returning_multiple_yield_parameter_group
     yield_parameters = YieldParameters.new
-    yield_parameters.multiple_add([1, 2, 3], [4, 5])
-    yield_parameters.next_invocation
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(MultipleYields)
-    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(MultipleYields)
-    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
+    yield_parameters.add([1, 2, 3], [4, 5])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3], [4, 5]])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3], [4, 5]])
   end
 
   def test_should_return_consecutive_multiple_yield_parameter_groups
     yield_parameters = YieldParameters.new
-    yield_parameters.multiple_add([1, 2, 3], [4, 5])
-    yield_parameters.multiple_add([6, 7], [8, 9, 0])
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(MultipleYields)
-    assert_equal [[1, 2, 3], [4, 5]], parameter_group.parameter_groups
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(MultipleYields)
-    assert_equal [[6, 7], [8, 9, 0]], parameter_group.parameter_groups
+    yield_parameters.add([1, 2, 3], [4, 5])
+    yield_parameters.add([6, 7], [8, 9, 0])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3], [4, 5]])
+    assert_next_invocation_yields(yield_parameters, [[6, 7], [8, 9, 0]])
   end
 
   def test_should_return_consecutive_single_and_multiple_yield_parameter_groups
     yield_parameters = YieldParameters.new
-    yield_parameters.add(1, 2, 3)
-    yield_parameters.multiple_add([4, 5, 6], [7, 8])
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(SingleYield)
-    assert_equal [1, 2, 3], parameter_group.parameters
-    parameter_group = yield_parameters.next_invocation
-    assert parameter_group.is_a?(MultipleYields)
-    assert_equal [[4, 5, 6], [7, 8]], parameter_group.parameter_groups
+    yield_parameters.add([1, 2, 3])
+    yield_parameters.add([4, 5, 6], [7, 8])
+    assert_next_invocation_yields(yield_parameters, [[1, 2, 3]])
+    assert_next_invocation_yields(yield_parameters, [[4, 5, 6], [7, 8]])
+  end
+
+  private
+
+  def assert_next_invocation_yields(yield_parameters, expected)
+    assert_equal expected, yield_parameters.next_invocation
   end
 end