mocha 1.7.0 → 1.10.2

data/test/unit/cardinality_test.rb

@@ -1,43 +1,61 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/cardinality'
+require 'mocha/invocation'
+require 'mocha/return_values'
+require 'mocha/yield_parameters'
 
 class CardinalityTest < Mocha::TestCase
   include Mocha
 
+  def new_invocation
+    Invocation.new(:irrelevant, :irrelevant)
+  end
+
   def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
     cardinality = Cardinality.new(2, 3)
-    assert cardinality.invocations_allowed?(0)
-    assert cardinality.invocations_allowed?(1)
-    assert cardinality.invocations_allowed?(2)
-    assert !cardinality.invocations_allowed?(3)
+    assert cardinality.invocations_allowed?
+    cardinality << new_invocation
+    assert cardinality.invocations_allowed?
+    cardinality << new_invocation
+    assert cardinality.invocations_allowed?
+    cardinality << new_invocation
+    assert !cardinality.invocations_allowed?
   end
 
   def test_should_be_satisfied_if_invocations_so_far_have_reached_required_threshold
     cardinality = Cardinality.new(2, 3)
-    assert !cardinality.satisfied?(0)
-    assert !cardinality.satisfied?(1)
-    assert cardinality.satisfied?(2)
-    assert cardinality.satisfied?(3)
+    assert !cardinality.satisfied?
+    cardinality << new_invocation
+    assert !cardinality.satisfied?
+    cardinality << new_invocation
+    assert cardinality.satisfied?
+    cardinality << new_invocation
+    assert cardinality.satisfied?
   end
 
-  def test_should_describe_cardinality
-    assert_equal 'allowed any number of times', Cardinality.at_least(0).mocha_inspect
-
-    assert_equal 'expected at most once', Cardinality.at_most(1).mocha_inspect
-    assert_equal 'expected at most twice', Cardinality.at_most(2).mocha_inspect
-    assert_equal 'expected at most 3 times', Cardinality.at_most(3).mocha_inspect
+  def test_should_describe_cardinality_defined_using_at_least
+    assert_equal 'allowed any number of times', Cardinality.at_least(0).anticipated_times
+    assert_equal 'expected at least once', Cardinality.at_least(1).anticipated_times
+    assert_equal 'expected at least twice', Cardinality.at_least(2).anticipated_times
+    assert_equal 'expected at least 3 times', Cardinality.at_least(3).anticipated_times
+  end
 
-    assert_equal 'expected at least once', Cardinality.at_least(1).mocha_inspect
-    assert_equal 'expected at least twice', Cardinality.at_least(2).mocha_inspect
-    assert_equal 'expected at least 3 times', Cardinality.at_least(3).mocha_inspect
+  def test_should_describe_cardinality_defined_using_at_most
+    assert_equal 'expected at most once', Cardinality.at_most(1).anticipated_times
+    assert_equal 'expected at most twice', Cardinality.at_most(2).anticipated_times
+    assert_equal 'expected at most 3 times', Cardinality.at_most(3).anticipated_times
+  end
 
-    assert_equal 'expected never', Cardinality.exactly(0).mocha_inspect
-    assert_equal 'expected exactly once', Cardinality.exactly(1).mocha_inspect
-    assert_equal 'expected exactly twice', Cardinality.exactly(2).mocha_inspect
-    assert_equal 'expected exactly 3 times', Cardinality.times(3).mocha_inspect
+  def test_should_describe_cardinality_defined_using_exactly
+    assert_equal 'expected never', Cardinality.exactly(0).anticipated_times
+    assert_equal 'expected exactly once', Cardinality.exactly(1).anticipated_times
+    assert_equal 'expected exactly twice', Cardinality.exactly(2).anticipated_times
+    assert_equal 'expected exactly 3 times', Cardinality.exactly(3).anticipated_times
+  end
 
