ci_reporter 1.9.3 → 2.0.0.alpha1

data/lib/ci/reporter/rake/spinach_loader.rb

@@ -1,5 +0,0 @@
-$: << File.dirname(__FILE__) + "/../../.."
-require 'ci/reporter/spinach'
-
-ENV['CI_CAPTURE'] = 'off'
-

data/lib/ci/reporter/rake/test_unit.rb

@@ -1,15 +0,0 @@
-# Copyright (c) 2006-2012 Nick Sieger <nicksieger@gmail.com>
-# See the file LICENSE.txt included with the distribution for
-# software license details.
-
-require File.expand_path('../utils', __FILE__)
-
-namespace :ci do
-  namespace :setup do
-    task :testunit do
-      rm_rf ENV["CI_REPORTS"] || "test/reports"
-      test_loader = CI::Reporter.maybe_quote_filename "#{File.dirname(__FILE__)}/test_unit_loader.rb"
-      ENV["TESTOPTS"] = "#{ENV["TESTOPTS"]} #{test_loader}"
-    end
-  end
-end

data/lib/ci/reporter/rake/test_unit_loader.rb

@@ -1,38 +0,0 @@
-# Copyright (c) 2006-2012 Nick Sieger <nicksieger@gmail.com>
-# See the file LICENSE.txt included with the distribution for
-# software license details.
-
-$: << File.dirname(__FILE__) + "/../../.."
-require 'ci/reporter/test_unit'
-
-# Intercepts mediator creation in ruby-test < 2.1
-module Test #:nodoc:all
-  module Unit
-    module UI
-      module Console
-        class TestRunner
-          undef :create_mediator if instance_methods.map(&:to_s).include?("create_mediator")
-          def create_mediator(suite)
-            # swap in our custom mediator
-            return CI::Reporter::TestUnit.new(suite)
-          end
-        end
-      end
-    end
-  end
-end
-
-# Intercepts mediator creation in ruby-test >= 2.1
-module Test #:nodoc:all
-  module Unit
-    module UI
-      class TestRunner
-        undef :setup_mediator if instance_methods.map(&:to_s).include?("setup_mediator")
-        def setup_mediator
-          # swap in our custom mediator
-          @mediator = CI::Reporter::TestUnit.new(@suite)
-        end
-      end
-    end
-  end
-end

data/lib/ci/reporter/rspec.rb

