cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/lib/cucumber/formatter/progress.rb

@@ -1,5 +1,12 @@
+# frozen_string_literal: true
+
+require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/console'
+require 'cucumber/formatter/console_counts'
+require 'cucumber/formatter/console_issues'
 require 'cucumber/formatter/io'
+require 'cucumber/formatter/duration_extractor'
+require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
@@ -7,90 +14,87 @@ module Cucumber
     class Progress
       include Console
       include Io
-      attr_reader :runtime
+      attr_reader :config, :current_feature_uri
+      private :config, :current_feature_uri
 
-      def initialize(runtime, path_or_io, options)
-        @runtime, @io, @options = runtime, ensure_io(path_or_io, "progress"), options
-        @previous_step_keyword = nil
+      def initialize(config)
+        @config = config
+        @io = ensure_io(config.out_stream)
         @snippets_input = []
-      end
-
-      def before_features(features)
-        print_profile_information
-      end
-
-      def after_features(features)
+        @total_duration = 0
+        @matches = {}
+        @pending_step_matches = []
+        @failed_results = []
+        @passed_test_cases = []
+        @current_feature_uri = ''
+        @gherkin_documents = {}
+        @ast_lookup = AstLookup.new(config)
+        @counts = ConsoleCounts.new(config)
+        @issues = ConsoleIssues.new(config, @ast_lookup)
+        config.on_event :step_activated, &method(:on_step_activated)
+        config.on_event :test_case_started, &method(:on_test_case_started)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+        config.on_event :test_case_finished, &method(:on_test_case_finished)
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
+      end
+
+      def on_step_activated(event)
+        @matches[event.test_step.to_s] = event.step_match
+      end
+
+      def on_test_case_started(event)
+        unless @profile_information_printed
+          do_print_profile_information(config.profiles) unless config.skip_profile_information? || config.profiles.nil? || config.profiles.empty?
+          @profile_information_printed = true
+        end
+        @current_feature_uri = event.test_case.location.file
+      end
+
+      def on_test_step_finished(event)
+        test_step = event.test_step
+        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        progress(result.to_sym) if !test_step.hook? || result.failed?
+
+        return if test_step.hook?
+        collect_snippet_data(test_step, @ast_lookup) if result.undefined?
+        @pending_step_matches << @matches[test_step.to_s] if result.pending?
+        @failed_results << result if result.failed?
+      end
+
+      def on_test_case_finished(event)
+        test_case = event.test_case
+        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        @passed_test_cases << test_case if result.passed?
+        @total_duration += DurationExtractor.new(result).result_duration
+      end
+
+      def on_test_run_finished(_event)
         @io.puts
         @io.puts
-        print_summary(features)
-      end
-
-      def before_feature_element(*args)
-        @exception_raised = false
-      end
-
-      def after_feature_element(*args)
-        progress(:failed) if (defined? @exception_raised) and (@exception_raised)
-        @exception_raised = false
-      end
-
-      def before_steps(*args)
-        progress(:failed) if (defined? @exception_raised) and (@exception_raised)
-        @exception_raised = false
-      end
-
-      def after_steps(*args)
-        @exception_raised = false
-      end
-
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
-        progress(status)
-        @status = status
-      end
-
-      def before_outline_table(outline_table)
-        @outline_table = outline_table
-      end
-
-      def after_outline_table(outline_table)
-        @outline_table = nil
-      end
-
-      def table_cell_value(value, status)
-        return unless @outline_table
-        status ||= @status
-        progress(status) unless table_header_cell?(status)
+        print_summary
       end
 
-      def exception(*args)
-        @exception_raised = true
-      end
+      private
 
-      def before_test_case(test_case)
-        @previous_step_keyword = nil
+      def gherkin_document
+        @ast_lookup.gherkin_document(current_feature_uri)
       end
 
-      def after_test_step(test_step, result)
-        collect_snippet_data(test_step, result)
-      end
-
-      private
-
-      def print_summary(features)
-        print_steps(:pending)
-        print_steps(:failed)
-        print_stats(features, @options)
-        print_snippets(@options)
-        print_passing_wip(@options)
+      def print_summary
+        print_elements(@pending_step_matches, :pending, 'steps')
+        print_elements(@failed_results, :failed, 'steps')
+        print_statistics(@total_duration, @config, @counts, @issues)
+        print_snippets(config.to_hash)
+        print_passing_wip(config, @passed_test_cases, @ast_lookup)
       end
 
       CHARS = {
-        :passed    => '.',
-        :failed    => 'F',
-        :undefined => 'U',
-        :pending   => 'P',
-        :skipped   => '-'
-      }
+        passed: '.',
+        failed: 'F',
+        undefined: 'U',
+        pending: 'P',
+        skipped: '-'
+      }.freeze
 
       def progress(status)
         char = CHARS[status]
