deep_test 1.0.0

data/README

@@ -0,0 +1,23 @@
+= DeepTest
+
+DeepTest enables tests to run in multiple processes.
+
+== Authors
+
+anonymous z, Dan[http://www.dcmanges.com/blog] Manges[http://www.dcmanges.com/blog], David Vollbracht
+
+== Usage
+
+In your Rakefile:
+
+  require "rubygems"
+  require "deep_test/rake_tasks"
+  
+  # sample DeepTest task
+  DeepTest::TestTask.new "task_name" do |t|
+    t.pattern = "test/**/*_test.rb"
+    t.processes = 2 # optional, defaults to 2
+  end
+
+== License
+Released under Ruby's[http://www.ruby-lang.org/en/LICENSE.txt] license[http://www.ruby-lang.org/en/LICENSE.txt]

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+$LOAD_PATH << File.dirname(__FILE__) + "/lib"
+require "deep_test/rake_tasks"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.libs += ['test', 'lib']
+end
+
+DeepTest::TestTask.new :deep_test do |t|
+  t.pattern = "test/**/*_test.rb"
+  t.processes = 2
+end
+
+desc "Generate documentation"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "doc"
+  rdoc.title    = "DeepTest"
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README', 'CHANGELOG')
+end
+
+desc "Upload RDoc to RubyForge"
+task :publish_rdoc => [:rdoc] do
+  Rake::SshDirPublisher.new("dcmanges@rubyforge.org", "/var/www/gforge-projects/deep-test", "doc").upload
+end
+
+Gem::manage_gems
+
+specification = Gem::Specification.new do |s|
+	s.name   = "deep_test"
+  s.summary = "DeepTest runs tests in multiple processes."
+	s.version = "1.0.0"
+	s.author = "anonymous z, Dan Manges, David Vollbracht"
+	s.description = s.summary
+	s.email = "daniel.manges@gmail.com"
+  s.homepage = "http://deep-test.rubyforge.org"
+  s.rubyforge_project = "deep-test"
+  s.add_dependency "daemons", ">= 1.0.7"
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'CHANGELOG']
+  s.rdoc_options << '--title' << "DeepTest" << '--main' << 'README' << '--line-numbers'
+
+  s.autorequire = "deep_test"
+  s.files = FileList['{lib,test}/**/*.{rb,rake}', 'CHANGELOG', 'README', 'Rakefile'].to_a
+end
+
+Rake::GemPackageTask.new(specification) do |package|
+  package.need_zip = true
+  package.need_tar = true
+end

data/lib/deep_test/extensions/error.rb

@@ -0,0 +1,14 @@
+module Test
+  module Unit
+    class Error
+      def initialize_with_exception_wrapping(test_name, exception)
+        wrap = Exception.new "#{exception.class}: #{exception.message}"
+        wrap.set_backtrace exception.backtrace
+        @test_name = test_name
+        @exception = wrap
+      end
+      alias_method :initialize_without_exception_wrapping, :initialize
+      alias_method :initialize, :initialize_with_exception_wrapping
+    end
+  end
+end

data/lib/deep_test/extensions/object_extension.rb

@@ -0,0 +1,12 @@
+module DeepTest
+  module ObjectExtension
+    def capture_stdout
+      old_stdout, $stdout = $stdout, StringIO.new
+      yield
+      $stdout.string
+    ensure
+      $stdout = old_stdout
+    end
+  end
+end
+Object.send :include, DeepTest::ObjectExtension

data/lib/deep_test/extensions/testresult.rb

@@ -0,0 +1,17 @@
+module Test
+  module Unit
+    class TestResult
+      attr_accessor :output
+      def add_to(result)
+        @failures.each {|e| result.add_failure(e)}
+        @errors.each {|e| result.add_error(e)}
+        assertion_count.times {result.add_assertion}
+        run_count.times {result.add_run}
+      end
+      
+      def failed_due_to_deadlock?
+        @errors.any? && !@errors.last.message.to_s.match(/Deadlock found when trying to get lock/).nil?
+      end
+    end
+  end
+end

