honeybadger 5.2.1 → 5.3.0

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.0.2/lib/cucumber/formatter/interceptor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Formatter
+    module Interceptor
+      class Pipe
+        attr_reader :pipe
+
+        def initialize(pipe)
+          @pipe = pipe
+          @buffer = StringIO.new
+          @wrapped = true
+          @lock = Mutex.new
+        end
+
+        def write(str)
+          @lock.synchronize do
+            @buffer << str if @wrapped
+            return @pipe.write(str)
+          end
+        end
+
+        def buffer_string
+          @lock.synchronize do
+            return @buffer.string.dup
+          end
+        end
+
+        def unwrap!
+          @wrapped = false
+          @pipe
+        end
+
+        def method_missing(method, *args, &blk)
+          @pipe.respond_to?(method) ? @pipe.send(method, *args, &blk) : super
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          super || @pipe.respond_to?(method, include_private)
+        end
+
+        def self.validate_pipe(pipe)
+          raise ArgumentError, '#wrap only accepts :stderr or :stdout' unless %i[stdout stderr].include? pipe
+        end
+
+        def self.unwrap!(pipe)
+          validate_pipe pipe
+          wrapped = nil
+          case pipe
+          when :stdout
+            wrapped = $stdout
+            $stdout = wrapped.unwrap! if $stdout.respond_to?(:unwrap!)
+          when :stderr
+            wrapped = $stderr
+            $stderr = wrapped.unwrap! if $stderr.respond_to?(:unwrap!)
+          end
+          wrapped
+        end
+
+        def self.wrap(pipe)
+          validate_pipe pipe
+
+          case pipe
+          when :stderr
+            $stderr = new($stderr)
+            $stderr
+          when :stdout
+            $stdout = new($stdout)
+            $stdout
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.0.2/lib/cucumber/formatter/io.rb

@@ -0,0 +1,80 @@
+# 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, error_stream)
+        return nil if path_or_url_or_io.nil?
+        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
+        @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
+      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 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, nil)
+      end
+
+      def ensure_dir(path, name)
+        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
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/cucumber-9.0.2/lib/cucumber/formatter/json.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+require 'cucumber/formatter/backtrace_filter'
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/ast_lookup'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format json</tt>
+    class Json
+      include Io
+
+      def initialize(config)
+        @io = ensure_io(config.out_stream, config.error_stream)
+        @ast_lookup = AstLookup.new(config)
+        @feature_hashes = []
+        @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_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_started(event)
+        test_case = event.test_case
+        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
+
+        @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
+          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)
+        steps << @step_or_hook_hash
+        @step_hash = @step_or_hook_hash
+      end
+
+      def on_test_step_finished(event)
+        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.pretty_generate(@feature_hashes))
+      end
+
+      def attach(src, mime_type)
+        if mime_type == 'text/x.cucumber.log+plain'
+          test_step_output << src
+          return
+        end
+        if mime_type =~ /;base64$/
+          mime_type = mime_type[0..-8]
+          data = src
+        else
+          data = encode64(src)
+        end
+        test_step_embeddings << { mime_type: mime_type, data: data }
+      end
+
+      private
+
+      def same_feature_as_previous_test_case?(test_case)
+        current_feature[:uri] == test_case.location.file
+      end
+
+      def first_step_after_background?(test_step)
+        @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
+
+      def steps
+        @element_hash[:steps] ||= []
+      end
+
+      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
+          raise "Unknown hook type #{hook_step}"
+        end
+      end
+
+      def before_hooks
+        @element_hash[:before] ||= []
+      end
+
+      def after_hooks
+        @element_hash[:after] ||= []
+      end
+
+      def around_hooks
+        @element_hash[:around] ||= []
+      end
+
+      def after_step_hooks
+        @step_hash[:after] ||= []
+      end
+
+      def test_step_output
+        @step_or_hook_hash[:output] ||= []
+      end
+
+      def test_step_embeddings
+        @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 = {
+          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, 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, doc_string_content)
+        content_type = doc_string.media_type || ''
+        {
+          value: doc_string_content,
+          content_type: content_type,
+          line: doc_string.location.line
+        }
+      end
+
+      def create_data_table_value(data_table)
+        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)
+        @step_or_hook_hash = {}
+        around_hooks << @step_or_hook_hash
+        @step_or_hook_hash[:match] = { location: 'unknown_hook_location:1' }
+
+        @step_or_hook_hash[:result] = create_result_hash(result)
+      end
+
+      def create_match_hash(test_step, _result)
+        { location: test_step.action_location.to_s }
+      end
+
+      def create_result_hash(result)
+        result_hash = {
+          status: result.to_sym
+        }
+        result_hash[:error_message] = create_error_message(result) if result.failed? || result.pending?
+        result.duration.tap { |duration| result_hash[:duration] = duration.nanoseconds }
+        result_hash
+      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 encode64(data)
+        # strip newlines from the encoded data
+        Base64.encode64(data).delete("\n")
+      end
+
+      class Builder
+        attr_reader :feature_hash, :background_hash, :test_case_hash
+
+        def initialize(test_case, ast_lookup)
+          @background_hash = nil
+          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, uri)
+          @feature_hash = {
+            id: create_id(feature.name),
+            uri: uri,
+            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)
+        end
+
+        def background(background)
+          @background_hash = {
+            keyword: background.keyword,
+            name: background.name,
+            description: value_or_empty_string(background.description),
+            line: background.location.line,
+            type: 'background',
+            steps: []
+          }
+        end
+
+        def scenario(scenario_source, test_case)
+          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: test_case.name,
+            description: value_or_empty_string(scenario.description),
+            line: test_case.location.lines.max,
+            type: 'scenario',
+            steps: []
+          }
+          @test_case_hash[:tags] = create_tags_array_from_tags_array(test_case.tags) unless test_case.tags.empty?
+        end
+
+        private
+
+        def value_or_empty_string(value)
+          value.nil? ? '' : value
+        end
+
+        def create_id(name)
+          name.downcase.tr(' ', '-')
+        end
+
+        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
+
+        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_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_from_tags_array(tags)
+          tags_array = []
+          tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
+          tags_array
+        end
+      end
+    end
+  end
+end