DTR 0.0.1

data/lib/dtr/drb_dtr.rb

@@ -0,0 +1,275 @@
+require 'drb/acl'
+require 'drb'
+require 'dtr/base'
+require 'dtr/ruby_ext'
+
+module DTR
+  class DRbObjectWrapper
+    def initialize(uri)
+      @uri = uri
+    end
+    
+    def method_missing(method, *args, &block)
+      (@drbo ||= DRbObject.new_with_uri(@uri)).send(method, *args, &block)
+    rescue DRb::DRbConnError => e
+      logger.info { "DRb #{@uri} is not alive!" }
+      nil
+    end
+  end
+  
+  class OriginalTestReports
+    def summary_of(report)
+      reports << report
+      convert_to_str(report.successes, '.') + convert_to_str(report.failures, 'F') + convert_to_str(report.errors, 'E')
+    end
+    
+    def reports
+      @reports ||= []
+    end
+    
+    def failures_and_errors
+      collect(reports.collect{|r|r.stdout})
+    end
+    
+    private
+    def convert_to_str(size, status_char)
+      return '' if size == 0
+      Array.new(size).fill(status_char).join
+    end
+    
+    def collect(stdouts)
+      test_errors = []
+      stdouts.each do |stdout|
+        stdout.gsub(/^\s+\d+\) Error:\n(.*:\n.*\n[\s\S]*?\n)\n/) do
+          test_errors << "  #{test_errors.size + 1}) Error:\n" + $1
+        end
+      end
+
+      test_failures = []
+      stdouts.each do |stdout|
+        stdout.gsub(/^\s+\d+\) Failure:\n([\S\s]*?\n)\n/) do
+          test_failures << "  #{test_errors.size + test_failures.size + 1}) Failure:\n" + $1
+        end
+      end
+      
+      if test_errors.empty?
+        test_failures.join("\n")
+      else
+        test_errors.join("\n") + "\n" + test_failures.join("\n")
+      end
+    end
+  end
+  
+  class DrbTestRunnerServer
+    
+    def initialize(my_uri, test_files, clients)
+      logger.info {'Initializing DTR server...'}
+      @server = Server.new(test_files)
+
+      clients.each do |uri|
+        @server.add_client DRbObjectWrapper.new(uri)
+        logger.info {"Added DTR client at #{uri}"}
+      end
+
+      DRb.install_acl clients.to_acl
+      logger.info { "Installed acl: #{clients.to_acl_list.join(', ')}" }
+
+      @my_uri = my_uri
+      @original_output_model = DTROPTIONS[:output_model] == :original
+
+      @progress_bar = unless @original_output_model
+        begin
+          require 'rubygems'
+          require 'progressbar'
+          ProgressBar.new("Completed", test_files.size)
+        rescue Exception => e
+          logger.info { "Progressbar gem is not installed or could not be loaded. " }
+          logger.info { e }
+          @original_output_model = true
+          original_output { "Progressbar gem is not installed or could not be loaded(got error: #{e.message}).\nTurn on original output model." }
+          NullObj.new
+        end
+      else
+        NullObj.new
+      end
+
+      @original_reports = @original_output_model ? OriginalTestReports.new : NullObj.new
+    end
+
+    def start(run_setup=false)
+      $SAFE = 1   # disable eval() and friends
+      logger.info {'Starting server...'}
+      DRb.start_service(@my_uri, self)
+      logger.info { "=> DTR server started on #{@my_uri}"}
+      original_output { "Loaded suites: #{@server.test_files.join(', ')}\n" }
+      output "Started\n"
+      begin
+        begin
+          @server.run :setup => run_setup
+        rescue Server::NoAliveClientsError => e
+          logger.info { e }
+        end
+
+        logger.debug { reports.to_yaml }
+        logger.info { '' }
+        @server.latest_build_summary.split("\n").each do |msg|
+          logger.info { msg }
+        end
+
+        logger.info { "Run tests completed #{succeeded? ? 'SUCCEEDED' : 'FAILED'}" }
+        original_output { "\n" }
+        original_output { "\n#{@original_reports.failures_and_errors}" }
+        output "\n#{@server.latest_build_summary}\n"
+      ensure
+        DRb.stop_service
+      end
+    end
+
+    def succeeded?
+      @server.succeeded?
+    end
+
+    def reports
+      @server.reports
+    end
+
+    def server_signature
+      @server.server_signature
+    end
+
+    def update_setup_log(signature, report)
+      if report[:exit_code] == 0
+        logger.debug {"updating setup report: #{report.to_yaml}"}
+      else
+        logger.info { report.to_yaml }
+      end
+      @server.update_setup_log(signature, report)
+    end
+
+    def update(signature, report)
+      original_output {@original_reports.summary_of report}
+      if report.succeeded?
+        logger.debug {"updating report: #{report.to_yaml}"}
+      else
+        logger.info { report.to_yaml }
+        
+        output report.stdout unless @original_output_model
+      end
+      
+      result = @server.update(signature, report)
+      @progress_bar.set reports.size
+      result
+    end
+
+    private
+    def original_output
+      if @original_output_model
+        output yield
+      end
+    end
+    
+    def output(msg)
+      $stdout.print msg
+      $stdout.flush
+    end
+  end
+
+  class DrbTestRunnerClientServer
+
+    def initialize(my_uri, server_uri)
+      @my_uri = my_uri
+      @server_uri = server_uri
+      @run_setup_signature = nil
+      @client_name = DTROPTIONS[:client_name]
+    end
+    
+    def name
+      @client_name
+    end
+
+    def queue
+      @queue ||= []
+    end
+
+    def idle?
+      queue.empty?
+    end
+
+    def setup(signature)
+      logger.info {"request setup"}
+      @run_setup_signature = signature
+    end
+
+    def run(runner_name, test_files, signature)
+      unless test_files.nil? || test_files.empty?
+        queue << [runner_name, test_files, signature]
+      else
+        logger.info { "Error: argument test_files is #{test_files.nil? ? 'nil' : 'empty'}!"}
+      end
+    end
+
+    def server_signature
+      drbServer.server_signature
+    end
+
+    def start
+      $SAFE = 1   # disable eval() and friends
+      access_uris = [@server_uri]
+      DRb.install_acl access_uris.to_acl
+      logger.info { "Installed acl: #{access_uris.to_acl_list.join(', ')}" }
+      DRb.start_service(@my_uri, self)
+      
+      begin
+        logger.info { "=> DTR client started on #{@my_uri}"}
+        logger.info { "=> OPTIONS: #{DTROPTIONS.to_yaml}"}
+        logger.info { "=> Ctrl-C to shutdown; call with --help for options" }
+
+        loop do
+          if @run_setup_signature
+            logger.info {"Setup"}
+            begin
+              result = dtrClient.setup(@run_setup_signature)
+              if result[:exit_code] != 0
+                logger.info { "SETUP FAILED: #{result.inspect}" }
+                puts "SETUP FAILED: #{result.inspect}"
+                break 
+              end
+            rescue Exception => e
+              logger.error { e }
+            end
+            @run_setup_signature = nil
+            logger.info {"Sleeping..."}
+          end
+          unless queue.empty?
+            logger.info {"Working..."}
+            logger.debug {queue.first.to_yaml}
+            begin
+              dtrClient.run(*queue.first.dup)
+            rescue Exception => e
+              logger.error { e }
+            end
+            queue.pop
+            logger.info {"Sleeping..."}
+          end
+  
+          begin
+            sleep(1)
+          rescue Interrupt => e
+            break # Ctrl-C to shutdown
+          end
+        end
+      ensure
+        DRb.stop_service
+      end
+    end
+
+    private
+    def dtrClient
+      Client.new(drbServer, @client_name)
+    end
+
+    def drbServer
+      @drbServer ||= DRbObjectWrapper.new(@server_uri)
+    end
+  end
+end

