jstorimer-deep-test 1.4.0 → 2.0.0

data/test/deep_test/listener_list_test.rb

@@ -1,20 +1,22 @@
 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
+module DeepTest
+  unit_tests do
+    test "forwards methods defined in NullListener to all listeners" do
+      listener_1, listener_2 = mock, mock
+      list = ListenerList.new([listener_1, listener_2])
+      listener_1.expects(:starting).with(:agent)
+      listener_2.expects(:starting).with(:agent)
+      listener_1.expects(:starting_work).with(:agent, :work)
+      listener_2.expects(:starting_work).with(:agent, :work)
+      list.starting(:agent)
+      list.starting_work(:agent, :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
+    test "doesn't forward methods not defined in NullListener" do
+      listener = mock
+      listener.expects(:to_s).never
+      ListenerList.new([listener]).to_s
+    end
   end
 end

data/test/deep_test/local_deployment_test.rb

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

data/test/deep_test/logger_test.rb

@@ -1,11 +1,38 @@
 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")
+module DeepTest
+  unit_tests do
+    test "info log level by default" do
+      assert_equal Logger::INFO, DeepTest.logger.level
+    end
+    
+    test "formatter uses msg only" do
+      time = Time.parse("2009-09-22 12:01:33")
+      assert_equal "[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 my_msg\n", DeepTest.logger.formatter.call(nil, time, nil, "my_msg")
+    end
+
+    Logger::Severity.constants.each do |severity|
+      test "#{severity.downcase} can not be called with any arguments" do
+        logger = Logger.new stub_everything
+        assert_raises(ArgumentError) { logger.send severity.downcase, "a"  }
+      end
+
+      THE_DATE = '\d{4}-\d\d-\d\d \d\d:\d\d:\d\d' unless defined?(THE_DATE)
+
+      test "#{severity.downcase} can be called with a block" do
+        logger = Logger.new(out = StringIO.new)
+        logger.level = Logger.const_get(severity)
+        logger.send(severity.downcase) { "a" }
+        assert_match /\[DeepTest@#{Socket.gethostname}\] #{THE_DATE} a\n/, out.string
+      end
+
+      test "#{severity.downcase} rescues errors from block and logs them" do
+        logger = Logger.new(out = StringIO.new)
+        logger.level = Logger.const_get(severity)
+        logger.send(severity.downcase) { raise Exception, "e" }
+        assert_match /\[DeepTest@#{Socket.gethostname}\] #{THE_DATE} Exception: e occurred logging on #{__FILE__}:#{__LINE__ - 1}:in `send'\n/,
+                    out.string
+      end
+    end
   end
 end

data/test/deep_test/main_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "shutdown calls done_with_work" do
+      main = Main.new(nil, stub_everything, nil, central_command = mock)
+      central_command.expects(:done_with_work)
+
+      main.shutdown
+    end
+  end
+end

data/test/deep_test/marshallable_exception_wrapper_test.rb

@@ -1,44 +1,46 @@
 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']
+module DeepTest
+  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)
+      marshalled = MarshallableExceptionWrapper.new(original)
+      MarshallableExceptionWrapper.any_instance.expects(:eval).
+        with("::RuntimeError").returns(RuntimeError)
 
-    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+      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
+      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']
+    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")
+      marshalled = MarshallableExceptionWrapper.new(original)
+      MarshallableExceptionWrapper.any_instance.expects(:eval).
+        raises("Eval Error")
 
-    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+      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
+      assert_equal 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"
+    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)
+      marshalled = MarshallableExceptionWrapper.new(original)
+      RuntimeError.expects(:new).raises(StandardError.new)
 
-    loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
 
-    assert_equal DeepTest::UnloadableException, loaded.class
+      assert_equal UnloadableException, loaded.class
+    end
   end
 end

data/test/deep_test/metrics/data_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Metrics
+    class DataTest < ::Test::Unit::TestCase
+      test "measurements are summarized in report" do
+        data = Data.new
+        data.add Measurement.new("category a", 1, "bytes")
+        data.add Measurement.new("category b", 2, "seconds")
+        data.add Measurement.new("category a", 2, "bytes")
+        data.add Measurement.new("category b", 3, "seconds")
+
+        assert_equal <<-end_text, data.summary
+Metrics Data
+------------
+category a: 1.5 avg / 3 total bytes
+category b: 2.5 avg / 5 total seconds
+        end_text
+      end
+    end
+  end
+end

data/test/deep_test/metrics/measurement_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Metrics
+    class MeasurementTest < ::Test::Unit::TestCase
+      test "of_time_taken should measure time an operation takes" do
+        measurement = Measurement.of_time_taken("category") do
+          sleep 0.5
+        end
+
+        assert_equal "category", measurement.category
+        assert_in_delta 0.5, measurement.value, 0.1
+        assert_equal "seconds", measurement.units
+      end
+    end
+  end
+end
+

data/test/deep_test/proxy_io_test.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "should write strings to proxy wire" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("my_string")
+      io.write "my_string"
+    end
+
+    test "should call to_s on any received objects" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("some value")
+      io.write mock(:to_s => "some value")
+    end
+
+    test "should clear string buffer after forwarding to wire" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("string 1")
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("string 2")
+      io.write "string 1"
+      io.write "string 2"
+    end
+
+    test "should forward flush to the wire" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with kind_of(ProxyIO::Stdout::Flush)
+      io.flush
+    end
+
+    test "Stdout::Output prints to stdout" do
+      output = ProxyIO::Stdout::Output.new("output")
+      assert_equal "output", capture_stdout { output.execute }
+    end
+
+    test "Stderr::Output prints to stdout" do
+      output = ProxyIO::Stderr::Output.new("output")
+      assert_equal "output", capture_stderr { output.execute }
+    end
+
+    test "Stdout::Flush prints to stdout" do
+      output = ProxyIO::Stdout::Flush.new
+      $stdout.expects :flush
+      output.execute
+    end
+
+    test "Stderr::Flush prints to stdout" do
+      output = ProxyIO::Stderr::Flush.new
+      $stderr.expects :flush
+      output.execute
+    end
+
+    test "replace_stdout_stderr! yields" do
+      yielded = false
+      ProxyIO.replace_stdout_stderr!(mock) { yielded = true }
+      assert yielded, "didn't yield"
+    end
+
+    test "will replace stdout with proxy to wire" do
+      ProxyIO.replace_stdout_stderr!(wire = mock) do
+        wire.expects(:send_message).with ProxyIO::Stdout::Output.new("global string")
+        wire.expects(:send_message).with ProxyIO::Stdout::Output.new("const string")
+        $stdout.write "global string"
+        STDOUT.write "const string"
+      end
+    end
+
+    test "will restore stdout after yielding" do
+      old_stdout_global, old_stdout_const = $stdout, STDOUT
+      ProxyIO.replace_stdout_stderr!(mock) { raise "error" } rescue nil
+      assert_equal old_stdout_global, $stdout
+      assert_equal old_stdout_const, STDOUT
+    end
+
+    test "will replace stderr with proxy to wire" do
+      ProxyIO.replace_stdout_stderr!(wire = mock) do
+        wire.expects(:send_message).with ProxyIO::Stderr::Output.new("global string")
+        wire.expects(:send_message).with ProxyIO::Stderr::Output.new("const string")
+        $stderr.write "global string"
+        STDERR.write "const string"
+      end
+    end
+
+    test "will restore stderr after yielding" do
+      old_stderr_global, old_stderr_const = $stderr, STDERR
+      ProxyIO.replace_stdout_stderr!(mock) { raise "error" } rescue nil
+      assert_equal old_stderr_global, $stderr
+      assert_equal old_stderr_const, STDERR
+    end
+
+    test "reconnect the logger to the new stdout" do
+      old_stderr_global, old_stderr_const = $stderr, STDERR
+      ProxyIO.replace_stdout_stderr!(mock) do 
+        assert_equal $stdout, DeepTest.logger.io_stream
+      end
+    end
+
+    test "supress warnings restores verbose" do
+      old_verbose = $VERBOSE
+      ProxyIO.supress_warnings { raise "error" } rescue nil
+      assert_equal old_verbose, $VERBOSE
+    end
+  end
+end

data/test/deep_test/result_reader_test.rb

@@ -1,128 +1,128 @@
 require File.dirname(__FILE__) + "/../test_helper"
 
-unit_tests do
+module DeepTest
+  unit_tests do
+    class FakeResult
+      attr_reader :identifier
+      def initialize(i) @identifier = i; end
+      def ==(other) identifier == other.identifier; end
+    end
 
-  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 "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 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 "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
+      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 "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
+      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 "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
+      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 "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
+      central_command = TestCentralCommand.start Options.new({})
+      central_command.write_result mock(:output => "output", :identifier => 1)
 
-  test "prints output if result has output" do
-    blackboard = DeepTest::SimpleTestBlackboard.new
-    blackboard.write_result mock(:output => "output", :identifier => 1)
+      out = capture_stdout do
+        ResultReader.new(central_command).read(1 => "One") {}
+      end
 
-    out = capture_stdout do
-      DeepTest::ResultReader.new(blackboard).read(1 => "One") {}
+      assert_equal "output", out
     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)
 
-  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
+        ResultReader.new(central_command).read(1 => "One") {}
+      end
 
-    out = capture_stdout do
-      DeepTest::ResultReader.new(blackboard).read(1 => "One") {}
+      assert_equal "", out
     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']
 
-  test "prints useful error information in case of Worker::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)
 
-    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
 
-    out = capture_stdout do
-      DeepTest::ResultReader.new(blackboard).read(1 => "One") {}
+      assert_equal "work_unit: message\na\nb\n", out
     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)
 
-  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
 
-    results = []
-    capture_stdout do
-      DeepTest::ResultReader.new(blackboard).read(1 => "One") {|r| results << r}
+      assert_equal [], results
     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 "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
-    blackboard = DeepTest::SimpleTestBlackboard.new
-    blackboard.write_result FakeResult.new(1)
-    blackboard.write_result DeepTest::Worker::Error.new("work_unit", RuntimeError.new)
+    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"}
+      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)
+      capture_stdout do
+        missing_work_units = ResultReader.new(central_command).read(work_units) {} 
+        assert_equal({2 => "Two"}, missing_work_units)
+      end
     end
   end
 end