data/lib/deep_test/loader.rb

@@ -0,0 +1,26 @@
+module DeepTest
+  class Loader
+    NO_FILTERS = Object.new.instance_eval do
+      def filters; []; end;
+      self
+    end
+    
+    def self.run(args)
+      require "deep_test"
+      ENV["RAILS_ENV"] = "test"
+      Object.const_set "RAILS_ENV", "test"
+      Dir.glob(ARGV.first).each { |file| load file }
+      suite = Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
+      blackboard = DeepTest::RindaBlackboard.new
+      supervisor = DeepTest::Supervisor.new blackboard
+      supervised_suite = DeepTest::SupervisedTestSuite.new(suite, supervisor)
+      require 'test/unit/ui/console/testrunner'
+      Test::Unit::UI::Console::TestRunner.run(supervised_suite, Test::Unit::UI::NORMAL)
+      Test::Unit.run = true
+    end
+  end
+end
+
+if __FILE__ == $0
+  DeepTest::Loader.run ARGV
+end

data/lib/deep_test/rake_tasks.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + "/test_task"
+Dir.glob(File.dirname(__FILE__) + "/tasks/**/*.rake").each { |file| load file }

data/lib/deep_test/rinda_blackboard.rb

@@ -0,0 +1,29 @@
+module DeepTest
+  class RindaBlackboard
+    def initialize
+      require "rinda/ring"
+      DRb.start_service
+      ring_server = Rinda::RingFinger.primary
+      ts = ring_server.read([:name, :TupleSpace, nil, nil])[2]
+      @tuple_space = Rinda::TupleSpaceProxy.new ts
+    end
+
+    def take_result
+      result = @tuple_space.take ["test_result", nil], 3
+      result[1]
+    end
+
+    def take_test
+      tuple = @tuple_space.take(["run_test", nil, nil])
+      eval(tuple[1]).new(tuple[2])
+    end
+
+    def write_result(result)
+      @tuple_space.write ["test_result", result]
+    end
+
+    def write_test(test_case)
+      @tuple_space.write ["run_test", test_case.class.to_s, test_case.method_name]
+    end
+  end
+end

data/lib/deep_test/server.rb

@@ -0,0 +1,16 @@
+module DeepTest
+  class Server
+    def self.start
+      require 'rinda/ring'
+      require 'rinda/tuplespace'
+      require 'test/unit'
+      require 'test/unit/testresult'
+      require 'deep_test'
+      DRb.start_service
+      ts = Rinda::TupleSpace.new
+      Rinda::RingServer.new(ts)
+      Rinda::RingProvider.new(:TupleSpace, ts, 'Tuple Space').provide
+      DRb.thread.join
+    end
+  end
+end

data/lib/deep_test/simple_test_blackboard.rb

@@ -0,0 +1,24 @@
+module DeepTest
+  class SimpleTestBlackboard
+    def initialize
+      @test_cases = []
+      @test_results = []
+    end
+
+    def take_result
+      @test_results.shift
+    end
+
+    def take_test
+      @test_cases.shift
+    end
+
+    def write_result(result)
+      @test_results.push result
+    end
+
+    def write_test(test_case)
+      @test_cases.push test_case
+    end
+  end
+end

data/lib/deep_test/start_workers.rb

@@ -0,0 +1,23 @@
+module DeepTest
+  module StartWorkers
+    def self.run(args)
+      processes, pattern = args
+      1.to_i.times do
+        Daemons.run_proc "deep_test_worker", :multiple => true, :ARGV => ["start"], :backtrace => true, :log_output => true do
+          require "deep_test"
+          ENV["RAILS_ENV"] = "test"
+          Object.const_set "RAILS_ENV", "test"
+          Dir.glob(pattern).each { |file| load file }
+          blackboard = DeepTest::RindaBlackboard.new
+          DeepTest::Worker.new(blackboard).run
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require "rubygems"
+  require "daemons"
+  DeepTest::StartWorkers.run ARGV
+end

