jason-o-matic-deep_test 1.2.2.1

data/script/public/test_server.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + "/../../lib/deep_test"
+require 'drb/drb'
+require 'optparse'
+
+config = DeepTest::Distributed::TestServer.parse_args(ARGV)
+
+#
+# Clear args so they won't be processed in any forked processes.
+#    - When specs are loaded by the RemoteWorkerServer, RSpec
+#      attempts to parse ARGV
+#
+ARGV.clear
+
+begin
+  DeepTest::Distributed::TestServer.start(config)
+rescue Interrupt
+  DeepTest.logger.info "Exiting due to Interrupt"
+end

data/script/public/test_throughput.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../lib/deep_test'
+
+unless ARGV.length == 2
+  puts "Usage: deep_test test_throughput <server uri> <test_count>"
+  exit(1)
+end
+
+uri        = ARGV[0]
+test_count = ARGV[1].to_i
+
+options = DeepTest::Options.new(:distributed_server => uri,
+                                :sync_options => {:source => ""})
+server  = DeepTest::Distributed::TestServer.connect options
+workers = DeepTest::Distributed::ThroughputWorkerClient.new(options, server)
+runner  = DeepTest::Distributed::ThroughputRunner.new(options, test_count) do |result|
+  $stdout.print "."
+  $stdout.flush
+end
+
+start_time = Time.now
+DeepTest::ProcessOrchestrator.new(options, workers, runner).run(false)
+end_time = Time.now
+
+puts
+puts runner.statistics.summary
+
+run_time = end_time.to_f - start_time.to_f
+puts "Total Run Time: #{run_time} seconds"
+puts "Run Time Not Spent On Tests: #{run_time - runner.statistics.timespan_in_seconds}"

data/test/deep_test/database/mysql_setup_listener_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "dump_schema includes procedures" do
+    listener = DeepTest::Database::MysqlSetupListener.new
+    listener.expects(:system).with do |command|
+      command =~ / -R /
+    end
+    listener.expects(:master_database_config).returns({})
+    listener.expects(:dump_file_name).returns("")
+    $?.expects(:success?).returns(true)
+    listener.dump_schema
+  end
+end

data/test/deep_test/distributed/dispatch_controller_test.rb