@@ -1,220 +0,0 @@
-# Copyright (c) 2006-2012 Nick Sieger <nicksieger@gmail.com>
-# See the file LICENSE.txt included with the distribution for
-# software license details.
-
-require 'ci/reporter/core'
-
-module CI
-  module Reporter
-    module RSpecFormatters
-      begin
-        require 'rspec/core/formatters/base_formatter'
-        require 'rspec/core/formatters/progress_formatter'
-        require 'rspec/core/formatters/documentation_formatter'
-        BaseFormatter = ::RSpec::Core::Formatters::BaseFormatter
-        ProgressFormatter = ::RSpec::Core::Formatters::ProgressFormatter
-        DocFormatter = ::RSpec::Core::Formatters::DocumentationFormatter
-        # See https://github.com/nicksieger/ci_reporter/issues/76 and
-        #     https://github.com/nicksieger/ci_reporter/issues/80
-        require 'rspec/core/version'
-        RSpec_2_12_0_bug = (::RSpec::Core::Version::STRING == '2.12.0' &&
-                            !BaseFormatter.instance_methods(false).map(&:to_s).include?("format_backtrace"))
-      rescue LoadError => first_error
-        begin
-          require 'spec/runner/formatter/progress_bar_formatter'
-          require 'spec/runner/formatter/specdoc_formatter'
-          BaseFormatter = ::Spec::Runner::Formatter::BaseFormatter
-          ProgressFormatter = ::Spec::Runner::Formatter::ProgressBarFormatter
-          DocFormatter = ::Spec::Runner::Formatter::SpecdocFormatter
-        rescue LoadError
-          raise first_error
-        end
-      end
-    end
-
-    # Wrapper around a <code>RSpec</code> error or failure to be used by the test suite to interpret results.
-    class RSpecFailure
-      attr_reader :exception
-      def initialize(failure)
-        @failure = failure
-        @exception = failure.exception
-      end
-
-      def failure?
-        @failure.expectation_not_met?
-      end
-
-      def error?
-        !failure?
-      end
-
-      def name() exception.class.name end
-      def message() exception.message end
-      def location() (exception.backtrace || ["No backtrace available"]).join("\n") end
-    end
-
-    class RSpec2Failure < RSpecFailure
-      def initialize(example, formatter)
-        @formatter = formatter
-        @example = example
-        if @example.respond_to?(:execution_result)
-          @exception = @example.execution_result[:exception] || @example.execution_result[:exception_encountered]
-        else
-          @exception = @example.metadata[:execution_result][:exception]
-        end
-      end
-
-      def name
-        @exception.class.name
-      end
-
-      def message
-        @exception.message
-      end
-
-      def failure?
-        exception.is_a?(::RSpec::Expectations::ExpectationNotMetError)
-      end
-
-      def location
-        output = []
-        output.push "#{exception.class.name << ":"}" unless exception.class.name =~ /RSpec/
-        output.push @exception.message
-
-        format_metadata = RSpecFormatters::RSpec_2_12_0_bug ? @example.metadata : @example
-
-        [@formatter.format_backtrace(@exception.backtrace, format_metadata)].flatten.each do |backtrace_info|
-          backtrace_info.lines.each do |line|
-            output.push "     #{line}"
-          end
-        end
-        output.join "\n"
-      end
-    end
-
-    # Custom +RSpec+ formatter used to hook into the spec runs and capture results.
-    class RSpec
-      attr_accessor :report_manager
-      attr_accessor :formatter
-      def initialize(*args)
-        @formatter ||= RSpecFormatters::ProgressFormatter.new(*args)
-        @report_manager = ReportManager.new("spec")
-        @suite = nil
-      end
-
-      # rspec 0.9
-      def add_behaviour(name)
-        @formatter.add_behaviour(name)
-        new_suite(name)
-      end
-
-      # Compatibility with rspec < 1.2.4
-      def add_example_group(example_group)
-        @formatter.add_example_group(example_group)
-        new_suite(description_for(example_group))
-      end
-
-      # rspec >= 1.2.4
-      def example_group_started(example_group)
-        @formatter.example_group_started(example_group)
-        new_suite(description_for(example_group))
-      end
-
-      def example_started(name_or_example)
-        @formatter.example_started(name_or_example)
-        spec = TestCase.new
-        @suite.testcases << spec
-        spec.start
-      end
-
-      def example_failed(name_or_example, *rest)
-        @formatter.example_failed(name_or_example, *rest)
-
-        # In case we fail in before(:all)
-        example_started(name_or_example) if @suite.testcases.empty?
-
-        if name_or_example.respond_to?(:execution_result) # RSpec 2
-          failure = RSpec2Failure.new(name_or_example, @formatter)
-        else
-          failure = RSpecFailure.new(rest[1]) # example_failed(name, counter, failure) in RSpec 1
-        end
-
-        spec = @suite.testcases.last
-        spec.finish
-        spec.name = description_for(name_or_example)
-        spec.failures << failure
-      end
-
-      def example_passed(name_or_example)
-        @formatter.example_passed(name_or_example)
-        spec = @suite.testcases.last
-        spec.finish
-        spec.name = description_for(name_or_example)
-      end
-
-      def example_pending(*args)
-        @formatter.example_pending(*args)
-        name = description_for(args[0])
-        spec = @suite.testcases.last
-        spec.finish
-        spec.name = "#{name} (PENDING)"
-        spec.skipped = true
-      end
-
-      def dump_summary(*args)
-        @formatter.dump_summary(*args)
-        write_report
-        @formatter.dump_failures
-      end
-
-      def respond_to?(*args)
-        @formatter.respond_to?(*args)
-      end
-
-      # Pass through other methods to RSpec formatter for compatibility
-      def method_missing(meth,*args,&block)
-        @formatter.send(meth,*args,&block)
-      end
-
-      private
-      def description_for(name_or_example)
-        if name_or_example.respond_to?(:full_description)
-          name_or_example.full_description
-        elsif name_or_example.respond_to?(:metadata)
-          name_or_example.metadata[:example_group][:full_description]
-        elsif name_or_example.respond_to?(:description)
-          name_or_example.description
-        else
-          "UNKNOWN"
-        end
-      end
-
-      def write_report
-        if @suite
-          @suite.finish
-          @report_manager.write_report(@suite)
-        end
-      end
-
-      def new_suite(name)
-        write_report if @suite
-        @suite = TestSuite.new name
-        @suite.start
-      end
-    end
-
-    class RSpecDoc < RSpec
-      def initialize(*args)
-        @formatter = RSpecFormatters::DocFormatter.new(*args)
-        super
-      end
-    end
-
-    class RSpecBase < RSpec
-      def initialize(*args)
-        @formatter = RSpecFormatters::BaseFormatter.new(*args)
-        super
-      end
-    end
-  end
-end

