cucumber 4.1.0 → 9.2.0

data/lib/cucumber/formatter/http_io.rb

@@ -1,145 +1,19 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'tempfile'
+require_relative 'curl_option_parser'
+require_relative 'io_http_buffer'
 
 module Cucumber
   module Formatter
     class HTTPIO
-      class << self
-        # Returns an IO that will write to a HTTP request's body
-        def open(url, https_verify_mode = nil)
-          @https_verify_mode = https_verify_mode
-          uri, method, headers = CurlOptionParser.parse(url)
-          IOHTTPBuffer.new(uri, method, headers, https_verify_mode)
-        end
-      end
-    end
-
-    class CurlOptionParser
-      def self.parse(options)
-        chunks = options.split(/\s/).compact
-        http_method = 'PUT'
-        url = chunks[0]
-        headers = ''
-
-        last_flag = nil
-        chunks.each do |chunk|
-          if ['-X', '--request'].include?(chunk)
-            last_flag = '-X'
-            next
-          end
-
-          if chunk == '-H'
-            last_flag = '-H'
-            next
-          end
-
-          if last_flag == '-X'
-            http_method = chunk
-            last_flag = nil
-          end
-
-          headers += chunk if last_flag == '-H'
-        end
-
-        [
-          url,
-          http_method,
-          make_headers(headers)
-        ]
-      end
-
-      def self.make_headers(headers)
-        hash_headers = {}
-        str_scanner = /("(?<key>[^":]+)\s*:\s*(?<value>[^":]+)")|('(?<key1>[^':]+)\s*:\s*(?<value1>[^':]+)')/
-
-        headers.scan(str_scanner) do |header|
-          header = header.compact!
-          hash_headers[header[0]] = header[1]&.strip
-        end
-
-        hash_headers
-      end
-    end
-
-    class IOHTTPBuffer
-      attr_reader :uri, :method, :headers
-
-      def initialize(uri, method, headers = {}, https_verify_mode = nil)
-        @uri = URI(uri)
-        @method = method
-        @headers = headers
-        @write_io = Tempfile.new('cucumber', encoding: 'UTF-8')
-        @https_verify_mode = https_verify_mode
-      end
-
-      def close
-        post_content(@uri, @method, @headers)
-        @write_io.close
-      end
-
-      def write(data)
-        @write_io.write(data)
-      end
-
-      def flush
-        @write_io.flush
-      end
-
-      def closed?
-        @write_io.closed?
-      end
-
-      private
-
-      def post_content(uri, method, headers, attempt = 10)
-        content = @write_io
-        http = build_client(uri, @https_verify_mode)
-
-        raise StandardError, "request to #{uri} failed (too many redirections)" if attempt <= 0
-        req = build_request(
-          uri,
-          method,
-          headers.merge(
-            'Content-Length' => content.size.to_s
-          )
-        )
-
-        content.rewind
-        req.body_stream = content
-
-        begin
-          response = http.request(req)
-        rescue SystemCallError
-          # We may get the redirect response before pushing the file.
-          response = http.request(build_request(uri, method, headers))
-        end
-
-        case response
-        when Net::HTTPSuccess
-          response
-        when Net::HTTPRedirection
-          post_content(URI(response['Location']), method, headers, attempt - 1)
-        else
-          raise StandardError, "request to #{uri} failed with status #{response.code}"
-        end
-      end
-
-      def build_request(uri, method, headers)
-        method_class_name = "#{method[0].upcase}#{method[1..-1].downcase}"
-        req = Net::HTTP.const_get(method_class_name).new(uri)
-        headers.each do |header, value|
-          req[header] = value
-        end
-        req
-      end
-
-      def build_client(uri, https_verify_mode)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        if uri.scheme == 'https'
-          http.use_ssl = true
-          http.verify_mode = https_verify_mode if https_verify_mode
-        end
-        http
+      # Returns an IO that will write to a HTTP request's body
+      # https_verify_mode can be set to OpenSSL::SSL::VERIFY_NONE
+      # to ignore unsigned certificate - setting to nil will verify the certificate
+      def self.open(url, https_verify_mode = nil, reporter = nil)
+        uri, method, headers = CurlOptionParser.parse(url)
+        IOHTTPBuffer.new(uri, method, headers, https_verify_mode, reporter)
       end
     end
   end

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -12,7 +12,7 @@ module Cucumber
       end
 
       def respond_to_missing?(name, include_private = false)
-        @receiver.respond_to?(name, include_private)
+        @receiver.respond_to?(name, include_private) || super(name, include_private)
       end
     end
   end

data/lib/cucumber/formatter/interceptor.rb

@@ -5,6 +5,7 @@ module Cucumber
     module Interceptor
       class Pipe
         attr_reader :pipe
+
         def initialize(pipe)
           @pipe = pipe
           @buffer = StringIO.new
@@ -31,7 +32,7 @@ module Cucumber
         end
 
         def method_missing(method, *args, &blk)
-          @pipe.send(method, *args, &blk) || super
+          @pipe.respond_to?(method) ? @pipe.send(method, *args, &blk) : super
         end
 
         def respond_to_missing?(method, include_private = false)
@@ -62,10 +63,10 @@ module Cucumber
           case pipe
           when :stderr
             $stderr = new($stderr)
-            return $stderr
+            $stderr
           when :stdout
             $stdout = new($stdout)
-            return $stdout
+            $stdout
           end
         end
       end

data/lib/cucumber/formatter/io.rb

@@ -1,39 +1,77 @@
 # frozen_string_literal: true
 
 require 'cucumber/formatter/http_io'
+require 'cucumber/formatter/url_reporter'
+require 'cucumber/cli/options'
 
 module Cucumber
   module Formatter
     module Io
       module_function
 
-      def ensure_io(path_or_url_or_io)
+      def ensure_io(path_or_url_or_io, error_stream)
         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)
