cucumber 2.0.0 → 2.0.1

data/lib/cucumber/formatter/junit.rb

@@ -8,10 +8,6 @@ module Cucumber
     # The formatter used for <tt>--format junit</tt>
     class Junit
 
-      # TODO: remove coupling to types
-      AST_SCENARIO_OUTLINE = Core::Ast::ScenarioOutline
-      AST_EXAMPLE_ROW = LegacyApi::Ast::ExampleTableRow
-
       include Io
 
       class UnNamedFeatureError < StandardError
@@ -20,168 +16,129 @@ module Cucumber
         end
       end
 
-      def initialize(runtime, io, options)
+      def initialize(_runtime, io, options)
         @reportdir = ensure_dir(io, "junit")
         @options = options
       end
 
-      def before_feature(feature)
-        @current_feature = feature
-        @failures = @errors = @tests = @skipped = 0
-        @builder = Builder::XmlMarkup.new( :indent => 2 )
-        @time = 0
+      def before_test_case(test_case)
+        unless same_feature_as_previous_test_case?(test_case.feature)
+          end_feature if @current_feature
+          start_feature(test_case.feature)
+        end
+        @failing_step_source = nil
         # In order to fill out <system-err/> and <system-out/>, we need to
         # intercept the $stderr and $stdout
         @interceptedout = Interceptor::Pipe.wrap(:stdout)
         @interceptederr = Interceptor::Pipe.wrap(:stderr)
       end
 
-      def before_feature_element(feature_element)
-        @in_examples = AST_SCENARIO_OUTLINE === feature_element
-        @steps_start = Time.now
-      end
+      def after_test_step(test_step, result)
+        return if @failing_step_source
 
-      def after_feature(feature)
-        @testsuite = Builder::XmlMarkup.new( :indent => 2 )
-        @testsuite.instruct!
-        @testsuite.testsuite(
-          :failures => @failures,
-          :errors => @errors,
-          :skipped => @skipped,
-          :tests => @tests,
-          :time => "%.6f" % @time,
-          :name => @feature_name ) do
-          @testsuite << @builder.target!
-          @testsuite.tag!('system-out') do
-            @testsuite.cdata! strip_control_chars(@interceptedout.buffer.join)
-          end
-          @testsuite.tag!('system-err') do
-            @testsuite.cdata! strip_control_chars(@interceptederr.buffer.join)
-          end
-        end
+        @failing_step_source = test_step.source.last unless result.ok?(@options[:strict])
+      end
 
-        write_file(feature_result_filename(feature.file), @testsuite.target!)
+      def after_test_case(test_case, result)
+        test_case_name = NameBuilder.new(test_case)
+        scenario = test_case_name.scenario_name
+        scenario_designation = "#{scenario}#{test_case_name.name_suffix}"
+        output = create_output_string(test_case, scenario, result, test_case_name.row_name)
+        build_testcase(result, scenario_designation, output)
 
         Interceptor::Pipe.unwrap! :stdout
         Interceptor::Pipe.unwrap! :stderr
       end
 
-      def before_background(*args)
-        @in_background = true
+      def done
+        end_feature if @current_feature
       end
 
-      def after_background(*args)
-        @in_background = false
-      end
-
-      def feature_name(keyword, name)
-        raise UnNamedFeatureError.new(@current_feature.file) if name.empty?
-        lines = name.split(/\r?\n/)
-        @feature_name = lines[0]
-      end
-
-      def scenario_name(keyword, name, file_colon_line, source_indent)
-        @scenario = (name.nil? || name == "") ? "Unnamed scenario" : name.split("\n")[0]
-        @output = "#{keyword}: #{@scenario}\n\n"
-      end
-
-      def before_steps(steps)
-      end
-
-      def after_steps(steps)
-        return if @in_background || @in_examples
-
-        duration = Time.now - @steps_start
-        if steps.failed?
-          steps.each { |step| @output += "#{step.keyword}#{step.name}\n" }
-          @output += "\nMessage:\n"
-        end
-        build_testcase(duration, steps.status, steps.exception)
-      end
-
-      def before_examples(*args)
-        @header_row = true
-        @in_examples = true
-      end
+      private
 
-      def after_examples(*args)
-        @in_examples = false
+      def same_feature_as_previous_test_case?(feature)
+        @current_feature && @current_feature.file == feature.file && @current_feature.location == feature.location
       end
 
