cucumber 10.2.0 → 11.1.0

data/lib/cucumber/formatter/message_builder.rb

@@ -1,201 +1,240 @@
 # frozen_string_literal: true
 
 require 'base64'
+require 'json'
+
 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
+      include Console
 
       def initialize(config)
         @config = config
+        @ast_lookup = AstLookup.new(config)
+        @repository = Cucumber::Repository.new
 
-        @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)
+        @test_run_started_id = config.test_run_started_id
 
-        config.on_event :envelope, &method(:on_envelope)
-        config.on_event :gherkin_source_read, &method(:on_gherkin_source_read)
+        # Fake Query objects
+        @test_case_by_step_id = {}
+        @pickle_id_by_test_case_id = {}
+        @pickle_id_step_by_test_step_id = {}
+        @hook_id_by_test_step_id = {}
+        @step_definition_ids_by_test_step_id = {}
+        @step_match_arguments_by_test_step_id = {}
+
+        # Ensure all handlers for events occur after all ivars are instantiated
+
+        config.on_event :gherkin_source_parsed, &method(:on_gherkin_source_parsed)
+
+        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 :test_case_created, &method(:on_test_case_created)
         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_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)
 
-      def output_message
-        raise 'To be implemented'
+        config.on_event :envelope, &method(:on_envelope)
       end
 
-      def attach(src, media_type, filename)
-        attachment_data = {
-          test_step_id: @current_test_step_id,
-          test_case_started_id: @current_test_case_started_id,
-          media_type: media_type,
-          file_name: filename
-        }
+      def on_envelope(event)
+        @current_test_run_hook_started_id = event.envelope.test_run_hook_started.id if event.envelope.test_run_hook_started
+      end
 
-        if media_type&.start_with?('text/')
-          attachment_data[:content_encoding] = Cucumber::Messages::AttachmentContentEncoding::IDENTITY
-          attachment_data[:body] = src
-        else
-          body = src.respond_to?(:read) ? src.read : src
+      def attach(src, media_type, filename, streamed_file)
+        attachment_data =
+          if @current_test_run_hook_started_id.nil?
+            {
+              test_step_id: @current_test_step_id,
+              test_case_started_id: @current_test_case_started_id,
+              media_type: media_type,
+              file_name: filename,
+              timestamp: time_to_timestamp(Time.now)
+            }
+          else
+            {
+              test_run_hook_started_id: @current_test_run_hook_started_id,
+              media_type: media_type,
+              file_name: filename,
+              timestamp: time_to_timestamp(Time.now)
+            }
+          end
+
+        if streamed_file
           attachment_data[:content_encoding] = Cucumber::Messages::AttachmentContentEncoding::BASE64
-          attachment_data[:body] = Base64.strict_encode64(body)
+          attachment_data[:body] = Base64.strict_encode64(src)
+        else
+          attachment_data[:content_encoding] = Cucumber::Messages::AttachmentContentEncoding::IDENTITY
+          attachment_data[:body] = src.is_a?(Hash) ? src.to_json : src
         end
 
         message = Cucumber::Messages::Envelope.new(attachment: Cucumber::Messages::Attachment.new(**attachment_data))
-        output_envelope(message)
+        @config.event_bus.envelope(message)
       end
 
       private
 
-      def on_envelope(event)
-        output_envelope(event.envelope)
+      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(
-            uri: event.path,
-            data: event.body,
-            media_type: 'text/x.cucumber.gherkin+plain'
-          )
-        )
+      def on_hook_test_step_created(event)
+        @hook_id_by_test_step_id[event.test_step.id] = event.hook.id
+      end
 
-        output_envelope(message)
+      def on_step_activated(event)
+        @step_definition_ids_by_test_step_id[event.test_step.id] << event.step_match.step_definition.id
+        @step_match_arguments_by_test_step_id[event.test_step.id] = event.step_match.step_arguments
       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_test_case_created(event)
+        @pickle_id_by_test_case_id[event.test_case.id] = event.pickle.id
+      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),
+            pickle_id: fake_query_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
           )
         )
 
-        output_envelope(message)
+        # 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)
+
+        @config.event_bus.envelope(message)
       end
 