data/lib/deep_test/supervised_test_suite.rb

@@ -0,0 +1,19 @@
+module DeepTest
+  class SupervisedTestSuite
+    def initialize(suite, supervisor)
+      @suite = suite
+      @supervisor = supervisor
+    end
+
+    def run(result, &progress_block)
+      yield Test::Unit::TestSuite::STARTED, @suite.name
+      @supervisor.add_tests @suite
+      @supervisor.read_results result, &progress_block
+      yield Test::Unit::TestSuite::FINISHED, @suite.name
+    end
+
+    def size
+      @suite.size
+    end
+  end
+end

data/lib/deep_test/supervisor.rb

@@ -0,0 +1,27 @@
+module DeepTest
+  class Supervisor
+    def initialize(blackboard)
+      @blackboard = blackboard
+      @count = 0
+    end
+
+    def add_tests(test_suite)
+      if test_suite.respond_to? :tests
+        test_suite.tests.each {|test| add_tests(test)}
+      else
+        @count += 1
+        @blackboard.write_test test_suite
+      end
+    end
+
+    def read_results(result)
+      while (@count > 0 && remote_result = @blackboard.take_result)
+        @count -= 1
+        remote_result.add_to result
+        # TODO: is this the right place for this next line? -Dan
+        print remote_result.output if remote_result.output
+        yield Test::Unit::TestCase::FINISHED, nil if block_given?
+      end
+    end
+  end
+end

data/lib/deep_test/tasks/rinda.rake

@@ -0,0 +1,37 @@
+require "rubygems"
+begin
+  require "daemons"
+rescue LoadError
+  raise "The daemons gem must be installed"
+end
+
+namespace :deep_test do
+  namespace :server do
+    desc "Starts the server"
+    task :start do
+      Daemons.run_proc "deep_test_server", :ARGV => ["start"] do
+        require "deep_test"
+        ENV["RAILS_ENV"] = "test"
+        Object.const_set "RAILS_ENV", "test"
+        DeepTest::Server.start
+      end
+      sleep 0.25
+    end
+    desc "Stops the server"
+    task :stop do
+      Daemons.run("deep_test_server", :ARGV => ["stop"])
+    end
+  end
+  
+  namespace :workers do
+    desc "Starts the workers"
+    task :start do
+      raise "deprecated -dan"
+    end
+    
+    desc "Stops the workers"
+    task :stop do
+      Daemons.run("deep_test_worker", :ARGV => ["stop"])
+    end
+  end
+end

data/lib/deep_test/test_task.rb

@@ -0,0 +1,39 @@
+module DeepTest
+  class TestTask
+    attr_writer :pattern, :processes
+
+    def initialize(name = :deep_test)
+      @name = name
+      yield self if block_given?
+      define
+    end
+    
+    def define
+      desc "Run '#{@name}' suite using DeepTest"
+      task @name => %w[deep_test:server:start] do
+        begin
+          deep_test_lib = File.expand_path(File.dirname(__FILE__) + "/..")
+          
+          # workers
+          starter = File.expand_path(File.dirname(__FILE__) + "/start_workers.rb")
+          ruby "-I#{deep_test_lib} #{starter} '#{processes}' '#{pattern}'"
+
+          # loader
+          loader = File.expand_path(File.dirname(__FILE__) + "/loader.rb")
+          ruby "-I#{deep_test_lib} #{loader} '#{pattern}'"
+        ensure
+          Rake::Task["deep_test:workers:stop"].invoke
+          Rake::Task["deep_test:server:stop"].invoke
+        end
+      end
+    end
+    
+    def pattern
+      Dir.pwd + "/" + (@pattern || "test/**/*_test.rb")
+    end
+    
+    def processes
+      @processes ? @processes.to_i : 2
+    end
+  end
+end

