xli-dtr 0.0.4 → 0.0.5

data/lib/dtr/test_unit.rb

@@ -12,278 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'dtr/base'
-require 'dtr/service_provider'
-require 'test/unit/testcase'
-require 'test/unit/util/observable'
-require 'monitor'
-require 'drb'
-require 'timeout'
-
-DTROPTIONS = {} unless defined?(DTROPTIONS)
-DTROPTIONS[:log_file] = 'dtr_master_process.log' unless DTROPTIONS[:log_file]
-
-module DTR
-  def reject
-    return unless Test::Unit::TestSuite.method_defined?(:dtr_injected?)
-    Test::Unit::TestCase.send(:include, Rejection)
-    Test::Unit::TestSuite.send(:include, Rejection)
-  end
-  
-  def inject
-    return if Test::Unit::TestSuite.method_defined?(:dtr_injected?)
-    Test::Unit::TestCase.send(:include, TestCaseInjection)
-    Test::Unit::TestSuite.send(:include, TestSuiteInjection)
-  end
-  
-  def service_provider
-    $dtr_service_provider ||= DTR::ServiceProvider.new
-  end
-
-  module_function :reject, :inject, :service_provider
-  
-  class Counter
-    
-    def initialize
-      extend MonitorMixin
-      @start_count, @finish_count = 0, 0
-      @complete_cond = new_cond
-    end
-
-    def add_start_count
-      synchronize do
-        @start_count += 1
-      end
-    end
-
-    def add_finish_count
-      synchronize do
-        @finish_count += 1
-        @complete_cond.signal
-      end
-    end
-    
-    def to_s
-      synchronize do
-        status
-      end
-    end
-    
-    def wait_until_complete
-      synchronize do
-        @complete_cond.wait_until {complete?}
-      end
-    end
-    
-    private
-    def complete?
-      DTR.info{ "Counter status: #{status}" }
-      @finish_count >= @start_count
-    end
-    
-    def status
-      "finish_count => #{@finish_count}, start_count => #{@start_count}"
-    end
-  end
-  
-  class ThreadSafeTestResult
-    include Test::Unit::Util::Observable
-    include DRbUndumped
-
-    def initialize(rs)
-      extend MonitorMixin
-      @rs = rs
-      @channels = @rs.send(:channels).dup
-      @rs.send(:channels).clear
-    end
-
-    def add_run
-      synchronize do
-        @rs.add_run
-      end  
-      notify_listeners(Test::Unit::TestResult::CHANGED, self)
-    end
-
-    def add_failure(failure)
-      synchronize do
-        @rs.add_failure(failure)
-      end  
-      notify_listeners(Test::Unit::TestResult::FAULT, failure)
-      notify_listeners(Test::Unit::TestResult::CHANGED, self)
-    end
-
-    def add_error(error)
-      synchronize do
-        @rs.add_error(error)
-      end  
-      notify_listeners(Test::Unit::TestResult::FAULT, error)
-      notify_listeners(Test::Unit::TestResult::CHANGED, self)
-    end
-
-    def add_assertion
-      synchronize do
-        @rs.add_assertion
-      end  
-      notify_listeners(Test::Unit::TestResult::CHANGED, self)
-    end
-
-    def to_s
-      synchronize do
-        @rs.to_s
-      end  
-    end
-
-    def passed?
-      synchronize do
-        @rs.passed?
-      end  
-    end
-
-    def failure_count
-      synchronize do
-        @rs.failure_count
-      end  
-    end
-    
-    def error_count
-      synchronize do
-        @rs.error_count
-      end  
-    end
-  end
-
-  class DRbTestRunner
-    
-    # because some test case will rewrite TestCase#run to ignore some tests, which
-    # makes TestResult#run_count different with TestSuite#size, so we need to count
-    # by ourselves.(for example: ActionController::IntegrationTest)
-    class << self
-      def counter
-        @counter ||= Counter.new
-      end
-    end
-    
-    RUN_TEST_FINISHED = "::DRbTestRunner::RUN_TEST_FINISHED"
-    DEFAULT_RUN_TEST_TIMEOUT = 60 #seconds
-    
-    def initialize(test, result, &progress_block)
-      @test = test
-      @result = result
-      @progress_block = progress_block
-      
-      DRbTestRunner.counter.add_start_count
-    end
-    
-    def run
-      if runner = lookup_runner
-        run_test_on(runner)
-      else
-        self.run
-      end
-    end
-    
-    def run_test_on(runner)
-      Thread.start do
-        begin
-          Timeout.timeout(ENV['RUN_TEST_TIMEOUT'] || DEFAULT_RUN_TEST_TIMEOUT) do
-            runner.run(@test, @result, &@progress_block)
-          end
-          @progress_block.call(RUN_TEST_FINISHED, @test.name)
-        rescue Timeout::Error => e
-          DTR.info {"Run test timeout(#{ENV['RUN_TEST_TIMEOUT'] || DEFAULT_RUN_TEST_TIMEOUT}), reboot runner"}
-          runner.reboot rescue nil
-          DTR.info {"rerun test: #{@test.name}"}
-          self.run
-        rescue DRb::DRbConnError => e
-          DTR.info {"DRb::DRbConnError(#{e.message}), rerun test: #{@test.name}"}
-          self.run
-        rescue Exception => e
-          DTR.info{ "#{test.name}, rescue an exception: #{e.message}, add error into result." }
-          @result.add_error(Test::Unit::Error.new(@test.name, e))
-          @result.add_run
-          @progress_block.call(Test::Unit::TestCase::FINISHED, @test.name)
-          @progress_block.call(RUN_TEST_FINISHED, @test.name)
-        end
-      end
-    end
-    
-    def lookup_runner
-      runner = DTR.service_provider.lookup_runner
-      begin
-        DTR.debug {"#{runner.name}.env ==?: #{WorkingEnv.current[:identifier] == runner.identifier}"}
-        return runner if runner.identifier == WorkingEnv.current[:identifier]
-        runner.shutdown
-      rescue DRb::DRbConnError => e
-        DTR.debug {"DRb::DRbConnError(#{e.message})"}
-      end
-      nil
-    end
-  end
-  
-  module TestCaseInjection
-    
-    def self.included(base)
-      base.class_eval do
-        alias_method :__run__, :run
-
-        def run(result, &progress_block)
-          DTR.debug {"start of run TestCase(#{name})"}
-          DRbTestRunner.new(self, result, &progress_block).run
-          DTR.debug {"end of run TestCase(#{name})"}
-        end
-      end
-    end  
-  end
-
-  module TestSuiteInjection
-    def self.included(base)
-      base.class_eval do
-        def dtr_injected?
-          true
-        end
-
-        alias_method :__run__, :run
-        
-        def run(result, &progress_block)
-          DTR.info { "start of run suite(#{name}), size: #{size};"}
-          
-          if result.kind_of?(ThreadSafeTestResult)
-            __run__(result, &progress_block)
-          else
-            if defined?(ActiveRecord::Base)
-              ActiveRecord::Base.clear_active_connections! rescue nil
-            end
-            
-            DTR.service_provider.setup_working_env WorkingEnv.refresh
-            
-            puts 'Refreshed dtr working environment, looking for runner service...' unless ENV['DTR_ENV'] == 'test'
-            DTR.info {"Master process started at #{Time.now}"}
-            result = ThreadSafeTestResult.new(result)
-            __run__(result) do |channel, value|
-              DTR.debug { "=> channel: #{channel}, value: #{value}" }
-              progress_block.call(channel, value)
-              if channel == DTR::DRbTestRunner::RUN_TEST_FINISHED
-                DRbTestRunner.counter.add_finish_count
-              end
-            end
-            DRbTestRunner.counter.wait_until_complete
-            DTR.debug { "==> teardown" }
-            DTR.service_provider.teardown_working_env
-          end
-          DTR.info { "end of run suite(#{name}), test result status: #{result}, counter status: #{DRbTestRunner.counter}"}
-        end
-      end
-    end
-  end
-  
-  module Rejection
-    def self.included(base)
-      base.class_eval do
-        remove_method :dtr_injected? if base.method_defined?(:dtr_injected?)
-        remove_method :run
-        alias_method :run, :__run__
-        remove_method :__run__
-      end
-    end
-  end
-end
+require 'dtr/master'
+
+require 'dtr/test_unit/worker_club'
+require 'dtr/test_unit/thread_safe_test_result'
+require 'dtr/test_unit/drb_test_runner'
+require 'dtr/test_unit/test_case_injection'
+require 'dtr/test_unit/testrunnermediator_injection'
+require 'dtr/test_unit/injection'