data/lib/ci/reporter/spinach.rb

@@ -1,80 +0,0 @@
-require 'ci/reporter/core'
-require 'spinach'
-
-module CI
-  module Reporter
-    class Spinach < ::Spinach::Reporter
-      def initialize(options = nil)
-        @options = options
-        @report_manager = ReportManager.new('features')
-      end
-
-      def before_feature_run(feature)
-        @test_suite = TestSuite.new(feature.is_a?(Hash) ? feature['name'] : feature.name)
-        @test_suite.start
-      end
-
-      def before_scenario_run(scenario, step_definitions = nil)
-        @test_case = TestCase.new(scenario.is_a?(Hash) ? scenario['name'] : scenario.name)
-        @test_case.start
-      end
-
-      def on_undefined_step(step, failure, step_definitions = nil)
-        @test_case.failures << SpinachFailure.new(:error, step, failure, nil)
-      end
-
-      def on_failed_step(step, failure, step_location, step_definitions = nil)
-        @test_case.failures << SpinachFailure.new(:failed, step, failure, step_location)
-      end
-
-      def on_error_step(step, failure, step_location, step_definitions = nil)
-        @test_case.failures << SpinachFailure.new(:error, step, failure, step_location)
-      end
-
-      def after_scenario_run(scenario, step_definitions = nil)
-        @test_case.finish
-        @test_suite.testcases << @test_case
-        @test_case = nil
-      end
-
-      def after_feature_run(feature)
-        @test_suite.finish
-        @report_manager.write_report(@test_suite)
-        @test_suite = nil
-      end
-    end
-
-    class SpinachFailure
-      def initialize(type, step, failure, step_location)
-        @type = type
-        @step = step
-        @failure = failure
-        @step_location = step_location
-      end
-
-      def failure?
-        @type == :failed
-      end
-
-      def error?
-        @type == :error
-      end
-
-      def name
-        @failure.class.name
-      end
-
-      def message
-        @failure.message
-      end
-
-      def location
-        @failure.backtrace.join("\n")
-      end
-    end
-  end
-end
-
-class Spinach::Reporter
-  CiReporter = ::CI::Reporter::Spinach
-end

data/lib/ci/reporter/test_unit.rb

