jason-o-matic-deep_test 1.2.2.1

data/test/deep_test/distributed/test_server_workers_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "number_of_workers is determined by mirror server options" do
+    workers = DeepTest::Distributed::TestServerWorkers.new(
+      DeepTest::Options.new({}),
+      {:number_of_workers => 4},
+      mock
+    )
+
+    assert_equal 4, workers.number_of_workers
+  end
+
+  test "server is retrieved using client connection information" do
+    workers = DeepTest::Distributed::TestServerWorkers.new(
+      options = DeepTest::Options.new({}),
+      {:number_of_workers => 4},
+      mock(:address => "address")
+    )
+    DeepTest::Server.expects(:remote_reference).
+      with("address", options.server_port).
+      returns(:server_reference)
+
+    assert_equal :server_reference, workers.server
+  end
+end

data/test/deep_test/distributed/throughput_runner_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "runner adds specified number of work units to blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    runner = DeepTest::Distributed::ThroughputRunner.new(
+      DeepTest::Options.new({}),
+      5,
+      blackboard
+    )
+
+    worker = ThreadWorker.new(blackboard, 5)
+    Timeout.timeout(5) do
+      runner.process_work_units
+    end
+    worker.wait_until_done
+  end
+
+  test "runner yields all results from blackboard" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    count = 0
+    runner = DeepTest::Distributed::ThroughputRunner.new(
+      DeepTest::Options.new({}),
+      2,
+      blackboard
+    ) do |result|
+      assert_equal :null_work_unit_result, result
+      count += 1
+    end
+
+    worker = ThreadWorker.new(blackboard, 2)
+    Timeout.timeout(5) do
+      runner.process_work_units
+    end
+    worker.wait_until_done
+
+    assert_equal 2, count
+  end
+
+  test "statistics are available after run" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    runner = DeepTest::Distributed::ThroughputRunner.new(
+      DeepTest::Options.new({}),
+      2,
+      blackboard
+    )
+
+    worker = ThreadWorker.new(blackboard, 2)
+    count = 0
+    Timeout.timeout(5) do
+      runner.process_work_units
+    end
+    worker.wait_until_done
+
+    assert_kind_of DeepTest::Distributed::ThroughputStatistics,
+                   runner.statistics
+  end
+
+  test "runner returns true" do
+    runner = DeepTest::Distributed::ThroughputRunner.new(
+      DeepTest::Options.new({}),
+      0,
+      DeepTest::SimpleTestBlackboard.new 
+    )
+
+    assert_equal true, runner.process_work_units
+  end
+end

data/test/deep_test/distributed/throughput_worker_client_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "start_all starts workers on a new worker server" do
+    client = DeepTest::Distributed::ThroughputWorkerClient.new(
+      options = DeepTest::Options.new({}),
+      test_server = stub_everything
+    )
+
+    test_server.expects(:spawn_worker_server).with(options).
+      returns(worker_server = stub_everything)
+
+    worker_server.expects(:start_all)
+    client.start_all
+  end
+
+  test "stop_all stops workers on worker server that was spawned in start_all" do
+    worker_server = stub_everything
+    client = DeepTest::Distributed::ThroughputWorkerClient.new(
+      DeepTest::Options.new({}),
+      test_server = stub_everything(:spawn_worker_server => worker_server)
+    )
+
+    client.start_all
+    worker_server.expects(:stop_all)
+    client.stop_all
+  end
+end

data/test/deep_test/extensions/object_extension_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "retrying once" do
+    object = Object.new
+    object.expects(:call_it_twice).times(2).raises(RuntimeError).then.returns(:ok)
+    result = nil
+    capture_stdout do
+      result = retrying do
+        object.call_it_twice
+      end
+    end
+    assert_equal :ok, result
+  end
+  
+  test "retrying defaults to 5 times" do
+    object = Object.new
+    object.expects(:may_i_please_have_another).times(5).
+      raises(RuntimeError).raises(RuntimeError).raises(RuntimeError).raises(RuntimeError).returns("ok")
+    capture_stdout do
+      retrying do
+        object.may_i_please_have_another
+      end
+    end
+  end
+  
+  test "retrying raises exception if still failing after number of attempts" do
+    my_error = Class.new(StandardError)
+    assert_raises(my_error) do
+      capture_stdout do
+        retrying "", 1 do
+          raise my_error
+        end
+      end
+    end
+  end
+end