-    assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).mocha_inspect
-    assert_equal 'expected between 1 and 3 times', Cardinality.times(1..3).mocha_inspect
+  def test_should_describe_cardinality_defined_using_times_with_range
+    assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).anticipated_times
+    assert_equal 'expected between 1 and 3 times', Cardinality.times(1..3).anticipated_times
   end
 
   def test_should_need_verifying

data/test/unit/central_test.rb

@@ -2,7 +2,6 @@ require File.expand_path('../../test_helper', __FILE__)
 
 require 'mocha/central'
 require 'mocha/mock'
-require 'method_definer'
 
 class CentralTest < Mocha::TestCase
   include Mocha

data/test/unit/class_methods_test.rb

@@ -51,7 +51,7 @@ class ClassMethodsTest < Mocha::TestCase
   end
 
   def test_should_use_stubba_class_method_for_class
-    assert_equal Mocha::ClassMethod, @klass.stubba_method
+    assert_equal Mocha::InstanceMethod, @klass.stubba_method
   end
 
   def test_should_use_stubba_class_method_for_any_instance

data/test/unit/configuration_test.rb

@@ -3,35 +3,35 @@ require 'mocha/configuration'
 
 class ConfigurationTest < Mocha::TestCase
   def test_allow_temporarily_changes_config_when_given_block
-    Mocha::Configuration.warn_when(:stubbing_method_unnecessarily)
+    Mocha.configure { |c| c.stubbing_method_unnecessarily = :warn }
     yielded = false
-    Mocha::Configuration.allow(:stubbing_method_unnecessarily) do
+    Mocha::Configuration.override(:stubbing_method_unnecessarily => :allow) do
       yielded = true
-      assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+      assert_equal :allow, Mocha.configuration.stubbing_method_unnecessarily
     end
     assert yielded
-    assert Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
+    assert_equal :warn, Mocha.configuration.stubbing_method_unnecessarily
   end
 
   def test_prevent_temporarily_changes_config_when_given_block
-    Mocha::Configuration.allow(:stubbing_method_unnecessarily)
+    Mocha.configure { |c| c.stubbing_method_unnecessarily = :allow }
     yielded = false
-    Mocha::Configuration.prevent(:stubbing_method_unnecessarily) do
+    Mocha::Configuration.override(:stubbing_method_unnecessarily => :prevent) do
       yielded = true
-      assert Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
+      assert_equal :prevent, Mocha.configuration.stubbing_method_unnecessarily
     end
     assert yielded
-    assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+    assert_equal :allow, Mocha.configuration.stubbing_method_unnecessarily
   end
 
   def test_warn_when_temporarily_changes_config_when_given_block
-    Mocha::Configuration.allow(:stubbing_method_unnecessarily)
+    Mocha.configure { |c| c.stubbing_method_unnecessarily = :allow }
     yielded = false
-    Mocha::Configuration.warn_when(:stubbing_method_unnecessarily) do
+    Mocha::Configuration.override(:stubbing_method_unnecessarily => :warn) do
       yielded = true
-      assert Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
+      assert_equal :warn, Mocha.configuration.stubbing_method_unnecessarily
     end
     assert yielded
-    assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+    assert_equal :allow, Mocha.configuration.stubbing_method_unnecessarily
   end
 end

data/test/unit/exception_raiser_test.rb

@@ -1,40 +1,45 @@
 require File.expand_path('../../test_helper', __FILE__)
 
+require 'mocha/invocation'
 require 'mocha/exception_raiser'
 require 'timeout'
 
 class ExceptionRaiserTest < Mocha::TestCase
   include Mocha
 
+  def new_invocation
+    Invocation.new(:irrelevant, :irrelevant)
+  end
+
   def test_should_raise_exception_with_specified_class_and_default_message
     exception_class = Class.new(StandardError)
     raiser = ExceptionRaiser.new(exception_class, nil)
-    exception = assert_raises(exception_class) { raiser.evaluate }
+    exception = assert_raises(exception_class) { raiser.evaluate(new_invocation) }
     assert_equal exception_class.to_s, exception.message
   end
 
   def test_should_raise_exception_with_specified_class_and_message
     exception_class = Class.new(StandardError)
     raiser = ExceptionRaiser.new(exception_class, 'message')
