hardmock 1.3.5 → 1.3.6

data/CHANGES

@@ -1,3 +1,8 @@
+Hardmock 1.3.6
+
+* BUG FIX: In Rails apps (and others) Hardmock and Fixtures battled viciously over "setup" and "teardown" and "method_added" (and any other clever test enhancement tool, namely Mocha) causing unpredictable results, notably failure to auto-verify mocks after teardown (leading to false positive tests).
+** The newly-added TestUnitBeforeAfter provides TestCase.before_setup and TestCase.after_teardown -- formal test wrapping hooks -- lets Hardmock provide its preparation and auto-verify behavior without contending for setup/teardown supremacy.  
+
 Hardmock 1.3.5
 
 * Aliased should_receive => expects and and_return => returns for easier transition from rspec mock and flexmock users.

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rake'
 require 'rubygems'
 
-HARDMOCK_VERSION = "1.3.5"
+HARDMOCK_VERSION = "1.3.6"
 
 Dir["rake_tasks/*.rake"].each { |f| load f }
 

data/lib/extend_test_unit.rb

@@ -0,0 +1,14 @@
+
+require 'test/unit/testcase'
+class Test::Unit::TestCase 
+  include Hardmock
+end
+
+require 'test_unit_before_after'
+Test::Unit::TestCase.before_setup do |test|
+  test.prepare_hardmock_control
+end
+
+Test::Unit::TestCase.after_teardown do |test|
+  test.verify_mocks
+end

data/lib/hardmock.rb

@@ -9,92 +9,8 @@ require 'hardmock/expectation'
 require 'hardmock/expectation_builder'
 require 'hardmock/stubbing'
 
-
 module Hardmock
 
-  # Setup auto mock verification on teardown, being careful not to interfere
-  # with inherited, pre-mixed or post-added user teardowns.
-  def self.included(base) #:nodoc:#
-    base.class_eval do 
-      # Core of our actual setup behavior
-      def hardmock_setup
-        prepare_hardmock_control
-      end
-      
-      # Core of our actual teardown behavior
-      def hardmock_teardown
-        verify_mocks
-      end
-
-      # disable until later:
-      def self.method_added(symbol) #:nodoc:
-      end
-
-      if method_defined?(:setup) then
-        # Wrap existing setup
-        alias_method :old_setup, :setup
-        define_method(:new_setup) do
-          begin
-            hardmock_setup
-          ensure
-            old_setup
-          end
-        end
-      else
-        # We don't need to account for previous setup
-        define_method(:new_setup) do
-          hardmock_setup
-        end
-      end
-      alias_method :setup, :new_setup
-
-      if method_defined?(:teardown) then
-        # Wrap existing teardown
-        alias_method :old_teardown, :teardown
-        define_method(:new_teardown) do
-          begin
-            hardmock_teardown
-          ensure
-            old_teardown
-          end
-        end
-      else
-        # We don't need to account for previous teardown
-        define_method(:new_teardown) do
-          hardmock_teardown
-        end
-      end
-      alias_method :teardown, :new_teardown
-
-      def self.method_added(method) #:nodoc:
-        case method
-        when :teardown
-          unless method_defined?(:user_teardown)
-            alias_method :user_teardown, :teardown
-            define_method(:teardown) do
-              begin
-                new_teardown 
-              ensure
-                user_teardown
-              end
-            end
-          end
-        when :setup
-          unless method_defined?(:user_setup)
-            alias_method :user_setup, :setup
-            define_method(:setup) do
-              begin
-                new_setup 
-              ensure
-                user_setup
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
   # Create one or more new Mock instances in your test suite. 
   # Once created, the Mocks are accessible as instance variables in your test.
   # Newly built Mocks are added to the full set of Mocks for this test, which will
@@ -167,10 +83,4 @@ module Hardmock
 
 end
 
-# Insert Hardmock functionality into the TestCase base class
-require 'test/unit/testcase'
-unless Test::Unit::TestCase.instance_methods.include?('hardmock_teardown')
-  class Test::Unit::TestCase #:nodoc:#
-    include Hardmock
-  end
-end
+require 'extend_test_unit'