@@ -0,0 +1,209 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "dispatch invokes each receiver once" do
+    receiver_1, receiver_2 = mock, mock
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}), 
+      [receiver_1, receiver_2]
+    )
+
+    receiver_1.expects(:a_method).with(:args)
+    receiver_2.expects(:a_method).with(:args)
+
+    controller.dispatch(:a_method, :args)
+  end
+
+  test "dispatch returns array of all results" do
+    receiver_1, receiver_2 = mock, mock
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}), 
+      [receiver_1, receiver_2]
+    )
+
+    receiver_1.expects(:a_method).returns(:result_1)
+    receiver_2.expects(:a_method).returns(:result_2)
+
+    results = controller.dispatch(:a_method)
+    assert_equal 2, results.size
+    assert_equal [:result_1, :result_2].to_set, results.to_set
+  end
+
+  test "dispatch calls all receivers in parallel" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    waiter = Waiter.new(tracker = Tracker.new)
+
+    Timeout.timeout(1) do
+      DeepTest::Distributed::DispatchController.new(options,[tracker, waiter]).
+        dispatch(:tracked_method)
+    end
+
+    waiter = Waiter.new(tracker = Tracker.new)
+
+    Timeout.timeout(1) do
+      DeepTest::Distributed::DispatchController.new(options,[waiter, tracker]).
+        dispatch(:tracked_method)
+    end
+  end
+
+  test "dispatch omits results that are taking too long" do
+    receiver = Object.new
+    def receiver.__drburi; ""; end
+    def receiver.sleep_100_millis
+      sleep 0.1
+    end
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver]
+    )
+
+    DeepTest.logger.expects(:error)
+
+    assert_equal [], controller.dispatch(:sleep_100_millis)
+  end
+
+  test "after timeout, no further calls are sent to that receiver" do
+    receiver_1, receiver_2 = mock(:__drburi => ""), mock
+    receiver_1.expects(:method_call_1).raises(Timeout::Error.new("message"))
+    receiver_1.expects(:method_call_2).never
+
+    receiver_2.expects(:method_call_1)
+    receiver_2.expects(:method_call_2)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1, receiver_2]
+    )
+
+    DeepTest.logger.expects(:error)
+    
+    controller.dispatch(:method_call_1)
+    controller.dispatch(:method_call_2)
+  end
+
+  test "receiver is dropped when connection is refused" do
+    receiver_1, receiver_2 = mock(:__drburi => ""), mock
+    receiver_1.expects(:method_call_1).raises(DRb::DRbConnError)
+    receiver_1.expects(:method_call_2).never
+
+    receiver_2.expects(:method_call_1).returns(:value)
+    receiver_2.expects(:method_call_2)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1, receiver_2]
+    )
+
+    DeepTest.logger.expects(:error)
+    
+    assert_equal [:value], controller.dispatch(:method_call_1)
+
+    controller.dispatch(:method_call_2)
+  end
+  
+  test "receiver is dropped when any exception occurs" do
+    receiver = mock(:__drburi => "")
+    receiver.expects(:method_call).raises(Exception)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver]
+    )
+
+    DeepTest.logger.expects(:error)
+    
+    controller.dispatch(:method_call)
+    assert_raises(DeepTest::Distributed::NoDispatchReceiversError) {controller.dispatch(:another_call)}
+  end
+
+  test "no error is printed if dispatching without error" do
+    receiver_1 =  mock
+    receiver_1.expects(:method_call_1).raises(DRb::DRbConnError)
+
+    controller = DeepTest::Distributed::DispatchController.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null", :timeout_in_seconds => 0.05}),
+      [receiver_1]
+    )
+
+    DeepTest.logger.expects(:error).never
+
+    controller.dispatch_with_options(:method_call_1, :ignore_connection_error => true)
+  end
+
+  test "dispatch calls notifies ui of start and stop of dispatch" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    controller = DeepTest::Distributed::DispatchController.new(
+      options, [stub_everything]
+    )
+
+    options.ui_instance.expects(:dispatch_starting).with(:method_name)
+    options.ui_instance.expects(:dispatch_finished).with(:method_name)
+    
+    controller.dispatch(:method_name)
+  end
+
+  test "dispatch calls notifies ui dispatch end in case of an error" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    controller = DeepTest::Distributed::DispatchController.new(
+      options, [receiver = mock(:__drburi => '')]
+    )
+    receiver.expects(:method_name).raises("An Error")
+    DeepTest.logger.expects(:error)
+    
+    options.ui_instance.expects(:dispatch_starting).with(:method_name)
+    options.ui_instance.expects(:dispatch_finished).with(:method_name)
+    
+    begin
+      controller.dispatch(:method_name)
+    rescue RuntimeError => e
+      raise unless e.message == "An Error"
+    end
+  end
+
+  test "error is raised if dispatch to no receivers in attempted" do
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+    controller = DeepTest::Distributed::DispatchController.new(
+      options, []
+    )
+
+    assert_raises(DeepTest::Distributed::NoDispatchReceiversError) do
+      controller.dispatch(:any_method)
+    end
+  end
+
+  class Tracker
+    def initialize
+      @mutex = Mutex.new
+      @condvar = ConditionVariable.new
+    end
+
+    def tracked_method 
+      @mutex.synchronize do
+        @tracked_method_called = true
+        @condvar.broadcast
+      end
+    end
+
+    def wait_for_tracked_method
+      @mutex.synchronize do
+        loop do
+          return if @tracked_method_called
+          @condvar.wait(@mutex)
+        end
+      end
+    end
+  end
+
+  class Waiter
+    def initialize(tracker)
+      @tracker = tracker
+    end
+
+    def tracked_method
+      @tracker.wait_for_tracked_method
+    end
+  end
+end

data/test/deep_test/distributed/drb_client_connection_info_test.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "returns ipaddress from peeraddr as address" do
+    info = Thread.current['DRb']
+    begin
+      Thread.current['DRb'] = {
+        'client' => mock(:peeraddr => [nil, nil, nil, "ip"])
+      }
+
+      info = DeepTest::Distributed::DRbClientConnectionInfo.new
+    ensure
+      Thread.current['DRb'] = info
+    end
+
+    assert_equal "ip", info.address
+  end
+
+  test "raises an error if no drb client is found" do
+    info = Thread.current['DRb']
+    begin
+      Thread.current['DRb'] = {}
+      assert_raises(RuntimeError) do
+        DeepTest::Distributed::DRbClientConnectionInfo.new
+      end
+    ensure
+      Thread.current['DRb'] = info
+    end
+  end
+
+  test "raises an error if no drb info is found" do
+    info = Thread.current['DRb']
+    begin
+      Thread.current['DRb'] = nil
+      assert_raises(RuntimeError) do
+        DeepTest::Distributed::DRbClientConnectionInfo.new
+      end
+    ensure
+      Thread.current['DRb'] = info
+    end
+  end
+end