+        return path_or_url_or_io if io?(path_or_url_or_io)
+
+        io = if url?(path_or_url_or_io)
+               url = path_or_url_or_io
+               reporter = url.start_with?(Cucumber::Cli::Options::CUCUMBER_PUBLISH_URL) ? URLReporter.new(error_stream) : NoReporter.new
+               HTTPIO.open(url, nil, reporter)
              else
                File.open(path_or_url_or_io, Cucumber.file_mode('w'))
              end
-        at_exit do
-          unless io.closed?
-            io.flush
-            io.close
+        @io_objects_to_close ||= []
+        @io_objects_to_close.push(io)
+        io
+      end
+
+      module ClassMethods
+        def new(*args, &block)
+          instance = super
+
+          config = args[0]
+          if config.respond_to? :on_event
+            config.on_event :test_run_finished do
+              ios = instance.instance_variable_get(:@io_objects_to_close) || []
+              ios.each do |io|
+                at_exit do
+                  unless io.closed?
+                    io.flush
+                    io.close
+                  end
+                end
+              end
+            end
           end
+
+          instance
         end
-        io
+      end
+
+      def self.included(formatter_class)
+        formatter_class.extend(ClassMethods)
+      end
+
+      def io?(path_or_url_or_io)
+        path_or_url_or_io.respond_to?(:write)
+      end
+
+      def url?(path_or_url_or_io)
+        path_or_url_or_io.match(/^https?:\/\//)
       end
 
       def ensure_file(path, name)
-        raise "You *must* specify --out FILE for the #{name} formatter" unless String == path.class
+        raise "You *must* specify --out FILE for the #{name} formatter" unless path.instance_of? String
         raise "I can't write #{name} to a directory - it has to be a file" if File.directory?(path)
         raise "I can't write #{name} to a file in the non-existing directory #{File.dirname(path)}" unless File.directory?(File.dirname(path))
-        ensure_io(path)
+
+        ensure_io(path, nil)
       end
 
       def ensure_dir(path, name)
-        raise "You *must* specify --out DIR for the #{name} formatter" unless String == path.class
+        raise "You *must* specify --out DIR for the #{name} formatter" unless path.instance_of? String
         raise "I can't write #{name} reports to a file - it has to be a directory" if File.file?(path)
+
         FileUtils.mkdir_p(path) unless File.directory?(path)
         File.absolute_path path
       end

data/lib/cucumber/formatter/io_http_buffer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Formatter
+    class IOHTTPBuffer
+      attr_reader :uri, :method, :headers
+
+      def initialize(uri, method, headers = {}, https_verify_mode = nil, reporter = nil)
+        @uri = URI(uri)
+        @method = method
+        @headers = headers
+        @write_io = Tempfile.new('cucumber', encoding: 'UTF-8')
+        @https_verify_mode = https_verify_mode
+        @reporter = reporter || NoReporter.new
+      end
+
+      def close
+        @reporter.report(response.body)
+        @write_io.close
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+
+        raise StandardError, "request to #{uri} failed with status #{response.code}"
+      end
+
+      def write(data)
+        @write_io.write(data)
+      end
+
+      def flush
+        @write_io.flush
+      end
+
+      def closed?
+        @write_io.closed?
+      end
+
+      private
+
+      def response
+        @response ||= send_content(uri, method, headers)
+      end
+
+      def send_content(uri, method, headers, attempts_remaining = 10)
+        content = (method == 'GET' ? StringIO.new : @write_io)
+        http = build_client(uri)
+
+        raise StandardError, "request to #{uri} failed (too many redirections)" if attempts_remaining <= 0
+
+        request = build_request(uri, method, headers.merge('Content-Length' => content.size.to_s))
+        content.rewind
+        request.body_stream = content
+
+        begin
+          response = http.request(request)
+        rescue SystemCallError
+          # We may get the redirect response before pushing the file.
+          response = http.request(build_request(uri, method, headers))
+        end
+
+        case response
+        when Net::HTTPAccepted
+          send_content(URI(response['Location']), 'PUT', {}, attempts_remaining - 1) if response['Location']
+        when Net::HTTPRedirection
+          send_content(URI(response['Location']), method, headers, attempts_remaining - 1)
+        end
+        response
+      end
+
+      def build_request(uri, method, headers)
+        method_class_name = "#{method[0].upcase}#{method[1..].downcase}"
+        Net::HTTP.const_get(method_class_name).new(uri).tap do |request|
+          headers.each do |header, value|
+            request[header] = value
+          end
+        end
+      end
+
+      def build_client(uri)
+        Net::HTTP.new(uri.hostname, uri.port).tap do |http|
+          if uri.scheme == 'https'
+            http.use_ssl = true
+            http.verify_mode = @https_verify_mode if @https_verify_mode
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/json.rb

@@ -5,7 +5,6 @@ require 'base64'
 require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/ast_lookup'
-require 'cucumber/deprecate'
 
 module Cucumber
   module Formatter
@@ -14,15 +13,7 @@ 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)
+        @io = ensure_io(config.out_stream, config.error_stream)
         @ast_lookup = AstLookup.new(config)
         @feature_hashes = []
         @step_or_hook_hash = {}
