cucumber 3.0.0.pre.2 → 4.0.0.rc.5

data/lib/cucumber/formatter/http_io.rb

@@ -0,0 +1,93 @@
+require 'net/http'
+
+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 = build_uri_method_headers(url)
+
+          @req = build_request(uri, method, headers)
+          @http = build_client(uri, https_verify_mode)
+
+          read_io, write_io = IO.pipe
+          @req.body_stream = read_io
+
+          class << write_io
+            attr_writer :request_thread
+
+            def start_request(http, req)
+              @req_thread = Thread.new do
+                begin
+                  res = http.request(req)
+                  raise StandardError, "request to #{req.uri} failed with status #{res.code}" if res.code.to_i >= 400
+                rescue StandardError => e
+                  @http_error = e
+                end
+              end
+            end
+
+            def close
+              super
+              begin
+                @req_thread.join
+              rescue StandardError
+                nil
+              end
+              raise @http_error unless @http_error.nil?
+            end
+          end
+          write_io.start_request(@http, @req)
+
+          write_io
+        end
+
+        def build_uri_method_headers(url)
+          uri = URI(url)
+          query_pairs = uri.query ? URI.decode_www_form(uri.query) : []
+
+          # Build headers from query parameters prefixed with http- and extract HTTP method
+          http_query_pairs = query_pairs.select { |pair| pair[0] =~ /^http-/ }
+          http_query_hash_without_prefix = Hash[http_query_pairs.map do |pair|
+                                                  [
+                                                    pair[0][5..-1].downcase, # remove http- prefix
+                                                    pair[1]
+                                                  ]
+                                                end]
+          method = http_query_hash_without_prefix.delete('method') || 'POST'
+          headers = {
+            'transfer-encoding' => 'chunked'
+          }.merge(http_query_hash_without_prefix)
+
+          # Update the query with the http-* parameters removed
+          remaining_query_pairs = query_pairs - http_query_pairs
+          new_query_hash = Hash[remaining_query_pairs]
+          uri.query = URI.encode_www_form(new_query_hash) unless new_query_hash.empty?
+          [uri, method, headers]
+        end
+
+        private
+
+        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
+end

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     class IgnoreMissingMessages < BasicObject
       def initialize(receiver)
         @receiver = receiver
       end
 
       def method_missing(message, *args)
-        @receiver.send(message, *args) if @receiver.respond_to?(message)
+        @receiver.respond_to?(message) ? @receiver.send(message, *args) : super
       end
 
       def respond_to_missing?(name, include_private = false)
         @receiver.respond_to?(name, include_private)
       end
     end
-
   end
 end
-

data/lib/cucumber/formatter/interceptor.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'thread'
 
 module Cucumber
   module Formatter
@@ -8,7 +7,7 @@ module Cucumber
         attr_reader :pipe
         def initialize(pipe)
           @pipe = pipe
-          @buffer = []
+          @buffer = StringIO.new
           @wrapped = true
         end
 
@@ -19,9 +18,9 @@ module Cucumber
           end
         end
 
-        def buffer
+        def buffer_string
           lock.synchronize do
-            return @buffer.dup
+            return @buffer.string.dup
           end
         end
 
@@ -31,17 +30,15 @@ module Cucumber
         end
 
         def method_missing(method, *args, &blk)
-          @pipe.send(method, *args, &blk)
+          @pipe.send(method, *args, &blk) || super
         end
 
-        def respond_to?(method, include_private=false)
+        def respond_to_missing?(method, include_private = false)
           super || @pipe.respond_to?(method, include_private)
         end
 
         def self.validate_pipe(pipe)
-          unless [:stdout, :stderr].include? pipe
-            raise ArgumentError, '#wrap only accepts :stderr or :stdout'
-          end
+          raise ArgumentError, '#wrap only accepts :stderr or :stdout' unless %i[stdout stderr].include? pipe
         end
 
         def self.unwrap!(pipe)