@@ -101,6 +105,8 @@ module Cucumber
       def table_header_cell?(status)
         status == :skipped_param
       end
+
+      TestCaseData = Struct.new(:name, :location)
     end
   end
 end

data/lib/cucumber/formatter/rerun.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/io'
 
 module Cucumber
@@ -5,30 +7,45 @@ module Cucumber
     class Rerun
       include Formatter::Io
 
-      def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io, "rerun")
+      def initialize(config) # rubocop:disable Metrics/PerceivedComplexity
+        @io = ensure_io(config.out_stream)
+        @config = config
         @failures = {}
-      end
-
-      def after_test_case(test_case, result)
-        return if result.passed?
-        @failures[test_case.location.file] ||= []
-        @failures[test_case.location.file] << test_case.location.line
-      end
-
-      def done
-        return if @failures.empty?
-        @io.print file_failures.join(' ')
-      end
-
-      [:before_test_case, :before_test_step, :after_test_step].each do |method|
-        define_method(method) { |*| }
+        config.on_event :test_case_finished do |event|
+          test_case, result = *event.attributes
+          if @config.strict.strict?(:flaky)
+            next if result.ok?(@config.strict)
+            add_to_failures(test_case)
+          else
+            unless @latest_failed_test_case.nil?
+              if @latest_failed_test_case != test_case
+                add_to_failures(@latest_failed_test_case)
+                @latest_failed_test_case = nil
+              elsif result.ok?(@config.strict)
+                @latest_failed_test_case = nil
+              end
+            end
+            @latest_failed_test_case = test_case unless result.ok?(@config.strict)
+          end
+        end
+        config.on_event :test_run_finished do
+          add_to_failures(@latest_failed_test_case) unless @latest_failed_test_case.nil?
+          next if @failures.empty?
+          @io.print file_failures.join("\n")
+        end
       end
 
       private
+
       def file_failures
         @failures.map { |file, lines| [file, lines].join(':') }
       end
+
+      def add_to_failures(test_case)
+        location = test_case.location
+        @failures[location.file] ||= []
+        @failures[location.file] << location.lines.max unless @failures[location.file].include?(location.lines.max)
+      end
     end
   end
 end

data/lib/cucumber/formatter/stepdefs.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/usage'
 
 module Cucumber
   module Formatter
     class Stepdefs < Usage
-      def print_steps(stepdef_key)
-      end
+      def print_steps(stepdef_key); end
 
       def max_step_length
         0

data/lib/cucumber/formatter/steps.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format steps</tt>
     class Steps
-
       def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io, "steps")
+        @io = ensure_io(path_or_io)
         @options = options
         @step_definition_files = collect_steps(runtime)
       end
 
-      def after_features(features)
+      def after_features(_features)
         print_summary
       end
 
@@ -34,15 +35,14 @@ module Cucumber
       end
 
       def collect_steps(runtime)
-        runtime.step_definitions.inject({}) do |step_definitions, step_definition|
+        runtime.step_definitions.each_with_object({}) do |step_definition, step_definitions|
           step_definitions[step_definition.file] ||= []
-          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp_source ]
-          step_definitions
+          step_definitions[step_definition.file] << [step_definition.file_colon_line, step_definition.regexp_source]
         end
       end
 
       def source_indent(sources)
-        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+        sources.map { |_file_colon_line, regexp| regexp.size }.max + 1
       end
     end
   end

data/lib/cucumber/formatter/summary.rb

@@ -1,35 +1,65 @@
+# frozen_string_literal: true
+
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/console_counts'
+require 'cucumber/formatter/console_issues'
+require 'cucumber/core/test/result'
+require 'cucumber/formatter/ast_lookup'
+
 module Cucumber
   module Formatter
-    module Summary
+    # Summary formatter, outputting only feature / scenario titles
+    class Summary
+      include Io
+      include Console
 