-      def before_table_row(table_row)
-        return unless @in_examples
-
-        @table_start = Time.now
+      def start_feature(feature)
+        raise UnNamedFeatureError.new(feature.file) if feature.name.empty?
+        @current_feature = feature
+        @failures = @errors = @tests = @skipped = 0
+        @builder = Builder::XmlMarkup.new(:indent => 2)
+        @time = 0
       end
 
-      def after_table_row(table_row)
-        return unless @in_examples and AST_EXAMPLE_ROW === table_row
-        duration = Time.now - @table_start
-        unless @header_row
-          name_suffix = " (outline example : #{table_row.name})"
-          if table_row.failed?
-            @output += "Example row: #{table_row.name}\n"
-            @output += "\nMessage:\n"
-          end
-          build_testcase(duration, table_row.status, table_row.exception, name_suffix)
+      def end_feature
+        @testsuite = Builder::XmlMarkup.new(:indent => 2)
+        @testsuite.instruct!
+        @testsuite.testsuite(
+          :failures => @failures,
+          :errors => @errors,
+          :skipped => @skipped,
+          :tests => @tests,
+          :time => "%.6f" % @time,
+          :name => @current_feature.name ) do
+          @testsuite << @builder.target!
         end
 
-        @header_row = false if @header_row
-      end
-
-      def before_test_case(test_case)
-        if @options[:expand] and test_case.keyword == "Scenario Outline"
-          @exception = nil
-        end
+        write_file(feature_result_filename(@current_feature.file), @testsuite.target!)
       end
 
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-        if @options[:expand] and @in_examples
-          if not @exception and exception
-            @exception = exception
-          end
+      def create_output_string(test_case, scenario, result, row_name)
+        output = "#{test_case.keyword}: #{scenario}\n\n"
+        return output if result.ok?(@options[:strict])
+        if test_case.keyword == "Scenario"
+          output += "#{@failing_step_source.keyword}" unless hook?(@failing_step_source)
+          output += "#{@failing_step_source.name}\n"
+        else
+          output += "Example row: #{row_name}\n"
         end
+        output + "\nMessage:\n"
       end
 
-      def after_test_case(test_case, result)
-        if @options[:expand] and test_case.keyword == "Scenario Outline"
-          test_case_name = NameBuilder.new(test_case)
-          @scenario = test_case_name.outline_name
-          @output = "#{test_case.keyword}: #{@scenario}\n\n"
-          if result.failed?
-            @output += "Example row: #{test_case_name.row_name}\n"
-            @output += "\nMessage:\n"
-          end
-          test_case_result = ResultBuilder.new(result)
-          build_testcase(test_case_result.test_case_duration, test_case_result.status, @exception, test_case_name.name_suffix)
-        end
+      def hook?(step)
+        ["Before hook", "After hook", "AfterStep hook"].include? step.name
       end
 
-      private
-
-      def build_testcase(duration, status, exception = nil, suffix = "")
+      def build_testcase(result, scenario_designation, output)
+        duration = ResultBuilder.new(result).test_case_duration
         @time += duration
-        classname = @feature_name
-        name = "#{@scenario}#{suffix}"
-        pending = [:pending, :undefined].include?(status) && (!@options[:strict])
+        classname = @current_feature.name
+        name = scenario_designation
 
         @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
-          if status == :skipped || pending
+          if !result.passed? && result.ok?(@options[:strict])
             @builder.skipped
             @skipped += 1
-          elsif status != :passed
-            @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
-              @builder.cdata! @output
+          elsif !result.passed?
+            status = result.to_sym
+            exception = get_backtrace_object(result)
+            @builder.failure(:message => "#{status} #{name}", :type => status) do
+              @builder.cdata! output
               @builder.cdata!(format_exception(exception)) if exception
             end
             @failures += 1
           end
-          @builder.tag!('system-out')
-          @builder.tag!('system-err')
+          @builder.tag!('system-out') do
+            @builder.cdata! strip_control_chars(@interceptedout.buffer.join)
+          end
+          @builder.tag!('system-err') do
+            @builder.cdata! strip_control_chars(@interceptederr.buffer.join)
+          end
         end
         @tests += 1
       end
 
