deep_test 1.1.2 → 1.1.3

data/CHANGELOG

@@ -1,3 +1,9 @@
+* 1.1.3 (March 10, 2008)
+
+* Added Support for RSpec
+* Added DeepTest::TestTask#timeout_in_seconds to configure Rinda IO timeouts
+* Added worker_listener to configuration options
+
 * 1.1.2 (February 9, 2008)
 
 * Fix bug with run_test_suite script not exiting with correct exit code.

data/README

@@ -12,16 +12,53 @@ In your Rakefile:
   # sample DeepTest task
 
   DeepTest::TestTask.new "task_name" do |t|
-    t.number_of_workers = 2 # optional, defaults to 2
+    t.number_of_workers = 2   # optional, defaults to 2
+    t.timeout_in_seconds = 30 # optional, defaults to 30
     t.pattern = "test/**/*_test.rb"
   end
 
+  # Sample SpecTask using DeepTest
+
+  Spec::Rake::SpecTask.new(:deep_spec) do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.deep_test :number_of_workers => 2,   # optional, defaults to 2
+                :timeout_in_seconds => 30, # optional, defaults to 30
+  end
+
+
+If you want to specify a listener to be notified of worker events:
+
+In my_worker_listener.rb
+  class MyWorkerListener
+    def starting(worker)
+    end
+
+    def starting_work(worker, work_unit)
+    end
+
+    def finished_work(worker, work_unit, result)
+    end
+  end
+
+In your Rakefile
+
+  DeepTest::TestTask.new "task_name" do |t|
+    t.pattern = "test/**/*_test.rb"
+    t.worker_listener = "MyWorkerListener"
+  end
+
+An instance of MyWorkerListener will be created for each worker that is
+started, and will receive events from that worker.  However, you must ensure
+that the MyWorkerListener class is loaded at the time that the test files are
+loaded, so it is available to be instantiated.
+
 == Contributors
 
 +* anonymous z
 +* Alex Chaffee
 +* Dan[http://www.dcmanges.com/blog] Manges[http://www.dcmanges.com/blog]
-+* David Vollbracht
++* David Vollbracht[http://davidvollbracht.com/]
++* Scott Taylor
 
 == License
 Released under Ruby's[http://www.ruby-lang.org/en/LICENSE.txt] license[http://www.ruby-lang.org/en/LICENSE.txt]

data/Rakefile

@@ -6,32 +6,37 @@ require 'rake/contrib/sshpublisher'
 $LOAD_PATH << File.dirname(__FILE__) + "/lib"
 require "deep_test/rake_tasks"
 
-task :default => %w[test failing_test deep_test]
+task :default => %w[test spec failing_test deep_test deep_spec]
 
 Rake::TestTask.new do |t|
   t.pattern = "test/**/*_test.rb"
   t.libs += ['test', 'lib']
 end
 
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
 DeepTest::TestTask.new :deep_test do |t|
   t.number_of_workers = 2
   t.pattern = "test/**/*_test.rb"
 end
 
-DeepTest::TestTask.new :deep_test_failing do |t|
-  t.number_of_workers = 1
-  t.pattern = "test/failing.rb"
+Spec::Rake::SpecTask.new(:deep_spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.deep_test :number_of_workers => 2
 end
 
-# TODO: figure out a better way to test this that doesn't
-#       involve having a failing test in the output of 'rake test'
 task :failing_test do
-  exception = nil
-  begin
-    Rake::Task[:deep_test_failing].invoke
-  rescue => exception
+  command = "rake --rakefile test/failing.rake 2>&1"
+  puts command
+  `#{command}`
+  if $?.success?
+    puts "F"
+    fail "****\ntest/failing.rake should have failed\n****"
+  else
+    puts "."
   end
-  fail "exception should not be nil" if exception.nil?
 end
 
 desc "Generate documentation"
@@ -53,7 +58,7 @@ specification = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
 	s.name   = "deep_test"
   s.summary = "DeepTest runs tests in multiple processes."
-	s.version = "1.1.2"
+	s.version = "1.1.3"
 	s.author = "anonymous z, Dan Manges, David Vollbracht"
 	s.description = s.summary
 	s.email = "daniel.manges@gmail.com"

data/lib/deep_test.rb

@@ -1,23 +1,32 @@
 module DeepTest
+  class << self
+    def logger
+      @logger ||= DeepTest::Logger.new($stdout)
+    end
+  end  
 end
-require 'rinda/ring'
-require 'rinda/tuplespace'
 
-require "test/unit/testresult"
-require "test/unit/error"
-require 'test/unit/failure'
+require "logger"
+require "rinda/ring"
+require "rinda/tuplespace"
 
-require "deep_test/extensions/testresult"
-require "deep_test/extensions/error"
-require "deep_test/extensions/object_extension"
+require File.dirname(__FILE__) + "/deep_test/extensions/object_extension"
+
+require File.dirname(__FILE__) + "/deep_test/deadlock_detector"
+require File.dirname(__FILE__) + "/deep_test/tuple_space_factory"
+require File.dirname(__FILE__) + "/deep_test/rinda_blackboard"
+require File.dirname(__FILE__) + "/deep_test/logger"
+require File.dirname(__FILE__) + "/deep_test/null_worker_listener"
+require File.dirname(__FILE__) + "/deep_test/options"
+require File.dirname(__FILE__) + "/deep_test/process_orchestrator"
+require File.dirname(__FILE__) + "/deep_test/rspec_detector"
+require File.dirname(__FILE__) + "/deep_test/server"
+require File.dirname(__FILE__) + "/deep_test/test_task"
+require File.dirname(__FILE__) + "/deep_test/worker"
+require File.dirname(__FILE__) + "/deep_test/warlock"
+
+DeepTest::RSpecDetector.if_rspec_available do
+  require File.dirname(__FILE__) + "/deep_test/spec"
+end
+require File.dirname(__FILE__) + "/deep_test/test"
 
-require "deep_test/tuple_space_factory"
-require "deep_test/rinda_blackboard"
-require "deep_test/loader"
-require "deep_test/server"
-require "deep_test/simple_test_blackboard"
-require "deep_test/supervised_test_suite"
-require "deep_test/supervisor"
-require "deep_test/test_task"
-require "deep_test/worker"
-require "deep_test/warlock"

data/lib/deep_test/deadlock_detector.rb

@@ -0,0 +1,7 @@
+module DeepTest
+  class DeadlockDetector
+    def self.due_to_deadlock?(error)
+      error && !error.message.to_s.match(/Deadlock found when trying to get lock/).nil?
+    end
+  end
+end

data/lib/deep_test/logger.rb

@@ -0,0 +1,9 @@
+module DeepTest
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+      self.formatter = proc { |severity, time, progname, msg| "#{msg}\n" }
+      self.level = Logger::INFO
+    end
+  end
+end

data/lib/deep_test/null_worker_listener.rb

@@ -0,0 +1,12 @@
+module DeepTest
+  class NullWorkerListener
+    def starting(worker)
+    end
+
+    def starting_work(worker, work_unit)
+    end
+
+    def finished_work(worker, work_unit, result)
+    end
+  end
+end

data/lib/deep_test/options.rb

@@ -0,0 +1,72 @@
+module DeepTest
+  class Options
+    class Option
+      attr_reader :name, :default
+
+      def initialize(name, conversion, default)
+        @name, @conversion, @default = name, conversion, default
+      end
+
+      def from_command_line(command_line)
+        command_line =~ /--#{name} (\S+)(\s|$)/
+        $1.send(@conversion) if $1
+      end
+
+      def to_command_line(value)
+        "--#{name} #{value}" if value && value != default
+      end
+    end
+
+    unless defined?(VALID_OPTIONS)
+      VALID_OPTIONS = [
+        Option.new(:number_of_workers, :to_i, 2),
+        Option.new(:pattern, :to_s, nil),
+        Option.new(:timeout_in_seconds, :to_i, 30),
+        Option.new(:worker_listener, :to_s, "DeepTest::NullWorkerListener"),
+      ]
+    end
+
+    attr_accessor *VALID_OPTIONS.map {|o| o.name}
+    def worker_listener=(value)
+      @worker_listener = value.to_s
+    end
+
+    def self.from_command_line(command_line)
+      hash = {}
+      VALID_OPTIONS.each do |option|
+        hash[option.name] = option.from_command_line(command_line)
+      end
+      new(hash)
+    end
+
+    def initialize(hash)
+      check_option_keys(hash)
+      VALID_OPTIONS.each do |option|
+        send("#{option.name}=", hash[option.name] || option.default)
+      end
+    end
+
+    def new_worker_listener
+      eval(worker_listener).new
+    end
+
+    def to_command_line
+      command_line = []
+      VALID_OPTIONS.each do |option|
+        value = send(option.name)
+        command_line << option.to_command_line(value)
+      end
+      command_line.compact.join(' ')
+    end
+
+    protected
+
+    def check_option_keys(hash)
+      hash.keys.each do |key|
+        raise InvalidOptionError.new(key) unless VALID_OPTIONS.any? {|o| o.name == key.to_sym}
+      end
+    end
+
+    class InvalidOptionError < StandardError; end
+  end
+end

data/lib/deep_test/process_orchestrator.rb

@@ -0,0 +1,85 @@
+module DeepTest
+  class ProcessOrchestrator
+    def self.run(options, runner)
+      new(options, runner).run
+    end
+    
+    def initialize(options, runner)
+      @options = options
+      @runner = runner
+    end
+    
+    def run
+      stop_zombie_warlocks
+      start_warlock_server
+      start_all_workers
+      start_loader
+      wait_for_loader_to_be_done
+      exit_process        
+    ensure
+      stop_all_warlocks
+    end
+    
+  private
+
+    def exit_process
+      Kernel.exit($?.success? ? 0 : 1)
+    end
+
+    def start_all_workers
+      each_worker do |worker_num|
+        start_worker(worker_num) do
+          reseed_random_numbers
+          reconnect_to_database
+          worker = DeepTest::Worker.new(worker_num,
+                                        RindaBlackboard.new(@options), 
+                                        @options.new_worker_listener)
+          worker.run
+        end
+      end        
+    end
+
+    def reconnect_to_database
+      ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
+    end
+
+    def start_worker(worker_num, &blk)
+      @warlock.start("worker #{worker_num}", &blk)
+    end
+
+    def reseed_random_numbers
+      srand
+    end
+
+    def wait_for_loader_to_be_done
+      Process.wait(@loader_pid)
+    end
+
+    def start_warlock_server
+      @warlock.start("server") { DeepTest::Server.start }
+      sleep 0.5 # TODO: change from sleep to something better... Process.wait?
+    end
+
+    def stop_all_warlocks
+      @warlock.stop_all if @warlock
+    end
+
+    def each_worker
+      @options.number_of_workers.to_i.times { |worker_num| yield worker_num }
+    end
+
+    def stop_zombie_warlocks
+      @warlock = DeepTest::Warlock.new
+      Signal.trap("HUP") { warlock.stop_all; exit 0 }
+    end
+
+    def start_loader
+      @loader_pid = fork do
+        DeepTest.logger.debug "Loader Starting (#{$$})"
+        passed = @runner.process_work_units
+        exit(passed ? 0 : 1)
+      end
+    end
+
+  end
+end

data/lib/deep_test/rake_tasks.rb

@@ -1 +1,8 @@
+require File.dirname(__FILE__) + "/options"
 require File.dirname(__FILE__) + "/test_task"
+require File.dirname(__FILE__) + "/rspec_detector"
+
+DeepTest::RSpecDetector.if_rspec_available do
+  require 'spec/rake/spectask'
+  require File.dirname(__FILE__) + "/spec/extensions/spec_task"
+end

data/lib/deep_test/rinda_blackboard.rb

@@ -1,25 +1,26 @@
 module DeepTest
   class RindaBlackboard
-    def initialize(tuple_space = TupleSpaceFactory.tuple_space)
+    def initialize(options, tuple_space = TupleSpaceFactory.tuple_space)
+      @options = options
       @tuple_space = tuple_space
     end
     
     def take_result
-      result = @tuple_space.take ["test_result", nil], 30
+      result = @tuple_space.take ["test_result", nil], @options.timeout_in_seconds
       result[1]
     end
 
-    def take_test
-      tuple = @tuple_space.take ["run_test", nil, nil], 30
-      eval(tuple[1]).new(tuple[2])
+    def take_work
+      tuple = @tuple_space.take ["deep_work", nil], @options.timeout_in_seconds
+      tuple[1]
     end
 
     def write_result(result)
       @tuple_space.write ["test_result", result]
     end
 
-    def write_test(test_case)
-      @tuple_space.write ["run_test", test_case.class.to_s, test_case.method_name]
+    def write_work(work_unit)
+      @tuple_space.write ["deep_work", work_unit]
     end
   end
 end

data/lib/deep_test/rspec_detector.rb

@@ -0,0 +1,17 @@
+module DeepTest
+  class RSpecDetector
+    def self.if_rspec_available
+      begin
+        require 'rubygems'
+      rescue LoadError
+      else
+        begin
+          gem 'rspec'
+        rescue Gem::LoadError
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/server.rb

@@ -1,17 +1,11 @@
 module DeepTest
   class Server
-    PORT = 6969
+    PORT = 6969 unless defined?(PORT)
     
     def self.start
-      require 'rinda/ring'
-      require 'rinda/tuplespace'
-      require 'test/unit'
-      require 'test/unit/testresult'
-      require 'deep_test'
       DRb.start_service
-      ts = Rinda::TupleSpace.new
-      Rinda::RingServer.new(ts, PORT)
-      puts "Started DeepTest service at #{DRb.uri}"
+      Rinda::RingServer.new(Rinda::TupleSpace.new, PORT)
+      DeepTest.logger.info "Started DeepTest service at #{DRb.uri}"
       DRb.thread.join
     end
   end