jstorimer-deep-test 1.4.0 → 2.0.0

data/lib/deep_test/server.rb

@@ -1,75 +0,0 @@
-module DeepTest
-  class Server
-    def self.start(options)
-      server = new(options)
-      DRb.start_service("druby://0.0.0.0:#{options.server_port}", server)
-      DeepTest.logger.info "Started DeepTest service at #{DRb.uri}"
-      server
-    end
-
-    def self.stop
-      DRb.stop_service
-    end
-
-    def self.remote_reference(address, port)
-      DRb.start_service
-      blackboard = DRbObject.new_with_uri("druby://#{address}:#{port}")
-      DeepTest.logger.debug "Connecting to DeepTest server at #{blackboard.__drburi}"
-      blackboard
-    end
-
-    def initialize(options)
-      @options = options
-      @work_queue = Queue.new
-      @result_queue = Queue.new
-
-      if Metrics::Gatherer.enabled?
-        require File.dirname(__FILE__) + "/metrics/queue_lock_wait_time_measurement"
-        @work_queue.extend Metrics::QueueLockWaitTimeMeasurement
-        @result_queue.extend Metrics::QueueLockWaitTimeMeasurement
-        Metrics::Gatherer.section("server queue lock wait times") do |s|
-          s.measurement("work queue total pop wait time", @work_queue.total_pop_time)
-          s.measurement("work queue total push wait time", @work_queue.total_push_time)
-          s.measurement("result queue total pop wait time", @result_queue.total_pop_time)
-          s.measurement("result queue total push wait time", @result_queue.total_push_time)
-        end
-      end
-    end
-
-    def done_with_work
-      @done_with_work = true
-    end
-
-    def take_result
-      Timeout.timeout(@options.timeout_in_seconds, ResultOverdueError) do
-        @result_queue.pop
-      end
-    end
-
-    def take_work
-      raise NoWorkUnitsRemainingError if @done_with_work
-
-      @work_queue.pop(true)
-    rescue ThreadError => e
-      if e.message == "queue empty"
-        raise NoWorkUnitsAvailableError
-      else
-        raise
-      end
-    end
-
-    def write_result(result)
-      @result_queue.push result
-      nil
-    end
-
-    def write_work(work_unit)
-      @work_queue.push work_unit
-      nil
-    end
-
-    class NoWorkUnitsAvailableError < StandardError; end
-    class NoWorkUnitsRemainingError < StandardError; end
-    class ResultOverdueError < StandardError; end
-  end
-end

data/lib/deep_test/spec/extensions/reporter.rb

@@ -1,29 +0,0 @@
-require 'spec/runner/reporter'
-module Spec
-  module Runner
-    class Reporter
-      def example_finished(example, error=nil)
-        @examples << example
-        
-        if error.nil?
-          example_passed(example)
-        elsif Spec::Example::ExamplePendingError === error
-          example_pending(example, error.message)
-        else
-          example_failed(example, error)
-        end
-      end
-
-      def failure(example, error)
-        backtrace_tweaker.tweak_backtrace(error)
-        example_name = "#{example.class.description} #{example.description}"
-        failure = Failure.new(example, error)
-        @failures << failure
-        formatters.each do |f|
-          f.example_failed(example, @failures.length, failure)
-        end
-      end
-      alias_method :example_failed, :failure
-    end
-  end
-end

data/lib/deep_test/worker.rb