@@ -63,17 +60,18 @@ module Cucumber
 
           case pipe
           when :stderr
-            $stderr = self.new($stderr)
+            $stderr = new($stderr)
             return $stderr
           when :stdout
-            $stdout = self.new($stdout)
+            $stdout = new($stdout)
             return $stdout
           end
         end
 
         private
+
         def lock
-          @lock||=Mutex.new
+          @lock ||= Mutex.new
         end
       end
     end

data/lib/cucumber/formatter/io.rb

@@ -1,34 +1,41 @@
 # 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)
-        raise "You *must* specify --out FILE for the #{name} formatter" unless String === path
+        raise "You *must* specify --out FILE for the #{name} formatter" unless String == path.class
         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)}" if !File.directory?(File.dirname(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)
       end
 
       def ensure_dir(path, name)
-        raise "You *must* specify --out DIR for the #{name} formatter" unless String === path
+        raise "You *must* specify --out DIR for the #{name} formatter" unless String == path.class
         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)
-        path
+        File.absolute_path path
       end
     end
   end

data/lib/cucumber/formatter/json.rb

@@ -1,9 +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/hook_query_visitor'
+require 'cucumber/formatter/ast_lookup'
+require 'cucumber/deprecate'
 
 module Cucumber
   module Formatter
@@ -12,47 +14,59 @@ 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 = []
-        config.on_event :test_case_starting, &method(:on_test_case_starting)
+        @step_or_hook_hash = {}
+        config.on_event :test_case_started, &method(:on_test_case_started)
         config.on_event :test_case_finished, &method(:on_test_case_finished)
-        config.on_event :test_step_starting, &method(:on_test_step_starting)
+        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_run_finished, &method(:on_test_run_finished)
       end
 
-      def on_test_case_starting(event)
+      def on_test_case_started(event)
         test_case = event.test_case
-        builder = Builder.new(test_case)
-        unless same_feature_as_previous_test_case?(test_case.feature)
+        builder = Builder.new(test_case, @ast_lookup)
+        unless same_feature_as_previous_test_case?(test_case)
           @feature_hash = builder.feature_hash
           @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
         @any_step_failed = false
       end
 
-      def on_test_step_starting(event)
+      def on_test_step_started(event)
         test_step = event.test_step
         return if internal_hook?(test_step)
-        hook_query = HookQueryVisitor.new(test_step)
-        if hook_query.hook?
+        if test_step.hook?
           @step_or_hook_hash = {}
-          hooks_of_type(hook_query) << @step_or_hook_hash
+          hooks_of_type(test_step) << @step_or_hook_hash
           return
         end
         if first_step_after_background?(test_step)
+          @in_background = false
           feature_elements << @test_case_hash
           @element_hash = @test_case_hash
         end
-        @step_or_hook_hash = create_step_hash(test_step.source.last)
+        @step_or_hook_hash = create_step_hash(test_step)
         steps << @step_or_hook_hash
         @step_hash = @step_or_hook_hash
       end
@@ -72,44 +86,42 @@ module Cucumber
       end
 
       def on_test_run_finished(_event)
-        @io.write(MultiJson.dump(@feature_hashes, pretty: true))
+        @io.write(JSON.generate(@feature_hashes, pretty: true))
       end
 
-      def puts(message)
-        test_step_output << message
-      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') { |f| f.read }
+          content = File.open(src, 'rb', &:read)
           data = encode64(content)
+        elsif mime_type =~ /;base64$/
+          mime_type = mime_type[0..-8]
+          data = src
         else
-          if mime_type =~ /;base64$/
-            mime_type = mime_type[0..-8]
-            data = src
-          else
-            data = encode64(src)
-          end
+          data = encode64(src)
         end
         test_step_embeddings << { mime_type: mime_type, data: data }
       end
 
       private
 
