deep_test 1.1.2 → 1.1.3

data/script/run_test_suite.rb

@@ -1,34 +1,5 @@
-number_of_workers, pattern = ARGV
-begin
-  require "deep_test"
-  warlock = DeepTest::Warlock.new
-  Signal.trap("HUP") { warlock.stop_all; exit 0 }
-  
-  Dir.glob(pattern).each { |file| load file }
-  Test::Unit.run = true
-  
-  # server
-  warlock.start "server" do
-    DeepTest::Server.start
-  end
-  sleep 0.25 # TODO: is this necessary?
-
-  # workers
-  number_of_workers.to_i.times do |i|
-    warlock.start "worker #{i}" do
-      srand # re-seed random numbers
-      ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
-      DeepTest::Worker.new.run
-    end
-  end
-
-  loader_pid = fork do
-    puts "Loader (#{$$})"
-    passed = DeepTest::Loader.run
-    exit(passed ? 0 : 1)
-  end
-  Process.wait(loader_pid)
-  exit($?.success? ? 0 : 1)
-ensure
-  warlock.stop_all if warlock
-end
+require File.dirname(__FILE__) + "/../lib/deep_test"
+options = DeepTest::Options.from_command_line(ARGV[0])
+runner = DeepTest::Test::Runner.new(options)
+runner.load_files
+DeepTest::ProcessOrchestrator.run(options, runner)

data/test/deep_test/rinda_blackboard_test.rb

@@ -2,14 +2,14 @@ require File.dirname(__FILE__) + '/../test_helper'
 
 unit_tests do
   test "take result waits 30 seconds before timing out" do
-    blackboard = DeepTest::RindaBlackboard.new(tuple_space = stub)
+    blackboard = DeepTest::RindaBlackboard.new(DeepTest::Options.new({}), tuple_space = stub)
     tuple_space.expects(:take).with(["test_result", nil], 30).returns([])
     blackboard.take_result
   end
 
   test "take test waits 30 seconds before timing out" do
-    blackboard = DeepTest::RindaBlackboard.new(tuple_space = stub)
-    tuple_space.expects(:take).with(["run_test", nil, nil], 30).returns([nil, "String", "foo"])
-    blackboard.take_test
+    blackboard = DeepTest::RindaBlackboard.new(DeepTest::Options.new({}), tuple_space = stub)
+    tuple_space.expects(:take).with(["deep_work", nil], 30).returns([nil, "String"])
+    blackboard.take_work
   end
-end
+end

data/test/{testresult_test.rb → deep_test/test/extensions/test_result_test.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + "/test_helper"
+require File.dirname(__FILE__) + "/../../../test_helper"
 
 unit_tests do
   test "add_to adds correct run_count" do
@@ -62,7 +62,7 @@ unit_tests do
   test "failed due to deadlock" do
     result = Test::Unit::TestResult.new
     begin
-      raise ActiveRecord::StatementInvalid.new("Deadlock found when trying to get lock")
+      raise FakeDeadlockError.new
     rescue => ex
       result.add_error Test::Unit::Error.new("test_", ex)
     end

data/test/deep_test/test/runner_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::Test::Runner::NO_FILTERS.filters
+  end
+end

data/test/deep_test/test/supervised_test_suite_test.rb

@@ -0,0 +1,89 @@
+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::Test::SupervisedTestSuite.new(suite, DeepTest::SimpleTestBlackboard.new)
+
+    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 tests to blackboard and reads results" do
+    test_case_class = Class.new(Test::Unit::TestCase) do
+      test("1") {}
+      test("2") {assert_equal true, false}
+    end
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case_class.suite, blackboard)
+    result = Test::Unit::TestResult.new
+
+    worker = ThreadWorker.new(blackboard, 2)
+    Timeout.timeout(5) do
+      supervised_suite.run(result) {}
+    end
+    worker.wait_until_done
+
+    assert_equal 2, result.run_count
+    assert_equal 1, result.failure_count
+  end
+
+  test "run yields test case finished events" do
+    test_case_class = Class.new(Test::Unit::TestCase) do
+      test("1") {}
+    end
+
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case_class.suite, blackboard)
+
+    yielded = []
+
+    worker = ThreadWorker.new(blackboard, 1)
+    Timeout.timeout(5) do
+      supervised_suite.run(stub_everything) do |channel,name|
+        yielded << [channel, name]
+      end
+    end
+    worker.wait_until_done
+
+    assert_equal true, yielded.include?([::Test::Unit::TestCase::FINISHED, nil])
+  end
+
+  test "prints output if any" do
+    test_case_class = Class.new(Test::Unit::TestCase) do
+      test("1") {puts "hello"}
+    end
+
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case_class.suite, blackboard)
+
+    worker = ThreadWorker.new(blackboard, 1)
+    class <<supervised_suite
+      def print(string)
+        output << string
+      end
+
+      def output
+        @output ||= ""
+      end
+    end
+    Timeout.timeout(5) do
+      supervised_suite.run(stub_everything) {}
+    end
+    worker.wait_until_done
+    assert_equal "hello\n", supervised_suite.output
+  end
+
+  test "has same size as underlying suite" do
+    suite = Test::Unit::TestSuite.new("name")
+    suite << "test"
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, DeepTest::SimpleTestBlackboard.new)
+    
+    assert_equal suite.size, supervised_suite.size
+  end
+end

data/test/deep_test/test/work_unit_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "returns passed result for passing test" do
+    work_unit = DeepTest::Test::WorkUnit.new TestFactory.passing_test
+    assert_equal true, work_unit.run.passed?
+  end
+
+  test "returns failed result for failing test" do
+    work_unit = DeepTest::Test::WorkUnit.new TestFactory.failing_test
+    assert_equal false, work_unit.run.passed?
+  end
+
+  test "returns passed result correctly after being loaded from yaml" do
+    work_unit = DeepTest::Test::WorkUnit.new TestFactory.passing_test
+    work_unit_from_yaml = YAML.load(work_unit.to_yaml)
+    assert_equal true, work_unit_from_yaml.run.passed?
+  end
+
+  test "capturing stdout" do
+    work_unit = DeepTest::Test::WorkUnit.new TestFactory.passing_test_with_stdout
+    assert_equal "message printed to stdout", work_unit.run.output
+  end
+  
+  test "retry on deadlock" do
+    work_unit = DeepTest::Test::WorkUnit.new TestFactory.deadlock_once_test
+    result = work_unit.run
+    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
+    work_unit = DeepTest::Test::WorkUnit.new TestFactory.deadlock_always_test
+    result = work_unit.run
+    assert_equal 0, result.error_count
+    assert_equal 0, result.failure_count
+    assert_equal 0, result.assertion_count
+  end
+
+  test "equality is based on test_case" do
+    test_case_1 = TestFactory.passing_test
+    test_case_2 = TestFactory.failing_test
+    assert_equal DeepTest::Test::WorkUnit.new(test_case_1),
+                 DeepTest::Test::WorkUnit.new(test_case_1)
+
+    assert_not_equal DeepTest::Test::WorkUnit.new(test_case_1),
+                     DeepTest::Test::WorkUnit.new(test_case_2)
+  end
+end

data/test/deep_test/test_task_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+unit_tests do
+  test "should support setting timeout_in_seconds" do
+    t = DeepTest::TestTask.new :deep_test do |t|
+      t.stubs(:desc)
+      t.stubs(:task)
+      t.timeout_in_seconds = 20
+    end
+    assert_equal 20, t.instance_variable_get(:@options).timeout_in_seconds
+    assert_equal 20, t.timeout_in_seconds
+  end
+
+  test "should support worker_listener" do
+    t = DeepTest::TestTask.new :deep_test do |t|
+      t.stubs(:desc)
+      t.stubs(:task)
+      t.worker_listener = "A"
+    end
+    assert_equal "A", t.instance_variable_get(:@options).worker_listener
+    assert_equal "A", t.worker_listener
+  end
+end

data/test/deep_test/worker_test.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "puts result on blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_work DeepTest::Test::WorkUnit.new(TestFactory.passing_test)
+
+    DeepTest::Worker.new(0, blackboard,stub_everything).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_work DeepTest::Test::WorkUnit.new(TestFactory.passing_test)
+    blackboard.write_work DeepTest::Test::WorkUnit.new(TestFactory.failing_test)
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).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 "notifies listener that it is starting" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    listener = stub_everything
+    worker = DeepTest::Worker.new(0, blackboard, listener)
+    listener.expects(:starting).with(worker)
+    worker.run
+  end
+
+  test "notifies listener that it is about to do work" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    work_unit = DeepTest::Test::WorkUnit.new(TestFactory.passing_test)
+    blackboard.write_work work_unit
+    listener = stub_everything
+    worker = DeepTest::Worker.new(0, blackboard, listener)
+    listener.expects(:starting_work).with(worker, work_unit)
+    worker.run
+  end
+
+  test "notifies listener that it has done work" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    work_unit = mock(:run => :result)
+    blackboard.write_work work_unit
+    listener = stub_everything
+    worker = DeepTest::Worker.new(0, blackboard, listener)
+    listener.expects(:finished_work).with(worker, work_unit, :result)
+    worker.run
+  end
+
+  test "number is available to indentify worker" do
+    assert_equal 1, DeepTest::Worker.new(1, nil, nil).number
+  end
+  
+  test "does not fork from rake" do
+    assert !defined?($rakefile)
+  end
+end

data/test/failing.rake

@@ -0,0 +1,11 @@
+require 'rake'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "deep_test"
+require "deep_test/rake_tasks"
+
+task :default => %w[deep_test_failing]
+
+DeepTest::TestTask.new :deep_test_failing do |t|
+  t.number_of_workers = 1
+  t.pattern = "test/failing.rb"
+end

data/test/fake_deadlock_error.rb

@@ -0,0 +1,12 @@
+unless defined?(ActiveRecord::StatementInvalid)
+  module ActiveRecord
+    class StatementInvalid < StandardError
+    end
+  end
+end
+
+class FakeDeadlockError
+  def self.new
+    ActiveRecord::StatementInvalid.new("Deadlock found when trying to get lock")
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+unit_tests do
+  test "info log level by default" do
+    assert_equal Logger::INFO, DeepTest.logger.level
+  end
+  
+  test "formatter uses msg only" do
+    assert_equal "my_msg\n", DeepTest.logger.formatter.call(nil, nil, nil, "my_msg")
+  end
+end

data/test/simple_test_blackboard.rb

@@ -0,0 +1,44 @@
+module DeepTest
+  class SimpleTestBlackboard
+    attr_accessor :debug
+
+    def initialize
+      @work_units = []
+      @test_results = []
+      @semaphore = Mutex.new
+    end
+
+    def take_result
+      @semaphore.synchronize do
+        log_and_return "take_result", @test_results.shift
+      end
+    end
+
+    def take_work
+      @semaphore.synchronize do
+        log_and_return "take_work", @work_units.shift
+      end
+    end
+
+    def write_result(result)
+      @semaphore.synchronize do
+        log_and_return "write_result", result
+        @test_results.push result
+      end
+    end
+
+    def write_work(work_unit)
+      @semaphore.synchronize do
+        log_and_return "write_work", work_unit
+        @work_units.push work_unit
+      end
+    end
+
+    def log_and_return(message, object)
+      if debug && object
+        puts "* #{message} #{object.inspect}"
+      end
+      object
+    end
+  end
+end

data/test/simple_test_blackboard_test.rb

@@ -4,16 +4,16 @@ 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
+    blackboard.write_work test_case
+    assert_equal test_case, blackboard.take_work
   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
+    blackboard.write_work test_case
+    blackboard.take_work
+    assert_nil blackboard.take_work
   end
 
   test "a result that is put on can be taken off later" do

data/test/test_factory.rb

@@ -0,0 +1,74 @@
+module TestFactory
+  def self.failing_test
+    test_class do
+      def test_failing
+        assert_equal 1, 0
+      end
+    end.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 do
+      def test_passing
+        assert_equal 0, 0
+      end
+    end.new(:test_passing)
+  end
+  
+  def self.passing_test_with_stdout
+    test_class do
+      def test_passing_with_stdout
+        print "message printed to stdout"
+        assert true
+      end
+    end.new :test_passing_with_stdout
+  end
+  
+  def self.deadlock_once_test
+    test_class do
+      def test_deadlock_once
+        if @deadlocked
+          assert true
+        else
+          @deadlocked = true
+          raise FakeDeadlockError.new
+        end
+      end
+    end.new :test_deadlock_once
+  end
+  
+  def self.deadlock_always_test
+    test_class do
+      def test_deadlock_always
+        raise FakeDeadlockError.new
+      end
+    end.new :test_deadlock_always
+  end
+
+  def self.suite
+    Test::Unit::TestSuite.new
+  end
+
+  def self.test_class(&block)
+    test_class = Class.new(Test::Unit::TestCase)
+
+    class_name = external_caller.upcase.gsub(/[^A-Z0-9]/,"_").sub(/^_*/,'')
+    const_set(class_name, test_class)
+
+    test_class.class_eval &block
+    test_class
+  end
+
+  def self.external_caller
+    caller.each do |trace_line|
+      return trace_line unless trace_line =~ /test_factory.rb/
+    end
+  end
+end