cucumber 4.0.0.rc.1 → 4.0.0.rc.6

data/lib/cucumber/formatter/interceptor.rb

@@ -9,30 +9,18 @@ module Cucumber
           @pipe = pipe
           @buffer = StringIO.new
           @wrapped = true
+          @lock = Mutex.new
         end
 
         def write(str)
-          lock.synchronize do
+          @lock.synchronize do
             @buffer << str if @wrapped
             return @pipe.write(str)
           end
         end
 
-        # @deprecated use #buffer_string
-        def buffer
-          require 'cucumber/deprecate.rb'
-          Cucumber.deprecate(
-            'Use Cucumber::Formatter::Interceptor::Pipe#buffer_string instead',
-            'Cucumber::Formatter::Interceptor::Pipe#buffer',
-            '3.99'
-          )
-          lock.synchronize do
-            return @buffer.string.lines
-          end
-        end
-
         def buffer_string
-          lock.synchronize do
+          @lock.synchronize do
             return @buffer.string.dup
           end
         end
@@ -80,12 +68,6 @@ module Cucumber
             return $stdout
           end
         end
-
-        private
-
-        def lock
-          @lock ||= Mutex.new
-        end
       end
     end
   end

data/lib/cucumber/formatter/io.rb

@@ -1,21 +1,27 @@
 # frozen_string_literal: true
 
+require 'cucumber/formatter/http_io'
+
 module Cucumber
   module Formatter
     module Io
       module_function
 