-      def same_feature_as_previous_test_case?(feature)
-        current_feature[:uri] == feature.file && current_feature[:line] == feature.location.line
+      def same_feature_as_previous_test_case?(test_case)
+        current_feature[:uri] == test_case.location.file
       end
 
       def first_step_after_background?(test_step)
-        test_step.source[1].name != @element_hash[:name]
+        @in_background && test_step.location.lines.max >= @test_case_hash[:line]
       end
 
       def internal_hook?(test_step)
-        test_step.source.last.location.file.include?('lib/cucumber/')
+        test_step.location.file.include?('lib/cucumber/')
       end
 
       def current_feature
-        @feature_hash ||= {}
+        @feature_hash ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
       end
 
       def feature_elements
@@ -120,16 +132,16 @@ module Cucumber
         @element_hash[:steps] ||= []
       end
 
-      def hooks_of_type(hook_query)
-        case hook_query.type
-        when :before
-          return before_hooks
-        when :after
-          return after_hooks
-        when :after_step
-          return after_step_hooks
+      def hooks_of_type(hook_step)
+        case hook_step.text
+        when 'Before hook'
+          before_hooks
+        when 'After hook'
+          after_hooks
+        when 'AfterStep hook'
+          after_step_hooks
         else
-          fail 'Unkown hook type ' + hook_query.type.to_s
+          raise 'Unknown hook type ' + hook_step.to_s
         end
       end
 
@@ -157,20 +169,20 @@ module Cucumber
         @step_or_hook_hash[:embeddings] ||= []
       end
 
-      def create_step_hash(step_source)
+      def create_step_hash(test_step)
+        step_source = @ast_lookup.step_source(test_step).step
         step_hash = {
           keyword: step_source.keyword,
-          name: step_source.name,
-          line: step_source.location.line
+          name: test_step.text,
+          line: test_step.location.lines.min
         }
-        step_hash[:comments] = Formatter.create_comments_array(step_source.comments) unless step_source.comments.empty?
-        step_hash[:doc_string] = create_doc_string_hash(step_source.multiline_arg) if step_source.multiline_arg.doc_string?
-        step_hash[:rows] = create_data_table_value(step_source.multiline_arg) if step_source.multiline_arg.data_table?
+        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 ? doc_string.content_type : ''
+        content_type = doc_string.media_type || ''
         {
           value: doc_string.content,
           content_type: content_type,
@@ -179,14 +191,15 @@ module Cucumber
       end
 
       def create_data_table_value(data_table)
-        data_table.raw.map do |row|
-          { cells: row }
+        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)
@@ -224,113 +237,94 @@ module Cucumber
       class Builder
         attr_reader :feature_hash, :background_hash, :test_case_hash
 
-        def initialize(test_case)
+        def initialize(test_case, ast_lookup)
           @background_hash = nil
-          test_case.describe_source_to(self)
-          test_case.feature.background.describe_to(self)
+          uri = test_case.location.file
+          feature = ast_lookup.gherkin_document(uri).feature
+          feature(feature, uri)
+          background(feature.children.first.background) unless feature.children.first.background.nil?
+          scenario(ast_lookup.scenario_source(test_case), test_case)
         end
 
         def background?
           @background_hash != nil
         end
 
-        def feature(feature)
+        def feature(feature, uri)
           @feature_hash = {
-            uri: feature.file,
-            id: create_id(feature),
+            id: create_id(feature.name),
+            uri: uri,
             keyword: feature.keyword,
             name: feature.name,
-            description: feature.description,
+            description: value_or_empty_string(feature.description),
             line: feature.location.line
           }
-          unless feature.tags.empty?
-            @feature_hash[:tags] = create_tags_array(feature.tags)
-            @test_case_hash[:tags] = if @test_case_hash[:tags]
-                                       @feature_hash[:tags] + @test_case_hash[:tags]
-                                     else
-                                       @feature_hash[:tags]
-                                     end
-          end
-          @feature_hash[:comments] = Formatter.create_comments_array(feature.comments) unless feature.comments.empty?
-          @test_case_hash[:id].insert(0, @feature_hash[:id] + ';')
+          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: background.description,
+            description: value_or_empty_string(background.description),
             line: background.location.line,
             type: 'background'
           }