+      def get_backtrace_object(result)
+        if result.failed?
+          return result.exception
+        elsif result.backtrace
+          return result
+        else
+          return nil
+        end
+      end
+
       def format_exception(exception)
         (["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n")
       end
@@ -202,13 +159,15 @@ module Cucumber
       def strip_control_chars(cdata)
         cdata.scan(/[[:print:]\t\n\r]/).join
       end
-      
+
     end
 
     class NameBuilder
-      attr_reader :outline_name, :name_suffix, :row_name
+      attr_reader :scenario_name, :name_suffix, :row_name
 
       def initialize(test_case)
+        @name_suffix = ""
+        @row_name = ""
         test_case.describe_source_to self
       end
 
@@ -216,12 +175,13 @@ module Cucumber
         self
       end
 
-      def scenario(*)
+      def scenario(scenario)
+        @scenario_name = (scenario.name.nil? || scenario.name == "") ? "Unnamed scenario" : scenario.name
         self
       end
 
       def scenario_outline(outline)
-        @outline_name = outline.name
+        @scenario_name = (outline.name.nil? || outline.name == "") ? "Unnamed scenario outline" : outline.name
         self
       end
 
@@ -237,37 +197,26 @@ module Cucumber
     end
 
     class ResultBuilder
-      attr_reader :status, :test_case_duration
+      attr_reader :test_case_duration
       def initialize(result)
         @test_case_duration = 0
         result.describe_to(self)
       end
 
-      def passed
-        @status = :passed
-      end
+      def passed(*) end
 
-      def failed
-        @status = :failed
-      end
+      def failed(*) end
 
-      def undefined
-        @status = :undefined
-      end
+      def undefined(*) end
 
-      def skipped
-        @status = :skipped
-      end
+      def skipped(*) end
 
-      def pending(*)
-        @status = :pending
-      end
+      def pending(*) end
 
-      def exception(*)
-      end
+      def exception(*) end
 
       def duration(duration, *)
-        duration.tap { |duration| @test_case_duration = duration.nanoseconds / 10 ** 9.0 }
+        duration.tap { |duration| @test_case_duration = duration.nanoseconds / 10**9.0 }
       end
     end
 

data/lib/cucumber/formatter/legacy_api/adapter.rb

@@ -2,6 +2,7 @@ require 'forwardable'
 require 'delegate'
 require 'cucumber/errors'
 require 'cucumber/multiline_argument'
+require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/legacy_api/ast'
 
 module Cucumber
@@ -29,13 +30,13 @@ module Cucumber
 
         def after_test_step(test_step, result)
           printer.after_test_step(test_step, result)
-          formatter.after_test_step(test_step, result)
+          formatter.after_test_step(test_step, result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter))
         end
 
         def after_test_case(test_case, result)
           record_test_case_result(test_case, result)
           printer.after_test_case(test_case, result)
-          formatter.after_test_case(test_case, result)
+          formatter.after_test_case(test_case, result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter))
         end
 
         def puts(*messages)
@@ -271,7 +272,7 @@ module Cucumber
 
           def after_step_hook(hook, result)
             p current_test_step_source if current_test_step_source.step.nil?
-            line = StepBacktraceLine.new(current_test_step_source.step)
+            line = current_test_step_source.step.backtrace_line
             @child.after_step_hook Ast::HookResult.new(LegacyResultBuilder.new(result).
               append_to_exception_backtrace(line), @delayed_messages, @delayed_embeddings)
             @delayed_messages = []
@@ -321,7 +322,7 @@ module Cucumber
               if same_background_as_previous_test_case?(source)
                 HiddenBackgroundPrinter.new(formatter, source.background)
               else
-                BackgroundPrinter.new(formatter, source.background, before_hook_results)
+                BackgroundPrinter.new(formatter, node, source.background, before_hook_results)
               end
             elsif source.scenario
               ScenarioPrinter.new(formatter, source.scenario, before_hook_results)
@@ -448,7 +449,7 @@ module Cucumber
           end
         end
 
-        BackgroundPrinter = Struct.new(:formatter, :node, :before_hook_results) do
+        BackgroundPrinter = Struct.new(:formatter, :feature, :node, :before_hook_results) do
 
           def after_test_case(*)
           end
@@ -457,7 +458,8 @@ module Cucumber
           end
 
           def before