data/lib/dtr/test_unit_injection.rb

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'dtr/service_provider'
 require 'dtr/test_unit'
 $argv_dup = ARGV.dup.delete_if{|f| f.include?('dtr/test_unit_injection')}
 

data/lib/dtr.rb

@@ -12,100 +12,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-DTRVERSION="0.0.4"
-DTROPTIONS = {} unless defined?(DTROPTIONS)
-
-require 'fileutils'
+DTRVERSION="0.0.5"
+DTR_AGENT_OPTIONS = {:runners => [], :agent_env_setup_cmd => nil}
 
 module DTR
 
-  def start_server
-    require 'dtr/service_provider'
-    ServiceProvider.new.start
-  end
-  
-  def start_runners
-    launch_runners(DTROPTIONS[:names], DTROPTIONS[:setup])
+  def start_agent
+    launch_agent(DTR_AGENT_OPTIONS[:runners], DTR_AGENT_OPTIONS[:agent_env_setup_cmd])
   end
-  
-  def launch_runners(names, setup=nil)
-    require 'dtr/runner'
+
+  def launch_agent(names, setup=nil)
+    require 'dtr/agent'
     names = names || "DTR(#{Time.now})"
-    DTR::RunnerAgent.start(names, setup)
+    DTR::Agent.start(names, setup)
   end
