jstorimer-deep-test 0.2.0 → 1.0.0

data/lib/deep_test/spec/work_result.rb

@@ -1,8 +1,6 @@
 module DeepTest
   module Spec
     class WorkResult
-      include CentralCommand::Result
-
       attr_reader :identifier, :output
 
       def initialize(identifier, error, output)

data/lib/deep_test/test/runner.rb

@@ -12,9 +12,9 @@ module DeepTest
         @options = options
       end
 
-      def process_work_units(central_command)
+      def process_work_units
         suite = ::Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
-        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, central_command)
+        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, @options.server)
         require 'test/unit/ui/console/testrunner'
         result = ::Test::Unit::UI::Console::TestRunner.run(supervised_suite, ::Test::Unit::UI::NORMAL)
         result.passed?

data/lib/deep_test/test/supervised_test_suite.rb

@@ -1,9 +1,9 @@
 module DeepTest
   module Test
     class SupervisedTestSuite
-      def initialize(suite, central_command)
+      def initialize(suite, blackboard)
         @suite = suite
-        @central_command = central_command
+        @blackboard = blackboard
       end
 
       def run(result, &progress_block)
@@ -25,23 +25,24 @@ module DeepTest
           end
         else
           tests_by_name[test_suite.name] = test_suite
-          @central_command.write_work Test::WorkUnit.new(test_suite)
+          @blackboard.write_work Test::WorkUnit.new(test_suite)
         end
       end
 
       def read_results(result, tests_by_name)
-        DeepTest.logger.debug { "SupervisedTestSuite: going to read #{tests_by_name.size} results" }
-        missing_tests =
-          ResultReader.new(@central_command).read(tests_by_name) do |test, remote_result|
+        DeepTest.logger.debug("SupervisedTestSuite: going to read #{tests_by_name.size} results")
+
+        missing_tests = 
+          ResultReader.new(@blackboard).read(tests_by_name) do |test, remote_result|
             remote_result.add_to result
             yield ::Test::Unit::TestCase::FINISHED, test.name if block_given?
           end
 
-        if missing_tests.any?
-          result.add_error ::Test::Unit::Error.new("DeepTest Test Run", IncompleteTestRunError.new(missing_tests.size))
+        missing_tests.each do |name, test_case|
+          result.add_error ::Test::Unit::Error.new(name, WorkUnitNeverReceivedError.new)
         end
       ensure
-        DeepTest.logger.debug { "SupervisedTestSuite: exiting with #{missing_tests.size} results left" }
+        DeepTest.logger.debug("SupervisedTestSuite: exiting with #{missing_tests.size} results left")
       end
     end
   end

data/lib/deep_test/test/work_result.rb

@@ -1,7 +1,6 @@
 module DeepTest
   module Test
     class WorkResult < ::Test::Unit::TestResult
-      include CentralCommand::Result
       attr_reader :identifier
       attr_accessor :output
 

data/lib/deep_test/test_task.rb

@@ -41,7 +41,7 @@ module DeepTest
   private
 
     def runner
-      File.expand_path(File.dirname(__FILE__) + "/test/run_test_suite.rb")
+      File.expand_path(File.dirname(__FILE__) + "/../../script/internal/run_test_suite.rb")
     end    
   end
 end

data/lib/deep_test/ui/console.rb

@@ -5,18 +5,20 @@ module DeepTest
       end
 
       METHOD_DESCRIPTIONS = {
-        :push_code => "Synchronizing working copies on distributed machines",
-        :establish_beachhead => "Spawning test environment processes",
-        :load_files => "Loading test files for agents",
-        :deploy_agents => "Deploying agents",
+        :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)
-        FailureMessage.show "Distributed DeepTest Failure", <<-end_msg
-          Failed during #{method}
-          #{exception.message}
-          Failing over to local run
-        end_msg
+        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)

data/lib/deep_test/warlock.rb

@@ -1,21 +1,20 @@
 module DeepTest
   class Warlock
-    def initialize(options)
-      @options = options
+    def initialize
       @demons_semaphore = Mutex.new
       @demons = []
       @reapers = []
     end
 
-    def start(name, demon, *demon_args)
+    def start(name, &block)
       # Not synchronizing for the fork seems to cause
       # random errors (Bus Error, Segfault, and GC non-object)
-      # in Beachhead processes.
+      # in RemoteWorkerServer processes.
       #
       begin
         pid = nil
         @demons_semaphore.synchronize do 
-          pid = fork do
+          pid = DeepTest.drb_safe_fork do
             # Fork leaves the semaphore locked and we'll never make it
             # to end of synchronize block.
             #
@@ -25,8 +24,12 @@ module DeepTest
             #
             @demons_semaphore.unlock if @demons_semaphore.locked?
 
-            close_open_network_connections
-            demon.forked name, @options, demon_args
+            begin
+              yield
+            rescue Exception => e
+              DeepTest.logger.debug "Exception in #{name} (#{Process.pid}): #{e.message}"
+              raise
+            end
 
             exit
           end
@@ -43,23 +46,14 @@ module DeepTest
       end
     end
 