-      def ensure_io(path_or_io)
-        return nil if path_or_io.nil?
-        return path_or_io if path_or_io.respond_to?(:write)
-        file = File.open(path_or_io, Cucumber.file_mode('w'))
+      def ensure_io(path_or_url_or_io)
+        return nil if path_or_url_or_io.nil?
+        return path_or_url_or_io if path_or_url_or_io.respond_to?(:write)
+        io = if path_or_url_or_io.match(%r{^https?://})
+               HTTPIO.open(path_or_url_or_io)
+             else
+               File.open(path_or_url_or_io, Cucumber.file_mode('w'))
+             end
         at_exit do
-          unless file.closed?
-            file.flush
-            file.close
+          unless io.closed?
+            io.flush
+            io.close
           end
         end
-        file
+        io
       end
 
       def ensure_file(path, name)

data/lib/cucumber/formatter/json.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require 'multi_json'
+require 'json'
 require 'base64'
 require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/ast_lookup'
+require 'cucumber/deprecate'
 
 module Cucumber
   module Formatter
@@ -13,6 +14,14 @@ module Cucumber
       include Io
 
       def initialize(config)
+        Cucumber::Deprecate::CliOption.deprecate(
+          config.error_stream,
+          '--format=json',
+          "Please use --format=message and stand-alone json-formatter.\n" \
+          'json-formatter homepage: https://github.com/cucumber/cucumber/tree/master/json-formatter#cucumber-json-formatter',
+          '5.0.0'
+        )
+
         @io = ensure_io(config.out_stream)
         @ast_lookup = AstLookup.new(config)
         @feature_hashes = []
@@ -77,14 +86,14 @@ module Cucumber
       end
 
       def on_test_run_finished(_event)
-        @io.write(MultiJson.dump(@feature_hashes, pretty: true))
-      end
-
-      def puts(message)
-        test_step_output << message
+        @io.write(JSON.generate(@feature_hashes, pretty: true))
       end
 
-      def embed(src, mime_type, _label)
+      def attach(src, mime_type)
+        if mime_type == 'text/x.cucumber.log+plain'
+          test_step_output << src
+          return
+        end
         if File.file?(src)
           content = File.open(src, 'rb', &:read)
           data = encode64(content)
@@ -163,33 +172,34 @@ module Cucumber
       def create_step_hash(test_step)
         step_source = @ast_lookup.step_source(test_step).step
         step_hash = {
-          keyword: step_source[:keyword],
+          keyword: step_source.keyword,
           name: test_step.text,
           line: test_step.location.lines.min
         }
-        step_hash[:doc_string] = create_doc_string_hash(step_source[:doc_string]) unless step_source[:doc_string].nil?
-        step_hash[:rows] = create_data_table_value(step_source[:data_table]) unless step_source[:data_table].nil?
+        step_hash[:doc_string] = create_doc_string_hash(step_source.doc_string) unless step_source.doc_string.nil?
+        step_hash[:rows] = create_data_table_value(step_source.data_table) unless step_source.data_table.nil?
         step_hash
       end
 
       def create_doc_string_hash(doc_string)
-        content_type = doc_string[:content_type] || ''
+        content_type = doc_string.media_type || ''
         {
-          value: doc_string[:content],
+          value: doc_string.content,
           content_type: content_type,
-          line: doc_string[:location][:line]
+          line: doc_string.location.line
         }
       end
 
       def create_data_table_value(data_table)
-        data_table[:rows].map do |row|
-          { cells: row[:cells].map { |cell| cell[:value] } }
+        data_table.rows.map do |row|
+          { cells: row.cells.map(&:value) }
         end
       end
 
       def add_match_and_result(test_step, result)
         @step_or_hook_hash[:match] = create_match_hash(test_step, result)
         @step_or_hook_hash[:result] = create_result_hash(result)
+        result.embeddings.each { |e| embed(e['src'], e['mime_type'], e['label']) } if result.respond_to?(:embeddings)
       end
 
       def add_failed_around_hook(result)
@@ -230,9 +240,9 @@ module Cucumber
         def initialize(test_case, ast_lookup)
           @background_hash = nil
           uri = test_case.location.file
-          feature = ast_lookup.gherkin_document(uri)[:feature]
+          feature = ast_lookup.gherkin_document(uri).feature
           feature(feature, uri)
-          background(feature[:children].first[:background]) unless feature[:children].first[:background].nil?
+          background(feature.children.first.background) unless feature.children.first.background.nil?
           scenario(ast_lookup.scenario_source(test_case), test_case)
         end
 
@@ -242,23 +252,23 @@ module Cucumber
 
         def feature(feature, uri)
           @feature_hash = {
-            id: create_id(feature[:name]),
+            id: create_id(feature.name),
             uri: uri,
-            keyword: feature[:keyword],
-            name: feature[:name],
-            description: value_or_empty_string(feature[:description]),
-            line: feature[:location][:line]
+            keyword: feature.keyword,
+            name: feature.name,
+            description: value_or_empty_string(feature.description),
+            line: feature.location.line
           }
-          return if feature[:tags].empty?
-          @feature_hash[:tags] = create_tags_array_from_hash_array(feature[:tags])
+          return if feature.tags.empty?
+          @feature_hash[:tags] = create_tags_array_from_hash_array(feature.tags)
         end
 
         def background(background)
           @background_hash = {
-            keyword: background[:keyword],
-            name: background[:name],
-            description: value_or_empty_string(background[:description]),
-            line: background[:location][:line],
+            keyword: background.keyword,
+            name: background.name,
+            description: value_or_empty_string(background.description),
+            line: background.location.line,
             type: 'background'
           }
         end
@@ -267,9 +277,9 @@ module Cucumber
           scenario = scenario_source.type == :Scenario ? scenario_source.scenario : scenario_source.scenario_outline
           @test_case_hash = {
             id: "#{@feature_hash[:id]};#{create_id_from_scenario_source(scenario_source)}",
-            keyword: scenario[:keyword],
-            name: scenario[:name],
-            description: value_or_empty_string(scenario[:description]),
+            keyword: scenario.keyword,
+            name: test_case.name,
+            description: value_or_empty_string(scenario.description),
             line: test_case.location.lines.max,
             type: 'scenario'
           }
@@ -288,24 +298,24 @@ module Cucumber
 
         def create_id_from_scenario_source(scenario_source)
           if scenario_source.type == :Scenario
-            create_id(scenario_source.scenario[:name])
+            create_id(scenario_source.scenario.name)
           else
-            scenario_outline_name = scenario_source.scenario_outline[:name]
-            examples_name = scenario_source.examples[:name]
+            scenario_outline_name = scenario_source.scenario_outline.name
+            examples_name = scenario_source.examples.name
             row_number = calculate_row_number(scenario_source)
             "#{create_id(scenario_outline_name)};#{create_id(examples_name)};#{row_number}"
           end
         end
 
         def calculate_row_number(scenario_source)
-          scenario_source.examples[:table_body].each_with_index do |row, index|
+          scenario_source.examples.table_body.each_with_index do |row, index|
             return index + 2 if row == scenario_source.row
           end
         end
 
         def create_tags_array_from_hash_array(tags)
           tags_array = []
-          tags.each { |tag| tags_array << { name: tag[:name], line: tag[:location][:line] } }
+          tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
           tags_array
         end
 

data/lib/cucumber/formatter/junit.rb

@@ -82,8 +82,8 @@ module Cucumber
 
       def start_feature(test_case)
         uri = test_case.location.file
-        feature = @ast_lookup.gherkin_document(uri)[:feature]
-        raise UnNamedFeatureError, uri if feature[:name].empty?
+        feature = @ast_lookup.gherkin_document(uri).feature
+        raise UnNamedFeatureError, uri if feature.name.empty?
         @current_feature_data = @features_data[uri]
         @current_feature_data[:uri] = uri unless @current_feature_data[:uri]
         @current_feature_data[:feature] = feature unless @current_feature_data[:feature]
@@ -97,8 +97,8 @@ module Cucumber
           errors: feature_data[:errors],
           skipped: feature_data[:skipped],
           tests: feature_data[:tests],
-          time: format('%.6f', feature_data[:time]),
-          name: feature_data[:feature][:name]
+          time: format('%<time>.6f', time: feature_data[:time]),
+          name: feature_data[:feature].name
         ) do
           @testsuite << feature_data[:builder].target!
         end
@@ -108,7 +108,7 @@ module Cucumber
 
       def create_output_string(test_case, scenario, result, row_name) # rubocop:disable Metrics/PerceivedComplexity
         scenario_source = @ast_lookup.scenario_source(test_case)
-        keyword = scenario_source.type == :Scenario ? scenario_source.scenario[:keyword] : scenario_source.scenario_outline[:keyword]
+        keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
         output = "#{keyword}: #{scenario}\n\n"
         return output if result.ok?(@config.strict)
         if scenario_source.type == :Scenario
@@ -117,7 +117,7 @@ module Cucumber
               output += "#{@failing_test_step.text} at #{@failing_test_step.location}\n"
             else
               step_source = @ast_lookup.step_source(@failing_test_step).step
-              output += "#{step_source[:keyword]}#{@failing_test_step.text}\n"
+              output += "#{step_source.keyword}#{@failing_test_step.text}\n"
             end
           else # An Around hook has failed
             output += "Around hook\n"
@@ -131,10 +131,10 @@ module Cucumber
       def build_testcase(result, scenario_designation, output)
         duration = ResultBuilder.new(result).test_case_duration
         @current_feature_data[:time] += duration
-        classname = @current_feature_data[:feature][:name]
+        classname = @current_feature_data[:feature].name
         name = scenario_designation
 
-        @current_feature_data[:builder].testcase(classname: classname, name: name, time: format('%.6f', duration)) do
+        @current_feature_data[:builder].testcase(classname: classname, name: name, time: format('%<duration>.6f', duration: duration)) do
           if !result.passed? && result.ok?(@config.strict)
             @current_feature_data[:builder].skipped
             @current_feature_data[:skipped] += 1
@@ -203,15 +203,15 @@ module Cucumber
       end
 
       def scenario(scenario)
-        @scenario_name = scenario[:name].empty? ? 'Unnamed scenario' : scenario[:name]
+        @scenario_name = scenario.name.empty? ? 'Unnamed scenario' : scenario.name
       end
 
       def scenario_outline(outline)
-        @scenario_name = outline[:name].empty? ? 'Unnamed scenario outline' : outline[:name]
+        @scenario_name = outline.name.empty? ? 'Unnamed scenario outline' : outline.name
       end
 
       def examples_table_row(row)
-        @row_name = '| ' + row[:cells].map { |cell| cell[:value] }.join(' | ') + ' |'
+        @row_name = '| ' + row.cells.map(&:value).join(' | ') + ' |'
         @name_suffix = " (outline example : #{@row_name})"
       end
     end
@@ -238,6 +238,8 @@ module Cucumber
       def duration(duration, *)
         duration.tap { |dur| @test_case_duration = dur.nanoseconds / 10**9.0 }
       end
+
+      def attach(*) end
     end
   end
 end

data/lib/cucumber/formatter/message.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/message_builder'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format message</tt>
+    class Message < MessageBuilder
+      include Io
+
+      def initialize(config)
+        @io = ensure_io(config.out_stream)
+        super(config)
+      end
+
+      def output_envelope(envelope)
+        envelope.write_ndjson_to(@io)
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/message_builder.rb

@@ -0,0 +1,243 @@
+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'
+
+module Cucumber
+  module Formatter
+    class MessageBuilder
+      include Cucumber::Messages::TimeConversion
+
+      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)
+
+        config.on_event :envelope, &method(:on_envelope)
+        config.on_event :gherkin_source_read, &method(:on_gherkin_source_read)
+        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_finished, &method(:on_test_run_finished)
+
+        @test_case_by_step_id = {}
+        @current_test_case_started_id = nil
+        @current_test_step_id = nil
+      end
+
+      def output_message
+        raise 'To be implemented'
+      end
+
+      def attach(src, media_type)
+        attachment_data = {
+          test_step_id: @current_test_step_id,
+          test_case_started_id: @current_test_case_started_id,
+          media_type: media_type
+        }
+
+        if media_type.start_with?('text/')
+          attachment_data[:content_encoding] = Cucumber::Messages::Attachment::ContentEncoding::IDENTITY
+          attachment_data[:body] = src
+        else
+          body = src.respond_to?(:read) ? src.read : src
+
+          attachment_data[:content_encoding] = Cucumber::Messages::Attachment::ContentEncoding::BASE64
+          attachment_data[:body] = Base64.strict_encode64(body)
+        end
+
+        message = Cucumber::Messages::Envelope.new(
+          attachment: Cucumber::Messages::Attachment.new(**attachment_data)
+        )
+
+        output_envelope(message)
+      end
+
+      private
+
+      def on_envelope(event)
+        output_envelope(event.envelope)
+      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'
+          )
+        )
+
+        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
+
+        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) }
+          )
+        )
+
+        output_envelope(message)
+      end
+
+      def test_step_to_message(step)
+        return hook_step_to_message(step) if step.hook?
+
+        Cucumber::Messages::TestCase::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
+
+      def hook_step_to_message(step)
+        Cucumber::Messages::TestCase::TestStep.new(
+          id: step.id,
+          hook_id: @hook_by_test_step.hook_id(step)
+        )
+      end
+
+      def step_match_arguments_lists(step)
+        match_arguments = step_match_arguments(step)
+        [Cucumber::Messages::TestCase::TestStep::StepMatchArgumentsList.new(
+          step_match_arguments: match_arguments
+        )]
+      rescue Cucumber::Formatter::TestStepUnknownError
+        []
+      end
+
+      def step_match_arguments(step)
+        @step_definitions_by_test_step.step_match_arguments(step).map do |argument|
+          Cucumber::Messages::TestCase::TestStep::StepMatchArgumentsList::StepMatchArgument.new(
+            group: argument_group_to_message(argument.group),
+            parameter_type_name: argument.parameter_type.name
+          )
+        end
+      end
+
+      def argument_group_to_message(group)
+        Cucumber::Messages::TestCase::TestStep::StepMatchArgumentsList::StepMatchArgument::Group.new(
+          start: group.start,
+          value: group.value,
+          children: group.children.map { |child| argument_group_to_message(child) }
+        )
+      end
+
+      def on_test_run_started(*)
+        message = Cucumber::Messages::Envelope.new(
+          test_run_started: Cucumber::Messages::TestRunStarted.new(
+            timestamp: time_to_timestamp(Time.now)
+          )
+        )
+
+        output_envelope(message)
+      end
+
+      def on_test_case_started(event)
+        @current_test_case_started_id = test_case_started_id(event.test_case)
+
+        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,
+            timestamp: time_to_timestamp(Time.now),
+            attempt: @test_case_started_by_test_case.attempt_by_test_case(event.test_case)
+          )
+        )
+
+        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]
+
+        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),
+            timestamp: time_to_timestamp(Time.now)
+          )
+        )
+
+        output_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)
+
+        result_message = result.to_message
+        if result.failed? || result.pending?
+          result_message = Cucumber::Messages::TestStepFinished::TestStepResult.new(
+            status: result_message.status,
+            duration: result_message.duration,
+            message: create_error_message(result)
+          )
+        end
+
+        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_step_result: result_message,
+            timestamp: time_to_timestamp(Time.now)
+          )
+        )
+
+        output_envelope(message)
+      end
+
+      def create_error_message(result)
+        message_element = result.failed? ? result.exception : result
+        message = "#{message_element.message} (#{message_element.class})"
+        ([message] + message_element.backtrace).join("\n")
+      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)
+      end
+
+      def on_test_run_finished(*)
+        message = Cucumber::Messages::Envelope.new(
+          test_run_finished: Cucumber::Messages::TestRunFinished.new(
+            timestamp: time_to_timestamp(Time.now)
+          )
+        )
+
+        output_envelope(message)
+      end
+
+      def test_case_started_id(test_case)
+        @test_case_started_by_test_case.test_case_started_id_by_test_case(test_case)
+      end
+    end
+  end
+end