-    exception = assert_raises(exception_class) { raiser.evaluate }
+    exception = assert_raises(exception_class) { raiser.evaluate(new_invocation) }
     assert_equal 'message', exception.message
   end
 
   def test_should_raise_exception_instance
     exception_class = Class.new(StandardError)
     raiser = ExceptionRaiser.new(exception_class.new('message'), nil)
-    exception = assert_raises(exception_class) { raiser.evaluate }
+    exception = assert_raises(exception_class) { raiser.evaluate(new_invocation) }
     assert_equal 'message', exception.message
   end
 
   def test_should_raise_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
     raiser = ExceptionRaiser.new(Interrupt, nil)
-    assert_raises(Interrupt) { raiser.evaluate }
+    assert_raises(Interrupt) { raiser.evaluate(new_invocation) }
   end
 
   def test_should_raise_subclass_of_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
     exception_class = Class.new(Interrupt)
     raiser = ExceptionRaiser.new(exception_class, nil)
-    assert_raises(exception_class) { raiser.evaluate }
+    assert_raises(exception_class) { raiser.evaluate(new_invocation) }
   end
 end

data/test/unit/expectation_list_test.rb

@@ -1,10 +1,12 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/expectation_list'
 require 'mocha/expectation'
+require 'mocha/invocation'
 require 'set'
 require 'method_definer'
 
 class ExpectationListTest < Mocha::TestCase
+  include MethodDefiner
   include Mocha
 
   def test_should_return_added_expectation
@@ -19,7 +21,7 @@ class ExpectationListTest < Mocha::TestCase
     expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match(:my_method, :argument1, :argument2)
+    assert_same expectation1, expectation_list.match(Invocation.new(:irrelevant, :my_method, :argument1, :argument2))
   end
 
   def test_should_remove_all_expectations_matching_method_name
@@ -31,9 +33,9 @@ class ExpectationListTest < Mocha::TestCase
     expectation_list.add(expectation2)
     expectation_list.add(expectation3)
     expectation_list.remove_all_matching_method(:method_one)
-    assert_nil expectation_list.match(:method_one, :argument1, :argument2)
-    assert_nil expectation_list.match(:method_one, :argument3, :argument4)
-    assert_same expectation3, expectation_list.match(:method_two)
+    assert_nil expectation_list.match(Invocation.new(:irrelevant, :method_one, :argument1, :argument2))
+    assert_nil expectation_list.match(Invocation.new(:irrelevant, :method_one, :argument3, :argument4))
+    assert_same expectation3, expectation_list.match(Invocation.new(:irrelevant, :method_two))
   end
 
   def test_should_find_most_recent_matching_expectation
@@ -42,29 +44,29 @@ class ExpectationListTest < Mocha::TestCase
     expectation2 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.match(:my_method, :argument1, :argument2)
+    assert_same expectation2, expectation_list.match(Invocation.new(:irrelevant, :my_method, :argument1, :argument2))
   end
 
   def test_should_find_matching_expectation_allowing_invocation
     expectation_list = ExpectationList.new
     expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
     expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
-    expectation1.define_instance_method(:invocations_allowed?) { true }
-    expectation2.define_instance_method(:invocations_allowed?) { true }
+    define_instance_method(expectation1, :invocations_allowed?) { true }
+    define_instance_method(expectation2, :invocations_allowed?) { true }
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match_allowing_invocation(:my_method, :argument1, :argument2)
+    assert_same expectation1, expectation_list.match_allowing_invocation(Invocation.new(:irrelevant, :my_method, :argument1, :argument2))
   end
 
   def test_should_find_most_recent_matching_expectation_allowing_invocation
     expectation_list = ExpectationList.new
     expectation1 = Expectation.new(nil, :my_method)
     expectation2 = Expectation.new(nil, :my_method)
