jstorimer-deep-test 0.2.0 → 1.0.0

data/test/deep_test/test/supervised_test_suite_test.rb

@@ -1,107 +1,79 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module Test
-    unit_tests do
-      test "run yields name for start and finished of underlying suite" do
-        options = Options.new({})
-        suite = ::Test::Unit::TestSuite.new("name")
-        supervised_suite = SupervisedTestSuite.new(suite, TestCentralCommand.start(options))
-
-        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 central_command and reads results" do
-        options = Options.new({})
-        class AddTestsTestCase < ::Test::Unit::TestCase
-          test("1") {}
-          test("2") {assert_equal true, false}
-        end
-        central_command = TestCentralCommand.start options
-        supervised_suite = SupervisedTestSuite.new(AddTestsTestCase.suite, central_command)
-        result = ::Test::Unit::TestResult.new
-
-        agent = ThreadAgent.new options
-        Timeout.timeout(5) do
-          supervised_suite.run(result) {}
-        end
-        central_command.done_with_work
-        agent.wait_until_done
-
-        assert_equal 2, result.run_count
-        assert_equal 1, result.failure_count
-      end
-
-      test "agent errors are counted as errors" do
-        options = Options.new({})
-        class AgentErrorTestCase < ::Test::Unit::TestCase
-          test("1") {}
-        end
+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
 
-        central_command = TestCentralCommand.start options
-        supervised_suite = SupervisedTestSuite.new(AgentErrorTestCase.suite, central_command)
-        result = ::Test::Unit::TestResult.new
+    assert_equal [[Test::Unit::TestSuite::STARTED, "name"],
+                  [Test::Unit::TestSuite::FINISHED, "name"]], yielded
+  end
 
-        central_command.write_result Agent::Error.new(AgentErrorTestCase.new("test_1"), RuntimeError.new)
-        capture_stdout {supervised_suite.run(result) {}}
+  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
 
-        assert_equal 1, result.error_count
-      end
+    worker = ThreadWorker.new(blackboard, 2)
+    Timeout.timeout(5) do
+      supervised_suite.run(result) {}
+    end
+    worker.wait_until_done
 
-      test "multiple agent errors are consolidated to be one error" do
-        options = Options.new({})
-        class MultipleAgentErrorTestCase < ::Test::Unit::TestCase
-          test("1") {}; test("2") {}
-        end
-        central_command = TestCentralCommand.start options
-        supervised_suite = SupervisedTestSuite.new(MultipleAgentErrorTestCase.suite, central_command)
-        result = ::Test::Unit::TestResult.new
+    assert_equal 2, result.run_count
+    assert_equal 1, result.failure_count
+  end
 
-        central_command.write_result Agent::Error.new(MultipleAgentErrorTestCase.new("test_1"), RuntimeError.new)
-        central_command.write_result Agent::Error.new(MultipleAgentErrorTestCase.new("test_2"), RuntimeError.new)
-        capture_stdout {supervised_suite.run(result) {}}
+  test "worker errors are counted as errors" do
+    test_case = Class.new(Test::Unit::TestCase) do
+      test("1") {}
+    end.new("test_1")
 
-        assert_equal 1, result.error_count
-      end
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case, blackboard)
+    result = Test::Unit::TestResult.new
 
-      test "run yields test case finished events" do
-        options = Options.new({})
-        class RunYieldsTestCase < ::Test::Unit::TestCase
-          test("1") {}
-        end
-        test_case = RunYieldsTestCase.new("test_1")
+    blackboard.write_result DeepTest::Worker::Error.new(test_case, RuntimeError.new)
+    capture_stdout {supervised_suite.run(result) {}}
 
-        central_command = TestCentralCommand.start options
-        supervised_suite = SupervisedTestSuite.new(test_case, central_command)
+    assert_equal 1, result.error_count
+  end
 
-        yielded = []
+  test "run yields test case finished events" do
+    test_case = Class.new(Test::Unit::TestCase) do
+      test("1") {}
+    end.new("test_1")
 
-        agent = ThreadAgent.new options
-        Timeout.timeout(5) do
-          supervised_suite.run(stub_everything) do |channel,name|
-            yielded << [channel, name]
-          end
-        end
-        central_command.done_with_work
-        agent.wait_until_done
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    supervised_suite = DeepTest::Test::SupervisedTestSuite.new(test_case, blackboard)
 
-        assert_equal true, yielded.include?([::Test::Unit::TestCase::FINISHED, test_case.name])
-      end
+    yielded = []
 
-      test "has same size as underlying suite" do
-        options = Options.new({})
-        suite = ::Test::Unit::TestSuite.new("name")
-        suite << "test"
-        supervised_suite = SupervisedTestSuite.new(suite, TestCentralCommand.start(options))
-        
-        assert_equal suite.size, supervised_suite.size
+    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

@@ -1,85 +1,81 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module Test
-    unit_tests do
-      test "add_to adds correct run_count" do
-        result_1 = 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 = 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 = 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 = 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 = 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 MarshallableExceptionWrapper, error.exception
-      end
-
-      test "add_to unwraps exception" do
-        work_result = 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 = 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
+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

@@ -1,63 +1,61 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-module DeepTest
-  module Test
-    unit_tests do
-      test "returns passed result for passing test" do
-        work_unit = WorkUnit.new TestFactory.passing_test
-        assert_equal true, work_unit.run.passed?
-      end
+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 = WorkUnit.new TestFactory.failing_test
-        assert_equal false, 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 = WorkUnit.new test
-        assert_equal test.name, work_unit.run.identifier
-      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 = 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 = 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 = 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 = 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 WorkUnit.new(test_case_1), WorkUnit.new(test_case_1)
+  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 WorkUnit.new(test_case_1), WorkUnit.new(test_case_2)
-      end
+    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, WorkUnit.new(test_case).to_s
-      end
-    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

@@ -1,15 +1,43 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
-module DeepTest
-  unit_tests do
-    test "should support listener" do
-      t = TestTask.new :deep_test do |t|
-        t.stubs(:desc)
-        t.stubs(:task)
-        t.listener = "A"
-      end
-      assert_equal "A", t.instance_variable_get(:@options).listener
-      assert_equal "A", t.listener
+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