cucumber 10.2.0 → 11.1.1

data/lib/cucumber/formatter/rerun.rb

@@ -1,52 +1,103 @@
 # frozen_string_literal: true
 
-require 'cucumber/formatter/io'
+require 'cucumber/query'
+
+require_relative 'io'
 
 module Cucumber
   module Formatter
     class Rerun
-      include Formatter::Io
+      include Io
 
       def initialize(config)
-        @io = ensure_io(config.out_stream, config.error_stream)
         @config = config
-        @failures = {}
-        config.on_event :test_case_finished do |event|
-          test_case, result = *event.attributes
-          if @config.strict.strict?(:flaky)
-            next if result.ok?(strict: @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?(strict: @config.strict)
-                @latest_failed_test_case = nil
-              end
-            end
-            @latest_failed_test_case = test_case unless result.ok?(strict: @config.strict)
+        @io = ensure_io(config.out_stream, config.error_stream)
+        @repository = Cucumber::Repository.new
+        @query = Cucumber::Query.new(@repository)
+        config.on_event :envelope, &method(:output_envelope)
+      end
+
+      def output_envelope(event)
+        envelope = event.envelope
+        @repository.update(envelope)
+        finish_report if envelope.test_run_finished
+      end
+
+      private
+
+      def finish_report
+        @query.find_all_test_case_started.each do |test_case|
+          status = @query.find_most_severe_test_step_result_by(test_case).status
+          # RULE: Don't log test cases without a pickle (Unsure what these could be?)
+          pickle = @query.find_pickle_by(test_case)
+          next if pickle.nil?
+
+          # RULE: (Configuration specific)
+          #   -> If the test case has already been logged (And so we're retrying), we remove prior references of failures
+          if passing?(test_case) && !rerun_flaky_tests?
+            uri_and_location_hash[pickle.uri].delete(pickle.location.line)
+            next
+          end
+
+          # RULE: (Configuration specific - to be amended once CCK conformance is finalised)
+          #   -> If the strict configuration permits the result - handle it accordingly
+          if status == 'UNDEFINED' && !@config.strict.strict?(:undefined)
+            Cucumber.deprecate(
+              'The strict configuration in cucumber is going away and moving towards a standardised set of behaviours',
+              '--strict=undefined',
+              '12.0.0'
+            )
+            next
           end
+
+          if status == 'PENDING' && !@config.strict.strict?(:pending)
+            Cucumber.deprecate(
+              'The strict configuration in cucumber is going away and moving towards a standardised set of behaviours',
+              '--strict=pending',
+              '12.0.0'
+            )
+            next
+          end
+
+          # RULE: Passing test cases are not considered failures (Don't log these)
+          next if passing?(test_case)
+
+          # RULE: Skipped test cases are not considered failures (on their own, don't log these)
+          next if skipped?(test_case)
+
+          # RULE: Before logging a failure, ensure we are not on a retried test case (Don't log a retry multiple times)
+          next if test_case.attempt > 1
+
+          # Log the failure if every other skip rule has not been met, and the failure has not already been logged
+          uri_and_location_hash[pickle.uri] << pickle.location.line
         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")
+        # Generate the final output from the logged failures to be formatted in the io output
+        @io.print(failure_array.join("\n"))
+      end
+
+      def failure_array
+        uri_and_location_hash.filter_map do |uri, lines|
+          "#{uri}:#{lines.join(':')}" if lines.any?
         end
       end
 
-      private
+      def uri_and_location_hash
+        @uri_and_location_hash ||= Hash.new { |hash, key| hash[key] = Set.new }
+      end
+
+      def rerun_flaky_tests?
+        @config.strict.strict?(:flaky)
+      end
 
-      def file_failures
-        @failures.map { |file, lines| [file, lines].join(':') }
+      def passing?(test_case_started)
+        most_severe_test_step_result = @query.find_most_severe_test_step_result_by(test_case_started)
+        most_severe_test_step_result.status == Cucumber::Messages::TestStepResultStatus::PASSED
       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)
+      def skipped?(test_case_started)
+        most_severe_test_step_result = @query.find_most_severe_test_step_result_by(test_case_started)
+        most_severe_test_step_result.status == Cucumber::Messages::TestStepResultStatus::SKIPPED
       end
     end
   end

data/lib/cucumber/formatter/summary.rb