-      def test_step_to_message(step)
-        return hook_step_to_message(step) if step.hook?
+      def on_test_case_started(event)
+        # For any new test_case_started events, we must ALWAYS generate a new id for a new run
+        @current_test_case_started_id = @config.id_generator.new_id
+        @current_test_run_hook_started_id = nil
 
-        Cucumber::Messages::TestStep.new(
-          id: step.id,
-          pickle_step_id: @pickle_step_by_test_step.pickle_step_id(step),
-          step_definition_ids: @step_definitions_by_test_step.step_definition_ids(step),
-          step_match_arguments_lists: step_match_arguments_lists(step)
-        )
-      end
+        find_all_test_case_started_by_test_case_id =
+          @repository.test_case_started_by_id
+                     .values
+                     .select { |test_case_started| test_case_started.test_case_id == event.test_case.id }
 
-      def hook_step_to_message(step)
-        Cucumber::Messages::TestStep.new(
-          id: step.id,
-          hook_id: @hook_by_test_step.hook_id(step)
+        # If no TestCaseStarted messages exist. We must be on attempt 1 (Hence the .to_i casting for a `nil` value)
+        attempts_previously_made = find_all_test_case_started_by_test_case_id.map(&:attempt).max.to_i
+
+        message = Cucumber::Messages::Envelope.new(
+          test_case_started: Cucumber::Messages::TestCaseStarted.new(
+            id: @current_test_case_started_id,
+            test_case_id: event.test_case.id,
+            timestamp: time_to_timestamp(Time.now),
+            attempt: attempts_previously_made + 1
+          )
         )
-      end
 
-      def step_match_arguments_lists(step)
-        match_arguments = step_match_arguments(step)
-        [Cucumber::Messages::StepMatchArgumentsList.new(
-          step_match_arguments: match_arguments
-        )]
-      rescue Cucumber::Formatter::TestStepUnknownError
-        []
+        @config.event_bus.envelope(message)
+        @repository.update(message)
       end
 
-      def step_match_arguments(step)
-        @step_definitions_by_test_step.step_match_arguments(step).map do |argument|
-          Cucumber::Messages::StepMatchArgument.new(
-            group: argument_group_to_message(argument.group),
-            parameter_type_name: parameter_type_name(argument)
-          )
-        end
-      end
+      def on_test_case_finished(event)
+        test_case_started_id =
+          @repository.test_case_started_by_id
+                     .values
+                     .detect { |test_case_started_message| test_case_started_message.test_case_id == event.test_case.id }
+                     .id
 
-      def argument_group_to_message(group)
-        Cucumber::Messages::Group.new(
-          start: group.start,
-          value: group.value,
-          children: group.children.map { |child| argument_group_to_message(child) }
+        test_case_started_message = @repository.test_case_started_by_id[test_case_started_id]
+        max_attempts = @config.retry_attempts
+        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,
+            timestamp: time_to_timestamp(Time.now),
+            will_be_retried: will_be_retried
+          )
         )
-      end
 
-      def parameter_type_name(step_match_argument)
-        step_match_argument.parameter_type&.name if step_match_argument.respond_to?(:parameter_type)
+        @config.event_bus.envelope(message)
       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
           )
         )
 
-        output_envelope(message)
+        @config.event_bus.envelope(message)
       end
 
-      def on_test_case_started(event)
-        @current_test_case_started_id = test_case_started_id(event.test_case)
-
+      def on_test_run_finished(event)
         message = Cucumber::Messages::Envelope.new(
-          test_case_started: Cucumber::Messages::TestCaseStarted.new(
-            id: test_case_started_id(event.test_case),
-            test_case_id: event.test_case.id,
+          test_run_finished: Cucumber::Messages::TestRunFinished.new(
             timestamp: time_to_timestamp(Time.now),
-            attempt: @test_case_started_by_test_case.attempt_by_test_case(event.test_case)
+            success: event.success,
+            test_run_started_id: @test_run_started_id
           )
         )
 
-        output_envelope(message)
+        @config.event_bus.envelope(message)
+      end
+
+      def on_test_step_created(event)
+        @pickle_id_step_by_test_step_id[event.test_step.id] = event.pickle_step.id
+        @step_definition_ids_by_test_step_id[event.test_step.id] = []
       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]
