deep_test_pre 2.0

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

@@ -0,0 +1,21 @@
+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(DeepTest::LIB_ROOT + "/deep_test")
+        @deep_test_spec_opts = [
+          "--require #{deep_test_path}",
+          "--runner 'DeepTest::Spec::Runner:#{deep_test_options.to_command_line}'"
+        ]
+        spec_opts.concat @deep_test_spec_opts
+      end
+
+      def spec_opts=(options)
+        @spec_opts = (@deep_test_spec_opts || []) + options
+      end
+    end
+  end
+end

data/lib/deep_test/spec/runner.rb

@@ -0,0 +1,72 @@
+module DeepTest
+  module Spec
+    class Runner < ::Spec::Runner::ExampleGroupRunner
+      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)
+      end
+
+      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
+        @central_command ||= main.central_command
+      end
+
+      def load_files(files)
+        main.load_files files
+      end
+
+      def run
+        main.run
+      end
+
+      def process_work_units(central_command)
+        prepare
+
+        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
+          central_command.write_work Spec::WorkUnit.new(example.identifier)
+        end
+
+        success = true
+
+        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_examples.empty?
+
+        if missing_examples.any?
+          @options.reporter.example_finished(examples_by_location[missing_examples.keys.first],
+                                             IncompleteTestRunError.new(missing_examples.size))
+        end
+
+        success
+      ensure
+        finish
+      end
+    end
+  end
+end

data/lib/deep_test/spec/work_result.rb

@@ -0,0 +1,35 @@
+module DeepTest
+  module Spec
+    class WorkResult
+      include CentralCommand::Result
+
+      attr_reader :identifier, :output
+
+      def initialize(identifier, error, output)
+        @identifier, @output = identifier, output
+        @error = MarshallableExceptionWrapper.new error if error
+      end
+
+      def error
+        @error.resolve if @error
+      end
+
+      def ==(other)
+        identifier == other.identifier && 
+            @error == other.instance_variable_get(:@error) 
+      end
+
+      def failed_due_to_deadlock?
+        DeadlockDetector.due_to_deadlock?(@error)
+      end
+
+      def success?
+        error.nil? || ::Spec::Example::ExamplePendingError === error
+      end
+
+      def deadlock_result
+        WorkResult.new(identifier, nil, '-deadlock-')
+      end
+    end
+  end
+end

data/lib/deep_test/spec/work_unit.rb

@@ -0,0 +1,59 @@
+module DeepTest
+  module Spec
+    class WorkUnit
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def run
+        # Dup options here to avoid clobbering the reporter on someone
+        # elses options reference (Such as ExampleGroupRunner)
+        original_options = ::Spec::Runner.options
+        ::Spec::Runner.use ::Spec::Runner.options.dup
+        ::Spec::Runner.options.reporter = ResultReporter.new(@identifier)
+        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
+        ::Spec::Runner.use original_options
+      end
+
+      def to_s
+        "#{@identifier.group_description}: #{@identifier.description}"
+      end
+
+      protected
+
+      def run_without_deadlock_protection
+        output = capture_stdout do
+          ::Spec::Runner.options.run_one_example(@identifier)
+        end
+        ::Spec::Runner.options.reporter.result(output)
+      end
+
+      class ResultReporter
+        attr_reader :result
+
+        def initialize(identifier)
+          @identifier = identifier 
+        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(@identifier, @error, output)
+        end
+
+        def start(example); end
+      end
+    end
+  end
+end

data/lib/deep_test/test.rb

@@ -0,0 +1,10 @@
+require "test/unit/testresult"
+require "test/unit/error"
+require 'test/unit/failure'
+require 'test/unit/autorunner'
+
+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"
+require File.dirname(__FILE__) + "/test/work_result"

data/lib/deep_test/test/extensions/error.rb

@@ -0,0 +1,14 @@
+module Test
+  module Unit
+    class Error
+      def resolve_marshallable_exception
+        @exception = @exception.resolve if @exception.kind_of?(DeepTest::MarshallableExceptionWrapper)
+      end
+
+      def make_exception_marshallable
+        return if @exception.kind_of?(DeepTest::MarshallableExceptionWrapper)
+        @exception = DeepTest::MarshallableExceptionWrapper.new(@exception)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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 process_work_units(central_command)
+        suite = ::Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
+        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?
+      end
+    end
+  end
+end

data/lib/deep_test/test/supervised_test_suite.rb

