deep_test 1.1.4 → 1.2.0

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

@@ -0,0 +1,46 @@
+module Spec
+  module Example
+    module ExampleMethods
+      def identifier
+        file, line = implementation_backtrace.first.split(/:/)
+        Identifier.new(file, line.to_i, self.class.description, description)
+      end
+
+      class Identifier
+        attr_reader :file, :line, :group_description, :description
+        def initialize(file, line, group_description, description)
+          @file, @line, @group_description, @description = 
+           file,  line,  group_description,  description
+        end
+
+        def ==(other)
+          eql?(other)
+        end
+
+        def eql?(other)
+          File.basename(file) == File.basename(other.file) && 
+                         line == other.line &&
+            group_description == other.group_description &&
+                  description == other.description
+        end
+
+        def hash
+          description.hash
+        end
+
+        def locate(groups)
+          groups.each do |group|
+            group.examples.each do |example|
+              return example if example.identifier == self
+            end
+          end
+          raise "Unable to locate example #{self}"
+        end
+
+        def to_s
+          "#{group_description} #{description}"
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,41 @@
 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
+      def run_one_example(identifier)
+        example = identifier.locate(example_groups)
+        SingleExampleRunner.new(self, example).run
+      end
+
+      class SingleExampleRunner < ExampleGroupRunner
+        def initialize(options, example)
+          super(options)
+          @example = example
+          example_group.extend ExampleGroupHelper
+        end
+
+        def example_group
+          @example.class
+        end
+
+        def example_groups
+          [example_group]
+        end
+
+        def run
+          example_group.with_example_objects([@example]) do
+            super
+          end
+        end
+
+        module ExampleGroupHelper
+          def with_example_objects(example_objects)
+            original_example_objects = @example_objects
+            @example_objects = example_objects
+            yield
+          ensure
+            @example_objects = original_example_objects
+          end
+        end
       end
     end
   end

data/lib/deep_test/spec/runner.rb

@@ -4,18 +4,24 @@ module DeepTest
       def initialize(options, deep_test_options, blackboard = nil)
         super(options)
         @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 
         # instantiation time
-        @blackboard ||= RindaBlackboard.new(@deep_test_options)
+        @blackboard ||= @deep_test_options.server
+      end
+
+      def load_files(files)
+        @workers.load_files files
       end
 
       def run
-        ProcessOrchestrator.run(@deep_test_options, self)
+        ProcessOrchestrator.run(@deep_test_options, @workers, self)
       end
 
       def process_work_units
@@ -24,21 +30,24 @@ module DeepTest
         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)
+          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)
         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}")
+
+        missing_exmaples = ResultReader.new(blackboard).read(examples_by_location) do |example, result|
           @options.reporter.example_finished(example, result.error)
           success &= result.success?
         end
 
+        success &= missing_exmaples.empty?
+
+        missing_exmaples.each do |identifier, example|
+          @options.reporter.example_finished(example, WorkUnitNeverReceivedError.new)
+        end
+
         success
       ensure
         finish

data/lib/deep_test/spec/work_result.rb

@@ -1,17 +1,20 @@
 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
+      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)
-                       file == other.file &&
-                       line == other.line &&
-        example_description == other.example_description &&
-                      error == other.error 
+        identifier == other.identifier && 
+            @error == other.instance_variable_get(:@error) 
       end
 
       def failed_due_to_deadlock?
@@ -23,7 +26,7 @@ module DeepTest
       end
 
       def deadlock_result
-        WorkResult.new(file, line, example_description, nil, '-deadlock-')
+        WorkResult.new(identifier, nil, '-deadlock-')
       end
     end
   end

data/lib/deep_test/spec/work_unit.rb

@@ -1,15 +1,15 @@
 module DeepTest
   module Spec
     class WorkUnit
-      def initialize(file, line)
-        @file, @line = file, line
+      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, $rspec_options = $rspec_options, $rspec_options.dup
-        rspec_options.reporter = ResultReporter.new(@file, @line)
+        rspec_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?
@@ -18,19 +18,24 @@ module DeepTest
         $rspec_options = original_options
       end
 
+      def to_s
+        "#{@identifier.group_description}: #{@identifier.description}"
+      end
+
       protected
 
       def run_without_deadlock_protection
         output = capture_stdout do
-          rspec_options.run_one_example(@file, @line)
+          rspec_options.run_one_example(@identifier)
         end
         rspec_options.reporter.result(output)
       end
 
       class ResultReporter
         attr_reader :result
