jason-o-matic-deep_test 1.2.2.1

data/lib/deep_test/test/work_result.rb

@@ -0,0 +1,34 @@
+module DeepTest
+  module Test
+    class WorkResult < ::Test::Unit::TestResult
+      attr_reader :identifier
+      attr_accessor :output
+
+      def initialize(identifier)
+        super()
+        @identifier = identifier
+      end
+
+      def add_to(result)
+        @failures.each {|e| result.add_failure(e)}
+
+        @errors.each do |e| 
+          e.resolve_marshallable_exception
+          result.add_error(e)
+        end
+
+        assertion_count.times {result.add_assertion}
+        run_count.times {result.add_run}
+      end
+
+      def add_error(error)
+        error.make_exception_marshallable
+        super(error)
+      end
+      
+      def failed_due_to_deadlock?
+        @errors.any? && DeepTest::DeadlockDetector.due_to_deadlock?(@errors.last)
+      end
+    end
+  end
+end

data/lib/deep_test/test/work_unit.rb

@@ -0,0 +1,40 @@
+module DeepTest
+  module Test
+    class WorkUnit
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def run
+        result = run_without_deadlock_protection 
+        result = run_without_deadlock_protection if result.failed_due_to_deadlock?
+        if result.failed_due_to_deadlock?
+          result = WorkResult.new(@test_case.name)
+          result.add_run
+          result.output = "-deadlock-"
+        end
+        result
+      end
+
+      def ==(other)
+        return false unless other.class == self.class
+        @test_case == other.instance_variable_get(:@test_case)
+      end
+
+      def to_s
+        @test_case.to_s
+      end
+
+      protected
+
+      def run_without_deadlock_protection
+        result = WorkResult.new(@test_case.name)
+        output = capture_stdout do
+          @test_case.run(result) {|channel,event|}
+        end
+        result.output = output
+        result
+      end
+    end
+  end
+end

data/lib/deep_test/test_task.rb

@@ -0,0 +1,51 @@
+module DeepTest
+  class TestTask
+    attr_accessor :libs, :requires
+
+    def initialize(name = :deep_test)
+#       @requires = []
+      @name = name
+#       @libs = ["lib"]
+      @options = Options.new({})
+      
+      @options.requires = []
+      @options.libs = ["lib"]
+      
+      self.pattern = "test/**/*_test.rb"
+      yield self if block_given?
+      define
+    end
+    
+    def define
+      require 'rake'
+      desc "Run '#{@name}' suite using DeepTest"
+      task @name do
+        lib_options = libs.any? ? "-I" + libs.join(File::PATH_SEPARATOR) : ""
+        require_options = requires.map {|f| "-r#{f}"}.join(" ")
+        ruby "#{lib_options} #{require_options} #{runner} '#{@options.to_command_line}'"
+      end
+    end
+
+    Options::VALID_OPTIONS.each do |option|
+      eval <<-end_src
+        def #{option.name}
+          @options.#{option.name}
+        end
+
+        def #{option.name}=(value)
+          @options.#{option.name} = value
+        end
+      end_src
+    end
+
+    def pattern=(pattern)
+      @options.pattern = Dir.pwd + "/" + pattern
+    end
+
+  private
+
+    def runner
+      File.expand_path(File.dirname(__FILE__) + "/../../script/internal/run_test_suite.rb")
+    end    
+  end
+end

data/lib/deep_test/ui/console.rb

@@ -0,0 +1,76 @@
+module DeepTest
+  module UI
+    class Console
+      def initialize(options)
+      end
+
+      METHOD_DESCRIPTIONS = {
+        :sync => "Synchronizing working copies on worker machines",
+        :spawn_worker_server => "Spawning test environment processes",
+        :load_files => "Loading test files for workers",
+        :start_all => "Starting workers",
+        :stop_all => "Stopping workers"
+      } unless defined?(METHOD_DESCRIPTIONS)
+
+      def distributed_failover_to_local(method, exception)
+        width = 70
+        puts " Distributed DeepTest Failure ".center(width, '*')
+        puts "*   Failed during #{method}".ljust(width - 1) + "*"
+        puts "* #{exception.message}".ljust(width - 1) + "*"
+        puts "* Failing over to local run".ljust(width - 1) + "*"
+        puts "*" * width
+      end
+
+      def dispatch_starting(method_name)
+        @spinner.stop if @spinner
+        @spinner = Spinner.new(label(method_name))
+        @spinner.start
+      end
+
+      def label(method_name)
+        METHOD_DESCRIPTIONS[method_name.to_sym] || method_name.to_s
+      end
+
+      def dispatch_finished(method_name)
+        @spinner.stop if @spinner
+        @spinner = nil
+      end
+
+      class Spinner
+        FRAMES = ['|', '/', '-', '\\'] unless defined?(FRAMES)
+        BACKSPACE = "\x08"  unless defined?(BACKSPACE)
+        SECONDS_PER_FRAME = 0.5 / 4 unless defined?(SECONDS_PER_FRAME)
+
+        def initialize(label)
+          @label = label
+        end
+
+        def start
+          @start_time = Time.now
+          show "#{@label}: "
+          @thread = Thread.new do
+            index = 0
+            loop do
+              show FRAMES[index]
+              sleep SECONDS_PER_FRAME
+              show BACKSPACE
+              index = (index + 1) % FRAMES.length
+            end
+          end 
+        end
+
+        def stop
+          @stop_time = Time.now
+          @thread.kill if @thread
+          show BACKSPACE
+          show("finished in %.2f seconds\n" % (@stop_time.to_f - @start_time.to_f))
+        end
+
+        def show(string)
+          $stdout.print string
+          $stdout.flush
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/ui/null.rb