data/test/deep_test/listener_list_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "forwards methods defined in NullWorkerListener to all listeners" do
+    listener_1, listener_2 = mock, mock
+    list = DeepTest::ListenerList.new([listener_1, listener_2])
+    listener_1.expects(:starting).with(:worker)
+    listener_2.expects(:starting).with(:worker)
+    listener_1.expects(:starting_work).with(:worker, :work)
+    listener_2.expects(:starting_work).with(:worker, :work)
+    list.starting(:worker)
+    list.starting_work(:worker, :work)
+  end
+
+  test "doesn't forward methods not defined in NullWorkerListener" do
+    listener = mock
+    listener.expects(:to_s).never
+    DeepTest::ListenerList.new([listener]).to_s
+  end
+end

data/test/deep_test/local_workers_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "number_of_workers is determined by options" do
+    workers = DeepTest::LocalWorkers.new(
+      DeepTest::Options.new(:number_of_workers => 4)
+    )
+
+    assert_equal 4, workers.number_of_workers
+  end
+
+  test "load_files simply loads each file provided" do
+    workers = DeepTest::LocalWorkers.new(
+      DeepTest::Options.new(:number_of_workers => 4)
+    )
+
+    workers.expects(:load).with(:file_1)
+    workers.expects(:load).with(:file_2)
+
+    workers.load_files([:file_1, :file_2])
+  end
+end

data/test/deep_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 "[DeepTest] my_msg\n", DeepTest.logger.formatter.call(nil, nil, nil, "my_msg")
+  end
+end

data/test/deep_test/marshallable_exception_wrapper_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+unit_tests do
+  test "loading a marshallable exception evals the classname and returns an instance of the original exception" do
+    original = RuntimeError.new "message"
+    original.set_backtrace ['1', '2']
+
+    marshalled = DeepTest::MarshallableExceptionWrapper.new(original)
+    DeepTest::MarshallableExceptionWrapper.any_instance.expects(:eval).
+      with("::RuntimeError").returns(RuntimeError)
+
+    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+
+    assert_equal original.class,     loaded.class
+    assert_equal original.message,   loaded.message
+    assert_equal original.backtrace, loaded.backtrace
+  end
+
+  test "loading a marshallable exception when class is not available returns an instance of unloadable exception" do
+    original = RuntimeError.new "message"
+    original.set_backtrace ['1', '2']
+
+    marshalled = DeepTest::MarshallableExceptionWrapper.new(original)
+    DeepTest::MarshallableExceptionWrapper.any_instance.expects(:eval).
+      raises("Eval Error")
+
+    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+
+    assert_equal DeepTest::UnloadableException, loaded.class
+    assert_equal "RuntimeError: " + original.message,   loaded.message
+    assert_equal original.backtrace, loaded.backtrace
+  end
+
+  test "loading a marshallable exception when class init throws an error returns an unloadable exception" do
+    original = RuntimeError.new "message"
+
+    marshalled = DeepTest::MarshallableExceptionWrapper.new(original)
+    RuntimeError.expects(:new).raises(StandardError.new)
+
+    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+
+    assert_equal DeepTest::UnloadableException, loaded.class
+  end
+end

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

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+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
+    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 "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 "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 "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 "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
+
+  test "prints output if result has output" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_result mock(:output => "output", :identifier => 1)
+
+    out = capture_stdout do
+      DeepTest::ResultReader.new(blackboard).read(1 => "One") {}
+    end
+
+    assert_equal "output", out
+  end
+
+  test "doesn't print any output if output is nil" do
+    blackboard = DeepTest::SimpleTestBlackboard.new
+    blackboard.write_result mock(:output => nil, :identifier => 1)
+
+    out = capture_stdout do
+      DeepTest::ResultReader.new(blackboard).read(1 => "One") {}
+    end
+
+    assert_equal "", out
+  end
+
+  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
+      DeepTest::ResultReader.new(blackboard).read(1 => "One") {}
+    end
+
+    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
+      DeepTest::ResultReader.new(blackboard).read(1 => "One") {|r| results << r}
+    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
+    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"}
+
+    capture_stdout do
+      missing_work_units = DeepTest::ResultReader.new(blackboard).read(work_units) {} 
+      assert_equal({2 => "Two"}, missing_work_units)
+    end
+  end
+end