+        find_test_case_by_step_id =
+          @repository.test_case_by_id
+                     .values
+                     .detect { |test_case_message| test_case_message.test_steps.any? { |step_message| step_message.id == event.test_step.id } }
+
+        find_test_case_started_by_test_case =
+          @repository.test_case_started_by_id
+                     .values
+                     .select { |test_case_started_message| test_case_started_message.test_case_id == find_test_case_by_step_id.id }
+                     .max_by(&:attempt)
 
         message = Cucumber::Messages::Envelope.new(
           test_step_started: Cucumber::Messages::TestStepStarted.new(
             test_step_id: event.test_step.id,
-            test_case_started_id: test_case_started_id(test_case),
+            test_case_started_id: find_test_case_started_by_test_case.id,
             timestamp: time_to_timestamp(Time.now)
           )
         )
 
-        output_envelope(message)
+        @config.event_bus.envelope(message)
       end
 
       def on_test_step_finished(event)
-        test_case = @test_case_by_step_id[event.test_step.id]
-        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
+        find_test_case_by_step_id =
+          @repository.test_case_by_id
+                     .values
+                     .detect { |test_case_message| test_case_message.test_steps.any? { |step_message| step_message.id == event.test_step.id } }
 
+        find_test_case_started_by_test_case =
+          @repository.test_case_started_by_id
+                     .values
+                     .select { |test_case_started_message| test_case_started_message.test_case_id == find_test_case_by_step_id.id }
+                     .max_by(&:attempt)
+
+        result = event.result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         result_message = result.to_message
         if result.failed? || result.pending?
           message_element = result.failed? ? result.exception : result
@@ -208,16 +247,105 @@ module Cucumber
           )
         end
 
+        output_snippet_envelope(event)
+
         message = Cucumber::Messages::Envelope.new(
           test_step_finished: Cucumber::Messages::TestStepFinished.new(
             test_step_id: event.test_step.id,
-            test_case_started_id: test_case_started_id(test_case),
+            test_case_started_id: find_test_case_started_by_test_case.id,
             test_step_result: result_message,
             timestamp: time_to_timestamp(Time.now)
           )
         )
 
-        output_envelope(message)
+        @config.event_bus.envelope(message)
+      end
+
+      def output_snippet_envelope(event)
+        return unless event.result.undefined?
+
+        collect_snippet_data(event.test_step, @ast_lookup)
+        snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
+          snippet_text(step_keyword, step_name, multiline_arg)
+        end
+
+        message = generate_snippet_envelope(snippet_text_proc, event)
+        @config.event_bus.envelope(message)
+        # To ensure we don't redistribute the "same" snippets over and over again
+        snippets_input.clear
+      end
+
+      def generate_snippet_envelope(snippet_text_proc, event)
+        snippets_array = snippets_input.map do |data|
+          snippet_text_proc.call(data.actual_keyword, data.step.text, data.step.multiline_arg)
+        end.uniq
+
+        Cucumber::Messages::Envelope.new(
+          suggestion: Cucumber::Messages::Suggestion.new(
+            id: @config.id_generator.new_id,
+            pickle_step_id: @repository.test_step_by_id[event.test_step.id].pickle_step_id,
+            snippets: snippets_array.map { |code_snippet| Cucumber::Messages::Snippet.new(language: 'ruby', code: code_snippet) }
+          )
+        )
+      end
+
+      def on_undefined_parameter_type(event)
+        message = Cucumber::Messages::Envelope.new(
+          undefined_parameter_type: Cucumber::Messages::UndefinedParameterType.new(
+            name: event.type_name,
+            expression: event.expression
+          )
+        )
+
+        @config.event_bus.envelope(message)
+      end
+
+      def test_step_to_message(step)
+        return hook_step_to_message(step) if step.hook?
+
+        Cucumber::Messages::TestStep.new(
+          id: step.id,
+          pickle_step_id: @pickle_id_step_by_test_step_id[step.id],
+          step_definition_ids: fake_query_step_definition_ids(step),
+          step_match_arguments_lists: step_match_arguments_lists(step)
+        )
+      end
+
+      def hook_step_to_message(step)
+        Cucumber::Messages::TestStep.new(
+          id: step.id,
+          hook_id: @hook_id_by_test_step_id[step.id]
+        )
+      end
+
+      def step_match_arguments_lists(step)
+        match_arguments = step_match_arguments(step)
+        if match_arguments.nil?
+          []
+        else
+          [Cucumber::Messages::StepMatchArgumentsList.new(step_match_arguments: match_arguments)]
+        end
+      end
+
+      def step_match_arguments(step)
+        fake_query_step_match_arguments(step)&.map do |argument|
+          Cucumber::Messages::StepMatchArgument.new(
+            group: argument_group_to_message(argument.group),
+            parameter_type_name: parameter_type_name(argument)
+          )
+        end
+      end
+
+      def argument_group_to_message(group)
+        Cucumber::Messages::Group.new(
+          start: group.start,
+          value: group.value,
+          children: group.children&.map { |child| argument_group_to_message(child) }
+        )
+      end
+
+      def parameter_type_name(step_match_argument)
+        step_match_argument.parameter_type&.name if step_match_argument.respond_to?(:parameter_type)
       end
 
       def create_error_message(message_element)
