cucumber 10.2.0 → 11.0.0

data/lib/cucumber/formatter/message_builder.rb

@@ -4,45 +4,60 @@ require 'base64'
 require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/query/hook_by_test_step'
 require 'cucumber/formatter/query/pickle_by_test'
-require 'cucumber/formatter/query/pickle_step_by_test_step'
 require 'cucumber/formatter/query/step_definitions_by_test_step'
 require 'cucumber/formatter/query/test_case_started_by_test_case'
-require 'cucumber/formatter/query/test_run_started'
+
+require 'cucumber/query'
 
 module Cucumber
   module Formatter
     class MessageBuilder
       include Cucumber::Messages::Helpers::TimeConversion
+      include Io
 
       def initialize(config)
         @config = config
 
         @hook_by_test_step = Query::HookByTestStep.new(config)
         @pickle_by_test = Query::PickleByTest.new(config)
-        @pickle_step_by_test_step = Query::PickleStepByTestStep.new(config)
         @step_definitions_by_test_step = Query::StepDefinitionsByTestStep.new(config)
         @test_case_started_by_test_case = Query::TestCaseStartedByTestCase.new(config)
-        @test_run_started = Query::TestRunStarted.new(config)
+
+        @repository = Cucumber::Repository.new
+        @query = Cucumber::Query.new(@repository)
+
+        @test_run_started_id = config.id_generator.new_id
+        @test_case_by_step_id = {}
+        @pickle_id_step_by_test_step_id = {}
+
+        # Ensure all handlers for events occur after all ivars are instantiated
 
         config.on_event :envelope, &method(:on_envelope)
+
+        config.on_event :gherkin_source_parsed, &method(:on_gherkin_source_parsed)
         config.on_event :gherkin_source_read, &method(:on_gherkin_source_read)
+
+        config.on_event :hook_test_step_created, &method(:on_hook_test_step_created)
+
+        config.on_event :step_activated, &method(:on_step_activated)
+        config.on_event :step_definition_registered, &method(:on_step_definition_registered)
+
+        # TODO: Handle TestCaseCreated
         config.on_event :test_case_ready, &method(:on_test_case_ready)
-        config.on_event :test_run_started, &method(:on_test_run_started)
         config.on_event :test_case_started, &method(:on_test_case_started)
-        config.on_event :test_step_started, &method(:on_test_step_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_started, &method(:on_test_run_started)
         config.on_event :test_run_finished, &method(:on_test_run_finished)
-        config.on_event :undefined_parameter_type, &method(:on_undefined_parameter_type)
 
-        @test_case_by_step_id = {}
-        @current_test_run_started_id = nil
-        @current_test_case_started_id = nil
-        @current_test_step_id = nil
-      end
+        config.on_event :test_run_hook_started, &method(:on_test_run_hook_started)
+        config.on_event :test_run_hook_finished, &method(:on_test_run_hook_finished)
 
-      def output_message
-        raise 'To be implemented'
+        config.on_event :test_step_created, &method(:on_test_step_created)
+        config.on_event :test_step_started, &method(:on_test_step_started)
+        config.on_event :test_step_finished, &method(:on_test_step_finished)
+
+        config.on_event :undefined_parameter_type, &method(:on_undefined_parameter_type)
       end
 
       def attach(src, media_type, filename)
@@ -50,7 +65,8 @@ module Cucumber
           test_step_id: @current_test_step_id,
           test_case_started_id: @current_test_case_started_id,
           media_type: media_type,
-          file_name: filename
+          file_name: filename,
+          timestamp: time_to_timestamp(Time.now)
         }
 
         if media_type&.start_with?('text/')
@@ -72,6 +88,10 @@ module Cucumber
         output_envelope(event.envelope)
       end
 