-    expectation1.define_instance_method(:invocations_allowed?) { true }
-    expectation2.define_instance_method(:invocations_allowed?) { false }
+    define_instance_method(expectation1, :invocations_allowed?) { true }
+    define_instance_method(expectation2, :invocations_allowed?) { false }
     expectation_list.add(expectation1)
     expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match_allowing_invocation(:my_method)
+    assert_same expectation1, expectation_list.match_allowing_invocation(Invocation.new(:irrelevant, :my_method))
   end
 
   def test_should_combine_two_expectation_lists_into_one

data/test/unit/expectation_test.rb

@@ -1,9 +1,12 @@
 require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
 require 'mocha/expectation'
+require 'mocha/invocation'
 require 'mocha/sequence'
+require 'mocha/configuration'
+require 'mocha/deprecation'
 require 'execution_point'
 require 'simple_counter'
+require 'deprecation_disabler'
 
 class ExpectationTest < Mocha::TestCase
   include Mocha
@@ -12,90 +15,85 @@ class ExpectationTest < Mocha::TestCase
     Expectation.new(nil, :expected_method)
   end
 
+  def invoke(expectation, &block)
+    expectation.invoke(Invocation.new(:irrelevant, :expected_method, &block))
+  end
+
   def test_should_match_calls_to_same_method_with_any_parameters
-    assert new_expectation.match?(:expected_method, 1, 2, 3)
+    assert new_expectation.match?(Invocation.new(:irrelevant, :expected_method, 1, 2, 3))
   end
 
   def test_should_match_calls_to_same_method_with_exactly_zero_parameters
-    expectation = new_expectation.with
-    assert expectation.match?(:expected_method)
+    assert new_expectation.with.match?(Invocation.new(:irrelevant, :expected_method))
   end
 
   def test_should_not_match_calls_to_same_method_with_more_than_zero_parameters
-    expectation = new_expectation.with
-    assert !expectation.match?(:expected_method, 1, 2, 3)
+    assert !new_expectation.with.match?(Invocation.new(:irrelevant, :expected_method, 1, 2, 3))
   end
 
   def test_should_match_calls_to_same_method_with_expected_parameter_values
-    expectation = new_expectation.with(1, 2, 3)
-    assert expectation.match?(:expected_method, 1, 2, 3)
+    assert new_expectation.with(1, 2, 3).match?(Invocation.new(:irrelevant, :expected_method, 1, 2, 3))
   end
 
   def test_should_match_calls_to_same_method_with_parameters_constrained_as_expected
     expectation = new_expectation.with { |x, y, z| x + y == z }
-    assert expectation.match?(:expected_method, 1, 2, 3)
+    assert expectation.match?(Invocation.new(:irrelevant, :expected_method, 1, 2, 3))
   end
 
   def test_should_not_match_calls_to_different_method_with_parameters_constrained_as_expected
     expectation = new_expectation.with { |x, y, z| x + y == z }
-    assert !expectation.match?(:different_method, 1, 2, 3)
+    assert !expectation.match?(Invocation.new(:irrelevant, :different_method, 1, 2, 3))
   end
 
   def test_should_not_match_calls_to_different_methods_with_no_parameters
-    assert !new_expectation.match?(:unexpected_method)
+    assert !new_expectation.match?(Invocation.new(:irrelevant, :unexpected_method))
   end
 
   def test_should_not_match_calls_to_same_method_with_too_few_parameters
-    expectation = new_expectation.with(1, 2, 3)
-    assert !expectation.match?(:unexpected_method, 1, 2)
+    assert !new_expectation.with(1, 2, 3).match?(Invocation.new(:irrelevant, :expected_method, 1, 2))
   end
 
   def test_should_not_match_calls_to_same_method_with_too_many_parameters
-    expectation = new_expectation.with(1, 2)
-    assert !expectation.match?(:unexpected_method, 1, 2, 3)
+    assert !new_expectation.with(1, 2).match?(Invocation.new(:irrelevant, :expected_method, 1, 2, 3))
   end
 
   def test_should_not_match_calls_to_same_method_with_unexpected_parameter_values