-    def close_open_network_connections
-      ObjectSpace.each_object(BasicSocket) do |sock|
-        begin
-          sock.close 
-        rescue IOError
-        end
-      end
-    end
-
     def demon_count
       @demons_semaphore.synchronize do
         @demons.size
       end
     end
 
-    def stop_demons
-      DeepTest.logger.debug { "stopping all demons" }
+    def stop_all
+      DeepTest.logger.debug("stopping all demons")
       receivers = @demons_semaphore.synchronize do
         @demons.reverse
       end
@@ -67,31 +61,25 @@ module DeepTest
       receivers.reverse.each do |demon|
         name, pid = demon
         if running?(pid)
-          DeepTest.logger.debug { "Sending SIGTERM to #{name}, #{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("Warlock: Stopped all receivers")
 
-      DeepTest.logger.debug { "waiting for reapers" }
+      DeepTest.logger.debug("waiting for reapers")
       @reapers.each {|r| r.join}
 
-      DeepTest.logger.debug { "Warlock: done reaping processes" }
+      DeepTest.logger.debug("Warlock: done reaping processes")
     end
 
     def exit_when_none_running
       Thread.new do
-        wait_for_all_to_finish
-        DeepTest.logger.debug { "exiting #{Process.pid} with all demons finished" }
-        exit(0)
-      end
-    end
-
-    def wait_for_all_to_finish
-      loop do
-        Thread.pass
-        return unless any_running?
-        sleep(0.01)
+        loop do
+          Thread.pass
+          exit(0) unless any_running?
+          sleep(0.01)
+        end
       end
     end
 
@@ -122,22 +110,22 @@ module DeepTest
     protected
 
     def add_demon(name, pid)
-      DeepTest.logger.debug { "Started: #{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})" }
+      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" }
+        DeepTest.logger.debug("#{name} (#{pid}) reaped")
         @demons_semaphore.synchronize do
-          DeepTest.logger.debug { "Warlock Reaper: removing #{name} (#{pid}) from demon list" }
+          DeepTest.logger.debug("Warlock Reaper: removing #{name} (#{pid}) from demon list")
           remove_demon name, pid
         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/sample_rails_project/deep_test.rb

@@ -12,10 +12,6 @@ unit_tests do
     assert_successful "rake deep_test"
   end
 
-  test "distributed_test" do
-    assert_successful "rake distributed_test" 
-  end
-
   test "spec" do
     assert_successful "rake spec"
   end

data/sample_rails_project/lib/{foreign_host_agent_simulation_listener.rb → foreign_host_worker_simulation_listener.rb}

@@ -1,13 +1,11 @@
-require File.dirname(__FILE__) + '/../vendor/gems/deep_test/lib/deep_test'
-
-class ForeignHostAgentSimulationListener < DeepTest::NullListener
-  def starting(agent)
+class ForeignHostWorkerSimulationListener < DeepTest::NullWorkerListener
+  def starting(worker)
     # On a foreign host, there won't necessarily be a database for tests
     # to run against.  We simulate that by dropping them here.
     #
-    # It's important that this happens as the first thing when the agents
+    # It's important that this happens as the first thing when the workers
     # are started, since this is the first listener event that would be
-    # invoked on a foreign host.  before_starting_agents would be invoked
+    # invoked on a foreign host.  before_starting_workers would be invoked
     # on the local host, which should have databases available as usual.
     #
     system "mysqladmin -u root -f drop sample_rails_project_development > /dev/null"

data/sample_rails_project/lib/tasks/deep_test.rake

@@ -1,27 +1,18 @@
 require 'rubygems'
 gem 'rspec', '=1.1.8'
 require 'spec/rake/spectask'
-$LOAD_PATH << File.dirname(__FILE__) + "/../../vendor/gems/deep_test/lib"
+$LOAD_PATH << File.dirname(__FILE__) + "/../../../lib"
 require 'deep_test/rake_tasks'
 
 DeepTest::TestTask.new(:deep_test) do |t|
-  t.number_of_agents = 1
+  t.number_of_workers = 1
   t.pattern = "test/unit/**/*_test.rb"
-  t.listener = "ForeignHostAgentSimulationListener,DeepTest::Database::MysqlSetupListener"
+  t.worker_listener = "ForeignHostWorkerSimulationListener,DeepTest::Database::MysqlSetupListener"
 end
 Rake::Task[:deep_test].enhance ["db:test:prepare"]
 
 Spec::Rake::SpecTask.new(:deep_spec) do |t|
   t.spec_files = FileList['spec/**/*_spec.rb']
-  t.deep_test :number_of_agents => 2
+  t.deep_test :number_of_workers => 2
 end
 Rake::Task[:deep_spec].enhance ["db:test:prepare"]
-
-DeepTest::TestTask.new(:distributed_test => %w[db:test:prepare]) do |t|
-  t.number_of_agents = 1
-  t.distributed_hosts = %w[localhost]
-  t.requires = File.dirname(__FILE__) + "/../foreign_host_agent_simulation_listener"
-  t.listener = "ForeignHostAgentSimulationListener,DeepTest::Database::MysqlSetupListener"
-  t.sync_options = {:source => File.expand_path(File.dirname(__FILE__) + "/../.."), 
-                    :rsync_options => "--exclude=.svn --copy-dirlinks"}
-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
+

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}"