data/lib/deep_test/worker.rb

@@ -0,0 +1,31 @@
+module DeepTest
+  class Worker
+    def initialize(blackboard)
+      @blackboard = blackboard
+    end
+
+    def run
+      while test_case = @blackboard.take_test
+        result = run_test_case test_case
+        result = run_test_case test_case if result.failed_due_to_deadlock?
+        if result.failed_due_to_deadlock?
+          result = Test::Unit::TestResult.new
+          result.add_run
+          result.output = "-deadlock-"
+        end
+        @blackboard.write_result result
+      end
+    end
+    
+    protected
+    
+    def run_test_case(test_case)
+      result = Test::Unit::TestResult.new
+      output = capture_stdout do
+        test_case.run(result) {|channel,event|}
+      end
+      result.output = output
+      result
+    end
+  end
+end

data/lib/deep_test.rb

@@ -0,0 +1,18 @@
+module DeepTest
+end
+
+require "test/unit/testresult"
+require "test/unit/error"
+
+require "deep_test/extensions/testresult"
+require "deep_test/extensions/error"
+require "deep_test/extensions/object_extension"
+
+# require "deep_test/loader"
+require "deep_test/rinda_blackboard"
+require "deep_test/server"
+require "deep_test/simple_test_blackboard"
+require "deep_test/supervised_test_suite"
+require "deep_test/supervisor"
+require "deep_test/test_task"
+require "deep_test/worker"

data/test/deep_test/loader_test.rb

@@ -0,0 +1,7 @@
+# require File.dirname(__FILE__) + "/../test_helper"
+# 
+# unit_tests do
+#   test "no filters constant has empty filters" do
+#     assert_equal [], DeepTest::Loader::NO_FILTERS.filters
+#   end
+# end

data/test/simple_test_blackboard_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "a test that is put on can be taken off later" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    test_case = TestFactory.passing_test
+    blackboard.write_test test_case
+    assert_equal test_case, blackboard.take_test
+  end
+
+  test "taking a test when all have been taken returns nil" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    test_case = TestFactory.passing_test
+    blackboard.write_test test_case
+    blackboard.take_test
+    assert_nil blackboard.take_test
+  end
+
+  test "a result that is put on can be taken off later" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    result = TestFactory.passed_result
+    blackboard.write_result result
+    assert_equal result, blackboard.take_result
+  end
+
+  test "taking a result when all have been taken returns nil" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    result = TestFactory.passed_result
+    blackboard.write_result result
+    blackboard.take_result
+    assert_nil blackboard.take_result
+  end
+end

data/test/supervised_test_suite_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "run yields name for start and finished of underlying suite" do
+    suite = Test::Unit::TestSuite.new("name")
+    supervised_suite = DeepTest::SupervisedTestSuite.new(suite, stub_everything)
+
+    yielded = []
+    supervised_suite.run(stub_everything) do |channel,name|
+      yielded << [channel,name]
+    end
+
+    assert_equal [[Test::Unit::TestSuite::STARTED, "name"],
+                  [Test::Unit::TestSuite::FINISHED, "name"]], yielded
+  end
+
+  test "run adds test suite to supervisor" do
+    suite = Test::Unit::TestSuite.new("name")
+    supervisor = stub_everything
+    supervised_suite = DeepTest::SupervisedTestSuite.new(suite, supervisor)
+    supervisor.expects(:add_tests).with(suite)
+    supervised_suite.run(stub_everything) {|channel,name|}
+  end
+
+
+  test "run tells supervisor to read resuts with passed in results" do
+    suite = Test::Unit::TestSuite.new("name")
+    results = stub_everything
+    supervisor = stub_everything
+    supervised_suite = DeepTest::SupervisedTestSuite.new(suite, supervisor)
+    supervisor.expects(:read_results).with(results)
+    supervised_suite.run(results) {|channel,name|}
+  end
+
+
+  test "run passes progress block on to supervisor" do
+    suite = Test::Unit::TestSuite.new("name")
+    supervisor = stub_everything
+    supervised_suite = DeepTest::SupervisedTestSuite.new(suite, supervisor)
+    supervisor.stubs(:read_results).yields("from_supervisor", "event")
+    yielded = []
+    supervised_suite.run(stub_everything) do |channel,name|
+      yielded << [channel, name]
+    end
+
+    assert_equal true, yielded.include?(["from_supervisor", "event"])
+  end
+
+  test "has same size as underlyng suite" do
+    suite = Test::Unit::TestSuite.new("name")
+    suite << "test"
+    supervisor = stub_everything
+    supervised_suite = DeepTest::SupervisedTestSuite.new(suite, supervisor)
+    
+    assert_equal suite.size, supervised_suite.size
+  end
+end