data/lib/dtr/ruby_ext.rb

@@ -0,0 +1,27 @@
+
+class Array
+  DEFAULT_ACL = %w(deny all)
+  def to_acl_list
+    self << "druby://localhost"
+    self << "druby://127.0.0.1"
+    addresses = self.collect do |uri|
+      if /^druby:\/\/([^:]+):?\d*$/ =~ uri
+        $1
+      end
+    end.compact.uniq
+    acl_list = addresses.inject([]) do |result, address|
+      result << 'allow'
+      result << address
+      result
+    end
+  end
+
+  def to_acl
+    ACL.new(DEFAULT_ACL + to_acl_list)
+  end
+end
+
+class NullObj
+  def method_missing(*args)
+  end
+end

data/lib/dtr.rb

@@ -0,0 +1,88 @@
+require "dtr/drb_dtr"
+require "fileutils"
+require "logger"
+
+DTRVERSION="0.0.1"
+DTROPTIONS = {
+  #dtr client
+  :client_name => "client(#{Time.now})",
+  :setup => "rake db:test:prepare",
+  :port => "3344",
+  :server_uri => "druby://localhost:1314",
+  #dtr server
+  :server_port => "1314",
+  :wait_a_moment => 5,
+  :output_model => :log,
+  :raise_on_no_alive_client => false,
+  #both
+  :tmp_dir => "tmp/dtr",
+  :log_level => Logger::INFO
+}
+
+unless defined?(logger)
+  def logger
+    return $logger if defined?($logger) && $logger
+    DTR.ensure_temp_dir_exist
+    $logger = DTROPTIONS[:output_model] == :stdout ? Logger.new(STDOUT) : Logger.new("#{DTROPTIONS[:tmp_dir]}/runtime.log", 2, 1024000)
+    $logger.level = DTROPTIONS[:log_level]
+    $logger
+  end
+end
+
+module DTR
+
+  def start_client_server(my_port=DTROPTIONS[:port], server_uri=DTROPTIONS[:server_uri])
+    my_uri = "druby://:" << my_port
+
+    DTROPTIONS[:tmp_dir] = DTROPTIONS[:tmp_dir] + '/' + DTROPTIONS[:client_name].gsub(/[^\d\w]+/, '_')
+    logger.info { "Initializing client server at '#{my_uri}'..." }
+    logger.info { "Working dir: #{Dir.pwd}" }
+    logger.info { "Listening server at '#{server_uri}'..." }
+    ensure_temp_dir_exist
+    server = DrbTestRunnerClientServer.new my_uri, server_uri
+    server.start
+  end
+
+  def run(tests, clients, opts={})
+    opts =  {:my_uri => "druby://:#{DTROPTIONS[:server_port]}", :run_setup_before_start => false}.merge(opts)
+    server = DrbTestRunnerServer.new opts[:my_uri], tests, clients
+    server.start opts[:run_setup_before_start]
+    server.succeeded?
+  end
+
+  def ensure_temp_dir_exist
+    raise "Tmp dir(#{DTROPTIONS[:tmp_dir]}) is a file!" if File.file?(DTROPTIONS[:tmp_dir])
+    unless File.exist?(DTROPTIONS[:tmp_dir])
+      FileUtils.makedirs(DTROPTIONS[:tmp_dir])
+    end
+  end
+
+  module_function :start_client_server, :run, :ensure_temp_dir_exist
+
+  class ClientServer
+    @@servers = []
+    
+    def self.stop_all
+      logger.info { "client servers: #{@@servers.join(", ")}" }
+      @@servers.each do |server|
+        Process.kill "TERM", server
+        logger.info { "Killed #{server}" }
+      end
+    end
+    
+    def initialize(opts={})
+      @opts = DTROPTIONS.merge opts
+    end
+    
+    def start
+      @@servers << Process.fork do
+        DTROPTIONS.merge! @opts
+        trap("TERM") do
+          exit!
+        end
+        DTR.start_client_server
+      end
+    end
+  end
+  
+end

