deep_test_pre 2.0

data/test/deep_test/result_reader_test.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    class FakeResult
+      attr_reader :identifier
+      def initialize(i) @identifier = i; end
+      def ==(other) identifier == other.identifier; end
+    end
+
+    test "reads all as many results as requested" do
+      central_command = TestCentralCommand.start Options.new({})
+      1.upto(4) {|i| central_command.write_result FakeResult.new(i)}
+      work_units = {1 => "One", 2 => "Two", 3 => "Three"}
+      ResultReader.new(central_command).read(work_units) {}
+      assert_equal FakeResult.new(4), central_command.take_result
+    end
+
+    test "returns unread tests on NoAgentsRunningError" do
+      central_command = TestCentralCommand.start Options.new({})
+      work_units = {1 => "One"}
+      FailureMessage.expects(:show)
+      ResultReader.new(central_command).read(work_units) {}
+      assert_equal({1 => "One"}, work_units)
+    end
+
+    test "yields each result" do
+      central_command = TestCentralCommand.start Options.new({})
+      1.upto(3) {|i| central_command.write_result FakeResult.new(i)}
+      results = []
+      work_units = {1 => "One", 2 => "Two", 3 => "Three"}
+      ResultReader.new(central_command).read(work_units) {|r| results << r}
+      assert_equal [["One", FakeResult.new(1)], 
+                    ["Two", FakeResult.new(2)],
+                    ["Three", FakeResult.new(3)]], 
+                   results
+    end
+
+    test "keeps attempting to read results when none are available" do
+      central_command = TestCentralCommand.start Options.new({})
+      work_units = {1 => "One", 2 => "Two", 3 => "Three"}
+      t = Thread.new {ResultReader.new(central_command).read(work_units) {}}
+      1.upto(4) {|i| central_command.write_result FakeResult.new(i)}
+      t.join
+      assert_equal FakeResult.new(4), central_command.take_result
+    end
+
+    test "doesn't yield empty results" do
+      central_command = TestCentralCommand.start Options.new({})
+      results = []
+      t = Thread.new {ResultReader.new(central_command).read(1 => "One") {|r| results << r}}
+      central_command.write_result FakeResult.new(1)
+      t.join
+      assert_equal [["One", FakeResult.new(1)]], results
+    end
+
+    test "prints output if result has output" do
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result mock(:output => "output", :identifier => 1)
+
+      out = capture_stdout do
+        ResultReader.new(central_command).read(1 => "One") {}
+      end
+
+      assert_equal "output", out
+    end
+
+    test "doesn't print any output if output is nil" do
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result mock(:output => nil, :identifier => 1)
+
+      out = capture_stdout do
+        ResultReader.new(central_command).read(1 => "One") {}
+      end
+
+      assert_equal "", out
+    end
+
+    test "prints useful error information in case of Agent::Error" do
+      error = RuntimeError.new "message"
+      error.set_backtrace ['a', 'b']
+
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result Agent::Error.new("work_unit", error)
+
+
+      out = capture_stdout do
+        ResultReader.new(central_command).read(1 => "One") {}
+      end
+
+      assert_equal "work_unit: message\na\nb\n", out
+    end
+
+    test "doesn't yield Agent::Error results" do
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result Agent::Error.new("work_unit", RuntimeError.new)
+
+
+      results = []
+      capture_stdout do
+        ResultReader.new(central_command).read(1 => "One") {|r| results << r}
+      end
+
+      assert_equal [], results
+    end
+
+    test "doesn't modify original work unit hash" do
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result FakeResult.new(1)
+      work_units = {1 => "One"}
+      ResultReader.new(central_command).read(work_units) {} 
+      assert_equal({1 => "One"}, work_units)
+    end
+
+    test "returns remaining tests that didn't have errors" do
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result FakeResult.new(1)
+      central_command.write_result Agent::Error.new("work_unit", RuntimeError.new)
+
+      work_units = {1 => "One", 2 => "Two"}
+
+      capture_stdout do
+        missing_work_units = ResultReader.new(central_command).read(work_units) {} 
+        assert_equal({2 => "Two"}, missing_work_units)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + "/../../../test_helper"
+
+module DeepTest
+  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 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 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
+end

data/test/deep_test/test/runner_test.rb

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

data/test/deep_test/test/supervised_test_suite_test.rb

@@ -0,0 +1,107 @@
+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
+
+        central_command = TestCentralCommand.start options
+        supervised_suite = SupervisedTestSuite.new(AgentErrorTestCase.suite, central_command)
+        result = ::Test::Unit::TestResult.new
+
+        central_command.write_result Agent::Error.new(AgentErrorTestCase.new("test_1"), RuntimeError.new)
+        capture_stdout {supervised_suite.run(result) {}}
+
+        assert_equal 1, result.error_count
+      end
+
+      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
+
+        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) {}}
+
+        assert_equal 1, result.error_count
+      end
+
+      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")
+
+        central_command = TestCentralCommand.start options
+        supervised_suite = SupervisedTestSuite.new(test_case, central_command)
+
+        yielded = []
+
+        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
+
+        assert_equal true, yielded.include?([::Test::Unit::TestCase::FINISHED, test_case.name])
+      end
+
+      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
+      end
+    end
+  end
+end

data/test/deep_test/test/work_result_test.rb

@@ -0,0 +1,85 @@
+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
+    end
+  end
+end

data/test/deep_test/test/work_unit_test.rb

@@ -0,0 +1,63 @@
+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
+
+      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 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 "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 "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)
+
+        assert_not_equal WorkUnit.new(test_case_1), 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
+  end
+end

data/test/deep_test/test_task_test.rb

@@ -0,0 +1,15 @@
+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
+    end
+  end
+end