mocha 1.1.0 → 1.13.0

data/lib/mocha/expectation.rb

@@ -9,12 +9,12 @@ require 'mocha/is_a'
 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}.
   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.
@@ -42,7 +42,7 @@ module Mocha
     #   object.expected_method
     #   # => verify fails
     def times(range)
-      @cardinality = Cardinality.times(range)
+      @cardinality.times(range)
       self
     end
 
@@ -68,7 +68,7 @@ module Mocha
     #   object.expected_method
     #   # => verify fails
     def twice
-      @cardinality = Cardinality.exactly(2)
+      @cardinality.exactly(2)
       self
     end
 
@@ -93,7 +93,7 @@ module Mocha
     #   object.expects(:expected_method).once
     #   # => verify fails
     def once
-      @cardinality = Cardinality.exactly(1)
+      @cardinality.exactly(1)
       self
     end
 
@@ -110,7 +110,7 @@ module Mocha
     #   object.expects(:expected_method).never
     #   # => verify succeeds
     def never
-      @cardinality = Cardinality.exactly(0)
+      @cardinality.exactly(0)
       self
     end
 
@@ -130,7 +130,7 @@ module Mocha
     #   object.expected_method
     #   # => verify fails
     def at_least(minimum_number_of_times)
-      @cardinality = Cardinality.at_least(minimum_number_of_times)
+      @cardinality.at_least(minimum_number_of_times)
       self
     end
 
@@ -149,7 +149,6 @@ module Mocha
     #   # => verify fails
     def at_least_once
       at_least(1)
-      self
     end
 
     # Modifies expectation so that the expected method must be called at most a +maximum_number_of_times+.
@@ -167,7 +166,7 @@ module Mocha
     #   object.expects(:expected_method).at_most(2)
     #   3.times { object.expected_method } # => unexpected invocation
     def at_most(maximum_number_of_times)
-      @cardinality = Cardinality.at_most(maximum_number_of_times)
+      @cardinality.at_most(maximum_number_of_times)
       self
     end
 
@@ -184,9 +183,8 @@ 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
 
     # Modifies expectation so that the expected method must be called with +expected_parameters+.
@@ -225,7 +223,49 @@ module Mocha
       self
     end
 
-    # Modifies expectation so that when the expected method is called, it yields with the specified +parameters+.
+    # 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 to the block with the specified +parameters+.
+    #
+    # If no +parameters+ are specified, it yields to the block without any parameters.
+    #
+    # If no block is provided, the method will still attempt to yield resulting in a +LocalJumpError+. Note that this is what would happen if a "real" (non-mock) method implementation tried to yield to a non-existent block.
     #
     # May be called multiple times on the same expectation for consecutive invocations.
     #
@@ -233,51 +273,58 @@ 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
+    #   yielded = false
+    #   benchmark.measure { yielded = true }
+    #   yielded # => true
+    #
     # @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
+      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+.
     #
-    # @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.
+    # If no block is provided, the method will still attempt to yield resulting in a +LocalJumpError+. Note that this is what would happen if a "real" (non-mock) method implementation tried to yield to a non-existent block.
+    #
+    # @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
     #
-    # @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)
+      @yield_parameters.add(*parameter_groups)
       self
     end
 
@@ -409,9 +456,9 @@ module Mocha
 
     # @overload def then
     #   Used as syntactic sugar to improve readability. It has no effect on state of the expectation.
-    # @overload def then(state_machine.is(state_name))
-    #   Used to change the +state_machine+ to the state specified by +state_name+ when the expected invocation occurs.
-    #   @param [StateMachine::State] state_machine.is(state_name) provides a mechanism to change the +state_machine+ into the state specified by +state_name+ when the expected method is invoked.
+    # @overload def then(state)
+    #   Used to change the +state_machine+ to the specified state when the expected invocation occurs.
+    #   @param [StateMachine::State] state state_machine.is(state_name) provides a mechanism to change the +state_machine+ into the state specified by +state_name+ when the expected method is invoked.
     #
     #   @see API#states
     #   @see StateMachine
@@ -437,17 +484,14 @@ module Mocha
     #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
     #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
     #   radio.expects(:switch_off).then(power.is('off'))
-    def then(*parameters)
-      if parameters.length == 1
-        state = parameters.first
-        add_side_effect(ChangeStateSideEffect.new(state))
-      end
+    def then(state = nil)
+      add_side_effect(ChangeStateSideEffect.new(state)) if state
       self
     end
 