-    expectation = new_expectation.with(1, 2, 3)
-    assert !expectation.match?(:unexpected_method, 1, 0, 3)
+    assert !new_expectation.with(1, 2, 3).match?(Invocation.new(:irrelevant, :expected_method, 1, 0, 3))
   end
 
   def test_should_not_match_calls_to_same_method_with_parameters_not_constrained_as_expected
     expectation = new_expectation.with { |x, y, z| x + y == z }
-    assert !expectation.match?(:expected_method, 1, 0, 3)
+    assert !expectation.match?(Invocation.new(:irrelevant, :expected_method, 1, 0, 3))
   end
 
   def test_should_allow_invocations_until_expected_invocation_count_is_one_and_actual_invocation_count_would_be_two
     expectation = new_expectation.times(1)
     assert expectation.invocations_allowed?
-    expectation.invoke
+    invoke(expectation)
     assert !expectation.invocations_allowed?
   end
 
   def test_should_allow_invocations_until_expected_invocation_count_is_two_and_actual_invocation_count_would_be_three
     expectation = new_expectation.times(2)
-    assert expectation.invocations_allowed?
-    expectation.invoke
-    assert expectation.invocations_allowed?
-    expectation.invoke
+    2.times do
+      assert expectation.invocations_allowed?
+      invoke(expectation)
+    end
     assert !expectation.invocations_allowed?
   end
 
   def test_should_allow_invocations_until_expected_invocation_count_is_a_range_from_two_to_three_and_actual_invocation_count_would_be_four
     expectation = new_expectation.times(2..3)
-    assert expectation.invocations_allowed?
-    expectation.invoke
-    assert expectation.invocations_allowed?
-    expectation.invoke
-    assert expectation.invocations_allowed?
-    expectation.invoke
+    3.times do
+      assert expectation.invocations_allowed?
+      invoke(expectation)
+    end
     assert !expectation.invocations_allowed?
   end
 
   def test_should_store_provided_backtrace
     backtrace = Object.new
-    expectation = Expectation.new(nil, :expected_method, backtrace)
-    assert_equal backtrace, expectation.backtrace
+    assert_equal backtrace, Expectation.new(nil, :expected_method, backtrace).backtrace
   end
 
   # rubocop:disable Style/Semicolon
@@ -107,217 +105,221 @@ class ExpectationTest < Mocha::TestCase
 
   def test_should_not_yield
     yielded = false
-    new_expectation.invoke { yielded = true }
+    invoke(new_expectation) { yielded = true }
     assert_equal false, yielded
   end
 
   def test_should_yield_no_parameters
-    expectation = new_expectation.yields
     yielded_parameters = nil
-    expectation.invoke { |*parameters| yielded_parameters = parameters }
+    invoke(new_expectation.yields) { |*parameters| yielded_parameters = parameters }
     assert_equal [], yielded_parameters
   end
 