-          @background_hash[:comments] = Formatter.create_comments_array(background.comments) unless background.comments.empty?
         end
 
-        def scenario(scenario)
+        def scenario(scenario_source, test_case)
+          scenario = scenario_source.type == :Scenario ? scenario_source.scenario : scenario_source.scenario_outline
           @test_case_hash = {
-            id: create_id(scenario),
+            id: "#{@feature_hash[:id]};#{create_id_from_scenario_source(scenario_source)}",
             keyword: scenario.keyword,
-            name: scenario.name,
-            description: scenario.description,
-            line: scenario.location.line,
+            name: test_case.name,
+            description: value_or_empty_string(scenario.description),
+            line: test_case.location.lines.max,
             type: 'scenario'
           }
-          @test_case_hash[:tags] = create_tags_array(scenario.tags) unless scenario.tags.empty?
-          @test_case_hash[:comments] = Formatter.create_comments_array(scenario.comments) unless scenario.comments.empty?
+          @test_case_hash[:tags] = create_tags_array_from_tags_array(test_case.tags) unless test_case.tags.empty?
         end
 
-        def scenario_outline(scenario)
-          @test_case_hash = {
-            id: create_id(scenario) + ';' + @example_id,
-            keyword: scenario.keyword,
-            name: scenario.name,
-            description: scenario.description,
-            line: @row.location.line,
-            type: 'scenario'
-          }
-          tags = []
-          tags += create_tags_array(scenario.tags) unless scenario.tags.empty?
-          tags += @examples_table_tags if @examples_table_tags
-          @test_case_hash[:tags] = tags unless tags.empty?
-          comments = []
-          comments += Formatter.create_comments_array(scenario.comments) unless scenario.comments.empty?
-          comments += @examples_table_comments if @examples_table_comments
-          comments += @row_comments if @row_comments
-          @test_case_hash[:comments] =  comments unless comments.empty?
-        end
+        private
 
-        def examples_table(examples_table)
-          # the json file have traditionally used the header row as row 1,
-          # wheras cucumber-ruby-core used the first example row as row 1.
-          @example_id = create_id(examples_table) + ";#{@row.number + 1}"
+        def value_or_empty_string(value)
+          value.nil? ? '' : value
+        end
 
-          @examples_table_tags = create_tags_array(examples_table.tags) unless examples_table.tags.empty?
-          @examples_table_comments = Formatter.create_comments_array(examples_table.comments) unless examples_table.comments.empty?
+        def create_id(name)
+          name.downcase.tr(' ', '-')
         end
 
-        def examples_table_row(row)
-          @row = row
-          @row_comments = Formatter.create_comments_array(row.comments) unless row.comments.empty?
+        def create_id_from_scenario_source(scenario_source)
+          if scenario_source.type == :Scenario
+            create_id(scenario_source.scenario.name)
+          else
+            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
 
-        private
+        def calculate_row_number(scenario_source)
+          scenario_source.examples.table_body.each_with_index do |row, index|
+            return index + 2 if row == scenario_source.row
+          end
+        end
 
-        def create_id(element)
-          element.name.downcase.tr(' ', '-')
+        def create_tags_array_from_hash_array(tags)
+          tags_array = []
+          tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
+          tags_array
         end
 
-        def create_tags_array(tags)
+        def create_tags_array_from_tags_array(tags)
           tags_array = []
           tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
           tags_array
         end
       end
     end
-
-    def self.create_comments_array(comments)
-      comments_array = []
-      comments.each { |comment| comments_array << { value: comment.to_s.strip, line: comment.location.line } }
-      comments_array
-    end
   end
 end