jstorimer-deep-test 1.4.0 → 2.0.0

data/lib/deep_test/rake_tasks.rb

@@ -1,7 +1,8 @@
 require "socket"
+require "base64"
 
-require File.dirname(__FILE__) + "/option"
 require File.dirname(__FILE__) + "/options"
+require File.dirname(__FILE__) + "/cpu_info"
 require File.dirname(__FILE__) + "/test_task"
 require File.dirname(__FILE__) + "/rspec_detector"
 
@@ -9,3 +10,4 @@ DeepTest::RSpecDetector.if_rspec_available do
   require 'spec/rake/spectask'
   require File.dirname(__FILE__) + "/spec/extensions/spec_task"
 end
+

data/lib/deep_test/result_reader.rb

@@ -1,7 +1,7 @@
 module DeepTest
   class ResultReader
-    def initialize(blackboard)
-      @blackboard = blackboard
+    def initialize(central_command)
+      @central_command = central_command
     end
 
     def read(original_work_units_by_id)
@@ -11,10 +11,10 @@ module DeepTest
       begin
         until errors == work_units_by_id.size
           Thread.pass
-          result = @blackboard.take_result
+          result = @central_command.take_result
           next if result.nil?
 
-          if Worker::Error === result
+          if Agent::Error === result
             puts result
             errors += 1
           else
@@ -26,8 +26,12 @@ module DeepTest
             yield [work_unit, result]
           end
         end
-      rescue Server::ResultOverdueError
-        DeepTest.logger.error("Results are overdue from server, ending run")
+      rescue CentralCommand::NoAgentsRunningError
+        FailureMessage.show "DeepTest Agents Are Not Running", <<-end_msg
+          DeepTest's test running agents have not contacted the 
+          server to indicate they are still running.
+          Shutting down the test run on the assumption that they have died. 
+        end_msg
       end
 
       work_units_by_id

data/lib/deep_test/rspec_detector.rb

@@ -5,7 +5,7 @@ module DeepTest
         require 'spec/version'
         if ::Spec::VERSION::MAJOR == 1 &&
            ::Spec::VERSION::MINOR == 1 &&
-           ::Spec::VERSION::TINY  == 8
+           ::Spec::VERSION::TINY  >= 8
           yield
         else
           require 'spec/rake/spectask'

data/lib/deep_test/spec.rb

@@ -1,5 +1,10 @@
 require 'rubygems'
 require 'spec/runner/example_group_runner'
+if ::Spec::VERSION::MAJOR == 1 &&
+   ::Spec::VERSION::MINOR == 1 &&
+   ::Spec::VERSION::TINY  >= 12
+  require 'spec/example/before_and_after_hooks'
+end
 require 'spec/example/example_group_methods'
 require 'spec/rake/spectask'
 
@@ -7,7 +12,6 @@ require File.dirname(__FILE__) + "/spec/extensions/example_group_methods"
 require File.dirname(__FILE__) + "/spec/extensions/example_methods"
 require File.dirname(__FILE__) + "/spec/extensions/spec_task"
 require File.dirname(__FILE__) + "/spec/extensions/options"
-require File.dirname(__FILE__) + "/spec/extensions/reporter"
 require File.dirname(__FILE__) + "/spec/runner"
 require File.dirname(__FILE__) + "/spec/work_unit"
 require File.dirname(__FILE__) + "/spec/work_result"

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

@@ -2,7 +2,13 @@ module Spec
   module Example
     module ExampleMethods
       def identifier
-        file, line = implementation_backtrace.first.split(/:/)
+        if ::Spec::VERSION::MAJOR == 1 &&
+           ::Spec::VERSION::MINOR == 1 &&
+           ::Spec::VERSION::TINY  >= 12
+          file, line = eval("caller", @_implementation).first.split(/:/)
+        else
+          file, line = implementation_backtrace.first.split(/:/)
+        end
         Identifier.new(file, line.to_i, self.class.description, description)
       end
 

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

@@ -1,10 +1,11 @@
+require File.dirname(__FILE__) + "/../../lib_root"
+
 module Spec
   module Rake
     class SpecTask
       def deep_test(options)
         deep_test_options = DeepTest::Options.new(options)