+  def test_yield_should_fail_when_the_caller_does_not_provide_a_block
+    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
+    Mocha::Configuration.override(:reinstate_undocumented_behaviour_from_v1_9 => true) do
+      DeprecationDisabler.disable_deprecations do
+        invoke(new_expectation.yields(:foo, 1, [2, 3]))
+      end
+    end
+    assert message = Deprecation.messages.last
+    assert message.include?('Stubbed method was instructed to yield (:foo, 1, [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
-    expectation = new_expectation.yields(1, 2, 3)
     yielded_parameters = nil
-    expectation.invoke { |*parameters| yielded_parameters = parameters }
+    invoke(new_expectation.yields(1, 2, 3)) { |*parameters| yielded_parameters = parameters }
     assert_equal [1, 2, 3], yielded_parameters
   end
 
   def test_should_yield_different_parameters_on_consecutive_invocations
     expectation = new_expectation.yields(1, 2, 3).yields(4, 5)
     yielded_parameters = []
-    expectation.invoke { |*parameters| yielded_parameters << parameters }
-    expectation.invoke { |*parameters| yielded_parameters << parameters }
+    invoke(expectation) { |*parameters| yielded_parameters << parameters }
+    invoke(expectation) { |*parameters| yielded_parameters << parameters }
     assert_equal [[1, 2, 3], [4, 5]], yielded_parameters
   end
 
   def test_should_yield_multiple_times_for_single_invocation
-    expectation = new_expectation.multiple_yields([1, 2, 3], [4, 5])
     yielded_parameters = []
-    expectation.invoke { |*parameters| yielded_parameters << parameters }
+    invoke(new_expectation.multiple_yields([1, 2, 3], [4, 5])) { |*parameters| yielded_parameters << parameters }
     assert_equal [[1, 2, 3], [4, 5]], yielded_parameters
   end
 
   def test_should_yield_multiple_times_for_first_invocation_and_once_for_second_invocation
     expectation = new_expectation.multiple_yields([1, 2, 3], [4, 5]).then.yields(6, 7)
     yielded_parameters = []
-    expectation.invoke { |*parameters| yielded_parameters << parameters }
-    expectation.invoke { |*parameters| yielded_parameters << parameters }
+    invoke(expectation) { |*parameters| yielded_parameters << parameters }
+    invoke(expectation) { |*parameters| yielded_parameters << parameters }
     assert_equal [[1, 2, 3], [4, 5], [6, 7]], yielded_parameters
   end
 
   def test_should_return_specified_value
-    expectation = new_expectation.returns(99)
-    assert_equal 99, expectation.invoke
+    assert_equal 99, invoke(new_expectation.returns(99))
   end
 
   def test_should_return_same_specified_value_multiple_times
     expectation = new_expectation.returns(99)
-    assert_equal 99, expectation.invoke
-    assert_equal 99, expectation.invoke
+    assert_equal 99, invoke(expectation)
+    assert_equal 99, invoke(expectation)
   end
 
   def test_should_return_specified_values_on_consecutive_calls
     expectation = new_expectation.returns(99, 100, 101)
-    assert_equal 99, expectation.invoke
-    assert_equal 100, expectation.invoke
-    assert_equal 101, expectation.invoke
+    assert_equal 99, invoke(expectation)
+    assert_equal 100, invoke(expectation)
+    assert_equal 101, invoke(expectation)
   end
 
   def test_should_return_specified_values_on_consecutive_calls_even_if_values_are_modified
     values = [99, 100, 101]
     expectation = new_expectation.returns(*values)
     values.shift
-    assert_equal 99, expectation.invoke
-    assert_equal 100, expectation.invoke
-    assert_equal 101, expectation.invoke
+    assert_equal 99, invoke(expectation)
+    assert_equal 100, invoke(expectation)
+    assert_equal 101, invoke(expectation)
   end
 
   def test_should_return_nil_by_default
-    assert_nil new_expectation.invoke
+    assert_nil invoke(new_expectation)
   end
 
   def test_should_return_nil_if_no_value_specified
-    expectation = new_expectation.returns
-    assert_nil expectation.invoke
+    assert_nil invoke(new_expectation.returns)
   end
 
   def test_should_raise_runtime_exception
-    expectation = new_expectation.raises
-    assert_raise(RuntimeError) { expectation.invoke }
+    assert_raises(RuntimeError) { invoke(new_expectation.raises) }
   end
 
   def test_should_raise_custom_exception
     exception = Class.new(Exception)
-    expectation = new_expectation.raises(exception)
-    assert_raise(exception) { expectation.invoke }
+    assert_raises(exception) { invoke(new_expectation.raises(exception)) }
   end
 
   def test_should_raise_same_instance_of_custom_exception
     exception_klass = Class.new(StandardError)
     expected_exception = exception_klass.new
-    expectation = new_expectation.raises(expected_exception)
-    actual_exception = assert_raise(exception_klass) { expectation.invoke }
+    actual_exception = assert_raises(exception_klass) { invoke(new_expectation.raises(expected_exception)) }
     assert_same expected_exception, actual_exception
   end
 
   def test_should_use_the_default_exception_message
-    expectation = new_expectation.raises(Exception)
-    exception = assert_raise(Exception) { expectation.invoke }
+    exception = assert_raises(Exception) { invoke(new_expectation.raises(Exception)) }
     assert_equal Exception.new.message, exception.message
   end
 
   def test_should_raise_custom_exception_with_message
     exception_msg = 'exception message'
-    expectation = new_expectation.raises(Exception, exception_msg)
-    exception = assert_raise(Exception) { expectation.invoke }
+    exception = assert_raises(Exception) { invoke(new_expectation.raises(Exception, exception_msg)) }
     assert_equal exception_msg, exception.message
   end
 
   def test_should_return_values_then_raise_exception
     expectation = new_expectation.returns(1, 2).then.raises
-    assert_equal 1, expectation.invoke
-    assert_equal 2, expectation.invoke
-    assert_raise(RuntimeError) { expectation.invoke }
+    assert_equal 1, invoke(expectation)
+    assert_equal 2, invoke(expectation)
+    assert_raises(RuntimeError) { invoke(expectation) }
   end
 
   def test_should_raise_exception_then_return_values
     expectation = new_expectation.raises.then.returns(1, 2)
-    assert_raise(RuntimeError) { expectation.invoke }
-    assert_equal 1, expectation.invoke
-    assert_equal 2, expectation.invoke
+    assert_raises(RuntimeError) { invoke(expectation) }
+    assert_equal 1, invoke(expectation)
+    assert_equal 2, invoke(expectation)
   end
 
   def test_should_verify_successfully_if_expected_call_was_made
     expectation = new_expectation
-    expectation.invoke
+    invoke(expectation)
     assert expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_call_expected_once_but_invoked_twice
     expectation = new_expectation.once
-    expectation.invoke
-    expectation.invoke
+    invoke(expectation)
+    invoke(expectation)
     assert !expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_call_expected_once_but_not_invoked
-    expectation = new_expectation.once
-    assert !expectation.verified?
+    assert !new_expectation.once.verified?
   end
 
   def test_should_verify_successfully_if_call_expected_once_and_invoked_once
     expectation = new_expectation.once
-    expectation.invoke
+    invoke(expectation)
     assert expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_call_expected_twice_and_invoked_three_times
     expectation = new_expectation.twice
-    expectation.invoke
-    expectation.invoke
-    expectation.invoke
+    invoke(expectation)
+    invoke(expectation)
+    invoke(expectation)
     assert !expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_call_expected_twice_but_invoked_once
     expectation = new_expectation.twice
-    expectation.invoke
+    invoke(expectation)
     assert !expectation.verified?
   end
 
   def test_should_verify_successfully_if_call_expected_twice_and_invoked_twice
     expectation = new_expectation.twice
-    expectation.invoke
-    expectation.invoke
+    invoke(expectation)
+    invoke(expectation)
     assert expectation.verified?
   end
 
   def test_should_verify_successfully_if_expected_call_was_made_at_least_once
     expectation = new_expectation.at_least_once
-    3.times { expectation.invoke }
+    3.times { invoke(expectation) }
     assert expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_expected_call_was_not_made_at_least_once
     expectation = new_expectation.with(1, 2, 3).at_least_once
     assert !expectation.verified?
-    assert_match(/expected at least once, not yet invoked/i, expectation.mocha_inspect)
+    assert_match(/expected at least once, invoked never/i, expectation.mocha_inspect)
   end
 
   def test_should_verify_successfully_if_expected_call_was_made_expected_number_of_times
     expectation = new_expectation.times(2)
-    2.times { expectation.invoke }
+    2.times { invoke(expectation) }
     assert expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_expected_call_was_made_too_few_times
     expectation = new_expectation.times(2)
-    1.times { expectation.invoke }
+    1.times { invoke(expectation) }
     assert !expectation.verified?
     assert_match(/expected exactly twice, invoked once/i, expectation.mocha_inspect)
   end
 
   def test_should_not_verify_successfully_if_expected_call_was_made_too_many_times
     expectation = new_expectation.times(2)
-    3.times { expectation.invoke }
+    3.times { invoke(expectation) }
     assert !expectation.verified?
   end
 
   def test_should_increment_assertion_counter_for_expectation_because_it_does_need_verifyng
     expectation = new_expectation
-    expectation.invoke
+    invoke(expectation)
     assertion_counter = SimpleCounter.new
     expectation.verified?(assertion_counter)
     assert_equal 1, assertion_counter.count
   end
 
   def test_should_not_increment_assertion_counter_for_stub_because_it_does_not_need_verifying
-    stub = Expectation.new(nil, :expected_method).at_least(0)
     assertion_counter = SimpleCounter.new
-    stub.verified?(assertion_counter)
+    Expectation.new(nil, :expected_method).at_least(0).verified?(assertion_counter)
     assert_equal 0, assertion_counter.count
   end
 
@@ -381,7 +383,7 @@ class ExpectationTest < Mocha::TestCase
     expectation = Expectation.new(nil, :method_one)
     expectation.add_ordering_constraint(constraint_one)
     expectation.add_ordering_constraint(constraint_two)
-    assert expectation.match?(:method_one)
+    assert expectation.match?(Invocation.new(:irrelevant, :method_one))
   end
 
   def test_should_not_match_if_one_ordering_constraints_does_not_allow_invocation_now
@@ -390,29 +392,28 @@ class ExpectationTest < Mocha::TestCase
     expectation = Expectation.new(nil, :method_one)
     expectation.add_ordering_constraint(constraint_one)
     expectation.add_ordering_constraint(constraint_two)
-    assert !expectation.match?(:method_one)
+    assert !expectation.match?(Invocation.new(:irrelevant, :method_one))
   end
 
   def test_should_not_be_satisfied_when_required_invocation_has_not_been_made
-    expectation = Expectation.new(nil, :method_one).times(1)
-    assert !expectation.satisfied?
+    assert !Expectation.new(nil, :method_one).times(1).satisfied?
   end
 
   def test_should_be_satisfied_when_required_invocation_has_been_made
     expectation = Expectation.new(nil, :method_one).times(1)
-    expectation.invoke
+    invoke(expectation)
     assert expectation.satisfied?
   end
 
   def test_should_not_be_satisfied_when_minimum_number_of_invocations_has_not_been_made
     expectation = Expectation.new(nil, :method_one).at_least(2)
-    expectation.invoke
+    invoke(expectation)
     assert !expectation.satisfied?
   end
 
   def test_should_be_satisfied_when_minimum_number_of_invocations_has_been_made
     expectation = Expectation.new(nil, :method_one).at_least(2)
-    2.times { expectation.invoke }
+    2.times { invoke(expectation) }
     assert expectation.satisfied?
   end
 
@@ -457,7 +458,7 @@ class ExpectationTest < Mocha::TestCase
 
     expectation.then(state)
 
-    expectation.invoke
+    invoke(expectation)
     assert state.active?
   end
 
@@ -466,10 +467,10 @@ class ExpectationTest < Mocha::TestCase
     expectation = Expectation.new(nil, :method_one)
 
     expectation.when(state)
-    assert !expectation.match?(:method_one)
+    assert !expectation.match?(Invocation.new(:irrelevant, :method_one))
 
     state.activate
-    assert expectation.match?(:method_one)
+    assert expectation.match?(Invocation.new(:irrelevant, :method_one))
   end
 
   def test_should_include_default_representation_of_object_in_inspect
@@ -477,8 +478,7 @@ class ExpectationTest < Mocha::TestCase
     class << object
       define_method(:inspect) { 'mock' }
     end
-    expectation = Expectation.new(object, :method_one)
-    assert_match Regexp.new('^#<Expectation:0x[0-9A-Fa-f]{1,12} .* >$'), expectation.inspect
+    assert_match Regexp.new('^#<Expectation:0x[0-9A-Fa-f]{1,12} .* >$'), Expectation.new(object, :method_one).inspect
   end
 
   def test_should_include_output_of_mocha_inspect_in_inspect