@@ -1,163 +0,0 @@
-# Copyright (c) 2006-2012 Nick Sieger <nicksieger@gmail.com>
-# See the file LICENSE.txt included with the distribution for
-# software license details.
-
-require 'ci/reporter/core'
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-module CI
-  module Reporter
-    # Factory for constructing either a CI::Reporter::TestUnitFailure or CI::Reporter::TestUnitError depending on the result
-    # of the test.
-    class Failure
-      CONST_DEFINED_ARITY = Module.method(:const_defined?).arity
-
-      def self.omission_constant?
-        if CONST_DEFINED_ARITY == 1 # 1.8.7 varieties
-          Test::Unit.const_defined?(:Omission)
-        else
-          Test::Unit.const_defined?(:Omission, false)
-        end
-      end
-
-      def self.notification_constant?
-        if CONST_DEFINED_ARITY == 1 # 1.8.7 varieties
-          Test::Unit.const_defined?(:Notification)
-        else
-          Test::Unit.const_defined?(:Notification, false)
-        end
-      end
-
-      def self.new(fault)
-        return TestUnitFailure.new(fault) if fault.kind_of?(Test::Unit::Failure)
-        return TestUnitSkipped.new(fault) if omission_constant? &&
-          (fault.kind_of?(Test::Unit::Omission) || fault.kind_of?(Test::Unit::Pending))
-        return TestUnitNotification.new(fault) if notification_constant? &&
-          fault.kind_of?(Test::Unit::Notification)
-        TestUnitError.new(fault)
-      end
-    end
-
-    # Wrapper around a <code>Test::Unit</code> error to be used by the test suite to interpret results.
-    class TestUnitError
-      def initialize(fault) @fault = fault end
-      def failure?() false end
-      def error?() true end
-      def name() @fault.exception.class.name end
-      def message() @fault.exception.message end
-      def location() @fault.exception.backtrace.join("\n") end
-    end
-
-    # Wrapper around a <code>Test::Unit</code> failure to be used by the test suite to interpret results.
-    class TestUnitFailure
-      def initialize(fault) @fault = fault end
-      def failure?() true end
-      def error?() false end
-      def name() Test::Unit::AssertionFailedError.name end
-      def message() @fault.message end
-      def location() @fault.location.join("\n") end
-    end
-
-    # Wrapper around a <code>Test::Unit</code> 2.0 omission.
-    class TestUnitSkipped
-      def initialize(fault) @fault = fault end
-      def failure?() false end
-      def error?() false end
-      def name() @fault.class.name end
-      def message() @fault.message end
-      def location() @fault.location.join("\n") end
-    end
-
-    # Wrapper around a <code>Test::Unit</code> 2.0 notification.
-    class TestUnitNotification
-      def initialize(fault) @fault = fault end
-      def failure?() false end
-      def error?() false end
-      def name() @fault.class.name end
-      def message() @fault.message end
-      def location() @fault.location.join("\n") end
-    end
-
-    # Replacement Mediator that adds listeners to capture the results of the <code>Test::Unit</code> runs.
-    class TestUnit < Test::Unit::UI::TestRunnerMediator
-      def initialize(suite, report_mgr = nil)
-        super(suite)
-        @report_manager = report_mgr || ReportManager.new("test")
-        add_listener(Test::Unit::UI::TestRunnerMediator::STARTED, &method(:started))
-        add_listener(Test::Unit::TestCase::STARTED, &method(:test_started))
-        add_listener(Test::Unit::TestCase::FINISHED, &method(:test_finished))
-        add_listener(Test::Unit::TestResult::FAULT, &method(:fault))
-        add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED, &method(:finished))
-      end
-
-      def started(result)
-        @suite_result = result
-        @last_assertion_count = 0
-        @current_suite = nil
-        @unknown_count = 0
-        @result_assertion_count = 0
-      end
-
-      def test_started(name)
-        test_name, suite_name = extract_names(name)
-        unless @current_suite && @current_suite.name == suite_name
-          finish_suite
-          start_suite(suite_name)
-        end
-        start_test(test_name)
-      end
-
-      def test_finished(name)
-        finish_test
-      end
-
-      def fault(fault)
-        tc = @current_suite.testcases.last
-        tc.failures << Failure.new(fault)
-      end
-
-      def finished(elapsed_time)
-        finish_suite
-      end
-
-      private
-      def extract_names(name)
-        match = name.match(/(.*)\(([^)]*)\)/)
-        if match
-          [match[1], match[2]]
-        else
-          @unknown_count += 1
-          [name, "unknown-#{@unknown_count}"]
-        end
-      end
-
-      def start_suite(suite_name)
-        @current_suite = TestSuite.new(suite_name)
-        @current_suite.start
-      end
-
-      def finish_suite
-        if @current_suite
-          @current_suite.finish
-          @current_suite.assertions = @suite_result.assertion_count - @last_assertion_count
-          @last_assertion_count = @suite_result.assertion_count
-          @report_manager.write_report(@current_suite)
-        end
-      end
-
-      def start_test(test_name)
-        tc = TestCase.new(test_name)
-        tc.start
-        @current_suite.testcases << tc
-      end
-
-      def finish_test
-        tc = @current_suite.testcases.last
-        tc.finish
-        tc.assertions = @suite_result.assertion_count - @result_assertion_count
-        @result_assertion_count = @suite_result.assertion_count
-      end
-    end
-  end
-end