@@ -0,0 +1,48 @@
+module DeepTest
+  module Test
+    class SupervisedTestSuite
+      def initialize(suite, central_command)
+        @suite = suite
+        @central_command = central_command
+      end
+
+      def run(result, &progress_block)
+        yield ::Test::Unit::TestSuite::STARTED, @suite.name
+        tests_by_name = {}
+        add_tests @suite, tests_by_name
+        read_results result, tests_by_name, &progress_block
+        yield ::Test::Unit::TestSuite::FINISHED, @suite.name
+      end
+
+      def size
+        @suite.size
+      end
+
+      def add_tests(test_suite, tests_by_name)
+        if test_suite.respond_to? :tests
+          test_suite.tests.each do |test| 
+            add_tests(test, tests_by_name)
+          end
+        else
+          tests_by_name[test_suite.name] = 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(@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
+
+        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" }
+      end
+    end
+  end
+end

data/lib/deep_test/test/work_result.rb

@@ -0,0 +1,35 @@
+module DeepTest
+  module Test
+    class WorkResult < ::Test::Unit::TestResult
+      include CentralCommand::Result
+      attr_reader :identifier
+      attr_accessor :output
+
+      def initialize(identifier)
+        super()
+        @identifier = identifier
+      end
+
+      def add_to(result)
+        @failures.each {|e| result.add_failure(e)}
+
+        @errors.each do |e| 
+          e.resolve_marshallable_exception
+          result.add_error(e)
+        end
+
+        assertion_count.times {result.add_assertion}
+        run_count.times {result.add_run}
+      end
+
+      def add_error(error)
+        error.make_exception_marshallable
+        super(error)
+      end
+      
+      def failed_due_to_deadlock?
+        @errors.any? && DeepTest::DeadlockDetector.due_to_deadlock?(@errors.last)
+      end
+    end
+  end
+end

data/lib/deep_test/test/work_unit.rb

@@ -0,0 +1,40 @@
+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 = WorkResult.new(@test_case.name)
+          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
+
+      def to_s
+        @test_case.to_s
+      end
+
+      protected
+
+      def run_without_deadlock_protection
+        result = WorkResult.new(@test_case.name)
+        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

@@ -0,0 +1,47 @@
+module DeepTest
+  class TestTask
+    attr_accessor :libs, :requires
+
+    def initialize(name = :deep_test)
+      @requires = []
+      @name = name
+      @libs = ["lib"]
+      @options = Options.new({})
+      self.pattern = "test/**/*_test.rb"
+      yield self if block_given?
+      define
+    end
+    
+    def define
+      require 'rake'
+      desc "Run '#{@name}' suite using DeepTest"
+      task @name do
+        lib_options = @libs.any? ? "-I" + @libs.join(File::PATH_SEPARATOR) : ""
+        require_options = requires.map {|f| "-r#{f}"}.join(" ")
+        ruby "#{lib_options} #{require_options} #{runner} '#{@options.to_command_line}'"
+      end
+    end
+
+    Options::VALID_OPTIONS.each do |option|
+      eval <<-end_src
+        def #{option.name}
+          @options.#{option.name}
+        end
+
+        def #{option.name}=(value)
+          @options.#{option.name} = value
+        end
+      end_src
+    end
+
+    def pattern=(pattern)
+      @options.pattern = Dir.pwd + "/" + pattern
+    end
+
+  private
+
+    def runner
+      File.expand_path(File.dirname(__FILE__) + "/test/run_test_suite.rb")
+    end    
+  end
+end

data/lib/deep_test/ui/console.rb

@@ -0,0 +1,74 @@
+module DeepTest
+  module UI
+    class Console
+      def initialize(options)
+      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",
+      } 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
+      end
+
+      def dispatch_starting(method_name)
+        @spinner.stop if @spinner
+        @spinner = Spinner.new(label(method_name))
+        @spinner.start
+      end
+
+      def label(method_name)
+        METHOD_DESCRIPTIONS[method_name.to_sym] || method_name.to_s
+      end
+
+      def dispatch_finished(method_name)
+        @spinner.stop if @spinner
+        @spinner = nil
+      end
+
+      class Spinner
+        FRAMES = ['|', '/', '-', '\\'] unless defined?(FRAMES)
+        BACKSPACE = "\x08"  unless defined?(BACKSPACE)
+        SECONDS_PER_FRAME = 0.5 / 4 unless defined?(SECONDS_PER_FRAME)
+
+        def initialize(label)
+          @label = label
+        end
+
+        def start
+          @start_time = Time.now
+          show "#{@label}: "
+          @thread = Thread.new do
+            index = 0
+            loop do
+              show FRAMES[index]
+              sleep SECONDS_PER_FRAME
+              show BACKSPACE
+              index = (index + 1) % FRAMES.length
+            end
+          end 
+        end
+
+        def stop
+          @stop_time = Time.now
+          @thread.kill if @thread
+          show BACKSPACE
+          show("finished in %.2f seconds\n" % (@stop_time.to_f - @start_time.to_f))
+        end
+
+        def show(string)
+          $stdout.print string
+          $stdout.flush
+        end
+      end
+    end
+  end
+end