data/test/supervisor_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "add_tests adds single test to blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervisor = DeepTest::Supervisor.new(blackboard)
+    test_case = TestFactory.passing_test
+    supervisor.add_tests test_case
+    assert_equal test_case, blackboard.take_test
+  end
+
+  test "add_tests adds entire suite to blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervisor = DeepTest::Supervisor.new(blackboard)
+    test_suite = TestFactory.suite
+    test_suite << (test_case_1 = TestFactory.passing_test)
+    test_suite << (test_case_2 = TestFactory.passing_test)
+
+    supervisor.add_tests test_suite
+
+    actual_tests = [blackboard.take_test, blackboard.take_test]
+
+    assert_equal true, actual_tests.member?(test_case_1), 
+                       "First test case is not on blackboard"
+
+    assert_equal true, actual_tests.member?(test_case_2),
+                       "Second test case is not on blackboard"
+  end
+
+  test "read_results adds blackboard result to local result" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervisor = DeepTest::Supervisor.new(blackboard)
+
+    supervisor.add_tests TestFactory.passing_test
+
+    blackboard_result = Test::Unit::TestResult.new
+    blackboard_result.add_run
+
+    blackboard.write_result blackboard_result
+
+    local_result = Test::Unit::TestResult.new
+    supervisor.read_results local_result
+
+    assert_equal 1, local_result.run_count
+  end
+
+  test "read_results yields TestCase::Finished event when reading a result" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervisor = DeepTest::Supervisor.new(blackboard)
+
+   supervisor.add_tests TestFactory.passing_test
+
+    blackboard.write_result Test::Unit::TestResult.new
+    yielded = nil
+
+    supervisor.read_results Test::Unit::TestResult.new do |channel,name|
+      yielded = [channel,name]
+    end
+
+    assert_equal [Test::Unit::TestCase::FINISHED, nil], yielded
+  end
+  
+  test "read_results prints output if any" do
+     blackboard = DeepTest::SimpleTestBlackboard.new
+     supervisor = DeepTest::Supervisor.new(blackboard)
+     supervisor.add_tests stub
+     result = Test::Unit::TestResult.new
+     result.output = "output"
+     blackboard.write_result result
+     supervisor.expects(:print).with("output")
+     supervisor.read_results Test::Unit::TestResult.new do |channel,name|
+     end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'test/unit'
+require 'dust'
+require 'mocha'
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/lib")
+require "deep_test"
+
+module TestFactory
+  def self.failing_test
+    test_class = Class.new(Test::Unit::TestCase) do
+      def test_failing
+        assert_equal 1, 0
+      end
+    end
+    test_class.new(:test_failing)
+  end
+
+  def self.passed_result
+    result = Test::Unit::TestResult.new
+    result.add_run
+    result.add_assertion
+    result
+  end
+
+  def self.passing_test
+    test_class = Class.new(Test::Unit::TestCase) do
+      def test_passing
+        assert_equal 0, 0
+      end
+    end
+    test_class.new(:test_passing)
+  end
+  
+  def self.passing_test_with_stdout
+    test_class = Class.new(Test::Unit::TestCase) do
+      def test_passing_with_stdout
+        print "message printed to stdout"
+        assert true
+      end
+    end
+    test_class.new :test_passing_with_stdout
+  end
+  
+  def self.deadlock_once_test
+    test_class = Class.new(Test::Unit::TestCase) do
+      def test_deadlock_once
+        if @deadlocked
+          assert true
+        else
+          @deadlocked = true
+          raise ActiveRecord::StatementInvalid.new("Deadlock found when trying to get lock")
+        end
+      end
+    end
+    test_class.new :test_deadlock_once
+  end
+  
+  def self.deadlock_always_test
+    test_class = Class.new(Test::Unit::TestCase) do
+      def test_deadlock_always
+        raise ActiveRecord::StatementInvalid.new("Deadlock found when trying to get lock")
+      end
+    end
+    test_class.new :test_deadlock_always
+  end
+
+  def self.suite
+    Test::Unit::TestSuite.new
+  end
+end
+
+class SomeCustomException < RuntimeError
+end
+
+unless defined?(ActiveRecord::StatementInvalid)
+  module ActiveRecord
+    class StatementInvalid < StandardError
+    end
+  end
+end

