jason-o-matic-deep_test 1.2.2.1

data/lib/deep_test/spec.rb

@@ -0,0 +1,12 @@
+require 'spec/runner/example_group_runner'
+require 'spec/example/example_group_methods'
+require 'spec/rake/spectask'
+
+require File.dirname(__FILE__) + "/spec/extensions/example_group_methods"
+require File.dirname(__FILE__) + "/spec/extensions/example_methods"
+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/example_group_methods.rb

@@ -0,0 +1,64 @@
+module Spec
+  module Example
+    module ExampleGroupMethods
+      class << self
+        def assign_instance_method_to_constant(proposed_constant)
+          method_sym = proposed_constant.to_s.downcase
+
+          unless const_defined?(proposed_constant)
+            const_set(proposed_constant, instance_method(method_sym))
+          end
+        end
+        
+        private :assign_instance_method_to_constant
+      end
+
+      assign_instance_method_to_constant :PREPEND_BEFORE
+      assign_instance_method_to_constant :APPEND_BEFORE
+      assign_instance_method_to_constant :PREPEND_AFTER
+      assign_instance_method_to_constant :APPEND_AFTER
+
+      def prepend_before(*args, &block)
+        check_filter_args(args)
+        call_regular_instance_method :prepend_before, *args, &block
+      end
+
+      def append_before(*args, &block)
+        check_filter_args(args)
+        call_regular_instance_method :append_before, *args, &block
+      end
+      
+      alias_method :before, :append_before
+
+      def prepend_after(*args, &block)
+        check_filter_args(args)
+        call_regular_instance_method :prepend_after, *args, &block
+      end
+
+      def append_after(*args, &block)
+        check_filter_args(args)
+        call_regular_instance_method :append_after, *args, &block
+      end
+      
+      alias_method :after, :append_after
+
+    private
+    
+      DeepTestAllBlockWarning = 
+        "Warning: DeepTest will run before(:all) and after(:all) blocks for *every* test that is run.  To remove this warning either convert all before/after blocks to each blocks or set $show_deep_test_all_block_warning to false" unless defined?(DeepTestAllBlockWarning)
+      
+      $show_deep_test_all_block_warning = true
+
+      def check_filter_args(args)
+        if args.first == :all && $show_deep_test_all_block_warning
+          $show_deep_test_all_block_warning = false
+          $stderr.puts DeepTestAllBlockWarning 
+        end
+      end
+    
+      def call_regular_instance_method(sym, *args, &block)
+        ExampleGroupMethods.const_get(sym.to_s.upcase).bind(self).call(*args, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Spec
+  module Runner
+    class Options
+      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
+end
+

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

@@ -0,0 +1,29 @@
+require 'spec/runner/reporter'
+module Spec
+  module Runner
+    class Reporter
+      def example_finished(example, error=nil)
+        @examples << example
+        
+        if error.nil?
+          example_passed(example)
+        elsif Spec::Example::ExamplePendingError === error
+          example_pending(example, error.message)
+        else
+          example_failed(example, error)
+        end
+      end
+
+      def failure(example, error)
+        backtrace_tweaker.tweak_backtrace(error)
+        example_name = "#{example.class.description} #{example.description}"
+        failure = Failure.new(example, 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,20 @@
+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")
+        @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,57 @@
+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)
+        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 ||= @deep_test_options.server
+      end
+
+      def load_files(files)
+        @workers.load_files files
+      end
+
+      def run
+        ProcessOrchestrator.run(@deep_test_options, @workers, 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|
+          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
+
+        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
+      end
+    end
+  end
+end

data/lib/deep_test/spec/work_result.rb

@@ -0,0 +1,33 @@
+module DeepTest
+  module Spec
+    class WorkResult
+      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/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
+        suite = ::Test::Unit::AutoRunner::COLLECTORS[:objectspace].call NO_FILTERS
+        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?
+      end
+    end
+  end
+end

data/lib/deep_test/test/supervised_test_suite.rb

@@ -0,0 +1,49 @@
+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
+        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
+          @blackboard.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(@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
+end