deep_test 1.1.2 → 1.1.3

data/lib/deep_test/spec.rb

@@ -0,0 +1,9 @@
+require 'spec/runner/example_group_runner'
+require 'spec/rake/spectask'
+
+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/options.rb

@@ -0,0 +1,11 @@
+module Spec
+  module Runner
+    class Options
+      def run_one_example(file, line_number)
+        @examples = [SpecParser.new.spec_name_for(file, line_number)]
+        ExampleGroupRunner.new(self).run
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+require 'spec/runner/reporter'
+module Spec
+  module Runner
+    class Reporter
+      def failure(example, error)
+        backtrace_tweaker.tweak_backtrace(error)
+        example_name = "#{example.class.description} #{example.description}"
+        failure = Failure.new(example_name, error)
+        @failures << failure
+        formatters.each do |f|
+          f.example_failed(example, @failures.length, failure)
+        end
+      end
+      alias_method :example_failed, :failure
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+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")
+        spec_opts << "--require #{deep_test_path}"
+        spec_opts << "--runner 'DeepTest::Spec::Runner:#{deep_test_options.to_command_line}'"
+      end
+    end
+  end
+end

data/lib/deep_test/spec/runner.rb

@@ -0,0 +1,48 @@
+module DeepTest
+  module Spec
+    class Runner < ::Spec::Runner::ExampleGroupRunner
+      def initialize(options, deep_test_options, blackboard = nil)
+        super(options)
+        @deep_test_options = DeepTest::Options.from_command_line(deep_test_options)
+        @blackboard = blackboard
+      end
+
+      def blackboard
+        # Can't create blackboard as default argument to initialize
+        # because ProcessOrchestrator hasn't been invoked at 
+        # instantiation time
+        @blackboard ||= RindaBlackboard.new(@deep_test_options)
+      end
+
+      def run
+        ProcessOrchestrator.run(@deep_test_options, self)
+      end
+
+      def process_work_units
+        prepare
+
+        examples = example_groups.map {|g| g.send(:examples_to_run)}.flatten
+        examples_by_location = {}
+        examples.each do |example|
+          file, line, *rest = example.implementation_backtrace.first.split(/:/)
+          examples_by_location["#{file}:#{line}"] = example
+          blackboard.write_work Spec::WorkUnit.new(file, line.to_i)
+        end
+
+        success = true
+        until examples_by_location.empty?
+          result = blackboard.take_result
+          next unless result
+          print result.output if result.output
+          example = examples_by_location.delete("#{result.file}:#{result.line}")
+          @options.reporter.example_finished(example, result.error)
+          success &= result.error.nil?
+        end
+
+        success
+      ensure
+        finish
+      end
+    end
+  end
+end

data/lib/deep_test/spec/work_result.rb

@@ -0,0 +1,26 @@
+module DeepTest
+  module Spec
+    class WorkResult
+      attr_reader :file, :line, :example_description, :error, :output
+      def initialize(file, line, example_description, error, output)
+        @file, @line, @example_description, @error, @output = 
+         file,  line,  example_description,  error,  output
+      end
+
+      def ==(other)
+                       file == other.file &&
+                       line == other.line &&
+        example_description == other.example_description &&
+                      error == other.error 
+      end
+
+      def failed_due_to_deadlock?
+        DeadlockDetector.due_to_deadlock?(@error)
+      end
+
+      def deadlock_result
+        WorkResult.new(file, line, example_description, nil, '-deadlock-')
+      end
+    end
+  end
+end

data/lib/deep_test/spec/work_unit.rb

@@ -0,0 +1,53 @@
+module DeepTest
+  module Spec
+    class WorkUnit
+      def initialize(file, line)
+        @file, @line = file, line
+      end
+
+      def run
+        # Dup options here to avoid clobbering the reporter on someone
+        # elses options reference (Such as ExampleGroupRunner)
+        original_options, $rspec_options = $rspec_options, $rspec_options.dup
+        rspec_options.reporter = ResultReporter.new(@file, @line)
+        result = run_without_deadlock_protection
+        result = run_without_deadlock_protection if result.failed_due_to_deadlock?
+        result = result.deadlock_result if result.failed_due_to_deadlock?
+        result
+      ensure
+        $rspec_options = original_options
+      end
+
+      protected
+
+      def run_without_deadlock_protection
+        output = capture_stdout do
+          rspec_options.run_one_example(@file, @line)
+        end
+        rspec_options.reporter.result(output)
+      end
+
+      class ResultReporter
+        attr_reader :result
+        def initialize(file,line)
+          @file, @line = file, line
+        end
+
+        def add_example_group(example_group); end
+        def dump; end
+        def end; end
+        def example_started(name); end
+
+        def example_finished(example, error)
+          @example, @error = example, error
+        end
+
+        def result(output)
+          Spec::WorkResult.new(@file, @line, @example.description, @error, output)
+        end
+
+        def start(example); end
+      end
+    end
+  end
+end