-      def scenario_summary(runtime, &block)
-        scenarios_proc = lambda{|status| runtime.scenarios(status)}
-        dump_count(runtime.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
-      end
+      def initialize(config)
+        @config = config
+        @io = ensure_io(config.out_stream)
+        @ast_lookup = AstLookup.new(config)
+        @counts = ConsoleCounts.new(@config)
+        @issues = ConsoleIssues.new(@config, @ast_lookup)
+        @start_time = Time.now
+
+        @config.on_event :test_case_started do |event|
+          print_feature event.test_case
+          print_test_case event.test_case
+        end
+
+        @config.on_event :test_case_finished do |event|
+          print_result event.result
+        end
 
-      def step_summary(runtime, &block)
-        steps_proc = lambda{|status| runtime.steps(status)}
-        dump_count(runtime.steps.length, "step") + dump_status_counts(steps_proc, &block)
+        @config.on_event :test_run_finished do |_event|
+          duration = Time.now - @start_time
+          @io.puts
+          print_statistics(duration, @config, @counts, @issues)
+        end
       end
 
       private
 
-      def dump_status_counts(find_elements_proc)
-        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
-          elements = find_elements_proc.call(status)
-          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
-        end.compact
-        if counts.any?
-          " (#{counts.join(', ')})"
-        else
-          ""
-        end
+      def gherkin_document(uri)
+        @ast_lookup.gherkin_document(uri)
       end
 
-      def dump_count(count, what, state=nil)
-        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      def print_feature(test_case)
+        uri = test_case.location.file
+        return if @current_feature_uri == uri
+        feature_name = gherkin_document(uri).feature.name
+        @io.puts unless @current_feature_uri.nil?
+        @io.puts feature_name
+        @current_feature_uri = uri
       end
 
+      def print_test_case(test_case)
+        @io.print "  #{test_case.name} "
+      end
+
+      def print_result(result)
+        @io.puts format_string(result, result.to_sym)
+      end
     end
   end
 end

data/lib/cucumber/formatter/unicode.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Require this file if you need Unicode support.
 # Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
 require 'cucumber/platform'
@@ -7,40 +9,37 @@ if Cucumber::WINDOWS
   if ENV['CUCUMBER_OUTPUT_ENCODING']
     Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
   elsif `cmd /c chcp` =~ /(\d+)/
-    if [65000, 65001].include? $1.to_i
-      Cucumber::CODEPAGE = 'UTF-8'
+    if [65_000, 65_001].include? Regexp.last_match(1).to_i
+      Cucumber::CODEPAGE = 'UTF-8'.freeze
       ENV['ANSICON_API'] = 'ruby'
     else
-      Cucumber::CODEPAGE = "cp#{$1.to_i}"
+      Cucumber::CODEPAGE = "cp#{Regexp.last_match(1).to_i}".freeze
     end
   else
-    Cucumber::CODEPAGE = "cp1252"
+    Cucumber::CODEPAGE = 'cp1252'.freeze
     STDERR.puts("WARNING: Couldn't detect your output codepage. Assuming it is 1252. You may have to chcp 1252 or SET CUCUMBER_OUTPUT_ENCODING=cp1252.")
   end
 
   module Cucumber
     # @private
     module WindowsOutput
-      def self.extended(o)
-        o.instance_eval do
-
-          def cucumber_preprocess_output(*a)
-            begin
-              a.map{|arg| arg.to_s.encode(Encoding.default_external)}
-            rescue Encoding::UndefinedConversionError => e
-              STDERR.cucumber_puts("WARNING: #{e.message}")
-              a
-            end
+      def self.extended(output)
+        output.instance_eval do
+          def cucumber_preprocess_output(*out)
+            out.map { |arg| arg.to_s.encode(Encoding.default_external) }
+          rescue Encoding::UndefinedConversionError => e
+            STDERR.cucumber_puts("WARNING: #{e.message}")
+            out
           end
 
           alias cucumber_print print
-          def print(*a)
-            cucumber_print(*cucumber_preprocess_output(*a))
+          def print(*out)
+            cucumber_print(*cucumber_preprocess_output(*out))
           end
 
           alias cucumber_puts puts
-          def puts(*a)
-            cucumber_puts(*cucumber_preprocess_output(*a))
+          def puts(*out)
+            cucumber_puts(*cucumber_preprocess_output(*out))
           end
         end
       end