data/test/test_task_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "defines a rake task with the name passed to the constructor" do
+    DeepTest::TestTask.any_instance.stubs(:desc)
+    DeepTest::TestTask.any_instance.expects(:task).with { |hash| hash.keys == [:my_task_name] }
+    DeepTest::TestTask.new :my_task_name do
+    end
+  end
+  
+  test "setting pattern" do
+    pattern = "test/**/x*_test.rb"
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
+      t.pattern = pattern
+    end
+    assert_equal pattern, task.pattern[-pattern.size..-1]
+  end
+  
+  test "default pattern is test/**/*_test.rb" do
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
+    end
+    assert_equal "test/**/*_test.rb", task.pattern[-"test/**/*_test.rb".size..-1]
+  end
+  
+  test "processes defaults to 2" do
+    task = DeepTest::TestTask.new do |t|
+      t.stubs(:define)
+    end
+    assert_equal 2, task.processes
+  end
+  
+  test "processes can be set" do
+    task = DeepTest::TestTask.new do |t|
+      t.processes = 42
+      t.stubs(:define)
+    end
+    assert_equal 42, task.processes
+  end
+end

data/test/testresult_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "add_to adds correct run_count" do
+    result_1 = Test::Unit::TestResult.new
+    result_1.add_run
+    result_1.add_run
+
+    result_2 = Test::Unit::TestResult.new
+    result_1.add_to result_2
+
+    assert_equal 2, result_2.run_count
+  end
+
+  test "add_to adds correct assertion_count" do
+    result_1 = Test::Unit::TestResult.new
+    result_1.add_assertion
+    result_1.add_assertion
+
+    result_2 = Test::Unit::TestResult.new
+    result_1.add_to result_2
+
+    assert_equal 2, result_2.assertion_count
+  end
+
+  test "add_to adds correct errors" do
+    result_1 = Test::Unit::TestResult.new
+    result_1.add_error(:error)
+
+    result_2 = Test::Unit::TestResult.new
+    result_1.add_to result_2
+
+    assert_equal [:error], result_2.instance_variable_get(:@errors)
+  end
+
+
+  test "add_to adds correct failures" do
+    result_1 = Test::Unit::TestResult.new
+    result_1.add_failure(:failure)
+
+    result_2 = Test::Unit::TestResult.new
+    result_1.add_to result_2
+
+    assert_equal [:failure], result_2.instance_variable_get(:@failures)
+  end
+  
+  test "wraps exceptions" do
+    result = Test::Unit::TestResult.new
+    begin
+      raise SomeCustomException.new("the exception message")
+    rescue => ex
+      result.add_error Test::Unit::Error.new("test_wraps_exceptions", ex)
+    end
+    error = result.instance_variable_get("@errors").last
+    # TODO: add this assertion
+    # assert_equal "SomeCustomException: the exception message", error.message
+    assert_equal "SomeCustomException: the exception message", error.exception.message
+    assert_equal Exception, error.exception.class
+    assert_equal ex.backtrace, error.exception.backtrace
+  end
+  
+  test "failed due to deadlock" do
+    result = Test::Unit::TestResult.new
+    begin
+      raise ActiveRecord::StatementInvalid.new("Deadlock found when trying to get lock")
+    rescue => ex
+      result.add_error Test::Unit::Error.new("test_", ex)
+    end
+    assert_equal true, result.failed_due_to_deadlock?
+  end
+end