data/lib/test_unit_before_after.rb

@@ -0,0 +1,170 @@
+require 'test/unit'
+require 'test/unit/testcase'
+require 'test/unit/assertions'
+
+module Test #:nodoc:#
+  module Unit #:nodoc:#
+    
+    # == TestCase Modifications
+    #
+    # Monkey-patch to provide a formal mechanism for appending actions to be executed after teardown.
+    # Use after_teardown to define one or more actions to be executed after teardown for ALL tests.
+    #
+    # COMING SOON?
+    # * Hook for running actions prior to setup
+    # * Hooks for before_teardown, after_setup, on_error
+    # * Options for positional control, eg, after_teardown :before_other_actions
+    # * Provide tagging/filtering so action execution can be controlled specifically?
+    #
+    # == Usage
+    #
+    # Invoke TestCase.after_teardown with optional parameter, which will be invoked with a reference
+    # to the test instance that has just been torn down.
+    #
+    # Example:
+    # 
+    #   Test::Unit::TestCase.after_teardown do |test|
+    #     test.verify_mocks
+    #   end
+    #   
+    # == Justification
+    #
+    # There are a number of tools and libraries that play fast-n-loose with setup and teardown by 
+    # wrapping them, and by overriding method_added as a means of upholding special setup/teardown 
+    # behavior, usually by re-wrapping newly defined user-level setup/teardown methods.
+    # mocha and active_record/fixtures (and previously, hardmock) will fight for this
+    # territory with often unpredictable results.
+    #
+    # We wouldn't have to battle if Test::Unit provided a formal pre- and post- hook mechanism.
+    #
+    class TestCase
+
+      class << self
+        
+        # Define an action to be run after teardown. Subsequent calls result in 
+        # multiple actions.  The block will be given a reference to the test
+        # being executed.
+        #
+        # Example:
+        # 
+        #   Test::Unit::TestCase.after_teardown do |test|
+        #     test.verify_mocks
+        #   end
+        def after_teardown(&block)
+          post_teardown_actions << block
+        end
+
+        # Used internally. Access the list of post teardown actions for to be
+        # used by all tests.
+        def post_teardown_actions
+          @@post_teardown_actions ||= []
+        end
+
+        # Define an action to be run before setup. Subsequent calls result in 
+        # multiple actions, EACH BEING PREPENDED TO THE PREVIOUS.  
+        # The block will be given a reference to the test being executed.
+        #
+        # Example:
+        # 
+        #   Test::Unit::TestCase.before_setup do |test|
+        #     test.prepare_hardmock_control
+        #   end
+        def before_setup(&block)
+          pre_setup_actions.unshift block
+        end
+
+        # Used internally. Access the list of post teardown actions for to be
+        # used by all tests.
+        def pre_setup_actions
+          @@pre_setup_actions ||= []
+        end
+      end
+
+      # OVERRIDE: This is a reimplementation of the default "run", updated to
+      # execute actions after teardown.
+      def run(result)
+        yield(STARTED, name)
+        @_result = result
+        begin
+          execute_pre_setup_actions(self)
+          setup
+          __send__(@method_name)
+        rescue Test::Unit::AssertionFailedError => e
+          add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+        rescue Exception
+          raise if should_passthru_exception($!) # See implementation; this is for pre-1.8.6 compat
+          add_error($!)
+        ensure
+          begin
+            teardown
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+          rescue Exception
+            raise if should_passthru_exception($!) # See implementation; this is for pre-1.8.6 compat
+            add_error($!)
+          ensure
+            execute_post_teardown_actions(self)
+          end
+        end
+        result.add_run
+        yield(FINISHED, name)
+      end
+
+      private
+
+      # Run through the after_teardown actions, treating failures and errors
+      # in the same way that "run" does: they are reported, and the remaining
+      # actions are executed.
+      def execute_post_teardown_actions(test_instance)
+        self.class.post_teardown_actions.each do |action|
+          begin
+            action.call test_instance
+          rescue Test::Unit::AssertionFailedError => e
+            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+          rescue Exception
+            raise if should_passthru_exception($!)
+            add_error($!)
+          end
+        end
+      end
+      
+      # Run through the before_setup actions.
+      # Failures or errors cause execution to stop.
+      def execute_pre_setup_actions(test_instance)
+        self.class.pre_setup_actions.each do |action|
+#          begin
+            action.call test_instance
+#          rescue Test::Unit::AssertionFailedError => e
+#            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
+#          rescue Exception
+#            raise if should_passthru_exception($!)
+#            add_error($!)
+#          end
+        end
+      end
+
+      # Make sure that this extension doesn't show up in failure backtraces
+      def auxiliary_backtrace_filter(trace)
+        trace.reject { |x| x =~ /test_unit_before_after/ }
+      end
+
+      # Is the given error of the type that we allow to fly out (rather than catching it)?
+      def should_passthru_exception(ex)
+        return passthrough_exception_types.include?($!.class)
+      end
+
+      # Provide a list of exception types that are to be allowed to explode out.
+      # Pre-ruby-1.8.6 doesn't use this functionality, so the PASSTHROUGH_EXCEPTIONS
+      # constant won't be defined.  This methods defends against that and returns
+      # an empty list instead.
+      def passthrough_exception_types
+        begin 
+          return PASSTHROUGH_EXCEPTIONS
+        rescue NameError
+          # older versions of test/unit do not have PASSTHROUGH_EXCEPTIONS constant
+          return []
+        end
+      end
+    end
+  end
+end