data/lib/deep_test/test.rb

@@ -0,0 +1,9 @@
+require "test/unit/testresult"
+require "test/unit/error"
+require 'test/unit/failure'
+
+require File.dirname(__FILE__) + "/test/extensions/test_result"
+require File.dirname(__FILE__) + "/test/extensions/error"
+require File.dirname(__FILE__) + "/test/runner"
+require File.dirname(__FILE__) + "/test/supervised_test_suite"
+require File.dirname(__FILE__) + "/test/work_unit"

data/lib/deep_test/{extensions/testresult.rb → test/extensions/test_result.rb}

@@ -10,7 +10,7 @@ module Test
       end
       
       def failed_due_to_deadlock?
-        @errors.any? && !@errors.last.message.to_s.match(/Deadlock found when trying to get lock/).nil?
+        @errors.any? && DeepTest::DeadlockDetector.due_to_deadlock?(@errors.last)
       end
     end
   end

data/lib/deep_test/test/runner.rb

@@ -0,0 +1,29 @@
+module DeepTest
+  module Test
+    class Runner
+      unless defined?(NO_FILTERS)
+        NO_FILTERS = Object.new.instance_eval do
+          def filters; []; end;
+          self
+        end
+      end
+
+      def initialize(options)
+        @options = options
+      end
+
+      def load_files
+        Dir.glob(@options.pattern).each { |file| load file }
+        ::Test::Unit.run = true
+      end
+
+      def process_work_units
+        suite = ::Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
+        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, RindaBlackboard.new(@options))
+        require 'test/unit/ui/console/testrunner'
+        result = ::Test::Unit::UI::Console::TestRunner.run(supervised_suite, ::Test::Unit::UI::NORMAL)
+        result.passed?
+      end
+    end
+  end
+end

data/lib/deep_test/test/supervised_test_suite.rb

@@ -0,0 +1,46 @@
+module DeepTest
+  module Test
+    class SupervisedTestSuite
+      def initialize(suite, blackboard)
+        @suite = suite
+        @blackboard = blackboard
+      end
+
+      def run(result, &progress_block)
+        yield ::Test::Unit::TestSuite::STARTED, @suite.name
+        count = add_tests @suite
+        read_results result, count, &progress_block
+        yield ::Test::Unit::TestSuite::FINISHED, @suite.name
+      end
+
+      def size
+        @suite.size
+      end
+
+      def add_tests(test_suite)
+        count = 0
+        if test_suite.respond_to? :tests
+          test_suite.tests.each do |test| 
+            count += add_tests(test)
+          end
+        else
+          count += 1
+          @blackboard.write_work Test::WorkUnit.new(test_suite)
+        end
+        count
+      end
+
+      def read_results(result, count)
+        while count > 0
+          remote_result = @blackboard.take_result
+          next unless remote_result
+          count -= 1
+          remote_result.add_to result
+          # TODO: is this the right place for this next line? -Dan
+          print remote_result.output if remote_result.output
+          yield ::Test::Unit::TestCase::FINISHED, nil if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/test/work_unit.rb

@@ -0,0 +1,36 @@
+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 = ::Test::Unit::TestResult.new
+          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
+
+      protected
+
+      def run_without_deadlock_protection
+        result = ::Test::Unit::TestResult.new
+        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

@@ -1,10 +1,9 @@
 module DeepTest
   class TestTask
-    DEFAULT_NUMBER_OF_WORKERS = 2
-    attr_writer :number_of_workers, :pattern
-
     def initialize(name = :deep_test)
       @name = name