@@ -41,21 +32,23 @@ module Cucumber
           @feature_hashes << @feature_hash
         end
         @test_case_hash = builder.test_case_hash
-        if builder.background?
-          @in_background = true
-          feature_elements << builder.background_hash
-          @element_hash = builder.background_hash
-        else
-          @in_background = false
-          feature_elements << @test_case_hash
-          @element_hash = @test_case_hash
-        end
+
+        @element_hash = nil
+        @element_background_hash = builder.background_hash
+        @in_background = builder.background?
+
         @any_step_failed = false
       end
 
       def on_test_step_started(event)
         test_step = event.test_step
         return if internal_hook?(test_step)
+
+        if @element_hash.nil?
+          @element_hash = create_element_hash(test_step)
+          feature_elements << @element_hash
+        end
+
         if test_step.hook?
           @step_or_hook_hash = {}
           hooks_of_type(test_step) << @step_or_hook_hash
@@ -75,29 +68,29 @@ module Cucumber
         test_step, result = *event.attributes
         result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         return if internal_hook?(test_step)
+
         add_match_and_result(test_step, result)
         @any_step_failed = true if result.failed?
       end
 
       def on_test_case_finished(event)
+        feature_elements << @test_case_hash if @in_background
+
         _test_case, result = *event.attributes
         result = result.with_filtered_backtrace(Cucumber::Formatter::BacktraceFilter)
         add_failed_around_hook(result) if result.failed? && !@any_step_failed
       end
 
       def on_test_run_finished(_event)