-  
+
   def lib_path
     File.expand_path(File.dirname(__FILE__))
   end
-  
+
   def broadcast_list=(list)
-    require 'dtr/service_provider'
-    ServiceProvider.broadcast_list = list
+    require 'dtr/shared'
+    DTR.configuration.broadcast_list = list
+    DTR.configuration.save
   end
-  
+
   def port=(port)
-    require 'dtr/service_provider'
-    ServiceProvider.port = port 
+    require 'dtr/shared'
+    DTR.configuration.rinda_server_port = port
+    DTR.configuration.save
   end
-  
-  def runners
-    require 'dtr/service_provider'
-    ServiceProvider.new.runners
-  end
-  
+
   def monitor
-    require 'dtr/service_provider'
-    DTROPTIONS[:log_file] = 'dtr_monitor.log'
-    ServiceProvider.new.monitor
+    require 'dtr/monitor'
+    DTR.logger('dtr_monitor.log')
+    Monitor.new.start
   end
-  
-  def stop_runners_daemon_mode
-    with_daemon_gem do
-      Daemons.run_proc "dtr_runners", :ARGV => ['stop'] 
-    end
-  end
-  
-  def start_runners_daemon_mode
-    with_daemon_gem do
-      FileUtils.rm_rf('dtr_runners.output')
-      pwd = Dir.pwd
-      Daemons.run_proc "dtr_runners", :ARGV => ['start'], :backtrace => true  do
-        Dir.chdir(pwd) do
-          start_runners
-        end
-      end
-    end
-  end
-  
-  def start_server_daemon_mode
-    with_daemon_gem do
-      Daemons.run_proc "dtr_server", :ARGV => ['start'] do
-        start_server
-      end
-    end
-    sleep(2)
-  end
-  
-  def stop_server_daemon_mode
-    with_daemon_gem do
-      Daemons.run_proc "dtr_server", :ARGV => ['stop']
-    end
-  end
-  
-  def with_daemon_gem
-    require "rubygems"
-    begin
-      require "daemons"
-    rescue LoadError
-      raise "The daemons gem must be installed"
-    end
-    yield
-  end
-  
-  def clean_server
-    require 'dtr/service_provider'
-    ServiceProvider.new.clear_workspace
-  end
-  
-  module_function :start_server, :start_runners, :launch_runners, :lib_path, :broadcast_list=, :runners, :with_daemon_gem, :start_runners_daemon_mode, :stop_runners_daemon_mode, :start_server_daemon_mode, :stop_server_daemon_mode, :monitor, :port=, :clean_server
+
+  module_function :start_agent, :launch_agent, :lib_path, :broadcast_list=, :monitor, :port=
 end