+      @options = Options.new({})
+      self.pattern = "test/**/*_test.rb"
       yield self if block_given?
       define
     end
@@ -12,18 +11,46 @@ module DeepTest
     def define
       desc "Run '#{@name}' suite using DeepTest"
       task @name do
-        deep_test_lib = File.expand_path(File.dirname(__FILE__) + "/..")
-        runner = File.expand_path(File.dirname(__FILE__) + "/../../script/run_test_suite.rb")
-        ruby "-I#{deep_test_lib} #{runner} '#{number_of_workers}' '#{pattern}'"
+        ruby "#{runner} '#{@options.to_command_line}'"
       end
     end
-    
+
     def number_of_workers
-      @number_of_workers ? @number_of_workers.to_i : DEFAULT_NUMBER_OF_WORKERS
+      @options.number_of_workers
+    end
+
+    def number_of_workers=(num)
+      @options.number_of_workers = num
     end
 
     def pattern
-      Dir.pwd + "/" + (@pattern || "test/**/*_test.rb")
+      @options.pattern
+    end
+
+    def pattern=(pattern)
+      @options.pattern = Dir.pwd + "/" + pattern
+    end
+
+    def timeout_in_seconds=(seconds)
+      @options.timeout_in_seconds = seconds
     end
+
+    def timeout_in_seconds
+      @options.timeout_in_seconds
+    end
+
+    def worker_listener=(listener)
+      @options.worker_listener = listener
+    end
+
+    def worker_listener
+      @options.worker_listener
+    end
+
+  private
+
+    def runner
+      File.expand_path(File.dirname(__FILE__) + "/../../script/run_test_suite.rb")
+    end    
   end
 end

data/lib/deep_test/tuple_space_factory.rb

@@ -2,9 +2,10 @@ module DeepTest
   class TupleSpaceFactory
     def self.tuple_space
       require "rinda/ring"
+      require "socket"
       DRb.start_service
-      ts = Rinda::RingFinger.new(['localhost'],DeepTest::Server::PORT).lookup_ring_any
-      puts "Connected to DeepTest server at #{ts.__drburi}"
+      ts = Rinda::RingFinger.new([Socket.gethostname],DeepTest::Server::PORT).lookup_ring_any
+      DeepTest.logger.debug "Connected to DeepTest server at #{ts.__drburi}"
       Rinda::TupleSpaceProxy.new ts      
     end
   end

data/lib/deep_test/warlock.rb

@@ -13,7 +13,7 @@ module DeepTest
         end
         raise "fatal: fork returned nil" if pid.nil?
         @demons << [name, pid]
-        puts "Started #{name} (#{pid})"
+        DeepTest.logger.debug "Started #{name} (#{pid})"
       rescue => e
         puts "exception starting #{name}: #{e}"
         puts "\t" + e.backtrace.join("\n\t")
@@ -34,7 +34,7 @@ module DeepTest
         rescue Errno::ECHILD => e
           puts e
         end
-        puts "Stopped #{name} (#{pid})"
+        DeepTest.logger.debug "Stopped #{name} (#{pid})"
       end
     end
 

data/lib/deep_test/worker.rb

@@ -1,31 +1,21 @@
 module DeepTest
   class Worker
-    def initialize(blackboard = DeepTest::RindaBlackboard.new)
+    attr_reader :number
+
+    def initialize(number, blackboard, worker_listener)
+      @number = number
       @blackboard = blackboard
+      @listener = worker_listener
     end
 
     def run
-      while test_case = @blackboard.take_test
-        result = run_test_case test_case
-        result = run_test_case test_case if result.failed_due_to_deadlock?
-        if result.failed_due_to_deadlock?
-          result = Test::Unit::TestResult.new
-          result.add_run
-          result.output = "-deadlock-"
-        end
+      @listener.starting(self)
+      while work_unit = @blackboard.take_work
+        @listener.starting_work(self, work_unit)
+        result = work_unit.run
+        @listener.finished_work(self, work_unit, result)
         @blackboard.write_result result
       end
     end
-    
-    protected
-    
-    def run_test_case(test_case)
-      result = Test::Unit::TestResult.new
-      output = capture_stdout do
-        test_case.run(result) {|channel,event|}
-      end
-      result.output = output
-      result
-    end
   end
 end