-        deep_test_path = File.expand_path(File.dirname(__FILE__) + 
-                                          "/../../../deep_test")
+        deep_test_path = File.expand_path(DeepTest::LIB_ROOT + "/deep_test")
         @deep_test_spec_opts = [
           "--require #{deep_test_path}",
           "--runner 'DeepTest::Spec::Runner:#{deep_test_options.to_command_line}'"

data/lib/deep_test/spec/runner.rb

@@ -1,51 +1,66 @@
 module DeepTest
   module Spec
     class Runner < ::Spec::Runner::ExampleGroupRunner
-      def initialize(options, deep_test_options, blackboard = nil)
+      def initialize(options, deep_test_options)
         super(options)
+        if ::Spec::VERSION::MAJOR == 1 &&
+           ::Spec::VERSION::MINOR == 1 &&
+           ::Spec::VERSION::TINY  >= 12
+          @runner_options = options # added to make work with 1.1.12
+        end
         @deep_test_options = DeepTest::Options.from_command_line(deep_test_options)
-        DeepTest.init(@deep_test_options)
-        @blackboard = blackboard
-        @workers = @deep_test_options.new_workers
       end
 
-      def blackboard
-        # Can't create blackboard as default argument to initialize
-        # because ProcessOrchestrator hasn't been invoked at 
+      def main
+        @main ||= Main.new @deep_test_options, @deep_test_options.new_deployment, self
+      end
+
+      def central_command
+        # Can't create central_command as default argument to initialize
+        # because Main hasn't been invoked at 
         # instantiation time
-        @blackboard ||= @deep_test_options.server
+        @central_command ||= main.central_command
       end
 
       def load_files(files)
-        @workers.load_files files
+        main.load_files files
       end
 
       def run
-        ProcessOrchestrator.run(@deep_test_options, @workers, self)
+        main.run
       end
 
-      def process_work_units
+      def process_work_units(central_command)
         prepare
 
-        examples = example_groups.map {|g| g.send(:examples_to_run)}.flatten
+        examples = (example_groups.map do |g|
+          if ::Spec::VERSION::MAJOR == 1 &&
+             ::Spec::VERSION::MINOR == 1 &&
+             ::Spec::VERSION::TINY  >= 12
+            g.send(:examples_to_run, @runner_options) # added @runner_options to make wiork with 1.1.12
+          else
+            g.send(:examples_to_run)
+          end
+        end).flatten
         examples_by_location = {}
         examples.each do |example|
           raise "duplicate example: #{example.identifier}" if examples_by_location[example.identifier]
           examples_by_location[example.identifier] = example
-          blackboard.write_work Spec::WorkUnit.new(example.identifier)
+          central_command.write_work Spec::WorkUnit.new(example.identifier)
         end
 
         success = true
 
-        missing_exmaples = ResultReader.new(blackboard).read(examples_by_location) do |example, result|
+        missing_examples = ResultReader.new(central_command).read(examples_by_location) do |example, result|
           @options.reporter.example_finished(example, result.error)
           success &= result.success?
         end
 
-        success &= missing_exmaples.empty?
+        success &= missing_examples.empty?
 
-        missing_exmaples.each do |identifier, example|
-          @options.reporter.example_finished(example, WorkUnitNeverReceivedError.new)
+        if missing_examples.any?
+          @options.reporter.example_finished(examples_by_location[missing_examples.keys.first],
+                                             IncompleteTestRunError.new(missing_examples.size))
         end
 
         success

data/lib/deep_test/spec/work_result.rb

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

data/lib/deep_test/test/run_test_suite.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + "/../../deep_test"
+options = DeepTest::Options.from_command_line(ARGV[0])
+main = DeepTest::Main.new options, options.new_deployment, DeepTest::Test::Runner.new(options) 
+main.load_files Dir.glob(options.pattern)
+main.run

data/lib/deep_test/test/runner.rb

@@ -12,9 +12,9 @@ module DeepTest
         @options = options
       end
 
-      def process_work_units
+      def process_work_units(central_command)
         suite = ::Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
-        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, @options.server)
+        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, central_command)
         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, blackboard)
+      def initialize(suite, central_command)
         @suite = suite
-        @blackboard = blackboard
+        @central_command = central_command
       end
 
       def run(result, &progress_block)
@@ -25,24 +25,23 @@ module DeepTest
           end
         else
           tests_by_name[test_suite.name] = test_suite
-          @blackboard.write_work Test::WorkUnit.new(test_suite)
+          @central_command.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(@blackboard).read(tests_by_name) do |test, remote_result|
+        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|
             remote_result.add_to result
             yield ::Test::Unit::TestCase::FINISHED, test.name if block_given?
           end
 
-        missing_tests.each do |name, test_case|
-          result.add_error ::Test::Unit::Error.new(name, WorkUnitNeverReceivedError.new)
+        if missing_tests.any?
+          result.add_error ::Test::Unit::Error.new("DeepTest Test Run", IncompleteTestRunError.new(missing_tests.size))
         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,6 +1,7 @@
 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__) + "/../../script/internal/run_test_suite.rb")
+      File.expand_path(File.dirname(__FILE__) + "/test/run_test_suite.rb")
     end    
   end
 end

data/lib/deep_test/ui/console.rb

@@ -5,20 +5,18 @@ module DeepTest
       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"
+        :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",
       } 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
+        FailureMessage.show "Distributed DeepTest Failure", <<-end_msg
+          Failed during #{method}
+          #{exception.message}
+          Failing over to local run
+        end_msg
       end
 
       def dispatch_starting(method_name)

data/lib/deep_test/warlock.rb

@@ -1,20 +1,21 @@
 module DeepTest
   class Warlock
-    def initialize
+    def initialize(options)
+      @options = options
       @demons_semaphore = Mutex.new
       @demons = []
       @reapers = []
     end
 
-    def start(name, &block)
+    def start(name, demon, *demon_args)
       # Not synchronizing for the fork seems to cause
       # random errors (Bus Error, Segfault, and GC non-object)
-      # in RemoteWorkerServer processes.
+      # in Beachhead processes.
       #
       begin
         pid = nil
         @demons_semaphore.synchronize do 
-          pid = DeepTest.drb_safe_fork do
+          pid = fork do
             # Fork leaves the semaphore locked and we'll never make it
             # to end of synchronize block.
             #
@@ -24,12 +25,8 @@ module DeepTest
             #
             @demons_semaphore.unlock if @demons_semaphore.locked?
 
-            begin
-              yield
-            rescue Exception => e
-              DeepTest.logger.debug "Exception in #{name} (#{Process.pid}): #{e.message}"
-              raise
-            end
+            close_open_network_connections
+            demon.forked name, @options, demon_args
 
             exit
           end
@@ -46,14 +43,23 @@ 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_all
-      DeepTest.logger.debug("stopping all demons")
+    def stop_demons
+      DeepTest.logger.debug { "stopping all demons" }
       receivers = @demons_semaphore.synchronize do
         @demons.reverse
       end
@@ -61,25 +67,31 @@ 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
-        loop do
-          Thread.pass
-          exit(0) unless any_running?
-          sleep(0.01)
-        end
+        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)
       end
     end
 
@@ -110,22 +122,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