+      def on_gherkin_source_parsed(_event)
+        # TODO: Handle GherkinSourceParsed
+      end
+
       def on_gherkin_source_read(event)
         message = Cucumber::Messages::Envelope.new(
           source: Cucumber::Messages::Source.new(
@@ -84,20 +104,29 @@ module Cucumber
         output_envelope(message)
       end
 
-      def on_test_case_ready(event)
-        event.test_case.test_steps.each do |step|
-          @test_case_by_step_id[step.id] = event.test_case
-        end
+      def on_hook_test_step_created(_event)
+        # TODO: Handle HookTestStepCreated
+      end
 
+      def on_test_case_ready(event)
         message = Cucumber::Messages::Envelope.new(
           test_case: Cucumber::Messages::TestCase.new(
             id: event.test_case.id,
             pickle_id: @pickle_by_test.pickle_id(event.test_case),
             test_steps: event.test_case.test_steps.map { |step| test_step_to_message(step) },
-            test_run_started_id: @current_test_run_started_id
+            test_run_started_id: @test_run_started_id
           )
         )
 
+        # TODO: This may be a redundant update. But for now we're leaving this in whilst we're in the transitory phase
+        @repository.update(message)
+
+        # TODO: Switch this over to using the Repo Query object -> `test_step_by_id`
+        # TODO: The finder in query is `find_test_step_by` (Using +TestStepStarted+ message)
+        event.test_case.test_steps.each do |step|
+          @test_case_by_step_id[step.id] = event.test_case
+        end
+
         output_envelope(message)
       end
 
@@ -106,7 +135,9 @@ module Cucumber
 
         Cucumber::Messages::TestStep.new(
           id: step.id,
-          pickle_step_id: @pickle_step_by_test_step.pickle_step_id(step),
+          # TODO: This "fake query" is only used once. It can likely be replace by `find_pickle_step_by` which
+          # takes a +TestStep+ message from the repo directly.
+          pickle_step_id: @pickle_id_step_by_test_step_id[step.id],
           step_definition_ids: @step_definitions_by_test_step.step_definition_ids(step),
           step_match_arguments_lists: step_match_arguments_lists(step)
         )
@@ -141,7 +172,7 @@ module Cucumber
         Cucumber::Messages::Group.new(
           start: group.start,
           value: group.value,
-          children: group.children.map { |child| argument_group_to_message(child) }
+          children: group.children&.map { |child| argument_group_to_message(child) }
         )
       end
 
@@ -150,12 +181,10 @@ module Cucumber
       end
 
       def on_test_run_started(*)
-        @current_test_run_started_id = @test_run_started.id
-
         message = Cucumber::Messages::Envelope.new(
           test_run_started: Cucumber::Messages::TestRunStarted.new(
             timestamp: time_to_timestamp(Time.now),
-            id: @current_test_run_started_id
+            id: @test_run_started_id
           )
         )
 
@@ -177,6 +206,26 @@ module Cucumber
         output_envelope(message)
       end
 
+      def on_test_step_created(event)
+        @pickle_id_step_by_test_step_id[event.test_step.id] = event.pickle_step.id
+        test_step_to_message(event.test_step)
+        # TODO: We need to determine what message to output here (Unsure - Placeholder added)
+        # message = Cucumber::Messages::Envelope.new(
+        #   pickle: {
+        #     id: '',
+        #     uri: '',
+        #     location: nil,
+        #     name: '',
+        #     language: '',
+        #     steps: test_step_to_message(event.test_step),
+        #     tags: [],
+        #     ast_node_ids: []
+        #   }
+        # )
+        #
+        # output_envelope(message)
+      end
+
       def on_test_step_started(event)
         @current_test_step_id = event.test_step.id
         test_case = @test_case_by_step_id[event.test_step.id]
@@ -238,10 +287,18 @@ module Cucumber
       end
 
       def on_test_case_finished(event)
+        test_case_started_id = test_case_started_id(event.test_case)
+        test_case_started_message = @repository.test_case_started_by_id[test_case_started_id]
+        max_attempts = @config.retry_attempts
+        # See "fake query" for reason this is index shifted
+        retries_attempted = test_case_started_message.attempt - 1
+        will_be_retried = event.result.failed? && (retries_attempted < max_attempts)
+
         message = Cucumber::Messages::Envelope.new(
           test_case_finished: Cucumber::Messages::TestCaseFinished.new(
-            test_case_started_id: test_case_started_id(event.test_case),
-            timestamp: time_to_timestamp(Time.now)
+            test_case_started_id: test_case_started_id,
+            timestamp: time_to_timestamp(Time.now),
+            will_be_retried: will_be_retried
           )
         )
 
@@ -253,7 +310,54 @@ module Cucumber
           test_run_finished: Cucumber::Messages::TestRunFinished.new(
             timestamp: time_to_timestamp(Time.now),
             success: event.success,
-            test_run_started_id: @current_test_run_started_id
+            test_run_started_id: @test_run_started_id
+          )
+        )
+
+        output_envelope(message)
+      end
+
+      def on_step_activated(event)
+        # TODO: Handle StepActivated
+      end
+
+      def on_step_definition_registered(event)
+        output_envelope(event.step_definition.to_envelope)
+      end
+
+      def on_test_run_hook_started(event)
+        @current_test_run_hook_started_id = @config.id_generator.new_id
+
+        message = Cucumber::Messages::Envelope.new(
+          test_run_hook_started: Cucumber::Messages::TestRunHookStarted.new(
+            id: @current_test_run_hook_started_id,
+            hook_id: event.hook.id,
+            test_run_started_id: @test_run_started_id,
+            timestamp: time_to_timestamp(Time.now)
+          )
+        )
+
+        output_envelope(message)
+      end
+
+      def on_test_run_hook_finished(event)
+        result = event.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
+
+        message = Cucumber::Messages::Envelope.new(
+          test_run_hook_finished: Cucumber::Messages::TestRunHookFinished.new(
+            test_run_hook_started_id: @current_test_run_hook_started_id,
+            timestamp: time_to_timestamp(Time.now),
+            result: result_message
           )
         )
 

data/lib/cucumber/formatter/progress.rb

@@ -94,6 +94,7 @@ module Cucumber
       CHARS = {
         passed: '.',
         failed: 'F',
+        ambiguous: 'A',
         undefined: 'U',
         pending: 'P',
         skipped: '-'

data/lib/cucumber/formatter/query/test_case_started_by_test_case.rb

@@ -35,6 +35,7 @@ module Cucumber
         end
 
         def on_test_case_started(event)
+          # TODO: LH - Apr '26 -> Clarify if this should start with attempt 1 or attempt 0
           @attempts_by_test_case_id[event.test_case.id] += 1
           @test_case_started_id_by_test_case_id[event.test_case.id] = @config.id_generator.new_id
         end

data/lib/cucumber/formatter/rerun.rb

@@ -1,52 +1,96 @@
 # frozen_string_literal: true
 
 require 'cucumber/formatter/io'
+require 'cucumber/formatter/message_builder'
 
 module Cucumber
   module Formatter
-    class Rerun
-      include Formatter::Io
-
+    class Rerun < MessageBuilder
       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)
+        super(config)
+      end
+
+      def output_envelope(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/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

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/registry_and_more.rb

@@ -13,7 +13,6 @@ require 'cucumber/glue/world_factory'
 require 'cucumber/gherkin/i18n'
 require 'multi_test'
 require 'cucumber/step_match'
-require 'cucumber/step_definition_light'
 require 'cucumber/events/step_definition_registered'
 
 module Cucumber
@@ -100,7 +99,6 @@ module Cucumber
         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
         step_definition
       rescue Cucumber::CucumberExpressions::UndefinedParameterTypeError => e
         # TODO: add a way to extract the parameter type directly from the error.
@@ -128,12 +126,7 @@ 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)
@@ -155,13 +148,13 @@ module Cucumber
 
       def before_all
         hooks[:before_all].each do |hook|
-          hook.invoke('BeforeAll', [])
+          invoke_run_hook(hook, 'BeforeAll')
         end
       end
 
       def after_all
         hooks[:after_all].each do |hook|
-          hook.invoke('AfterAll', [])
+          invoke_run_hook(hook, 'AfterAll')
         end
       end
 
@@ -187,6 +180,18 @@ module Cucumber
 
       private
 
+      def invoke_run_hook(hook, pseudo_method)
+        @configuration.notify(:test_run_hook_started, hook)
+        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))
+        rescue StandardError => e
+          @configuration.notify(:test_run_hook_finished, hook, Core::Test::Result::Failed.new(timer.duration, e))
+          raise
+        end
+      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,14 +202,22 @@ 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

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