-        @io.write(JSON.generate(@feature_hashes, pretty: true))
+        @io.write(JSON.pretty_generate(@feature_hashes))
       end
 
-      def attach(src, mime_type)
+      def attach(src, mime_type, _filename)
         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)
-        elsif mime_type =~ /;base64$/
+        if mime_type =~ /;base64$/
           mime_type = mime_type[0..-8]
           data = src
         else
@@ -109,21 +102,17 @@ module Cucumber
       private
 
       def same_feature_as_previous_test_case?(test_case)
-        current_feature[:uri] == test_case.location.file
+        @feature_hash&.fetch(:uri, nil) == test_case.location.file
       end
 
       def first_step_after_background?(test_step)
-        @in_background && test_step.location.lines.max >= @test_case_hash[:line]
+        @in_background && test_step.location.file == @feature_hash[:uri] && test_step.location.lines.max >= @test_case_hash[:line]
       end
 
       def internal_hook?(test_step)
         test_step.location.file.include?('lib/cucumber/')
       end
 
-      def current_feature
-        @feature_hash ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
-      end
-
       def feature_elements
         @feature_hash[:elements] ||= []
       end
@@ -141,7 +130,7 @@ module Cucumber
         when 'AfterStep hook'
           after_step_hooks
         else
-          raise 'Unknown hook type ' + hook_step.to_s
+          raise "Unknown hook type #{hook_step}"
         end
       end
 
@@ -169,6 +158,13 @@ module Cucumber
         @step_or_hook_hash[:embeddings] ||= []
       end
 
+      def create_element_hash(test_step)
+        return @element_background_hash if @in_background && !first_step_after_background?(test_step)
+
+        @in_background = false
+        @test_case_hash
+      end
+
       def create_step_hash(test_step)
         step_source = @ast_lookup.step_source(test_step).step
         step_hash = {
@@ -176,15 +172,15 @@ module Cucumber
           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[:doc_string] = create_doc_string_hash(step_source.doc_string, test_step.multiline_arg.content) 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)
+      def create_doc_string_hash(doc_string, doc_string_content)
         content_type = doc_string.media_type || ''
         {
-          value: doc_string.content,
+          value: doc_string_content,
           content_type: content_type,
           line: doc_string.location.line
         }
@@ -260,6 +256,7 @@ module Cucumber
             line: feature.location.line
           }
           return if feature.tags.empty?
+
           @feature_hash[:tags] = create_tags_array_from_hash_array(feature.tags)
         end
 
@@ -269,7 +266,8 @@ module Cucumber
             name: background.name,
             description: value_or_empty_string(background.description),
             line: background.location.line,
-            type: 'background'
+            type: 'background',
+            steps: []
           }
         end
 
@@ -281,7 +279,8 @@ module Cucumber
             name: test_case.name,
             description: value_or_empty_string(scenario.description),
             line: test_case.location.lines.max,
-            type: 'scenario'
+            type: 'scenario',
+            steps: []
           }
           @test_case_hash[:tags] = create_tags_array_from_tags_array(test_case.tags) unless test_case.tags.empty?
         end

data/lib/cucumber/formatter/junit.rb

@@ -54,7 +54,7 @@ module Cucumber
         test_step, result = *event.attributes
         return if @failing_test_step
 
