jstorimer-deep-test 0.2.0 → 1.0.0

data/test/deep_test/metrics/gatherer_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "section uses block to add measurements when render is called" do
+    i = j = 0
+    section = DeepTest::Metrics::Gatherer::Section.new("my section") do |s|
+      s.measurement("i", i)
+      s.measurement("j", j)
+    end
+
+    i = 1
+    j = 2
+
+    rendered_string = section.render
+
+    assert_match /^i: 1$/, rendered_string
+    assert_match /^j: 2$/, rendered_string
+  end
+
+  test "section starts with title" do
+    section = DeepTest::Metrics::Gatherer::Section.new("my section") {|s|}
+    assert_equal "[my section]\n", section.render
+  end
+
+  test "gatherer renders all sections defined" do
+    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new(:metrics_file => "something"))
+    gatherer.section("section 1") {|s|}
+    gatherer.section("section 2") {|s|}
+
+    assert_equal "[section 1]\n\n[section 2]\n", gatherer.render
+  end
+
+  test "no sections are added if not gathering metrics" do
+    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new({}))
+    gatherer.section("section 1") {|s|}
+    gatherer.section("section 2") {|s|}
+
+    assert_equal "", gatherer.render
+  end
+
+  test "enabled? is true if metrics_file is specified" do
+    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new(:metrics_file => "something"))
+    assert_equal true, gatherer.enabled?
+  end
+
+  test "enabled? is false if metrics_file is not specified" do
+    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new({}))
+    assert_equal false, gatherer.enabled?
+  end
+
+  test "write_file writes rendered contents to metrics file" do
+    gatherer = DeepTest::Metrics::Gatherer.new(
+      DeepTest::Options.new(:metrics_file => "a_file")
+    )
+    gatherer.section("section 1") {|s|}
+    File.expects(:open).with("a_file", "w").yields(io = StringIO.new)
+    gatherer.write_file
+    assert_equal gatherer.render, io.string
+  end
+
+  test "write_file does nothing if not enabled" do
+    gatherer = DeepTest::Metrics::Gatherer.new(DeepTest::Options.new({}))
+    File.expects(:open).never
+    gatherer.write_file
+  end
+end

data/test/deep_test/process_orchestrator_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "shutdown calls done_with_work" do
+    orchestrator = DeepTest::ProcessOrchestrator.new(nil, stub_everything, nil)
+    server = mock
+    server.expects(:done_with_work)
+
+    orchestrator.shutdown(server)
+  end
+end

data/test/deep_test/result_reader_test.rb

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

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

@@ -1,42 +1,40 @@
 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
+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

@@ -1,11 +1,7 @@
 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
+unit_tests do
+  test "no filters constant has empty filters" do
+    assert_equal [], DeepTest::Test::Runner::NO_FILTERS.filters
   end
 end