@@ -1,57 +0,0 @@
-module DeepTest
-  class Worker
-    attr_reader :number
-
-    def initialize(number, blackboard, worker_listener)
-      @number = number
-      @blackboard = blackboard
-      @listener = worker_listener
-    end
-
-    def run
-      @listener.starting(self)
-      while work_unit = next_work_unit
-        @listener.starting_work(self, work_unit)
-
-        result = begin
-                   work_unit.run
-                 rescue Exception => error
-                   Error.new(work_unit, error)
-                 end
-
-        @listener.finished_work(self, work_unit, result)
-        @blackboard.write_result result
-        if ENV['DEEP_TEST_SHOW_WORKER_DOTS'] == 'yes'
-          $stdout.print '.'
-          $stdout.flush
-        end
-      end
-    rescue Server::NoWorkUnitsRemainingError
-      DeepTest.logger.debug("Worker #{number}: no more work to do")
-    end
-
-    def next_work_unit
-      @blackboard.take_work
-    rescue Server::NoWorkUnitsAvailableError
-      sleep 0.02
-      retry
-    end
-
-    class Error
-      attr_accessor :work_unit, :error
-
-      def initialize(work_unit, error)
-        @work_unit, @error = work_unit, error
-      end
-
-      def ==(other)
-        work_unit == other.work_unit &&
-            error == other.error
-      end
-
-      def to_s
-        "#{@work_unit}: #{@error}\n" + (@error.backtrace || []).join("\n")
-      end
-    end
-  end
-end

data/script/internal/run_test_suite.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + "/../../lib/deep_test"
-options = DeepTest::Options.from_command_line(ARGV[0])
-DeepTest.init(options)
-runner = DeepTest::Test::Runner.new(options)
-workers = options.new_workers
-workers.load_files Dir.glob(options.pattern)
-DeepTest::ProcessOrchestrator.run(options, workers, runner)

data/script/public/master_test_server.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + "/../../lib/deep_test"
-require 'drb/drb'
-require 'optparse'
-
-uri = "drubyall://:4021"
-slave_uris = OptionParser.new do |opts|
-  opts.banner = "Usage: deep_test master_test_server [options] <test_server_uris>"
-
-  opts.on("--uri URI", "DRb URI to bind server to") do |v|
-    uri = v
-  end
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-end.parse(ARGV)
-
-begin
-  DeepTest::Distributed::MasterTestServer.start(uri, slave_uris)
-rescue Interrupt
-  DeepTest.logger.info "Exiting due to Interrupt"
-end
-

data/script/public/test_server.rb

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

@@ -1,29 +0,0 @@
-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/spec/deep_test/option_spec.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper"
-
-module DeepTest
-  describe Option do
-    it "should have hash conversion" do
-      option = Option.new(:name, Option::Hash, {})
-      string = option.to_command_line({:a => "1", :b => "a"})
-      string.should be_instance_of(String)
-      option.from_command_line(string).should == {:a => "1", :b => "a"}
-    end
-
-    it "should support booleans in hash" do
-      option = Option.new(:name, Option::Hash, {})
-      string = option.to_command_line({:a => true})
-      string.should be_instance_of(String)
-      option.from_command_line(string).should == {:a => true}
-    end
-
-    it "should handle hash values with spaces" do
-      option = Option.new(:name, Option::Hash, {})
-
-      string = option.to_command_line(
-        {:a => "has a space", :b => "has more spaces"}
-      )
-
-      string.should be_instance_of(String)
-
-      option.from_command_line(string).should == 
-        {:a => "has a space", :b => "has more spaces"}
-    end
-  end
-end
-

data/spec/thread_worker.rb

@@ -1,25 +0,0 @@
-class ThreadWorker
-  attr_reader :work_done
-
-  def initialize(blackboard, expected_work)
-    @blackboard, @expected_work = blackboard, expected_work
-    @thread = Thread.new {run}
-  end
-
-  def wait_until_done
-    Timeout.timeout(5) {@thread.join}
-    @thread.kill if @thread.alive?
-  end
-
-  def run
-    @work_done = 0
-    until @work_done >= @expected_work
-      Thread.pass
-      work = @blackboard.take_work
-      if work
-        @blackboard.write_result work.run 
-        @work_done += 1
-      end
-    end
-  end
-end

data/test/deep_test/distributed/drb_client_connection_info_test.rb

@@ -1,42 +0,0 @@
-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/master_test_server_test.rb

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

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