-        def initialize(file,line)
-          @file, @line = file, line
+
+        def initialize(identifier)
+          @identifier = identifier 
         end
 
         def add_example_group(example_group); end
@@ -43,7 +48,7 @@ module DeepTest
         end
 
         def result(output)
-          Spec::WorkResult.new(@file, @line, @example.description, @error, output)
+          Spec::WorkResult.new(@identifier, @error, output)
         end
 
         def start(example); end

data/lib/deep_test/test.rb

@@ -2,8 +2,8 @@ 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"
+require File.dirname(__FILE__) + "/test/work_result"

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

@@ -1,14 +1,14 @@
 module Test
   module Unit
     class Error
-      def initialize_with_exception_wrapping(test_name, exception)
-        wrap = Exception.new "#{exception.class}: #{exception.message}"
-        wrap.set_backtrace exception.backtrace
-        @test_name = test_name
-        @exception = wrap
+      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
-      alias_method :initialize_without_exception_wrapping, :initialize
-      alias_method :initialize, :initialize_with_exception_wrapping
     end
   end
 end

data/lib/deep_test/test/runner.rb

@@ -12,14 +12,9 @@ module DeepTest
         @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))
+        supervised_suite = DeepTest::Test::SupervisedTestSuite.new(suite, @options.server)
         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

@@ -8,8 +8,9 @@ module DeepTest
 
       def run(result, &progress_block)
         yield ::Test::Unit::TestSuite::STARTED, @suite.name
-        count = add_tests @suite
-        read_results result, count, &progress_block
+        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
 
@@ -17,29 +18,31 @@ module DeepTest
         @suite.size
       end
 
-      def add_tests(test_suite)
-        count = 0
+      def add_tests(test_suite, tests_by_name)
         if test_suite.respond_to? :tests
           test_suite.tests.each do |test| 
-            count += add_tests(test)
+            add_tests(test, tests_by_name)
           end
         else
-          count += 1
+          tests_by_name[test_suite.name] = test_suite
           @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?
+      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|
+            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)
         end
+      ensure
+        DeepTest.logger.debug("SupervisedTestSuite: exiting with #{missing_tests.size} results left")
       end
     end
   end

data/lib/deep_test/test/work_result.rb

@@ -0,0 +1,34 @@
+module DeepTest
+  module Test
+    class WorkResult < ::Test::Unit::TestResult
+      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

@@ -9,7 +9,7 @@ module DeepTest
         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 = WorkResult.new(@test_case.name)
           result.add_run
           result.output = "-deadlock-"
         end
@@ -21,10 +21,14 @@ module DeepTest
         @test_case == other.instance_variable_get(:@test_case)
       end
 
+      def to_s
+        @test_case.to_s
+      end
+
       protected
 
       def run_without_deadlock_protection
-        result = ::Test::Unit::TestResult.new
+        result = WorkResult.new(@test_case.name)
         output = capture_stdout do
           @test_case.run(result) {|channel,event|}
         end

data/lib/deep_test/test_task.rb

@@ -1,6 +1,9 @@
 module DeepTest
   class TestTask
+    attr_accessor :requires
+
     def initialize(name = :deep_test)
+      @requires = []
       @name = name
       @options = Options.new({})
       self.pattern = "test/**/*_test.rb"
@@ -11,54 +14,31 @@ module DeepTest
     def define
       desc "Run '#{@name}' suite using DeepTest"
       task @name do
-        ruby "#{runner} '#{@options.to_command_line}'"
+        require_options = requires.map {|f| "-r#{f}"}.join(" ")
+        ruby "#{require_options} #{runner} '#{@options.to_command_line}'"
       end
     end
 
-    def number_of_workers
-      @options.number_of_workers
-    end
-
-    def number_of_workers=(num)
-      @options.number_of_workers = num
-    end
+    Options::VALID_OPTIONS.each do |option|
+      eval <<-end_src
+        def #{option.name}
+          @options.#{option.name}
+        end
 
-    def pattern
-      @options.pattern
+        def #{option.name}=(value)
+          @options.#{option.name} = value
+        end
+      end_src
     end
 
     def pattern=(pattern)
       @options.pattern = Dir.pwd + "/" + pattern
     end
 
-    def server_port=(port)
-      @options.server_port = port
-    end
-
-    def server_port
-      @options.server_port
-    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")
+      File.expand_path(File.dirname(__FILE__) + "/../../script/internal/run_test_suite.rb")
     end    
   end
 end