-    # Constrains the expectation to occur only when the +state_machine+ is in the state specified by +state_name+.
+    # Constrains the expectation to occur only when the +state_machine+ is in the state specified by +state_predicate+.
     #
-    # @param [StateMachine::StatePredicate] state_machine.is(state_name) provides a mechanism to determine whether the +state_machine+ is in the state specified by +state_name+ when the expected method is invoked.
+    # @param [StateMachine::StatePredicate] state_predicate +state_machine.is(state_name)+ provides a mechanism to determine whether the +state_machine+ is in the state specified by +state_predicate+ when the expected method is invoked.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
     # @see API#states
@@ -479,7 +523,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 +536,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
 
@@ -504,9 +549,10 @@ 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, @invocation_count = Cardinality.exactly(1), 0
+      @cardinality = Cardinality.new.exactly(1)
       @return_values = ReturnValues.new
       @yield_parameters = YieldParameters.new
       @backtrace = backtrace || caller
@@ -529,12 +575,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,70 +589,60 @@ 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) && @block_matcher.match?(invocation.block) && 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)
     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
 
     # @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/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

data/lib/mocha/inspect.rb

@@ -1,67 +1,59 @@
 require 'date'
 
 module Mocha
-
-  module ObjectMethods
-    def mocha_inspect
-      address = self.__id__ * 2
-      address += 0x100000000 if address < 0
-      inspect =~ /#</ ? "#<#{self.class}:0x#{'%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 StringMethods
-    def mocha_inspect
-      inspect.gsub(/\"/, "'")
+    module ArrayMethods
+      def mocha_inspect(wrapped = true)
+        unwrapped = collect(&:mocha_inspect).join(', ')
+        wrapped ? "[#{unwrapped}]" : unwrapped
+      end
     end
-  end
 
-  module ArrayMethods
-    def mocha_inspect
-      "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
+    module HashMethods
+      def mocha_inspect(wrapped = true)
+        unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
+        wrapped ? "{#{unwrapped}}" : unwrapped
+      end
     end
-  end
 
-  module HashMethods
-    def mocha_inspect
-      "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+    module TimeMethods
+      def mocha_inspect
+        "#{inspect} (#{to_f} secs)"
+      end
     end
-  end
 
-  module TimeMethods
-    def mocha_inspect
-      "#{inspect} (#{to_f} secs)"
+    module DateMethods
+      def mocha_inspect
+        to_s
+      end
     end
   end
-
-  module DateMethods
-    def mocha_inspect
-      to_s
-    end
-  end
-
 end
 
 class Object
-  include Mocha::ObjectMethods
-end
-
-class String
-  include Mocha::StringMethods
+  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,16 +1,23 @@
-require 'mocha/class_method'
+require 'mocha/stubbed_method'
 
 module Mocha
+  class InstanceMethod < StubbedMethod
+    private
 
-  class InstanceMethod < ClassMethod
+    def mock_owner
+      stubbee
+    end
 
-    def method_exists?(method)
-      return true if stubbee.public_methods(false).include?(method)
-      return true if stubbee.protected_methods(false).include?(method)
-      return true if stubbee.private_methods(false).include?(method)
-      return false
+    def method_body(method)
+      PRE_RUBY_V19 ? proc { |*args, &block| method.call(*args, &block) } : method
     end
 
-  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/mini_test/adapter.rb

@@ -5,7 +5,6 @@ require 'mocha/expectation_error_factory'
 module Mocha
   module Integration
     module MiniTest
-
       # Integrates Mocha into recent versions of MiniTest.
       #
       # See the source code for an example of how to integrate Mocha into a test library.
@@ -19,11 +18,11 @@ module Mocha
 
         # @private
         def self.description
-          "adapter for MiniTest gem >= v3.3.0"
+          'adapter for MiniTest gem >= v3.3.0'
         end
 
         # @private
-        def self.included(mod)
+        def self.included(_mod)
           Mocha::ExpectationErrorFactory.exception_class = ::MiniTest::Assertion
         end
 
@@ -51,4 +50,3 @@ module Mocha
     end
   end
 end
-

data/lib/mocha/integration/mini_test/exception_translation.rb

@@ -4,7 +4,7 @@ module Mocha
   module Integration
     module MiniTest
       def self.translate(exception)
-        return exception unless exception.kind_of?(::Mocha::ExpectationError)
+        return exception unless exception.is_a?(::Mocha::ExpectationError)
         translated_exception = ::MiniTest::Assertion.new(exception.message)
         translated_exception.set_backtrace(exception.backtrace)
         translated_exception