@@ -4,12 +4,13 @@ require 'cucumber/formatter/io'
 require 'cucumber/formatter/console'
 require 'cucumber/formatter/console_counts'
 require 'cucumber/formatter/console_issues'
+require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/core/test/result'
 require 'cucumber/formatter/ast_lookup'
 
 module Cucumber
   module Formatter
-    # Summary formatter, outputting only feature / scenario titles
+    # Summary formatter, outputting feature / scenario titles plus failure details
     class Summary
       include Io
       include Console
@@ -20,6 +21,7 @@ module Cucumber
         @ast_lookup = AstLookup.new(config)
         @counts = ConsoleCounts.new(@config)
         @issues = ConsoleIssues.new(@config, @ast_lookup)
+        @failed_results = []
         @start_time = Time.now
 
         @config.on_event :test_case_started do |event|
@@ -31,9 +33,14 @@ module Cucumber
           print_result event.result
         end
 
+        @config.on_event :test_step_finished do |event|
+          collect_failed_result(event.test_step, event.result)
+        end
+
         @config.on_event :test_run_finished do |_event|
           duration = Time.now - @start_time
           @io.puts
+          print_elements(@failed_results, :failed, 'steps')
           print_statistics(duration, @config, @counts, @issues)
         end
       end
@@ -61,6 +68,13 @@ module Cucumber
       def print_result(result)
         @io.puts format_string(result, result.to_sym)
       end
+
+      def collect_failed_result(test_step, result)
+        return if test_step.hook?
+
+        result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        @failed_results << result if result.failed?
+      end
     end
   end
 end

data/lib/cucumber/formatter/usage.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require 'cucumber/formatter/progress'
-require 'cucumber/step_definition_light'
 require 'cucumber/formatter/console'
 
 module Cucumber
   module Formatter
     class Usage < Progress
       include Console
+
       class StepDefKey
         attr_accessor :mean_duration, :status
         attr_reader :regexp_source, :location
@@ -32,8 +32,7 @@ module Cucumber
         @total_duration = 0
         @matches = {}
         config.on_event :step_activated do |event|
-          test_step, step_match = *event.attributes
-          @matches[test_step.to_s] = step_match
+          @matches[event.test_step.to_s] = event.step_match
         end
         config.on_event :step_definition_registered, &method(:on_step_definition_registered)
       end