data/test/acceptance/agent_working_env_test.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+include DTR::AgentHelper
+
+class AgentWorkingEnvTest < Test::Unit::TestCase
+  include DTR::Service::WorkingEnv
+  def setup
+    #start_agents first for test files loaded would be copied into sub processes
+    start_agents
+    DTR.inject
+  end
+
+  def teardown
+    DTR.reject
+    stop_agents
+    $argv_dup = nil
+  end
+
+  def test_run_2_project_should_be_independence
+    Dir.chdir(File.expand_path(File.dirname(__FILE__) + "/../../testdata/")) do
+      $argv_dup = ['an_error_test_case.rb']
+      require 'an_error_test_case'
+
+      suite = Test::Unit::TestSuite.new('test_run_2_project_should_be_independence 1')
+      suite << AnErrorTestCase.suite
+
+      assert_fork_process_exits_ok do
+        @result = runit(suite)
+
+        assert_false @result.passed?
+        assert_equal 1, @result.run_count
+        assert_equal 0, @result.failure_count
+        assert_equal 1, @result.error_count
+      end
+    end
+
+    Dir.chdir(File.expand_path(File.dirname(__FILE__) + "/../../testdata/another_project")) do
+      $argv_dup = ['passed_test_case.rb']
+      require 'passed_test_case'
+      suite = Test::Unit::TestSuite.new('test_run_2_project_should_be_independence 2')
+      suite << PassedTestCase.suite
+
+      assert_fork_process_exits_ok do
+        @result = runit(suite)
+
+        assert @result.passed?
+        assert_equal 1, @result.run_count
+        assert_equal 0, @result.failure_count
+        assert_equal 0, @result.error_count
+      end
+    end
+  end
+
+  def test_run_same_project_twice_should_be_independence
+    Dir.chdir(File.expand_path(File.dirname(__FILE__) + "/../../testdata/another_project")) do
+      $argv_dup = ['passed_test_case.rb']
+      require 'passed_test_case'
+      suite = Test::Unit::TestSuite.new('test_run_same_project_twice_should_be_independence 1')
+      suite << PassedTestCase.suite
+
+      assert_fork_process_exits_ok do
+        @result = runit(suite)
+
+        assert @result.passed?
+        assert_equal 1, @result.run_count
+        assert_equal 0, @result.failure_count
+        assert_equal 0, @result.error_count
+      end
+    end
+
+    Dir.chdir(File.expand_path(File.dirname(__FILE__) + "/../../testdata/another_project")) do
+      FileUtils.cp("./../an_error_test_case.rb", '.')
+      begin
+        $argv_dup = ['an_error_test_case.rb']
+        require 'an_error_test_case'
+        suite = Test::Unit::TestSuite.new('test_run_same_project_twice_should_be_independence 2')
+        suite << AnErrorTestCase.suite
+
+        assert_fork_process_exits_ok do
+          @result = runit(suite)
+
+          assert_false @result.passed?
+          assert_equal 1, @result.run_count
+          assert_equal 0, @result.failure_count
+          assert_equal 1, @result.error_count
+        end
+      ensure
+        FileUtils.rm_f('an_error_test_case.rb')
+      end
+    end
+  end
+end

data/test/acceptance/dtr_package_task_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'fileutils'
+
+class DTRPackageTaskTest < Test::Unit::TestCase
+  def test_package
+    testdata_dir = File.expand_path(File.dirname(__FILE__) + '/../../testdata')
+    Dir.chdir(testdata_dir) do
+      %x[rake --rakefile package_task_test_rakefile dtr_package]
+      assert File.exists?(testdata_dir + "/dtr_pkg/codebase-dump/a_test_case2.rb")
+      assert File.exists?(testdata_dir + "/dtr_pkg/codebase-dump/lib/lib_test_case.rb")
+      assert File.exists?(testdata_dir + "/dtr_pkg/codebase-dump/is_required_by_a_test.rb")
+
+      assert File.exists?(testdata_dir + "/dtr_pkg/codebase-dump.tar.bz2")
+
+      %x[rake --rakefile package_task_test_rakefile dtr_clobber_package]
+
+      assert !File.exists?(testdata_dir + "/dtr_pkg/codebase-dump/a_test_case2.rb")
+      assert !File.exists?(testdata_dir + "/dtr_pkg/codebase-dump/lib/lib_test_case.rb")
+      assert !File.exists?(testdata_dir + "/dtr_pkg/codebase-dump/is_required_by_a_test.rb")
+
+      assert !File.exists?(testdata_dir + "/dtr_pkg/codebase-dump.tar.bz2")
+    end
+  ensure
+    FileUtils.rm_rf(testdata_dir + "/dtr_pkg") rescue nil
+  end
+end