-        @failing_test_step = test_step unless result.ok?(@config.strict)
+        @failing_test_step = test_step unless result.ok?(strict: @config.strict)
       end
 
       def on_test_case_finished(event)
@@ -71,7 +71,7 @@ module Cucumber
       end
 
       def on_test_run_finished(_event)
-        @features_data.each { |_file, data| end_feature(data) }
+        @features_data.each_value { |data| end_feature(data) }
       end
 
       private
@@ -84,6 +84,7 @@ module Cucumber
         uri = test_case.location.file
         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]
@@ -106,11 +107,12 @@ module Cucumber
         write_file(feature_result_filename(feature_data[:uri]), @testsuite.target!)
       end
 
-      def create_output_string(test_case, scenario, result, row_name) # rubocop:disable Metrics/PerceivedComplexity
+      def create_output_string(test_case, scenario, result, row_name)
         scenario_source = @ast_lookup.scenario_source(test_case)
         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)
+        return output if result.ok?(strict: @config.strict)
+
         if scenario_source.type == :Scenario
           if @failing_test_step
             if @failing_test_step.hook?
@@ -125,17 +127,20 @@ module Cucumber
         else
           output += "Example row: #{row_name}\n"
         end
-        output + "\nMessage:\n"
+        "#{output}\nMessage:\n"
       end
 
       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
+        filename = @current_feature_data[:uri]
         name = scenario_designation
 
-        @current_feature_data[:builder].testcase(classname: classname, name: name, time: format('%<duration>.6f', duration: duration)) do
-          if !result.passed? && result.ok?(@config.strict)
+        testcase_attributes = get_testcase_attributes(classname, name, duration, filename)
+
+        @current_feature_data[:builder].testcase(testcase_attributes) do
+          if !result.passed? && result.ok?(strict: @config.strict)
             @current_feature_data[:builder].skipped
             @current_feature_data[:skipped] += 1
           elsif !result.passed?
@@ -157,6 +162,20 @@ module Cucumber
         @current_feature_data[:tests] += 1
       end
 
+      def get_testcase_attributes(classname, name, duration, filename)
+        { classname: classname, name: name, time: format('%<duration>.6f', duration: duration) }.tap do |attributes|
+          attributes[:file] = filename if add_fileattribute?
+        end
+      end
+
+      def add_fileattribute?
+        return false if @config.formats.nil? || @config.formats.empty?
+
+        !!@config.formats.find do |format|
+          format.first == 'junit' && format.dig(1, 'fileattribute') == 'true'
+        end
+      end
+
       def get_backtrace_object(result)
         if result.failed?
           result.exception
@@ -174,7 +193,7 @@ module Cucumber
       end
 
       def basename(feature_file)
-        File.basename(feature_file.gsub(/[\\\/]/, '-'), '.feature') # rubocop:disable Style/RegexpLiteral
+        File.basename(feature_file.gsub(/[\\\/]/, '-'), '.feature')
       end
 
       def write_file(feature_filename, data)
@@ -211,13 +230,14 @@ module Cucumber
       end
 
       def examples_table_row(row)
-        @row_name = '| ' + row.cells.map(&:value).join(' | ') + ' |'
+        @row_name = "| #{row.cells.map(&:value).join(' | ')} |"
         @name_suffix = " (outline example : #{@row_name})"
       end
     end
 
     class ResultBuilder
       attr_reader :test_case_duration
+
       def initialize(result)
         @test_case_duration = 0
         result.describe_to(self)

data/lib/cucumber/formatter/message.rb

@@ -10,12 +10,13 @@ module Cucumber
       include Io
 
       def initialize(config)
-        @io = ensure_io(config.out_stream)
+        @io = ensure_io(config.out_stream, config.error_stream)
         super(config)
       end
 
       def output_envelope(envelope)
-        envelope.write_ndjson_to(@io)
+        @io.write(envelope.to_json)
+        @io.write("\n")
       end
     end
   end