data/test/functional/auto_verify_test.rb

@@ -51,7 +51,6 @@ class AutoVerifyTest < Test::Unit::TestCase
   end
 
   it "is quiet when verification is ok" do
-#  def test_should_not_raise_error_if_verification_goes_according_to_plan
     @test_code =<<-EOM
         def test_ok
           create_mock :automobile
@@ -71,14 +70,13 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_output_contains(/User teardown/)
   end
 
-  should "not auto-verify if user teardown explodes" do
-#  def test_should_not_do_verification_if_user_teardown_explodes
+  should "auto-verify even if user teardown explodes" do
     @teardown_code =<<-EOM 
       def teardown
         raise "self destruct"
       end
     EOM
-    @expect_unmet_expectations = false
+    @expect_errors = 2
     write_and_execute_test
     assert_output_contains(/self destruct/)
   end
@@ -103,29 +101,6 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_output_contains(/Test helper teardown/)
   end
 
-  it "plays nice with inherited and user-defined teardowns at the same time" do
-    @full_code ||=<<-EOTEST
-      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-      class Test::Unit::TestCase 
-        def teardown
-          puts "Test helper teardown"
-        end
-      end
-      require 'hardmock' # IMPORTANT TO DO THIS HERE, between the old and new teardown defs
-      class DummyTest < Test::Unit::TestCase
-        def teardown
-          puts "User teardown"
-        end
-        def test_prepare_to_die
-          create_mock :automobile
-          @automobile.expects.start
-        end
-      end 
-    EOTEST
-    write_and_execute_test
-    assert_output_contains(/Test helper teardown/, /User teardown/)
-  end
-
   #
   # HELPERS
   #
@@ -139,18 +114,29 @@ class AutoVerifyTest < Test::Unit::TestCase
     @test_output = `ruby #{temp_test_file} 2>&1`
   end
 
+  def formatted_test_output
+    if @test_output
+      @test_output.split(/\n/).map { |line| "> #{line}" }.join("\n")
+    else
+      "(NO TEST OUTPUT!)"
+    end
+  end
+
   def remove_temp_test_file
     FileUtils::rm_f temp_test_file
   end
 
   def assert_results(h)
-    assert_match(/#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/,
-     @test_output)
+    if @test_output !~ /#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/
+      flunk "Test results didn't match #{h.inspect}:\n#{formatted_test_output}"
+    end
   end
 
   def assert_output_contains(*patterns)
     patterns.each do |pattern|
-      assert_match(pattern,@test_output)
+      if @test_output !~ pattern
+        flunk "Test output didn't match #{pattern.inspect}:\n#{formatted_test_output}"
+      end
     end
   end
   