data/test/worker_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "puts result on blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_test TestFactory.passing_test
+
+    DeepTest::Worker.new(blackboard).run
+
+    assert_kind_of Test::Unit::TestResult, blackboard.take_result
+  end
+
+  test "puts passing and failing tests on blackboard for each test" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_test TestFactory.passing_test
+    blackboard.write_test TestFactory.failing_test
+
+    DeepTest::Worker.new(blackboard).run
+
+    result_1 = blackboard.take_result
+    result_2 = blackboard.take_result
+
+    assert_equal true, (result_1.passed? || result_2.passed?)
+    assert_equal false, (result_1.passed? && result_2.passed?)
+  end
+  
+  test "capturing stdout" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_test TestFactory.passing_test_with_stdout
+    DeepTest::Worker.new(blackboard).run
+    result = blackboard.take_result
+    assert_equal "message printed to stdout", result.output
+  end
+  
+  test "retry on deadlock" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_test TestFactory.deadlock_once_test
+    DeepTest::Worker.new(blackboard).run
+    result = blackboard.take_result
+    assert_equal 0, result.error_count
+    assert_equal 0, result.failure_count
+    assert_equal 1, result.assertion_count
+  end
+  
+  test "skip on deadlock twice" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_test TestFactory.deadlock_always_test
+    DeepTest::Worker.new(blackboard).run
+    result = blackboard.take_result
+    assert_equal 0, result.error_count
+    assert_equal 0, result.failure_count
+    assert_equal 0, result.assertion_count
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.3
+specification_version: 1
+name: deep_test
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-09-04 00:00:00 -04:00
+summary: DeepTest runs tests in multiple processes.
+require_paths: 
+- lib
+email: daniel.manges@gmail.com
+homepage: http://deep-test.rubyforge.org
+rubyforge_project: deep-test
+description: DeepTest runs tests in multiple processes.
+autorequire: deep_test
+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: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- anonymous z, Dan Manges, David Vollbracht
+files: 
+- lib/deep_test.rb
+- lib/deep_test/loader.rb
+- lib/deep_test/rake_tasks.rb
+- lib/deep_test/rinda_blackboard.rb
+- lib/deep_test/server.rb
+- lib/deep_test/simple_test_blackboard.rb
+- lib/deep_test/start_workers.rb
+- lib/deep_test/supervised_test_suite.rb
+- lib/deep_test/supervisor.rb
+- lib/deep_test/test_task.rb
+- lib/deep_test/worker.rb
+- lib/deep_test/extensions/error.rb
+- lib/deep_test/extensions/object_extension.rb
+- lib/deep_test/extensions/testresult.rb
+- lib/deep_test/tasks/rinda.rake
+- test/simple_test_blackboard_test.rb
+- test/supervised_test_suite_test.rb
+- test/supervisor_test.rb
+- test/test_helper.rb
+- test/test_task_test.rb
+- test/testresult_test.rb
+- test/worker_test.rb
+- test/deep_test/loader_test.rb
+- CHANGELOG
+- README
+- Rakefile
+test_files: []
+
+rdoc_options: 
+- --title
+- DeepTest
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- CHANGELOG
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.7
+    version: