jason-o-matic-deep_test 1.2.2.1

data/test/deep_test/server_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "take_work returns result of push_work when it is available" do
+    server = DeepTest::Server.new(DeepTest::Options.new({}))
+    server.write_work :work
+    assert_equal :work, server.take_work
+  end
+
+  test "take_work raises error when no work is currently available" do
+    assert_raises(DeepTest::Server::NoWorkUnitsAvailableError) do
+      DeepTest::Server.new(DeepTest::Options.new({})).take_work
+    end
+  end
+
+  test "take_work raises error when there is no work left to" do
+    server = DeepTest::Server.new(DeepTest::Options.new({}))
+    server.done_with_work
+
+    assert_raises(DeepTest::Server::NoWorkUnitsRemainingError) do
+      server.take_work
+    end
+  end
+
+  test "take_result returns result of push_result when it is available" do
+    server = DeepTest::Server.new(DeepTest::Options.new({}))
+    t = Thread.new {server.take_result}
+    server.write_result :result
+    assert_equal :result, t.value
+  end
+
+  test "take_result timeouts out after configurable number of seconds" do
+    server = DeepTest::Server.new(
+      DeepTest::Options.new(:timeout_in_seconds => 0.01)
+    )
+    Thread.new {sleep 0.1; server.write_result :too_late}
+    assert_raises(DeepTest::Server::ResultOverdueError) {server.take_result}
+  end
+
+  test "write_work returns nil" do
+    server = DeepTest::Server.new(DeepTest::Options.new({}))
+    assert_equal nil, server.write_work(:a)
+  end
+
+  test "write_result returns nil" do
+    server = DeepTest::Server.new(DeepTest::Options.new({}))
+    assert_equal nil, server.write_result(:a)
+  end
+
+  test "start returns instance of server" do
+    DRb.expects(:start_service)
+    DRb.expects(:uri)
+    DeepTest.logger.expects(:info)
+
+    server = DeepTest::Server.start(DeepTest::Options.new({}))
+    assert_kind_of DeepTest::Server, server
+  end
+end

data/test/deep_test/test/extensions/error_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + "/../../../test_helper"
+
+unit_tests do
+  test "make_exception_marshallable wraps exception in a mashallable exception" do
+    error = Test::Unit::Error.new "test_name", Exception.new("message")
+    error.make_exception_marshallable
+
+    assert_kind_of DeepTest::MarshallableExceptionWrapper, error.exception
+  end
+
+  test "calling make_exception_marshallable twice only wraps exception once" do
+    error = Test::Unit::Error.new "test_name", Exception.new("message")
+    error.make_exception_marshallable
+    error.make_exception_marshallable
+
+    assert_kind_of DeepTest::MarshallableExceptionWrapper, error.exception
+  end
+
+  test "error is accessible as normal when it has not been made marshallable" do
+    error = Test::Unit::Error.new "test_name", e = Exception.new("message")
+    assert_equal e, error.exception
+  end
+
+  test "resolve_marshallable_exception restores the original exception" do
+    error = Test::Unit::Error.new "test_name", Exception.new("message")
+    error.make_exception_marshallable
+    error.resolve_marshallable_exception
+
+    assert_kind_of Exception, error.exception
+    assert_equal   'message', error.exception.message
+  end
+
+  test "resolve_marshallable_exception does not fail when exception has not been made marshallable" do
+    error = Test::Unit::Error.new "test_name", Exception.new("message")
+    error.resolve_marshallable_exception
+
+    assert_kind_of Exception, error.exception
+    assert_equal   'message', error.exception.message
+  end
+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,79 @@
+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 "worker errors are counted as errors" do
+    test_case = Class.new(Test::Unit::TestCase) do
+      test("1") {}
+    end.new("test_1")
+
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case, blackboard)
+    result = Test::Unit::TestResult.new
+
+    blackboard.write_result DeepTest::Worker::Error.new(test_case, RuntimeError.new)
+    capture_stdout {supervised_suite.run(result) {}}
+
+    assert_equal 1, result.error_count
+  end
+
+  test "run yields test case finished events" do
+    test_case = Class.new(Test::Unit::TestCase) do
+      test("1") {}
+    end.new("test_1")
+
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case, 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, test_case.name])
+  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_result_test.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "add_to adds correct run_count" do
+    result_1 = DeepTest::Test::WorkResult.new "test_name"
+    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 = DeepTest::Test::WorkResult.new "test_name"
+    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 = DeepTest::Test::WorkResult.new "test_name"
+    result_1.add_error(e = Test::Unit::Error.new("test_name", Exception.new))
+
+    result_2 = Test::Unit::TestResult.new
+    result_1.add_to result_2
+
+    assert_equal [e], result_2.instance_variable_get(:@errors)
+  end
+
+
+  test "add_to adds correct failures" do
+    result_1 = DeepTest::Test::WorkResult.new "test_name"
+    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 "add_error wraps exceptions" do
+    result = DeepTest::Test::WorkResult.new "test_name"
+    result.add_error Test::Unit::Error.new(
+      "test_wraps_exceptions", 
+      SomeCustomException.new("the exception message")
+    )
+
+    error = result.instance_variable_get("@errors").last
+    assert_kind_of DeepTest::MarshallableExceptionWrapper, error.exception
+  end
+
+  test "add_to unwraps exception" do
+    work_result = DeepTest::Test::WorkResult.new "test_name"
+    work_result.add_error Test::Unit::Error.new(
+      "test_wraps_exceptions", 
+      SomeCustomException.new("the exception message")
+    )
+
+    test_result = ::Test::Unit::TestResult.new
+    work_result.add_to(test_result)
+
+    error = test_result.instance_variable_get("@errors").last
+    assert_kind_of SomeCustomException, error.exception
+  end
+  
+  test "failed due to deadlock" do
+    result = DeepTest::Test::WorkResult.new "test_name"
+    begin
+      raise FakeDeadlockError.new
+    rescue => ex
+      result.add_error Test::Unit::Error.new("test_", ex)
+    end
+    assert_equal true, result.failed_due_to_deadlock?
+  end
+end

data/test/deep_test/test/work_unit_test.rb

@@ -0,0 +1,61 @@
+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 result with identifier of test name" do
+    test = TestFactory.passing_test
+    work_unit = DeepTest::Test::WorkUnit.new test
+    assert_equal test.name, work_unit.run.identifier
+  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 "set test_name as identifier on deadlock" do
+    test = TestFactory.deadlock_always_test
+    work_unit = DeepTest::Test::WorkUnit.new test
+    assert_equal test.name, work_unit.run.identifier
+  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
+
+  test "to_s is delegated to test case" do
+    test_case = TestFactory.passing_test
+    assert_equal test_case.to_s, DeepTest::Test::WorkUnit.new(test_case).to_s
+  end
+end

data/test/deep_test/test_task_test.rb

@@ -0,0 +1,43 @@
+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 setting distributed_server" do
+    t = DeepTest::TestTask.new :deep_test do |t|
+      t.stubs(:desc)
+      t.stubs(:task)
+      t.distributed_server = "uri"
+    end
+    assert_equal "uri", t.instance_variable_get(:@options).distributed_server
+    assert_equal "uri", t.distributed_server
+  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
+
+  test "should support server_port" do
+    t = DeepTest::TestTask.new :deep_test do |t|
+      t.stubs(:desc)
+      t.stubs(:task)
+      t.server_port = 10
+    end
+    assert_equal 10, t.instance_variable_get(:@options).server_port
+    assert_equal 10, t.server_port
+  end
+end

data/test/deep_test/ui/console_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "dispatch_finished doesn't fail if spinner is nil" do
+    assert_nothing_raised do
+      DeepTest::UI::Console.new(:options).dispatch_finished(:method_name)
+    end
+  end
+end

data/test/deep_test/warlock_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+unit_tests do
+  test "running? is true if sending kill(0, pid) does not fail" do
+    warlock = DeepTest::Warlock.new
+    Process.expects(:kill).with(0, :pid)
+    assert_equal true, warlock.running?(:pid)
+  end
+  
+  test "running? is false if Process.kill(0, pid) raises Errno::ESRCH" do
+    warlock = DeepTest::Warlock.new
+    Process.stubs(:kill).raises(Errno::ESRCH)
+    assert_equal false, warlock.running?(:pid)
+  end
+  
+  test "running? is true if Process.kill raises Exception" do
+    warlock = DeepTest::Warlock.new
+    Process.stubs(:kill).raises(Exception)
+    assert_equal true, warlock.running?(:pid)
+  end
+
+  test "demon_count is 0 initially" do
+    assert_equal 0, DeepTest::Warlock.new.demon_count
+  end
+
+  test "add_demon increases demon_count by 1" do
+    warlock = DeepTest::Warlock.new
+    warlock.send(:add_demon, "name", 1)
+    assert_equal 1, warlock.demon_count
+  end
+
+  test "remove_demon increases demon_count by 1" do
+    warlock = DeepTest::Warlock.new
+    warlock.send(:add_demon, "name", 1)
+    warlock.send(:remove_demon, "name", 1)
+    assert_equal 0, warlock.demon_count
+  end
+end

data/test/deep_test/worker_test.rb

@@ -0,0 +1,94 @@
+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 "exception raised by work unit gives in Worker::Error" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    work_unit = mock
+    work_unit.expects(:run).raises(exception = RuntimeError.new)
+    blackboard.write_work work_unit
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).run
+    
+    assert_equal DeepTest::Worker::Error.new(work_unit, exception),
+                 blackboard.take_result
+  end
+
+  test "requests work until it finds some" do
+    blackboard = mock
+    blackboard.expects(:take_work).times(3).
+      raises(DeepTest::Server::NoWorkUnitsAvailableError).
+      returns(work_unit = mock(:run => nil)).
+      returns(nil)
+
+    blackboard.expects(:write_result)
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).run
+  end
+
+  test "finishes running when no more work units are remaining" do
+    blackboard = mock
+    blackboard.expects(:take_work).
+      raises(DeepTest::Server::NoWorkUnitsRemainingError)
+
+    DeepTest::Worker.new(0, blackboard, stub_everything).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