cucumber 4.0.0.rc.3 → 4.0.1

data/lib/cucumber/formatter/html.rb

@@ -0,0 +1,24 @@
+require 'cucumber/formatter/io'
+require 'cucumber/html_formatter'
+require 'cucumber/formatter/message_builder'
+
+module Cucumber
+  module Formatter
+    class HTML < MessageBuilder
+      include Io
+
+      def initialize(config)
+        @io = ensure_io(config.out_stream)
+        @html_formatter = Cucumber::HTMLFormatter::Formatter.new(@io)
+        @html_formatter.write_pre_message
+
+        super(config)
+      end
+
+      def output_envelope(envelope)
+        @html_formatter.write_message(envelope)
+        @html_formatter.write_post_message if envelope.test_run_finished
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/http_io.rb

@@ -0,0 +1,146 @@
+require 'net/http'
+require 'tempfile'
+
+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
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/interceptor.rb

@@ -9,17 +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
 
         def buffer_string
-          lock.synchronize do
+          @lock.synchronize do
             return @buffer.string.dup
           end
         end
@@ -67,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)
@@ -173,7 +182,7 @@ module Cucumber
       end
 
       def create_doc_string_hash(doc_string)
-        content_type = doc_string.content_type || ''
+        content_type = doc_string.media_type || ''
         {
           value: doc_string.content,
           content_type: content_type,

data/lib/cucumber/formatter/junit.rb

@@ -239,7 +239,7 @@ module Cucumber
         duration.tap { |dur| @test_case_duration = dur.nanoseconds / 10**9.0 }
       end
 
-      def embed(*) 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,255 @@
+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)
+        config.on_event :undefined_parameter_type, &method(:on_undefined_parameter_type)
+
+        @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 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)
+      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