data/lib/cucumber/formatter.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/formatter/*.rb"].map(&method(:require))

data/lib/cucumber/glue/proto_world.rb

@@ -94,9 +94,10 @@ module Cucumber
           media_type = MiniMime.lookup_by_filename(file)&.content_type if media_type.nil?
           file = File.read(file, mode: 'rb')
         end
-        super
+        # We pass in the concept of whether the file is streamed to ensure that the envelope encoding is correct
+        super(file, media_type, filename)
       rescue StandardError
-        super
+        super(file, media_type, filename)
       end
 
       # Mark the matched step as pending.

data/lib/cucumber/glue/registry_and_more.rb

@@ -4,6 +4,8 @@ require 'cucumber/cucumber_expressions/parameter_type_registry'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'
 require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/messages/helpers/time_conversion'
+
 require 'cucumber/glue/dsl'
 require 'cucumber/glue/snippet'
 require 'cucumber/glue/hook'
@@ -13,7 +15,7 @@ require 'cucumber/glue/world_factory'
 require 'cucumber/gherkin/i18n'
 require 'multi_test'
 require 'cucumber/step_match'
-require 'cucumber/step_definition_light'
+require 'cucumber/events/base'
 require 'cucumber/events/step_definition_registered'
 
 module Cucumber
@@ -49,6 +51,8 @@ module Cucumber
     class RegistryAndMore
       attr_reader :current_world, :step_definitions
 
+      include Cucumber::Messages::Helpers::TimeConversion
+
       all_keywords = ::Gherkin::DIALECTS.keys.map do |dialect_name|
         dialect = ::Gherkin::Dialect.for(dialect_name)
         dialect.given_keywords + dialect.when_keywords + dialect.then_keywords + dialect.and_keywords + dialect.but_keywords
@@ -99,14 +103,20 @@ module Cucumber
       def register_rb_step_definition(string_or_regexp, proc_or_sym, options)
         step_definition = StepDefinition.new(@configuration.id_generator.new_id, self, string_or_regexp, proc_or_sym, options)
         @step_definitions << step_definition
-        @configuration.notify :step_definition_registered, step_definition
-        @configuration.notify :envelope, step_definition.to_envelope
+        @configuration.notify(:step_definition_registered, step_definition)
+        @configuration.notify(:envelope, step_definition.to_envelope)
         step_definition
       rescue Cucumber::CucumberExpressions::UndefinedParameterTypeError => e
-        # TODO: add a way to extract the parameter type directly from the error.
-        type_name = e.message.match(/^Undefined parameter type ['|{](.*)['|}].?$/)[1]
-
-        @configuration.notify :undefined_parameter_type, type_name, string_or_regexp
+        @configuration.notify(:undefined_parameter_type, e.undefined_parameter_type_name, string_or_regexp)
+        # Move the below code into cucumber-expressions. Once done. Switch the line for
+        # @configuration.notify(:envelope, e.to_envelope(string_or_regexp))
+        to_envelope = Cucumber::Messages::Envelope.new(
+          undefined_parameter_type: Cucumber::Messages::UndefinedParameterType.new(
+            name: e.undefined_parameter_type_name,
+            expression: string_or_regexp
+          )
+        )
+        @configuration.notify(:envelope, to_envelope)
       end
 
       def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
@@ -128,17 +138,12 @@ module Cucumber
         return unless File.extname(code_file) == '.rb'
 
         # This will cause self.add_step_definition, self.add_hook, and self.define_parameter_type to be called from Glue::Dsl
-
-        if Cucumber.use_legacy_autoloader
-          load File.expand_path(code_file)
-        else
-          require File.expand_path(code_file)
-        end
+        require File.expand_path(code_file)
       end
 
       def begin_scenario(test_case)
         @current_world = WorldFactory.new(@world_proc).create_world
-        @current_world.extend(ProtoWorld.for(@runtime, test_case.language))
+        @current_world.extend(ProtoWorld.for(@runtime, test_case&.language))
         MultiTest.extend_with_best_assertion_library(@current_world)
         @current_world.add_modules!(@world_modules || [], @namespaced_world_modules || {})
       end
@@ -154,15 +159,27 @@ module Cucumber
       end
 
       def before_all
+        set_up_world_for_global_hooks
+        all_succeeded = true
+        # Run each `BeforeAll` hook. Ensuring that we store the overall result as the worst status
         hooks[:before_all].each do |hook|
-          hook.invoke('BeforeAll', [])
+          result = invoke_run_hook(hook, 'BeforeAll')
+          all_succeeded = false unless result
         end
+        @current_world = nil
+        all_succeeded
       end
 
       def after_all
+        set_up_world_for_global_hooks
+        all_succeeded = true
+        # Run each `AfterAll` hook. Ensuring that we store the overall result as the worst status
         hooks[:after_all].each do |hook|
-          hook.invoke('AfterAll', [])
+          result = invoke_run_hook(hook, 'AfterAll')
+          all_succeeded = false unless result
         end
+        @current_world = nil
+        all_succeeded
       end
 
       def add_hook(type, hook)
@@ -187,6 +204,78 @@ module Cucumber
 
       private
 
+      def invoke_run_hook(hook, pseudo_method)
+        @configuration.notify(:test_run_hook_started, hook)
+
+        current_test_run_hook_started_id = @configuration.id_generator.new_id
+        started_envelope = test_run_hook_started_envelope(hook, current_test_run_hook_started_id)
+        @configuration.notify(:envelope, started_envelope)
+
+        timer = Core::Test::Timer.new.start
+        begin
+          hook.invoke(pseudo_method, [])
+          @configuration.notify(:test_run_hook_finished, hook, Core::Test::Result::Passed.new(timer.duration))
+          finished_envelope = test_run_hook_finished_envelope(Core::Test::Result::Passed.new(timer.duration), current_test_run_hook_started_id)
+          @configuration.notify(:envelope, finished_envelope)
+          true
+        rescue StandardError => e
+          @configuration.notify(:test_run_hook_finished, hook, Core::Test::Result::Failed.new(timer.duration, e))
+          finished_envelope = test_run_hook_finished_envelope(Core::Test::Result::Failed.new(timer.duration, e), current_test_run_hook_started_id)
+          @configuration.notify(:envelope, finished_envelope)
+          false
+        end
+      end
+
+      def test_run_hook_started_envelope(hook, id)
+        Cucumber::Messages::Envelope.new(
+          test_run_hook_started: Cucumber::Messages::TestRunHookStarted.new(
+            id: id,
+            hook_id: hook.id,
+            test_run_started_id: @configuration.test_run_started_id,
+            timestamp: time_to_timestamp(Time.now)
+          )
+        )
+      end
+
+      def test_run_hook_finished_envelope(test_result, test_run_hook_started_id)
+        result = test_result
+        result_message = result.to_message
+
+        if result.failed?
+          result_message = Cucumber::Messages::TestStepResult.new(
+            status: result_message.status,
+            duration: result_message.duration,
+            message: create_error_message(result.exception),
+            exception: create_exception_object(result, result.exception)
+          )
+        end
+
+        Cucumber::Messages::Envelope.new(
+          test_run_hook_finished: Cucumber::Messages::TestRunHookFinished.new(
+            test_run_hook_started_id: test_run_hook_started_id,
+            timestamp: time_to_timestamp(Time.now),
+            result: result_message
+          )
+        )
+      end
+
+      def create_error_message(message_element)
+        <<~ERROR_MESSAGE
+          #{message_element.message} (#{message_element.class})
+          #{message_element.backtrace}
+        ERROR_MESSAGE
+      end
+
+      def create_exception_object(result, message_element)
+        return unless result.failed?
+
+        Cucumber::Messages::Exception.new(
+          type: message_element.class,
+          message: message_element.message,
+          stack_trace: message_element.backtrace.join("\n")
+        )
+      end
+
       def parameter_type_envelope(parameter_type)
         # TODO: should this be moved to Cucumber::Expression::ParameterType#to_envelope ??
         # Note: that would mean that cucumber-expression would depend on cucumber-messages
@@ -197,17 +286,30 @@ module Cucumber
             regular_expressions: parameter_type.regexps.map(&:to_s),
             prefer_for_regular_expression_match: parameter_type.prefer_for_regexp_match,
             use_for_snippets: parameter_type.use_for_snippets,
-            source_reference: Cucumber::Messages::SourceReference.new(
-              uri: parameter_type.transformer.source_location[0],
-              location: Cucumber::Messages::Location.new(line: parameter_type.transformer.source_location[1])
-            )
+            source_reference: source_reference_for(parameter_type.transformer)
           )
         )
       end
 
+      def source_reference_for(transformer)
+        # #source_location may return nil if no definition was found
+        # This is the case for transformers created using method(sym) or similar
+        return nil if transformer.source_location.nil?
+
+        Cucumber::Messages::SourceReference.new(
+          uri: transformer.source_location[0],
+          location: Cucumber::Messages::Location.new(line: transformer.source_location[1])
+        )
+      end
+
       def hooks
         @hooks ||= Hash.new { |h, k| h[k] = [] }
       end
+
+      def set_up_world_for_global_hooks
+        # We don't need a language as we're just creating a world object to attach the BeforeAll / AfterAll hooks to
+        begin_scenario(nil)
+      end
     end
   end
 end

data/lib/cucumber/glue.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/glue/*.rb"].map(&method(:require))

data/lib/cucumber/multiline_argument/data_table.rb

@@ -364,17 +364,6 @@ module Cucumber
         raise %(The table must have exactly #{width} columns) unless raw[0].size == width
       end
 
-      # TODO: remove the below function if it's not actually being used.
-      # Nothing else in this repo calls it.
-      def text?(text)
-        Cucumber.deprecate(
-          'This method is no longer supported for checking text',
-          '#text?',
-          '11.0.0'
-        )
-        raw.flatten.compact.detect { |cell_value| cell_value.index(text) }
-      end
-
       def cells_rows
         @rows ||= cell_matrix.map do |cell_row|
           Cells.new(self, cell_row)

data/lib/cucumber/platform.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require 'rbconfig'
-require 'cucumber/core/platform'
 
 module Cucumber
   VERSION       = File.read(File.expand_path('../../VERSION', __dir__)).strip
   BINARY        = File.expand_path("#{File.dirname(__FILE__)}/../../bin/cucumber")
-  LIBDIR        = File.expand_path("#{File.dirname(__FILE__)}/../../lib")
   RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  JRUBY         = defined?(JRUBY_VERSION)
+  WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
 
   class << self
     attr_writer :use_full_backtrace