data/test/test_helper.rb

@@ -33,9 +33,6 @@ class Test::Unit::TestCase
     tname = self.name.sub(/Test$/,'')
     if block
       define_method "test #{prefix} #{str}" do
-#        phrase = str
-#        phrase = prefix + " " + phrase unless prefix == "it"
-#        puts "#{tname} #{phrase}..."
         instance_eval &block
       end
     else

data/test/unit/test_unit_before_after_test.rb

@@ -0,0 +1,452 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper") 
+
+class TestUnitBeforeAfter < Test::Unit::TestCase
+
+  #
+  # after_teardown
+  #
+
+  it "adds TestCase.after_teardown hook for appending post-teardown actions" do
+    write_and_run_test :use_after_teardown => true
+
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "THE TEARDOWN",
+      "1st after_teardown",
+      "2nd after_teardown",
+      "Finished in"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 0
+  end
+
+  should "execute all after_teardowns, even if the main teardown flunks" do
+    write_and_run_test :use_after_teardown => true, :flunk_in_teardown => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "F",
+      "1st after_teardown",
+      "2nd after_teardown",
+      "Finished in",
+      "1) Failure:",
+      "test_something(MyExampleTest) [_test_file_temp.rb:20]:",
+      "FLUNK IN TEARDOWN"
+    see_results :tests => 1, :assertions => 1, :failures => 1, :errors => 0
+  end
+
+  should "execute all after_teardowns, even if the main teardown explodes" do
+    write_and_run_test :use_after_teardown => true, :raise_in_teardown => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "E",
+      "1st after_teardown",
+      "2nd after_teardown",
+      "Finished in",
+      "RuntimeError: ERROR IN TEARDOWN"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 1
+  end
+
+  should "execute all after_teardowns, even if some of them flunk" do
+    write_and_run_test :use_after_teardown => true, :flunk_in_after_teardown => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "THE TEARDOWN",
+      "1st after_teardown",
+      "F",
+      "2nd after_teardown",
+      "Finished in",
+      "1) Failure:",
+      "test_something(MyExampleTest) [_test_file_temp.rb:7]:",
+      "Flunk in first after_teardown",
+      "2) Failure:",
+      "test_something(MyExampleTest) [_test_file_temp.rb:10]:",
+      "Flunk in second after_teardown"
+    see_results :tests => 1, :assertions => 2, :failures => 2, :errors => 0
+  end
+
+  should "execute all after_teardowns, even if some of them explode" do
+    write_and_run_test :use_after_teardown => true, :raise_in_after_teardown => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "THE TEARDOWN",
+      "1st after_teardown",
+      "E",
+      "2nd after_teardown",
+      "Finished in",
+      "RuntimeError: Error in first after_teardown",
+      "RuntimeError: Error in second after_teardown"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 2
+  end
+
+  it "will run after_teardowns in the absence of a regular teardown" do
+    write_and_run_test :omit_teardown => true, :use_after_teardown => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "1st after_teardown",
+      "2nd after_teardown",
+      "Finished in"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 0
+  end
+
+  should "not interfere with normal test writing" do
+    write_and_run_test
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A TEST",
+      "THE TEARDOWN",
+      "Finished in"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 0
+  end
+
+  it "provides a cleaned-up backtrace" do
+    write_and_run_test :with_failure => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A FAILING TEST",
+      "F", "THE TEARDOWN",
+      "Finished in",
+      "1) Failure:",
+      "test_something(MyExampleTest) [_test_file_temp.rb:17]:",
+      "Instrumented failure.",
+      "<false> is not true."
+    see_results :tests => 1, :assertions => 1, :failures => 1, :errors => 0
+  end
+
+  it "provides a cleaned-up backtrace, but not TOO cleaned up" do
+    write_and_run_test :with_failure => true, :use_helpers => true
+    see_in_order "Loaded suite",
+      "THE SETUP",
+      "A FAILING TEST",
+      "F", "THE TEARDOWN",
+      "Finished in",
+      "1) Failure:",
+      "test_something(MyExampleTest)\n",
+      "[_test_file_temp.rb:25:in `tripwire'",
+      "_test_file_temp.rb:21:in `my_helper'",
+      "_test_file_temp.rb:17:in `test_something']:",
+      "Instrumented failure.",
+      "<false> is not true."
+    see_results :tests => 1, :assertions => 1, :failures => 1, :errors => 0
+  end
+
+  should "not interfere with passthrough exception types" do
+    if is_modern_test_unit?
+      write_and_run_test :raise_nasty_in_test => true
+      see_in_no_particular_order "Loaded suite", 
+        "THE TEARDOWN",
+        "_test_file_temp.rb:16:in `test_something': NASTY ERROR (NoMemoryError)"
+      see_no_results
+    end
+  end
+
+  #
+  # before_setup
+  #
+
+  it "adds TestCase.before_setup hook for prepending pre-setup actions" do
+    write_and_run_test :use_before_setup => true
+    see_in_order "Loaded suite",
+      "3rd before_setup",
+      "2nd before_setup",
+      "1st before_setup",
+      "THE SETUP",
+      "A TEST",
+      "THE TEARDOWN",
+      "Finished in"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 0
+  end
+
+  should "stop executing the test on the first failure withing a before_setup action" do 
+    write_and_run_test :use_before_setup => true, :flunk_in_before_setup => true
+    see_in_order "Loaded suite",
+      "3rd before_setup",
+      "2nd before_setup",
+      "FTHE TEARDOWN",
+      "1) Failure:",
+      "test_something(MyExampleTest) [_test_file_temp.rb:10]:",
+      "Flunk in 2nd before_setup."
+    see_results :tests => 1, :assertions => 1, :failures => 1, :errors => 0
+  end
+
+  should "stop executing the test on the first error within a before_setup action" do
+    write_and_run_test :use_before_setup => true, :raise_in_before_setup => true
+    see_in_order "Loaded suite",
+      "3rd before_setup",
+      "2nd before_setup",
+      "ETHE TEARDOWN",
+      "Finished in",
+      "test_something(MyExampleTest):",
+      "RuntimeError: Error in 2nd before_setup",
+      "_test_file_temp.rb:10",
+      "/hardmock/lib/test_unit_before_after.rb:136:in `call'"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 1
+  end
+
+  it "will run before_setup actions in the absence of a regular setup" do
+    write_and_run_test :omit_setup => true, :use_before_setup => true
+    see_in_order "Loaded suite",
+      "3rd before_setup",
+      "2nd before_setup",
+      "1st before_setup",
+      "A TEST",
+      "THE TEARDOWN",
+      "Finished in"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 0
+  end
+
+  it "allows before_setup and after_teardown to be used at the same time" do
+    write_and_run_test :use_before_setup => true, :use_after_teardown => true
+    see_in_order "Loaded suite",
+      "3rd before_setup",
+      "2nd before_setup",
+      "1st before_setup",
+      "A TEST",
+      "THE TEARDOWN",
+      "1st after_teardown",
+      "2nd after_teardown",
+      "Finished in"
+    see_results :tests => 1, :assertions => 0, :failures => 0, :errors => 0
+  end
+
+  #
+  # HELPERS
+  #
+
+  def teardown
+    remove_test
+  end
+
+  def test_filename
+    "_test_file_temp.rb"
+  end 
+
+  def remove_test
+    rm_f test_filename
+  end
+
+  def write_and_run_test(opts={})
+    write(test_filename, generate_test_code(opts))
+    run_test
+  end
+
+  def run_test
+    @output = `ruby #{test_filename} 2>&1`
+  end
+
+
+  def write(fname, code)
+    File.open(fname,"w") do |f|
+      f.print code     
+    end
+  end
+
+  def show_output
+    puts "-- BEGIN TEST OUTPUT"
+    puts @output
+    puts "-- END TEST OUTPUT"
+  end
+
+  def see_in_order(*phrases)
+    idx = 0
+    phrases.each do |txt|
+      idx = @output.index(txt, idx)
+      if idx.nil?
+        if @output.index(txt)
+          flunk "Phrase '#{txt}' is out-of-order in test output:\n#{@output}"
+        else
+          flunk "Phrase '#{txt}' not found in test output:\n#{@output}"
+        end
+      end
+    end
+  end
+
+  def see_in_no_particular_order(*phrases)
+    phrases.each do |txt|
+      assert_not_nil @output.index(txt), "Didn't see '#{txt}' in test output:\n#{@output}"
+    end
+  end
+
+  def see_results(opts)
+    if @output =~ /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/
+      tests, assertions, failures, errors = [ $1, $2, $3, $4 ]
+      [:tests, :assertions, :failures, :errors].each do |key|
+        eval %{assert_equal(opts[:#{key}].to_s, #{key}, "Wrong number of #{key} in report") if opts[:#{key}]}
+      end
+    else
+      flunk "Didn't see the test results report line"
+    end
+  end
+
+  def see_no_results
+    if @output =~ /\d+ tests, \d+ assertions, \d+ failures, \d+ errors/
+      flunk "Should not have had a results line:\n#{@output}"
+    end
+  end
+
+  def lib_dir
+    File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  end
+
+  def generate_test_code(opts={})
+
+    if opts[:with_failure] or opts[:raise_nasty_in_test]
+      test_method_code = generate_failing_test("test_something", opts)
+    else
+      test_method_code = generate_passing_test("test_something")
+    end
+
+
+    requires_for_ext = ''
+    if opts[:use_before_setup] or opts[:use_after_teardown]
+      requires_for_ext =<<-RFE
+        $: << "#{lib_dir}"
+        require 'test_unit_before_after'
+      RFE
+    end
+
+    before_setups = ''
+    if opts[:use_before_setup]
+      add_on_two = ""
+      if opts[:flunk_in_before_setup]
+        add_on_two = %{; test.flunk "Flunk in 2nd before_setup"}
+      elsif opts[:raise_in_before_setup]
+        add_on_two = %{; raise "Error in 2nd before_setup"}
+      end
+      before_setups =<<-BSTS
+        Test::Unit::TestCase.before_setup do |test| 
+          puts "1st before_setup"
+        end
+        Test::Unit::TestCase.before_setup do |test| 
+          puts "2nd before_setup" #{add_on_two}
+        end
+        Test::Unit::TestCase.before_setup do |test| 
+          puts "3rd before_setup"
+        end
+
+      BSTS
+    end
+
+
+    setup_code =<<-SC
+      def setup
+        puts "THE SETUP"
+      end
+    SC
+    if opts[:omit_setup]
+      setup_code = ""
+    end
+
+    after_teardowns = ''
+    if opts[:use_after_teardown]
+      add_on_one = ""
+      add_on_two = ""
+      if opts[:flunk_in_after_teardown]
+        add_on_one = %{; test.flunk "Flunk in first after_teardown"}
+        add_on_two = %{; test.flunk "Flunk in second after_teardown"}
+      elsif opts[:raise_in_after_teardown]
+        add_on_one = %{; raise "Error in first after_teardown"}
+        add_on_two = %{; raise "Error in second after_teardown"}
+      end
+      after_teardowns =<<-ATDS
+        Test::Unit::TestCase.after_teardown do |test| 
+          puts "1st after_teardown" #{add_on_one}
+        end
+        Test::Unit::TestCase.after_teardown do |test| 
+          puts "2nd after_teardown" #{add_on_two}
+        end
+      ATDS
+    end
+
+    teardown_code =<<-TDC
+      def teardown
+        puts "THE TEARDOWN"
+      end
+    TDC
+    if opts[:flunk_in_teardown]
+      teardown_code =<<-TDC
+        def teardown
+          flunk "FLUNK IN TEARDOWN"
+        end
+      TDC
+    elsif opts[:raise_in_teardown]
+      teardown_code =<<-TDC
+        def teardown
+          raise "ERROR IN TEARDOWN"
+        end
+      TDC
+    end
+    if opts[:omit_teardown]
+      teardown_code = ""
+    end
+
+    str = <<-TCODE
+    require 'test/unit'
+    #{requires_for_ext}
+
+    #{before_setups} #{after_teardowns}
+    
+    class MyExampleTest < Test::Unit::TestCase
+      #{setup_code}
+      #{teardown_code}
+      #{test_method_code}
+    end
+    TCODE
+  end
+
+  def generate_passing_test(tname)
+    str = <<-TMETH
+      def #{tname}
+        puts "A TEST"
+      end
+    TMETH
+  end
+
+  def generate_failing_test(tname, opts={})
+    str = "NOT DEFINED?"
+    if opts[:raise_nasty_in_test]
+      str = <<-TMETH
+        def #{tname}
+          raise NoMemoryError, "NASTY ERROR"
+        end
+      TMETH
+
+    elsif opts[:use_helpers]
+      str = <<-TMETH
+        def #{tname}
+          puts "A FAILING TEST"
+          my_helper
+        end
+
+        def my_helper
+          tripwire
+        end
+
+        def tripwire
+          assert false, "Instrumented failure"
+        end
+      TMETH
+    else
+      str = <<-TMETH
+        def #{tname}
+          puts "A FAILING TEST"
+          assert false, "Instrumented failure"
+        end
+      TMETH
+    end
+    return str
+  end
+
+  def is_modern_test_unit?
+    begin
+      Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
+      return true
+    rescue NameError
+      return false
+    end
+  end
+
+end

metadata

@@ -1,36 +1,31 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
 name: hardmock
 version: !ruby/object:Gem::Version 
-  version: 1.3.5
-date: 2007-12-10 00:00:00 -05:00
-summary: A strict, ordered, expectation-oriented mock object library.
-require_paths: 
-- lib
-email: crosby@atomicobject.com
-homepage: http://hardmock.rubyforge.org
-rubyforge_project: hardmock
-description: 
-autorequire: hardmock
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.3.6
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - David Crosby
+autorequire: hardmock
+bindir: bin
+cert_chain: []
+
+date: 2007-12-11 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: crosby@atomicobject.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- LICENSE
 files: 
 - lib/assert_error.rb
-- lib/hardmock.rb
+- lib/extend_test_unit.rb
 - lib/hardmock/errors.rb
 - lib/hardmock/expectation.rb
 - lib/hardmock/expectation_builder.rb
@@ -41,18 +36,21 @@ files:
 - lib/hardmock/stubbing.rb
 - lib/hardmock/trapper.rb
 - lib/hardmock/utils.rb
-- test/test_helper.rb
+- lib/hardmock.rb
+- lib/test_unit_before_after.rb
 - test/functional/assert_error_test.rb
 - test/functional/auto_verify_test.rb
 - test/functional/direct_mock_usage_test.rb
 - test/functional/hardmock_test.rb
 - test/functional/stubbing_test.rb
+- test/test_helper.rb
 - test/unit/expectation_builder_test.rb
 - test/unit/expectation_test.rb
 - test/unit/expector_test.rb
 - test/unit/method_cleanout_test.rb
 - test/unit/mock_control_test.rb
 - test/unit/mock_test.rb
+- test/unit/test_unit_before_after_test.rb
 - test/unit/trapper_test.rb
 - test/unit/verify_error_test.rb
 - Rakefile
@@ -63,6 +61,37 @@ files:
 - README
 - CHANGES
 - LICENSE
+has_rdoc: true
+homepage: http://hardmock.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README
+- --title
+- Hardmock
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: hardmock
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: A strict, ordered, expectation-oriented mock object library.
 test_files: 
 - test/functional/assert_error_test.rb
 - test/functional/auto_verify_test.rb
@@ -75,24 +104,6 @@ test_files:
 - test/unit/method_cleanout_test.rb
 - test/unit/mock_control_test.rb
 - test/unit/mock_test.rb
+- test/unit/test_unit_before_after_test.rb
 - test/unit/trapper_test.rb
 - test/unit/verify_error_test.rb
-rdoc_options: 
-- --line-numbers
-- --inline-source
-- --main
-- README
-- --title
-- Hardmock
-extra_rdoc_files: 
-- README
-- CHANGES
-- LICENSE
-executables: []
-
-extensions: []
-
-requirements: []
-
-dependencies: []
-