@@ -0,0 +1,17 @@
+module DeepTest
+  module UI
+    class Null
+      def initialize(options)
+      end
+
+      def distributed_failover_to_local(method, exception)
+      end
+
+      def dispatch_starting(method_name)
+      end
+
+      def dispatch_finished(method_name)
+      end
+    end
+  end
+end

data/lib/deep_test/warlock.rb

@@ -0,0 +1,134 @@
+module DeepTest
+  class Warlock
+    def initialize
+      @demons_semaphore = Mutex.new
+      @demons = []
+      @reapers = []
+    end
+
+    def start(name, &block)
+      # Not synchronizing for the fork seems to cause
+      # random errors (Bus Error, Segfault, and GC non-object)
+      # in RemoteWorkerServer processes.
+      #
+      begin
+        pid = nil
+        @demons_semaphore.synchronize do 
+          pid = DeepTest.drb_safe_fork do
+            # Fork leaves the semaphore locked and we'll never make it
+            # to end of synchronize block.
+            #
+            # The Ruby 1.8.6 C mutex implementation automatically treats
+            # a mutex locked by a dead thread as unlocked and will raise
+            # an error if we try to unlock it from this thread.
+            #
+            @demons_semaphore.unlock if @demons_semaphore.locked?
+
+            begin
+              yield
+            rescue Exception => e
+              DeepTest.logger.debug "Exception in #{name} (#{Process.pid}): #{e.message}"
+              raise
+            end
+
+            exit
+          end
+
+          raise "fatal: fork returned nil" if pid.nil?
+          add_demon name, pid
+        end
+
+        launch_reaper_thread name, pid
+
+      rescue => e
+        puts "exception starting #{name}: #{e}"
+        puts "\t" + e.backtrace.join("\n\t")
+      end
+    end
+
+    def demon_count
+      @demons_semaphore.synchronize do
+        @demons.size
+      end
+    end
+
+    def stop_all
+      DeepTest.logger.debug("stopping all demons")
+      receivers = @demons_semaphore.synchronize do
+        @demons.reverse
+      end
+
+      receivers.reverse.each do |demon|
+        name, pid = demon
+        if running?(pid)
+          DeepTest.logger.debug("Sending SIGTERM to #{name}, #{pid}")
+          Process.kill("TERM", pid)
+        end
+      end
+      DeepTest.logger.debug("Warlock: Stopped all receivers")
+
+      DeepTest.logger.debug("waiting for reapers")
+      @reapers.each {|r| r.join}
+
+      DeepTest.logger.debug("Warlock: done reaping processes")
+    end
+
+    def exit_when_none_running
+      Thread.new do
+        loop do
+          Thread.pass
+          exit(0) unless any_running?
+          sleep(0.01)
+        end
+      end
+    end
+
+    def any_running?
+      @demons_semaphore.synchronize do
+        @demons.any? {|name, pid| running?(pid)}
+      end
+    end
+
+    #stolen from daemons
+    def running?(pid)
+      # Check if process is in existence
+      # The simplest way to do this is to send signal '0'
+      # (which is a single system call) that doesn't actually
+      # send a signal
+      begin
+        Process.kill(0, pid)
+        return true
+      rescue Errno::ESRCH
+        return false
+      rescue ::Exception   # for example on EPERM (process exists but does not belong to us)
+        return true
+      #rescue Errno::EPERM
+      #  return false
+      end
+    end    
+
+    protected
+
+    def add_demon(name, pid)
+      DeepTest.logger.debug "Started: #{name} (#{pid})"
+      @demons << [name, pid]
+    end
+
+    def remove_demon(name, pid)
+      @demons.delete [name, pid]
+      DeepTest.logger.debug "Stopped: #{name} (#{pid})"
+    end
+
+
+    def launch_reaper_thread(name, pid)
+      @reapers << Thread.new do
+        Process.detach(pid).join
+        DeepTest.logger.debug("#{name} (#{pid}) reaped")
+        @demons_semaphore.synchronize do
+          DeepTest.logger.debug("Warlock Reaper: removing #{name} (#{pid}) from demon list")
+          remove_demon name, pid
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/worker.rb

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

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

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