data/show_process_exit_code.bat

@@ -0,0 +1,5 @@
+call rake run_dtr_s
+echo "prog exit code [%errorlevel%]" 
+
+call rake run_dtr_f
+echo "prog exit code [%errorlevel%]" 

data/test/average_packer_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+
+class AveragePackerTest < Test::Unit::TestCase
+  def setup
+    @packer = DTR::AveragePacker.new
+  end
+  def test_pack
+    assert_raise RuntimeError do
+      @packer.pack([], 2)
+    end
+    
+    assert_raise RuntimeError do
+      @packer.pack(nil, 2)
+    end
+    
+    assert_equal [[1]], @packer.pack([1], 1)
+    
+    assert_equal [[1, 2]], @packer.pack([1, 2], 1)
+
+    assert_equal [[1], []], @packer.pack([1], 2)
+
+    assert_equal [['1'], []], @packer.pack(['1'], 2)
+
+    assert_equal [[1], [2]], @packer.pack([1, 2], 2)
+
+    assert_equal [[1, 3], [2]], @packer.pack([1, 2, 3], 2)
+    assert_equal [[1, 4], [2], [3]], @packer.pack([1, 2, 3, 4], 3)
+
+    assert_equal [[1, 4, 7], [2, 5, 8], [3, 6]], @packer.pack([1, 2, 3, 4, 5, 6, 7, 8], 3)
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,236 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class BaseTest < Test::Unit::TestCase
+
+  def setup
+    DTROPTIONS[:packing_once] = false
+    @server = DTR::Server.new
+    @client_num = 0
+    
+    NoResponseClient.server = @server
+  end
+
+  def test_run_test_successfully
+    @server.test_files = [new_successful_test_file]
+    @server.add_client new_client
+
+    assert_false @server.complete?
+    assert_false @server.succeeded?
+    @server.run
+    assert @server.complete?
+    assert @server.succeeded?
+
+    test_report = @server.reports[@server.test_files[0]]
+    assert_equal @server.clients.first.name, test_report.client_name
+    assert test_report.succeeded?
+    assert test_report.stdout.length > 0
+    assert test_report.stderr.length > 0
+  end
+
+  def test_run_test_failed
+    @server.test_files = [new_failed_test_file]
+    @server.add_client new_client
+
+    assert_false @server.complete?
+    assert_false @server.succeeded?
+    @server.run
+    assert @server.complete?
+    assert_false @server.succeeded?
+
+    test_report = @server.reports[@server.test_files[0]]
+    assert_false test_report.succeeded?
+  end
+
+  def test_run_on_multi_clients_with_average_strategy
+    @server.test_files = [new_successful_test_file, new_successful_test_file]
+    @server.add_client new_client
+    @server.add_client new_client
+
+    @server.run
+
+    assert @server.complete?
+    assert @server.succeeded?
+    assert_equal 1, @server.clients[0].completed_cmds.size
+    assert_equal 1, @server.clients[1].completed_cmds.size
+  end
+
+  def test_should_dispatch_tests_which_is_waiting_for_report_to_idle_client
+    @server.test_files = [new_successful_test_file, new_successful_test_file]
+    @server.add_client NoResponseClient.new
+    client = new_client
+    @server.add_client client
+
+    @server.run
+
+    assert @server.complete?
+    assert @server.succeeded?
+    assert_equal 2, client.completed_cmds.size
+  end
+
+  def test_update_report_by_signature
+    @server.test_files = [new_successful_test_file]
+    @server.add_client NoResponseClient.new
+    @server.run(:wait_for_reports => false)
+
+    assert_false @server.complete?
+    report = new_report
+    assert @server.update(@server.clients.first.report_signature, report)
+    assert @server.complete?
+    assert_equal({report.test => report}, @server.reports)
+  end
+
+  def test_should_not_be_able_to_update_report_after_completed
+    @server.test_files = [new_successful_test_file]
+    @server.add_client NoResponseClient.new
+    @server.run(:wait_for_reports => false)
+    report = new_report
+    @server.update @server.clients.first.report_signature, report
+    assert @server.complete?
+
+    @server.reports.clear
+    assert_false @server.update(@server.clients.first.report_signature, report)
+    assert_equal({}, @server.reports)
+  end
+
+  def test_should_not_update_reports_if_server_never_ran
+    @server.test_files = [new_successful_test_file]
+    assert_false @server.update(nil, DTR::TestReport.new('test', {:name => 'client name', :exit_code => 0}, *success_test_summary))
+    assert_equal({}, @server.reports)
+
+    @server.update(Time.now.to_s, new_report)
+    assert_equal({}, @server.reports)
+  end
+
+  def test_should_not_update_reports_if_signature_is_incorrect
+    @server.test_files = [new_successful_test_file]
+    @server.add_client NoResponseClient.new
+    @server.run(:wait_for_reports => false)
+
+    assert_false @server.complete?
+    assert_false @server.update('incorrect signature', new_report)
+    assert_equal({}, @server.reports)
+  end
+
+  def test_summary_after_ran_tests
+    @server.test_files = [new_successful_test_file, new_failed_test_file, new_error_test_file]
+    @server.add_client new_client
+
+    assert_raise RuntimeError do
+      @server.latest_build_summary
+    end
+    @server.run
+    assert(/Finished in \d\.\d seconds./ =~ @server.latest_build_summary)
+    assert(/4 tests, 2 assertions, 1 failures, 2 errors/ =~ @server.latest_build_summary)
+  end
+  
+  def test_should_be_able_to_setup_test_env_on_client_side
+    @server.test_files = [new_successful_test_file]
+    client = NoResponseClient.new
+    @server.add_client client
+    @server.run :setup => true, :wait_for_reports => false
+    assert_equal "setup #{client.report_signature}", client.log
+  end
+  
+  def test_should_have_client_setup_log
+    @server.test_files = [new_successful_test_file]
+    client = new_client
+    @server.add_client client
+    @server.run :setup => true, :wait_for_reports => false
+    assert @server.client_setup_logs[client.name]
+    assert(/echo "setup_dtr_client"/ =~ @server.client_setup_logs[client.name][:stdout])
+    assert_equal client.name, @server.client_setup_logs[client.name][:client_name]
+    assert_equal 0, @server.client_setup_logs[client.name][:exit_code]
+  end
+
+  def test_should_ignore_out_of_date_report_of_client_setup
+    @server.test_files = [new_successful_test_file]
+    client = NoResponseClient.new
+    @server.add_client client
+    @server.run :setup => true, :wait_for_reports => false
+    out_of_date = client.report_signature
+    sleep(1)
+    @server.run :setup => true, :wait_for_reports => false
+    assert_false @server.update_setup_log(out_of_date, {:client_name => client.name})
+  end
+  
+  def test_should_update_as_0_tests_when_test_file_execution_result_has_no_summary_line
+    empty_test_file = new_test_file {|file, num|}
+    @server.test_files = [empty_test_file]
+    @server.add_client new_client
+
+    @server.run
+    
+    assert(/Finished in \d\.\d seconds./ =~ @server.latest_build_summary)
+    assert(/0 tests, 0 assertions, 0 failures, 0 errors/ =~ @server.latest_build_summary)
+  end
+    
+  def test_should_be_failed_when_no_test_files_specified
+    @server.test_files = []
+    @server.add_client new_client
+
+    @server.run
+    
+    assert @server.complete?
+    assert_false @server.succeeded?
+    assert(/Finished in \d\.\d seconds./ =~ @server.latest_build_summary)
+    assert(/0 tests, 0 assertions, 0 failures, 0 errors/ =~ @server.latest_build_summary)
+  end
+  
+  def test_should_remove_client_when_client_setup_failed
+    @server.test_files = [new_successful_test_file]
+    @server.add_client DTR::Client.new(@server, "client name", 'error cmd')
+    
+    @server.run :setup => true
+    
+    assert @server.clients.empty?
+    assert @server.client_setup_logs["client name"]
+  end
+  
+  def test_should_work_with_client_which_is_added_after_ran_tests
+    @server.test_files = [new_successful_test_file]
+    @server.add_client NoResponseClient.new
+    
+    @server.send(:run_start, :setup => true)
+    @server.send(:run_once)
+    assert_false @server.complete?
+    
+    client = new_client
+    @server.add_client client
+    @server.send(:run_once)
+    assert @server.complete?
+    assert @server.client_setup_logs[client.name]
+  end
+  
+  def test_should_only_ask_client_to_setup_once
+    @server.test_files = [new_successful_test_file]
+    client = NoResponseClient.new
+    @server.add_client client
+    
+    @server.send(:run_start, :setup => true)
+    @server.send(:run_once)
+    @server.send(:run_once)
+    @server.send(:run_once)
+    assert_equal "setup #{client.report_signature}", client.log
+  end
+  
+  def xtest_pack_once
+    DTROPTIONS[:packing_once] = true
+    @server.test_files = [new_successful_test_file, new_successful_test_file]
+    @server.add_client NoResponseClient.new
+    @server.add_client new_client
+    @server.run
+  end
+
+  def success_test_summary
+    [1, 0, 0, 0]
+  end
+
+  def new_client
+    DTR::Client.new(@server, "client#{@client_num += 1}")
+  end
+
+  def new_report(test=@server.test_files.first)
+    DTR::TestReport.new(test, {:name => 'client name', :exit_code => 0}, *success_test_summary)
+  end
+
+end