data/test/deep_test/distributed/filename_resolver_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "should strip off directories until file exists in base path" do
+    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+
+    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
+    File.expects(:exist?).with("base_path/b/c/d.rb").returns(false)
+    File.expects(:exist?).with("base_path/c/d.rb").returns(true)
+
+    assert_equal "base_path/c/d.rb", resolver.resolve("/a/b/c/d.rb")
+  end
+
+  test "should resolve relative names starting at first element" do
+    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+
+    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(true)
+
+    assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
+  end
+
+  test "should resolve relative names the same each time" do
+    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+
+    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(true)
+
+    assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
+    assert_equal "base_path/a/b/c/d.rb", resolver.resolve("a/b/c/d.rb")
+  end
+
+  test "should raise exception if filename can't be resolved" do
+    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+
+    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
+    File.expects(:exist?).with("base_path/b/c/d.rb").returns(false)
+    File.expects(:exist?).with("base_path/c/d.rb").returns(false)
+    File.expects(:exist?).with("base_path/d.rb").returns(false)
+
+    assert_raises(RuntimeError) { resolver.resolve("/a/b/c/d.rb") }
+  end
+
+  test "should remember how many directories to strip off after first resolution" do
+    resolver = DeepTest::Distributed::FilenameResolver.new("base_path")
+
+    File.expects(:exist?).with("base_path/a/b/c/d.rb").returns(false)
+    File.expects(:exist?).with("base_path/b/c/d.rb").returns(true)
+    
+    resolver.resolve("/a/b/c/d.rb")
+
+    assert_equal "base_path/x/y/z.rb", resolver.resolve("/a/x/y/z.rb")
+  end
+end

data/test/deep_test/distributed/master_test_server_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "show_status renders status of all servers as html" do
+    status = DeepTest::Distributed::TestServerStatus.new(
+      "binding_uri", 
+      5,
+      3
+    )
+
+    test_server = mock(:__drburi => "drburi_1", :status => status) 
+    server = DeepTest::Distributed::MasterTestServer.new([test_server])
+    res = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+    server.show_status(:req, res)
+
+    assert_match "<td>binding_uri</td>", res.body
+    assert_match "<td>5</td>", res.body
+    assert_match "<td>3</td>", res.body
+  end
+
+  test "show_status display error message if exception occurs" do
+    test_server = mock(:__drburi => "drburi_1")
+    test_server.expects(:status).raises("An Error")
+
+    server = DeepTest::Distributed::MasterTestServer.new([test_server])
+
+    res = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+    server.show_status(:req, res)
+
+    assert_match /<td.*?>An Error<\/td>/, res.body
+  end
+end

data/test/deep_test/distributed/multi_test_server_proxy_test.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "sync is invoked on all servers" do
+    server_1, server_2 = mock, mock
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+
+    master = DeepTest::Distributed::MultiTestServerProxy.new(options, [server_1, server_2])
+
+    server_1.expects(:sync).with(options)
+    server_2.expects(:sync).with(options)
+
+    master.sync(options)
+  end
+
+  test "spawn_worker_server is invoked on all server" do
+    server_1, server_2 = mock, mock
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+
+    master = DeepTest::Distributed::MultiTestServerProxy.new(options, [server_1, server_2])
+
+    server_1.expects(:spawn_worker_server).with(options)
+    server_2.expects(:spawn_worker_server).with(options)
+
+    master.spawn_worker_server(options)
+  end
+
+  test "spawn_worker_server returns WorkerServerProxy with each worker" do
+    server_1 = mock(:spawn_worker_server => :worker_server_1)
+    server_2 = mock(:spawn_worker_server => :worker_server_2)
+    options = DeepTest::Options.new({:ui => "DeepTest::UI::Null"})
+
+    master = DeepTest::Distributed::MultiTestServerProxy.new(options, [server_1, server_2])
+
+    DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.
+      expects(:new).with(options, [:worker_server_1, :worker_server_2])
+
+    master.spawn_worker_server(options)
+  end
+
+  test "WorkerServerProxy dispatches start_all" do
+    server_1, server_2 = mock, mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1, server_2]
+    )
+
+    server_1.expects(:start_all)
+    server_2.expects(:start_all)
+
+    master.start_all
+  end
+
+  test "WorkerServerProxy dispatches stop_all" do
+    server_1, server_2 = mock, mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1, server_2]
+    )
+
+    server_1.expects(:stop_all)
+    server_2.expects(:stop_all)
+
+    master.stop_all
+  end
+
+  test "WorkerServerProxy stop_all ignores connection errors" do
+    server_1 = mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1]
+    )
+
+    server_1.expects(:__drburi).never
+    server_1.expects(:stop_all).raises(DRb::DRbConnError)
+
+    master.stop_all
+  end
+
+  test "WorkerServerProxy dispatches load_files" do
+    server_1, server_2 = mock, mock
+
+    master = DeepTest::Distributed::MultiTestServerProxy::WorkerServerProxy.new(
+      DeepTest::Options.new({:ui => "DeepTest::UI::Null"}),
+      [server_1, server_2]
+    )
+
+    server_1.expects(:load_files).with(:filelist)
+    server_2.expects(:load_files).with(:filelist)
+
+    master.load_files :filelist
+  end
+end