-            formatter.before_background node
+            formatter.before_background Ast::Background.new(feature, node)
+            Ast::Comments.new(node.comments).accept(formatter)
             formatter.background_name node.keyword, node.legacy_conflated_name_and_description, node.location.to_s, indent.of(node)
             before_hook_results.accept(formatter)
             self
@@ -477,7 +479,7 @@ module Cucumber
 
           def after
             @child.after if @child
-            formatter.after_background(node)
+            formatter.after_background(Ast::Background.new(feature, node))
             self
           end
 
@@ -519,6 +521,7 @@ module Cucumber
 
           def before
             formatter.before_feature_element(node)
+            Ast::Comments.new(node.comments).accept(formatter)
             Ast::Tags.new(node.tags).accept(formatter)
             formatter.scenario_name node.keyword, node.legacy_conflated_name_and_description, node.location.to_s, indent.of(node)
             before_hook_results.accept(formatter)
@@ -593,6 +596,7 @@ module Cucumber
 
           def before
             formatter.before_feature_element(node)
+            Ast::Comments.new(node.comments).accept(formatter)
             Ast::Tags.new(node.tags).accept(formatter)
             formatter.scenario_name node.keyword, node.legacy_conflated_name_and_description, node.location.to_s, indent.of(node)
             OutlineStepsPrinter.new(formatter, configuration, indent).print(node)
@@ -693,6 +697,8 @@ module Cucumber
 
           def before
             formatter.before_examples(node)
+            Ast::Comments.new(node.comments).accept(formatter)
+            Ast::Tags.new(node.tags).accept(formatter)
             formatter.examples_name(node.keyword, node.legacy_conflated_name_and_description)
             formatter.before_outline_table(legacy_table)
             if !configuration.expand?
@@ -803,6 +809,7 @@ module Cucumber
           end
 
           def before
+            Ast::Comments.new(node.comments).accept(formatter)
             formatter.before_table_row(node)
             self
           end
@@ -822,6 +829,7 @@ module Cucumber
         class TableRowPrinter < TableRowPrinterBase
           def before
             before_hook_results.accept(formatter)
+            Ast::Comments.new(node.comments).accept(formatter)
             formatter.before_table_row(node)
             self
           end
@@ -995,66 +1003,22 @@ module Cucumber
             return filtered_step_exception(step) if @exception
             return nil unless @status == :undefined && configuration.strict?
             @exception = Cucumber::Undefined.from(@result, step.name)
+            @exception.backtrace << step.backtrace_line
             filtered_step_exception(step)
           end
 
           def filtered_exception
-            BacktraceFilter.new(@exception.dup).exception
+            Cucumber::Formatter::BacktraceFilter.new(@exception.dup).exception
           end
 
           def filtered_step_exception(step)
             exception = filtered_exception
-            exception.backtrace << StepBacktraceLine.new(step).to_s
-            return BacktraceFilter.new(exception).exception
+            return Cucumber::Formatter::BacktraceFilter.new(exception).exception
           end
         end
 
       end
 
-      class StepBacktraceLine < Struct.new(:step)
-        def initialize(step)
-          raise ArgumentError if step.nil?
-          super
-        end
-
-        def to_s
-          step.backtrace_line
-        end
-      end
-
-      require 'cucumber/platform'
-      class BacktraceFilter
-        BACKTRACE_FILTER_PATTERNS = \
-          [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit|.gem\/ruby|lib\/ruby/]
-        if(::Cucumber::JRUBY)
-          BACKTRACE_FILTER_PATTERNS << /org\/jruby/
-        end
-        PWD_PATTERN = /#{::Regexp.escape(::Dir.pwd)}\//m
-
-        def initialize(exception)
-          @exception = exception
-        end
-
-        def exception
-          return @exception if ::Cucumber.use_full_backtrace
-          @exception.backtrace.each{|line| line.gsub!(PWD_PATTERN, "./")}
-
-          filtered = (@exception.backtrace || []).reject do |line|
-            BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
-          end
-
-          if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']
-            # Strip off file locations
-            filtered = filtered.map do |line|
-              line =~ /(.*):in `/ ? $1 : line
-            end
-          end
-
-          @exception.set_backtrace(filtered)
-          @exception
-        end
-      end
-
     end
   end
 end