@@ -237,42 +365,20 @@ module Cucumber
         )
       end
 
-      def on_test_case_finished(event)
-        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)
-          )
-        )
-
-        output_envelope(message)
+      def fake_query_hook_id(test_step)
+        @hook_id_by_test_step_id.fetch(test_step.id)
       end
 
-      def on_test_run_finished(event)
-        message = Cucumber::Messages::Envelope.new(
-          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
-          )
-        )
-
-        output_envelope(message)
+      def fake_query_pickle_id(test_case)
+        @pickle_id_by_test_case_id.fetch(test_case.id)
       end
 
-      def on_undefined_parameter_type(event)
-        message = Cucumber::Messages::Envelope.new(
-          undefined_parameter_type: Cucumber::Messages::UndefinedParameterType.new(
-            name: event.type_name,
-            expression: event.expression
-          )
-        )
-
-        output_envelope(message)
+      def fake_query_step_definition_ids(test_step)
+        @step_definition_ids_by_test_step_id.fetch(test_step.id)
       end
 
-      def test_case_started_id(test_case)
-        @test_case_started_by_test_case.test_case_started_id_by_test_case(test_case)
+      def fake_query_step_match_arguments(test_step)
+        @step_match_arguments_by_test_step_id.fetch(test_step.id, nil)
       end
     end
   end

data/lib/cucumber/formatter/pretty.rb

@@ -33,8 +33,6 @@ module Cucumber
         @io = ensure_io(config.out_stream, config.error_stream)
         @config = config
         @options = config.to_hash
-        @snippets_input = []
-        @undefined_parameter_types = []
         @total_duration = 0
         @exceptions = []
         @gherkin_sources = {}
@@ -73,8 +71,7 @@ module Cucumber
       end
 
       def on_step_activated(event)
-        test_step, step_match = *event.attributes
-        @step_matches[test_step.to_s] = step_match
+        @step_matches[event.test_step.to_s] = event.step_match
       end
 
       def on_test_case_started(event)
@@ -140,7 +137,7 @@ module Cucumber
         print_summary
       end
 
-      def attach(src, media_type, filename)
+      def attach(src, media_type, filename, _streamed_file)
         return unless media_type == 'text/x.cucumber.log+plain'
 
         if filename

data/lib/cucumber/formatter/progress.rb

@@ -20,8 +20,6 @@ module Cucumber
       def initialize(config)
         @config = config
         @io = ensure_io(config.out_stream, config.error_stream)
-        @snippets_input = []
-        @undefined_parameter_types = []
         @total_duration = 0
         @matches = {}
         @pending_step_matches = []
@@ -94,6 +92,7 @@ module Cucumber
       CHARS = {
         passed: '.',
         failed: 'F',
+        ambiguous: 'A',
         undefined: 'U',
         pending: 'P',
         skipped: '-'