custom_reportportal 0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3329d8710195e00a49de5a3a6e63cc3bd7347677c1f600a0c7c38fec0afe2f89
+  data.tar.gz: d9dca3456e0a35916f1851a67792247ab322eba53b63a52aa6d132ef1af552c8
+SHA512:
+  metadata.gz: 4720f6bf3456575803b3becf7e70cde3d8f7d03ab4847bf24b5022daa4a195d614a00722098eda3acb4157c1ab36a6c28153e98ef7ae4b437dc71e102e58d00d
+  data.tar.gz: 7ba9dec0fb68ca6819b6be3020282a8be77482814f5fa3af0f8981a883830b11d74dade26aeac177a8e932f0ac683d761e7e337c6a3ade6e4268cf6e585518e7

data/README.md

@@ -0,0 +1,104 @@
+# Ruby Cucumber and RSpec formatters for ReportPortal
+
+ [Download](https://rubygems.org/gems/reportportal)
+ 
+[![Join Slack chat!](https://reportportal-slack-auto.herokuapp.com/badge.svg)](https://reportportal-slack-auto.herokuapp.com)
+[![stackoverflow](https://img.shields.io/badge/reportportal-stackoverflow-orange.svg?style=flat)](http://stackoverflow.com/questions/tagged/reportportal)
+[![UserVoice](https://img.shields.io/badge/uservoice-vote%20ideas-orange.svg?style=flat)](https://rpp.uservoice.com/forums/247117-report-portal)
+[![Build with Love](https://img.shields.io/badge/build%20with-❤%EF%B8%8F%E2%80%8D-lightgrey.svg)](http://reportportal.io?style=flat)
+
+
+## Installation
+
+Use Ruby 2.3+
+
+**Rubygems**
+
+From https://rubygems.org
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+gem install reportportal
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+or
+
+Add `gem 'reportportal', git: 'https://github.com/reportportal/agent-ruby.git'` to your `Gemfile`. Run `bundle install`.
+
+## Usage (examples)
+
+* With Cucumber:
+
+```cucumber <other options> -f ReportPortal::Cucumber::Formatter```
+
+* With Cucumber and parallel_tests gem:
+
+```parallel_cucumber <some options> -o '<some other options> -f ReportPortal::Cucumber::ParallelFormatter'```
+
+* With RSpec:
+
+```rspec <other options> -f ReportPortal::RSpec::Formatter```
+
+## Configuration
+Create report_portal.yml configuration file in one of the following folders of your project: '.', './.config', './config' (see report_portal.yaml.example).
+Alternatively specify path to configuration file via rp_config environment variable.
+
+Supported settings:
+
+ - uuid - uuid of the ReportPortal user
+ - endpoint - URI of ReportPortal web service where requests should be sent
+ - launch - launch name
+ - description - custom launch description
+ - project - project name
+ - attributes - launch attributes. key value object
+ - formatter_modes - array of modes that modify formatter behavior, see [formatter modes](#formatter_modes)
+ - launch_id - id of previously created launch (to be used if formatter_modes contains attach_to_launch)
+ - file_with_launch_id - path to file with id of launch (to be used if formatter_modes contains attach_to_launch)
+ - disable_ssl_verification - set to true to disable SSL verification on connect to ReportPortal (potential security hole!). Set `disable_ssl_verification` to `true` if you see the following error:
+```
+Request to https://rp.epam.com/reportportal-ws/api/v1/pass-team/launch//finish produced an exception: RestClient::SSLCertificateNotVerified: SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed
+```
+ - is_debug - set to true to mark the launch as 'DEBUG' (it will appear in Debug tab in Report Portal)
+ - use_standard_logger - set to true to enable logging via standard Ruby Logger class to ReportPortal. Note that log messages are transformed to strings before sending.
+
+Each of these settings can be overridden by an environment variable with the same name and 'rp_' prefix (e.g. 'rp_uuid' for 'uuid'). Environment variable can be upper cased (e.g. 'RP_UUID').
+Environment variables take precedence over YAML configuration.
+Environment variable values are parsed as YAML values.
+
+## WebMock configuration
+If you use WebMock for stubbing and setting expectations on HTTP requests in Ruby,
+add this to your configuration file (for RSpec it would be `rails_helper.rb` or `spec_helper.rb`)
+
+```ruby
+WebMock.disable_net_connect!(:net_http_connect_on_start => true, :allow_localhost => true, :allow => [/rp\.epam\.com/]) # Don't break Net::HTTP
+```
+
+<a name="formatter_modes"></a>
+## Formatter modes
+
+The following modes are supported:
+
+| Name | Purpose |
+| --- | --- |
+| attach_to_launch | Do not create a new launch but add executing features/scenarios to an existing launch. Use launch_id or file_with_launch_id settings to configure that. If they are not present client will check rp_launch_id.tmp in `Dir.tmpdir`)
+| use_same_thread_for_reporting | Send reporting commands in the same main thread used for running tests. This mode is useful for debugging this Report Portal client. It changes default behavior to send commands in the separate thread. Default behavior is there not to slow test execution. |
+| skip_reporting_hierarchy | Do not create items for folders and feature files |
+| use_persistent_connection | Use persistent connection to connect to the server |
+
+## Logging
+Experimental support for three common logging frameworks was added:
+
+- Logger (part of standard Ruby library)
+- [Logging](http://rubygems.org/gems/logging)
+- [Log4r](https://rubygems.org/gems/log4r)
+
+To use Logger, set use_standard_logger parameter to true (see Configuration chapter). For the other two corresponding appenders/outputters are available under reportportal/logging.
+
+## Parallel formatter
+
+ReportPortal::Cucumber::ParallelFormatter can be used for tests started via parallel_tests gem.
+
+Note: Launch id is shared between independent processes (as is the case with parallel_tests gem) via a file in `Dir.tmpdir`.
+
+## Links
+
+ - [ReportPortal](https://github.com/reportportal/)

data/lib/report_portal/cucumber/formatter.rb

@@ -0,0 +1,72 @@
+require_relative 'report'
+
+module ReportPortal
+  module Cucumber
+    class Formatter
+      # @api private
+      def initialize(config)
+        ENV['REPORT_PORTAL_USED'] = 'true'
+
+        setup_message_processing
+
+        @io = config.out_stream
+
+        %i[test_case_started test_case_finished test_step_started test_step_finished test_run_finished].each do |event_name|
+          config.on_event event_name do |event|
+            process_message(event_name, event)
+          end
+        end
+        config.on_event(:test_run_finished) { finish_message_processing }
+      end
+
+      def puts(message)
+        process_message(:puts, message)
+        @io.puts(message)
+        @io.flush
+      end
+
+      def embed(*args)
+        process_message(:embed, *args)
+      end
+
+      private
+
+      def report
+        @report ||= ReportPortal::Cucumber::Report.new
+      end
+
+      def setup_message_processing
+        return if use_same_thread_for_reporting?
+
+        @queue = Queue.new
+        @thread = Thread.new do
+          loop do
+            method_arr = @queue.pop
+            report.public_send(*method_arr)
+          end
+        end
+        @thread.abort_on_exception = true
+      end
+
+      def finish_message_processing
+        return if use_same_thread_for_reporting?
+
+        sleep 0.03 while !@queue.empty? || @queue.num_waiting.zero? # TODO: how to interrupt launch if the user aborted execution
+        @thread.kill
+      end
+
+      def process_message(report_method_name, *method_args)
+        args = [report_method_name, *method_args, ReportPortal.now]
+        if use_same_thread_for_reporting?
+          report.public_send(*args)
+        else
+          @queue.push(args)
+        end
+      end
+
+      def use_same_thread_for_reporting?
+        ReportPortal::Settings.instance.formatter_modes.include?('use_same_thread_for_reporting')
+      end
+    end
+  end
+end

data/lib/report_portal/cucumber/parallel_formatter.rb

@@ -0,0 +1,14 @@
+require_relative 'formatter'
+require_relative 'parallel_report'
+
+module ReportPortal
+  module Cucumber
+    class ParallelFormatter < Formatter
+      private
+
+      def report
+        @report ||= ReportPortal::Cucumber::ParallelReport.new
+      end
+    end
+  end
+end

data/lib/report_portal/cucumber/parallel_report.rb

@@ -0,0 +1,54 @@
+require 'parallel_tests'
+
+require_relative 'report'
+
+module ReportPortal
+  module Cucumber
+    class ParallelReport < Report
+      FILE_WITH_LAUNCH_ID = Pathname(Dir.tmpdir) + "parallel_launch_id_for_#{Process.ppid}.lck"
+
+      def parallel?
+        true
+      end
+
+      def initialize
+        @root_node = Tree::TreeNode.new('')
+        @parent_item_node = @root_node
+        @last_used_time ||= 0
+
+        if ParallelTests.first_process?
+          File.open(FILE_WITH_LAUNCH_ID, 'w') do |f|
+            f.flock(File::LOCK_EX)
+            start_launch
+            f.write(ReportPortal.launch_id)
+            f.flush
+            f.flock(File::LOCK_UN)
+          end
+        else
+          File.open(FILE_WITH_LAUNCH_ID, 'r') do |f|
+            f.flock(File::LOCK_SH)
+            ReportPortal.launch_id = f.read
+            f.flock(File::LOCK_UN)
+          end
+        end
+      end
+
+      def test_run_finished(_event, desired_time = ReportPortal.now)
+        end_feature(desired_time) unless @parent_item_node.is_root?
+
+        if ParallelTests.first_process?
+          ParallelTests.wait_for_other_processes_to_finish
+
+          File.delete(FILE_WITH_LAUNCH_ID)
+
+          unless attach_to_launch?
+            $stdout.puts "Finishing launch #{ReportPortal.launch_id}"
+            ReportPortal.close_child_items(nil)
+            time_to_send = time_to_send(desired_time)
+            ReportPortal.finish_launch(time_to_send)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/report_portal/cucumber/report.rb

@@ -0,0 +1,220 @@
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/hook_query_visitor'
+require 'tree'
+require 'securerandom'
+
+require_relative '../../reportportal'
+require_relative '../logging/logger'
+
+module ReportPortal
+  module Cucumber
+    # @api private
+    class Report
+      def parallel?
+        false
+      end
+
+      def attach_to_launch?
+        ReportPortal::Settings.instance.formatter_modes.include?('attach_to_launch')
+      end
+
+      def initialize
+        @last_used_time = 0
+        @root_node = Tree::TreeNode.new('')
+        @parent_item_node = @root_node
+        start_launch
+      end
+
+      def start_launch(desired_time = ReportPortal.now)
+        if attach_to_launch?
+          ReportPortal.launch_id =
+            if ReportPortal::Settings.instance.launch_id
+              ReportPortal::Settings.instance.launch_id
+            else
+              file_path = ReportPortal::Settings.instance.file_with_launch_id || (Pathname(Dir.tmpdir) + 'rp_launch_id.tmp')
+              File.read(file_path)
+            end
+          $stdout.puts "Attaching to launch #{ReportPortal.launch_id}"
+        else
+          description = ReportPortal::Settings.instance.description
+          description ||= ARGV.map { |arg| arg.gsub(/rp_uuid=.+/, 'rp_uuid=[FILTERED]') }.join(' ')
+          ReportPortal.start_launch(description, time_to_send(desired_time))
+        end
+      end
+
+      # TODO: time should be a required argument
+      def test_case_started(event, desired_time = ReportPortal.now)
+        test_case = event.test_case
+        feature = test_case.feature
+        if report_hierarchy? && !same_feature_as_previous_test_case?(feature)
+          end_feature(desired_time) unless @parent_item_node.is_root?
+          start_feature_with_parentage(feature, desired_time)
+        end
+
+        name = "#{test_case.keyword}: #{test_case.name}"
+        description = test_case.location.to_s
+        tags = test_case.tags.map(&:name)
+        type = :STEP
+
+        ReportPortal.current_scenario = ReportPortal::TestItem.new(name: name, type: type, id: nil, start_time: time_to_send(desired_time), description: description, closed: false, tags: tags)
+        scenario_node = Tree::TreeNode.new(SecureRandom.hex, ReportPortal.current_scenario)
+        @parent_item_node << scenario_node
+        ReportPortal.current_scenario.id = ReportPortal.start_item(scenario_node)
+      end
+
+      def test_case_finished(event, desired_time = ReportPortal.now)
+        result = event.result
+        status = result.to_sym
+        issue = nil
+        if %i[undefined pending].include?(status)
+          status = :failed
+          issue = result.message
+        end
+        ReportPortal.finish_item(ReportPortal.current_scenario, status, time_to_send(desired_time), issue)
+        ReportPortal.current_scenario = nil
+      end
+
+      def test_step_started(event, desired_time = ReportPortal.now)
+        test_step = event.test_step
+        if step?(test_step) # `after_test_step` is also invoked for hooks
+          step_source = test_step.source.last
+          message = "-- #{step_source.keyword}#{step_source.text} --"
+          if step_source.multiline_arg.doc_string?
+            message << %(\n"""\n#{step_source.multiline_arg.content}\n""")
+          elsif step_source.multiline_arg.data_table?
+            message << step_source.multiline_arg.raw.reduce("\n") { |acc, row| acc << "| #{row.join(' | ')} |\n" }
+          end
+          ReportPortal.send_log(:trace, message, time_to_send(desired_time))
+        end
+      end
+
+      def test_step_finished(event, desired_time = ReportPortal.now)
+        test_step = event.test_step
+        result = event.result
+        status = result.to_sym
+
+        if %i[failed pending undefined].include?(status)
+          exception_info = if %i[failed pending].include?(status)
+                             ex = result.exception
+                             format("%s: %s\n  %s", ex.class.name, ex.message, ex.backtrace.join("\n  "))
+                           else
+                             format("Undefined step: %s:\n%s", test_step.text, test_step.source.last.backtrace_line)
+                           end
+          ReportPortal.send_log(:error, exception_info, time_to_send(desired_time))
+        end
+
+        if status != :passed
+          log_level = status == :skipped ? :warn : :error
+          step_type = if step?(test_step)
+                        'Step'
+                      else
+                        hook_class_name = test_step.source.last.class.name.split('::').last
+                        location = test_step.location
+                        "#{hook_class_name} at `#{location}`"
+                      end
+          ReportPortal.send_log(log_level, "#{step_type} #{status}", time_to_send(desired_time))
+        end
+      end
+
+      def test_run_finished(_event, desired_time = ReportPortal.now)
+        end_feature(desired_time) unless @parent_item_node.is_root?
+
+        unless attach_to_launch?
+          close_all_children_of(@root_node) # Folder items are closed here as they can't be closed after finishing a feature
+          time_to_send = time_to_send(desired_time)
+          ReportPortal.finish_launch(time_to_send)
+        end
+      end
+
+      def puts(message, desired_time = ReportPortal.now)
+        ReportPortal.send_log(:info, message, time_to_send(desired_time))
+      end
+
+      def embed(path_or_src, mime_type, label, desired_time = ReportPortal.now)
+        ReportPortal.send_file(:info, path_or_src, label, time_to_send(desired_time), mime_type)
+      end
+
+      private
+
+      # Report Portal sorts logs by time. However, several logs might have the same time.
+      #   So to get Report Portal sort them properly the time should be different in all logs related to the same item.
+      #   And thus it should be stored.
+      # Only the last time needs to be stored as:
+      #   * only one test framework process/thread may send data for a single Report Portal item
+      #   * that process/thread can't start the next test until it's done with the previous one
+      def time_to_send(desired_time)
+        time_to_send = desired_time
+        if time_to_send <= @last_used_time
+          time_to_send = @last_used_time + 1
+        end
+        @last_used_time = time_to_send
+      end
+
+      def same_feature_as_previous_test_case?(feature)
+        @parent_item_node.name == feature.location.file.split(File::SEPARATOR).last
+      end
+
+      def start_feature_with_parentage(feature, desired_time)
+        parent_node = @root_node
+        child_node = nil
+        path_components = feature.location.file.split(File::SEPARATOR)
+        path_components.each_with_index do |path_component, index|
+          child_node = parent_node[path_component]
+          unless child_node # if child node was not created yet
+            if index < path_components.size - 1
+              name = "Folder: #{path_component}"
+              description = nil
+              tags = []
+              type = :SUITE
+            else
+              name = "#{feature.keyword}: #{feature.name}"
+              description = feature.file # TODO: consider adding feature description and comments
+              tags = feature.tags.map(&:name)
+              type = :TEST
+            end
+            # TODO: multithreading # Parallel formatter always executes scenarios inside the same feature in the same process
+            if parallel? &&
+               index < path_components.size - 1 && # is folder?
+               (id_of_created_item = ReportPortal.item_id_of(name, parent_node)) # get id for folder from report portal
+              # get child id from other process
+              item = ReportPortal::TestItem.new(name: name, type: type, id: id_of_created_item, start_time: time_to_send(desired_time), description: description, closed: false, tags: tags)
+              child_node = Tree::TreeNode.new(path_component, item)
+              parent_node << child_node
+            else
+              item = ReportPortal::TestItem.new(name: name, type: type, id: nil, start_time: time_to_send(desired_time), description: description, closed: false, tags: tags)
+              child_node = Tree::TreeNode.new(path_component, item)
+              parent_node << child_node
+              item.id = ReportPortal.start_item(child_node) # TODO: multithreading
+            end
+          end
+          parent_node = child_node
+        end
+        @parent_item_node = child_node
+      end
+
+      def end_feature(desired_time)
+        ReportPortal.finish_item(@parent_item_node.content, nil, time_to_send(desired_time))
+        # Folder items can't be finished here because when the folder started we didn't track
+        #   which features the folder contains.
+        # It's not easy to do it using Cucumber currently:
+        #   https://github.com/cucumber/cucumber-ruby/issues/887
+      end
+
+      def close_all_children_of(root_node)
+        root_node.postordered_each do |node|
+          if !node.is_root? && !node.content.closed
+            ReportPortal.finish_item(node.content)
+          end
+        end
+      end
+
+      def step?(test_step)
+        !::Cucumber::Formatter::HookQueryVisitor.new(test_step).hook?
+      end
+
+      def report_hierarchy?
+        !ReportPortal::Settings.instance.formatter_modes.include?('skip_reporting_hierarchy')
+      end
+    end
+  end
+end

data/lib/report_portal/event_bus.rb

@@ -0,0 +1,30 @@
+require_relative 'events/prepare_start_item_request'
+
+module ReportPortal
+  # @api private
+  class EventBus
+    attr_reader :event_types
+
+    def initialize
+      @event_types = {
+        prepare_start_item_request: Events::PrepareStartItemRequest
+      }
+      @handlers = {}
+    end
+
+    def on(event_name, &proc)
+      handlers_for(event_name) << proc
+    end
+
+    def broadcast(event_name, **attributes)
+      event = event_types.fetch(event_name).new(**attributes)
+      handlers_for(event_name).each { |handler| handler.call(event) }
+    end
+
+    private
+
+    def handlers_for(event_name)
+      @handlers[event_name] ||= []
+    end
+  end
+end

data/lib/report_portal/events/prepare_start_item_request.rb

@@ -0,0 +1,13 @@
+module ReportPortal
+  module Events
+    # An event executed before sending a StartTestItem request.
+    class PrepareStartItemRequest
+      # A hash that contains keys like item's `start_time`, `name`, `description`.
+      attr_reader :request_data
+
+      def initialize(request_data:)
+        @request_data = request_data
+      end
+    end
+  end
+end

data/lib/report_portal/http_client.rb

@@ -0,0 +1,64 @@
+require 'http'
+
+module ReportPortal
+  # @api private
+  class HttpClient
+    def initialize
+      create_client
+    end
+
+    def send_request(verb, path, options = {})
+      path.prepend("/api/v1/#{Settings.instance.project}/")
+      path.prepend(origin) unless use_persistent?
+      3.times do
+        begin
+          response = @http.request(verb, path, options)
+        rescue StandardError => e
+          puts "Request #{request_info(verb, path)} produced an exception:"
+          puts e
+          recreate_client
+        else
+          return response.parse(:json) if response.status.success?
+
+          message = "Request #{request_info(verb, path)} returned code #{response.code}."
+          message << " Response:\n#{response}" unless response.to_s.empty?
+          puts message
+        end
+      end
+    end
+
+    private
+
+    def create_client
+      @http = HTTP.auth("Bearer #{Settings.instance.uuid}")
+      @http = @http.persistent(origin) if use_persistent?
+      add_insecure_ssl_options if Settings.instance.disable_ssl_verification
+    end
+
+    def add_insecure_ssl_options
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      @http.default_options = { ssl_context: ssl_context }
+    end
+
+    # Response should be consumed before sending next request via the same persistent connection.
+    # If an exception occurred, there may be no response so a connection has to be recreated.
+    def recreate_client
+      @http.close
+      create_client
+    end
+
+    def request_info(verb, path)
+      uri = URI.join(origin, path)
+      "#{verb.upcase} `#{uri}`"
+    end
+
+    def origin
+      Addressable::URI.parse(Settings.instance.endpoint).origin
+    end
+
+    def use_persistent?
+      ReportPortal::Settings.instance.formatter_modes.include?('use_persistent_connection')
+    end
+  end
+end

data/lib/report_portal/logging/log4r_outputter.rb

@@ -0,0 +1,16 @@
+require 'log4r/outputter/outputter'
+
+require_relative '../../reportportal'
+
+module ReportPortal
+  # Custom ReportPortal outputter for 'log4r' gem
+  class Log4rOutputter < Log4r::Outputter
+    def canonical_log(logevent)
+      synch { write(Log4r::LNAMES[logevent.level], format(logevent)) }
+    end
+
+    def write(level, data)
+      ReportPortal.send_log(level, data, ReportPortal.now)
+    end
+  end
+end

data/lib/report_portal/logging/logger.rb

@@ -0,0 +1,36 @@
+require 'logger'
+
+module ReportPortal
+  class << self
+    # Monkey-patch for built-in Logger class
+    def patch_logger
+      Logger.class_eval do
+        alias_method :orig_add, :add
+        alias_method :orig_write, :<<
+        def add(severity, message = nil, progname = nil, &block)
+          ret = orig_add(severity, message, progname, &block)
+
+          unless severity < @level
+            progname ||= @progname
+            if message.nil?
+              if block_given?
+                message = yield
+              else
+                message = progname
+                progname = @progname
+              end
+            end
+            ReportPortal.send_log(format_severity(severity), format_message(format_severity(severity), Time.now, progname, message.to_s), ReportPortal.now)
+          end
+          ret
+        end
+
+        def <<(msg)
+          ret = orig_write(msg)
+          ReportPortal.send_log(ReportPortal::LOG_LEVELS[:unknown], msg.to_s, ReportPortal.now)
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/report_portal/logging/logging_appender.rb

@@ -0,0 +1,18 @@
+require 'logging'
+
+require_relative '../../reportportal'
+
+module ReportPortal
+  # Custom ReportPortal appender for 'logging' gem
+  class LoggingAppender < ::Logging::Appender
+    def write(event)
+      (str, lvl) = if event.instance_of?(::Logging::LogEvent)
+                     [layout.format(event), event.level]
+                   else
+                     [event.to_s, ReportPortal::LOG_LEVELS[:unknown]]
+                   end
+
+      ReportPortal.send_log(lvl, str, ReportPortal.now)
+    end
+  end
+end

data/lib/report_portal/models/item_search_options.rb

@@ -0,0 +1,26 @@
+module ReportPortal
+  # Options of a request to search items
+  class ItemSearchOptions
+    MAPPING = {
+      launch_id: 'filter.eq.launch',
+      name: 'filter.eq.name',
+      description: 'filter.eq.description',
+      parameter_key: 'filter.eq.parameters$key',
+      parameter_value: 'filter.eq.parameters$value',
+      page_size: 'page.size',
+      page_number: 'page.page'
+    }.freeze
+
+    attr_reader :query_params
+
+    def initialize(params = {})
+      @query_params = params.map { |mapping_key, v| [param_name(mapping_key), v] }.to_h
+    end
+
+    private
+
+    def param_name(mapping_key)
+      MAPPING.fetch(mapping_key) { raise KeyError, "key not found: '#{mapping_key.inspect}'. It should be one of: #{MAPPING.keys}" }
+    end
+  end
+end

data/lib/report_portal/models/test_item.rb

@@ -0,0 +1,22 @@
+module ReportPortal
+  # Represents a test item
+  class TestItem
+    attr_reader :launch_id, :unique_id, :name, :description, :type, :parameters, :tags, :status, :start_time
+    attr_accessor :id, :closed
+
+    def initialize(options = {})
+      options = options.map { |k, v| [k.to_sym, v] }.to_h
+      @launch_id = options[:launch_id]
+      @unique_id = options[:unique_id]
+      @name = options[:name]
+      @description = options[:description]
+      @type = options[:type]
+      @parameters = options[:parameters]
+      @tags = options[:tags]
+      @status = options[:status]
+      @start_time = options[:start_time]
+      @id = options[:id]
+      @closed = options[:closed]
+    end
+  end
+end

data/lib/report_portal/rspec/formatter.rb

@@ -0,0 +1,112 @@
+require 'securerandom'
+require 'tree'
+require 'rspec/core'
+
+require_relative '../../reportportal'
+
+# TODO: Screenshots
+# TODO: Logs
+module ReportPortal
+  module RSpec
+    class Formatter
+      MAX_DESCRIPTION_LENGTH = 255
+      MIN_DESCRIPTION_LENGTH = 3
+
+      ::RSpec::Core::Formatters.register self, :start, :example_group_started, :example_group_finished,
+                                         :example_started, :example_passed, :example_failed,
+                                         :example_pending, :message, :stop
+
+      def initialize(_output)
+        ENV['REPORT_PORTAL_USED'] = 'true'
+      end
+
+      def start(_start_notification)
+        cmd_args = ARGV.map { |arg| arg.include?('rp_uuid=') ? 'rp_uuid=[FILTERED]' : arg }.join(' ')
+        ReportPortal.start_launch(cmd_args)
+        @root_node = Tree::TreeNode.new(SecureRandom.hex)
+        @current_group_node = @root_node
+      end
+
+      def example_group_started(group_notification)
+        description = group_notification.group.description
+        if description.size < MIN_DESCRIPTION_LENGTH
+          p "Group description should be at least #{MIN_DESCRIPTION_LENGTH} characters ('group_notification': #{group_notification.inspect})"
+          return
+        end
+        item = ReportPortal::TestItem.new(name: description[0..MAX_DESCRIPTION_LENGTH - 1],
+                                          type: :TEST,
+                                          id: nil,
+                                          start_time: ReportPortal.now,
+                                          description: '',
+                                          closed: false,
+                                          tags: [])
+        group_node = Tree::TreeNode.new(SecureRandom.hex, item)
+        if group_node.nil?
+          p "Group node is nil for item #{item.inspect}"
+        else
+          @current_group_node << group_node unless @current_group_node.nil? # make @current_group_node parent of group_node
+          @current_group_node = group_node
+          group_node.content.id = ReportPortal.start_item(group_node)
+        end
+      end
+
+      def example_group_finished(_group_notification)
+        unless @current_group_node.nil?
+          ReportPortal.finish_item(@current_group_node.content)
+          @current_group_node = @current_group_node.parent
+        end
+      end
+
+      def example_started(notification)
+        description = notification.example.description
+        if description.size < MIN_DESCRIPTION_LENGTH
+          p "Example description should be at least #{MIN_DESCRIPTION_LENGTH} characters ('notification': #{notification.inspect})"
+          return
+        end
+        ReportPortal.current_scenario = ReportPortal::TestItem.new(name: description[0..MAX_DESCRIPTION_LENGTH - 1],
+                                                                   type: :STEP,
+                                                                   id: nil,
+                                                                   start_time: ReportPortal.now,
+                                                                   description: '',
+                                                                   closed: false,
+                                                                   tags: [])
+        example_node = Tree::TreeNode.new(SecureRandom.hex, ReportPortal.current_scenario)
+        if example_node.nil?
+          p "Example node is nil for scenario #{ReportPortal.current_scenario.inspect}"
+        else
+          @current_group_node << example_node
+          example_node.content.id = ReportPortal.start_item(example_node)
+        end
+      end
+
+      def example_passed(_notification)
+        ReportPortal.finish_item(ReportPortal.current_scenario, :passed) unless ReportPortal.current_scenario.nil?
+        ReportPortal.current_scenario = nil
+      end
+
+      def example_failed(notification)
+        exception = notification.exception
+        ReportPortal.send_log(:failed, %(#{exception.class}: #{exception.message}\n\nStacktrace: #{notification.formatted_backtrace.join("\n")}), ReportPortal.now)
+        ReportPortal.finish_item(ReportPortal.current_scenario, :failed) unless ReportPortal.current_scenario.nil?
+        ReportPortal.current_scenario = nil
+      end
+
+      def example_pending(_notification)
+        ReportPortal.finish_item(ReportPortal.current_scenario, :skipped) unless ReportPortal.current_scenario.nil?
+        ReportPortal.current_scenario = nil
+      end
+
+      def message(notification)
+        if notification.message.respond_to?(:read)
+          ReportPortal.send_file(:passed, notification.message)
+        else
+          ReportPortal.send_log(:passed, notification.message, ReportPortal.now)
+        end
+      end
+
+      def stop(_notification)
+        ReportPortal.finish_launch
+      end
+    end
+  end
+end

data/lib/report_portal/settings.rb

@@ -0,0 +1,66 @@
+require 'yaml'
+require 'singleton'
+
+module ReportPortal
+  class Settings
+    include Singleton
+
+    def initialize
+      filename = ENV.fetch('rp_config') do
+        glob = Dir.glob('{,.config/,config/}report{,-,_}portal{.yml,.yaml}')
+        p "Multiple configuration files found for ReportPortal. Using the first one: #{glob.first}" if glob.size > 1
+        glob.first
+      end
+
+      @properties = filename.nil? ? {} : YAML.load_file(filename)
+      keys = {
+        'uuid' => true,
+        'endpoint' => true,
+        'project' => true,
+        'launch' => true,
+        'tags' => false,
+        'description' => false,
+        'attributes' => false,
+        'is_debug' => false,
+        'disable_ssl_verification' => false,
+        # for parallel execution only
+        'use_standard_logger' => false,
+        'launch_id' => false,
+        'file_with_launch_id' => false,
+        'logLaunchLink' => false
+      }
+
+      keys.each do |key, is_required|
+        define_singleton_method(key.to_sym) { setting(key) }
+        next unless is_required && public_send(key).nil?
+
+        env_variable_name = env_variable_name(key)
+        raise "ReportPortal: Define environment variable '#{env_variable_name.upcase}', '#{env_variable_name}' "\
+          "or key #{key} in the configuration YAML file"
+      end
+    end
+
+    def launch_mode
+      is_debug ? 'DEBUG' : 'DEFAULT'
+    end
+
+    def formatter_modes
+      setting('formatter_modes') || []
+    end
+
+    private
+
+    def setting(key)
+      env_variable_name = env_variable_name(key)
+      return YAML.safe_load(ENV[env_variable_name.upcase]) if ENV.key?(env_variable_name.upcase)
+
+      return YAML.safe_load(ENV[env_variable_name]) if ENV.key?(env_variable_name)
+
+      @properties[key]
+    end
+
+    def env_variable_name(key)
+      'rp_' + key
+    end
+  end
+end

data/lib/report_portal/tasks.rb

@@ -0,0 +1,27 @@
+require 'rake'
+require 'pathname'
+require 'tempfile'
+require_relative '../reportportal'
+
+namespace :reportportal do
+  desc 'Start launch in Report Portal and print its id to $stdout (for use with attach_to_launch formatter mode)'
+  task :start_launch do
+    description = ENV['description'] || ReportPortal::Settings.instance.description
+    file_to_write_launch_id = ENV['file_for_launch_id'] || ReportPortal::Settings.instance.file_with_launch_id
+    file_to_write_launch_id ||= Pathname(Dir.tmpdir) + 'rp_launch_id.tmp'
+    launch_id = ReportPortal.start_launch(description)
+    File.write(file_to_write_launch_id, launch_id)
+    puts launch_id
+  end
+
+  desc 'Finish launch in Report Portal (for use with attach_to_launch formatter mode)'
+  task :finish_launch do
+    launch_id = ENV['launch_id'] || ReportPortal::Settings.instance.launch_id
+    file_with_launch_id = ENV['file_with_launch_id'] || ReportPortal::Settings.instance.file_with_launch_id
+    puts "Launch id isn't provided. Provide it either via RP_LAUNCH_ID or RP_FILE_WITH_LAUNCH_ID environment variables" if !launch_id && !file_with_launch_id
+    puts 'Both RP_LAUNCH_ID and RP_FILE_WITH_LAUNCH_ID are provided via environment variables' if launch_id && file_with_launch_id
+    ReportPortal.launch_id = launch_id || File.read(file_with_launch_id)
+    ReportPortal.close_child_items(nil)
+    ReportPortal.finish_launch
+  end
+end

data/lib/report_portal/version.rb

@@ -0,0 +1,3 @@
+module ReportPortal
+  VERSION = '0.7'.freeze
+end

data/lib/reportportal.rb

@@ -0,0 +1,217 @@
+require 'base64'
+require 'cgi'
+require 'http'
+require 'json'
+require 'mime/types'
+require 'pathname'
+require 'tempfile'
+require 'uri'
+
+require_relative 'report_portal/event_bus'
+require_relative 'report_portal/models/item_search_options'
+require_relative 'report_portal/models/test_item'
+require_relative 'report_portal/settings'
+require_relative 'report_portal/http_client'
+
+module ReportPortal
+  LOG_LEVELS = { error: 'ERROR', warn: 'WARN', info: 'INFO', debug: 'DEBUG', trace: 'TRACE', fatal: 'FATAL', unknown: 'UNKNOWN' }.freeze
+
+  class << self
+    attr_accessor :launch_id, :current_scenario
+
+    def now
+      (current_time.to_f * 1000).to_i
+    end
+
+    def status_to_level(status)
+      case status
+      when :passed
+        LOG_LEVELS[:info]
+      when :failed, :undefined, :pending, :error
+        LOG_LEVELS[:error]
+      when :skipped
+        LOG_LEVELS[:warn]
+      else
+        LOG_LEVELS.fetch(status, LOG_LEVELS[:info])
+      end
+    end
+
+    def start_launch(description, start_time = now)
+      required_data = { name: Settings.instance.launch, start_time: start_time, description:
+          description, mode: Settings.instance.launch_mode }
+      data = prepare_options(required_data, Settings.instance)
+      @launch_id = send_request(:post, 'launch', json: data)['id']
+    end
+
+    def finish_launch(end_time = now)
+      data = { end_time: end_time }
+      @finished_launch = send_request(:put, "launch/#{@launch_id}/finish", json: data)
+      @launch_link = @finished_launch['link']
+      if Settings.instance.logLaunchLink
+      	print "Launch ID ReportPortal: #{@launch_link}"
+      end
+    end
+
+    def start_item(item_node)
+      path = 'item'
+      path += "/#{item_node.parent.content.id}" unless item_node.parent&.is_root?
+      item = item_node.content
+      data = { start_time: item.start_time, name: item.name[0, 255], type: item.type.to_s, launch_id: @launch_id, description: item.description }
+      data[:tags] = item.tags unless item.tags.empty?
+      event_bus.broadcast(:prepare_start_item_request, request_data: data)
+      send_request(:post, path, json: data)['id']
+    end
+
+    def finish_item(item, status = nil, end_time = nil, force_issue = nil)
+      unless item.nil? || item.id.nil? || item.closed
+        data = { end_time: end_time.nil? ? now : end_time }
+        data[:status] = status unless status.nil?
+        if force_issue && status != :passed # TODO: check for :passed status is probably not needed
+          data[:issue] = { issue_type: 'AUTOMATION_BUG', comment: force_issue.to_s }
+        elsif status == :skipped
+          data[:issue] = { issue_type: 'NOT_ISSUE' }
+        end
+        send_request(:put, "item/#{item.id}", json: data)
+        item.closed = true
+      end
+    end
+
+    # TODO: implement force finish
+
+    def send_log(status, message, time)
+      unless @current_scenario.nil? || @current_scenario.closed # it can be nil if scenario outline in expand mode is executed
+        data = { item_id: @current_scenario.id, time: time, level: status_to_level(status), message: message.to_s }
+        send_request(:post, 'log', json: data)
+      end
+    end
+
+    def send_file(status, path_or_src, label = nil, time = now, mime_type = 'image/png')
+      str_without_nils = path_or_src.to_s.gsub("\0", '') # file? does not allow NULLs inside the string
+      if File.file?(str_without_nils)
+        send_file_from_path(status, path_or_src, label, time, mime_type)
+      else
+        if mime_type =~ /;base64$/
+          mime_type = mime_type[0..-8]
+          path_or_src = Base64.decode64(path_or_src)
+        end
+        extension = ".#{MIME::Types[mime_type].first.extensions.first}"
+        Tempfile.open(['report_portal', extension]) do |tempfile|
+          tempfile.binmode
+          tempfile.write(path_or_src)
+          tempfile.rewind
+          send_file_from_path(status, tempfile.path, label, time, mime_type)
+        end
+      end
+    end
+
+    # @option options [Hash] options, see ReportPortal::ItemSearchOptions
+    def get_items(filter_options = {})
+      page_size = 100
+      max_pages = 100
+      all_items = []
+      1.step.each do |page_number|
+        raise 'Too many pages with the results were returned' if page_number > max_pages
+
+        options = ItemSearchOptions.new({ page_size: page_size, page_number: page_number }.merge(filter_options))
+        page_items = send_request(:get, 'item', params: options.query_params)['content'].map do |item_params|
+          TestItem.new(item_params)
+        end
+        all_items += page_items
+        break if page_items.size < page_size
+      end
+      all_items
+    end
+
+    # @param item_ids [Array<String>] an array of items to remove (represented by ids)
+    def delete_items(item_ids)
+      send_request(:delete, 'item', params: { ids: item_ids })
+    end
+
+    # needed for parallel formatter
+    def item_id_of(name, parent_node)
+      path = if parent_node.is_root? # folder without parent folder
+               "item?filter.eq.launch=#{@launch_id}&filter.eq.name=#{CGI.escape(name)}&filter.size.path=0"
+             else
+               "item?filter.eq.parent=#{parent_node.content.id}&filter.eq.name=#{CGI.escape(name)}"
+             end
+      data = send_request(:get, path)
+      if data.key? 'content'
+        data['content'].empty? ? nil : data['content'][0]['id']
+      end
+    end
+
+    # needed for parallel formatter
+    def close_child_items(parent_id)
+      path = if parent_id.nil?
+               "item?filter.eq.launch=#{@launch_id}&filter.size.path=0&page.page=1&page.size=100"
+             else
+               "item?filter.eq.parent=#{parent_id}&page.page=1&page.size=100"
+             end
+      ids = []
+      loop do
+        data = send_request(:get, path)
+        if data.key?('links')
+          link = data['links'].find { |i| i['rel'] == 'next' }
+          url = link.nil? ? nil : link['href']
+        else
+          url = nil
+        end
+        data['content'].each do |i|
+          ids << i['id'] if i['has_childs'] && i['status'] == 'IN_PROGRESS'
+        end
+        break if url.nil?
+      end
+
+      ids.each do |id|
+        close_child_items(id)
+        finish_item(TestItem.new(id: id))
+      end
+    end
+
+    # Registers an event. The proc will be called back with the event object.
+    def on_event(name, &proc)
+      event_bus.on(name, &proc)
+    end
+
+    private
+
+    def send_file_from_path(status, path, label, time, mime_type)
+      File.open(File.realpath(path), 'rb') do |file|
+        filename = File.basename(file)
+        json = [{ level: status_to_level(status), message: label || filename, item_id: @current_scenario.id, time: time, file: { name: filename } }]
+        form = {
+          json_request_part: HTTP::FormData::Part.new(JSON.dump(json), content_type: 'application/json'),
+          binary_part: HTTP::FormData::File.new(file, filename: filename, content_type: MIME::Types[mime_type].first.to_s)
+        }
+        send_request(:post, 'log', form: form)
+      end
+    end
+
+    def send_request(verb, path, options = {})
+      http_client.send_request(verb, path, options)
+    end
+
+    def http_client
+      @http_client ||= HttpClient.new
+    end
+
+    def current_time
+      # `now_without_mock_time` is provided by Timecop and returns a real, not mocked time
+      return Time.now_without_mock_time if Time.respond_to?(:now_without_mock_time)
+
+      Time.now
+    end
+
+    def event_bus
+      @event_bus ||= EventBus.new
+    end
+
+    def prepare_options(data, config = {})
+      if config.attributes
+        data[:attributes] = config.attributes
+      elsif (data[:tags] = config.tags)
+      end
+      data
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: custom_reportportal
+version: !ruby/object:Gem::Version
+  version: '0.7'
+platform: ruby
+authors:
+- Aliaksandr Trush
+- Sergey Gvozdyukevich
+- Andrei Botalov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubytree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.71'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.71'
+description: Cucumber and RSpec clients for EPAM ReportPortal system
+email: dzmitry_humianiuk@epam.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/report_portal/cucumber/formatter.rb
+- lib/report_portal/cucumber/parallel_formatter.rb
+- lib/report_portal/cucumber/parallel_report.rb
+- lib/report_portal/cucumber/report.rb
+- lib/report_portal/event_bus.rb
+- lib/report_portal/events/prepare_start_item_request.rb
+- lib/report_portal/http_client.rb
+- lib/report_portal/logging/log4r_outputter.rb
+- lib/report_portal/logging/logger.rb
+- lib/report_portal/logging/logging_appender.rb
+- lib/report_portal/models/item_search_options.rb
+- lib/report_portal/models/test_item.rb
+- lib/report_portal/rspec/formatter.rb
+- lib/report_portal/settings.rb
+- lib/report_portal/tasks.rb
+- lib/report_portal/version.rb
+- lib/reportportal.rb
+homepage: https://github.com/reportportal/agent-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: ReportPortal Ruby Client
+test_files: []