rpruby 1.2 → 1.2.1

data/lib/rpruby/cucumber/parallel_report.rb

@@ -0,0 +1,54 @@
+require 'parallel_tests'
+
+require_relative 'report'
+
+module Rpruby
+  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(Rpruby.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 = Rpruby.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 #{Rpruby.launch_id}"
+            Rpruby.close_child_items(nil)
+            time_to_send = time_to_send(desired_time)
+            Rpruby.finish_launch(time_to_send)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpruby/cucumber/report.rb

@@ -0,0 +1,220 @@
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/hook_query_visitor'
+require 'tree'
+require 'securerandom'
+
+require_relative '../../rpruby'
+require_relative '../logging/logger'
+
+module Rpruby
+  module Cucumber
+    # @api private
+    class Report
+      def parallel?
+        false
+      end
+
+      def attach_to_launch?
+        Rpruby::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 = Rpruby.now)
+        if attach_to_launch?
+          Rpruby.launch_id =
+            if Rpruby::Settings.instance.launch_id
+              Rpruby::Settings.instance.launch_id
+            else
+              file_path = Rpruby::Settings.instance.file_with_launch_id || (Pathname(Dir.tmpdir) + 'rp_launch_id.tmp')
+              File.read(file_path)
+            end
+          $stdout.puts "Attaching to launch #{Rpruby.launch_id}"
+        else
+          description = Rpruby::Settings.instance.description
+          description ||= ARGV.map { |arg| arg.gsub(/rp_uuid=.+/, 'rp_uuid=[FILTERED]') }.join(' ')
+          Rpruby.start_launch(description, time_to_send(desired_time))
+        end
+      end
+
+      # TODO: time should be a required argument
+      def test_case_started(event, desired_time = Rpruby.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
+
+        Rpruby.current_scenario = Rpruby::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, Rpruby.current_scenario)
+        @parent_item_node << scenario_node
+        Rpruby.current_scenario.id = Rpruby.start_item(scenario_node)
+      end
+
+      def test_case_finished(event, desired_time = Rpruby.now)
+        result = event.result
+        status = result.to_sym
+        issue = nil
+        if %i[undefined pending].include?(status)
+          status = :failed
+          issue = result.message
+        end
+        Rpruby.finish_item(Rpruby.current_scenario, status, time_to_send(desired_time), issue)
+        Rpruby.current_scenario = nil
+      end
+
+      def test_step_started(event, desired_time = Rpruby.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
+          Rpruby.send_log(:trace, message, time_to_send(desired_time))
+        end
+      end
+
+      def test_step_finished(event, desired_time = Rpruby.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
+          Rpruby.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
+          Rpruby.send_log(log_level, "#{step_type} #{status}", time_to_send(desired_time))
+        end
+      end
+
+      def test_run_finished(_event, desired_time = Rpruby.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)
+          Rpruby.finish_launch(time_to_send)
+        end
+      end
+
+      def puts(message, desired_time = Rpruby.now)
+        Rpruby.send_log(:info, message, time_to_send(desired_time))
+      end
+
+      def embed(path_or_src, mime_type, label, desired_time = Rpruby.now)
+        Rpruby.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 = Rpruby.item_id_of(name, parent_node)) # get id for folder from report portal
+              # get child id from other process
+              item = Rpruby::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 = Rpruby::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 = Rpruby.start_item(child_node) # TODO: multithreading
+            end
+          end
+          parent_node = child_node
+        end
+        @parent_item_node = child_node
+      end
+
+      def end_feature(desired_time)
+        Rpruby.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
+            Rpruby.finish_item(node.content)
+          end
+        end
+      end
+
+      def step?(test_step)
+        !::Cucumber::Formatter::HookQueryVisitor.new(test_step).hook?
+      end
+
+      def report_hierarchy?
+        !Rpruby::Settings.instance.formatter_modes.include?('skip_reporting_hierarchy')
+      end
+    end
+  end
+end

data/lib/rpruby/event_bus.rb

@@ -0,0 +1,30 @@
+require_relative 'events/prepare_start_item_request'
+
+module Rpruby
+  # @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/rpruby/events/prepare_start_item_request.rb

@@ -0,0 +1,13 @@
+module Rpruby
+  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/rpruby/http_client.rb

@@ -0,0 +1,64 @@
+require 'http'
+
+module Rpruby
+  # @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?
+      Rpruby::Settings.instance.formatter_modes.include?('use_persistent_connection')
+    end
+  end
+end

data/lib/rpruby/logging/log4r_outputter.rb

@@ -0,0 +1,16 @@
+require 'log4r/outputter/outputter'
+
+require_relative '../../rpruby'
+
+module Rpruby
+  # 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)
+      Rpruby.send_log(level, data, Rpruby.now)
+    end
+  end
+end

data/lib/rpruby/logging/logger.rb

@@ -0,0 +1,36 @@
+require 'logger'
+
+module Rpruby
+  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
+            Rpruby.send_log(format_severity(severity), format_message(format_severity(severity), Time.now, progname, message.to_s), Rpruby.now)
+          end
+          ret
+        end
+
+        def <<(msg)
+          ret = orig_write(msg)
+          Rpruby.send_log(Rpruby::LOG_LEVELS[:unknown], msg.to_s, Rpruby.now)
+          ret
+        end
+      end
+    end
+  end
+end

data/lib/rpruby/logging/logging_appender.rb

@@ -0,0 +1,18 @@
+require 'logging'
+
+require_relative '../../rpruby'
+
+module Rpruby
+  # 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, Rpruby::LOG_LEVELS[:unknown]]
+                   end
+
+      Rpruby.send_log(lvl, str, Rpruby.now)
+    end
+  end
+end

data/lib/rpruby/models/item_search_options.rb

@@ -0,0 +1,26 @@
+module Rpruby
+  # 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/rpruby/models/test_item.rb

@@ -0,0 +1,22 @@
+module Rpruby
+  # 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/rpruby/rspec/formatter.rb

@@ -0,0 +1,112 @@
+require 'securerandom'
+require 'tree'
+require 'rspec/core'
+
+require_relative '../../rpruby'
+
+# TODO: Screenshots
+# TODO: Logs
+module Rpruby
+  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(' ')
+        Rpruby.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 = Rpruby::TestItem.new(name: description[0..MAX_DESCRIPTION_LENGTH - 1],
+                                          type: :TEST,
+                                          id: nil,
+                                          start_time: Rpruby.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?
+          Rpruby.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
+        Rpruby.current_scenario = Rpruby::TestItem.new(name: description[0..MAX_DESCRIPTION_LENGTH - 1],
+                                                                   type: :STEP,
+                                                                   id: nil,
+                                                                   start_time: Rpruby.now,
+                                                                   description: '',
+                                                                   closed: false,
+                                                                   tags: [])
+        example_node = Tree::TreeNode.new(SecureRandom.hex, Rpruby.current_scenario)
+        if example_node.nil?
+          p "Example node is nil for scenario #{Rpruby.current_scenario.inspect}"
+        else
+          @current_group_node << example_node
+          example_node.content.id = Rpruby.start_item(example_node)
+        end
+      end
+
+      def example_passed(_notification)
+        Rpruby.finish_item(Rpruby.current_scenario, :passed) unless Rpruby.current_scenario.nil?
+        Rpruby.current_scenario = nil
+      end
+
+      def example_failed(notification)
+        exception = notification.exception
+        Rpruby.send_log(:failed, %(#{exception.class}: #{exception.message}\n\nStacktrace: #{notification.formatted_backtrace.join("\n")}), Rpruby.now)
+        Rpruby.finish_item(Rpruby.current_scenario, :failed) unless Rpruby.current_scenario.nil?
+        Rpruby.current_scenario = nil
+      end
+
+      def example_pending(_notification)
+        Rpruby.finish_item(Rpruby.current_scenario, :skipped) unless Rpruby.current_scenario.nil?
+        Rpruby.current_scenario = nil
+      end
+
+      def message(notification)
+        if notification.message.respond_to?(:read)
+          Rpruby.send_file(:passed, notification.message)
+        else
+          Rpruby.send_log(:passed, notification.message, Rpruby.now)
+        end
+      end
+
+      def stop(_notification)
+        Rpruby.finish_launch
+      end
+    end
+  end
+end

data/lib/rpruby/settings.rb

@@ -0,0 +1,65 @@
+require 'yaml'
+require 'singleton'
+
+module Rpruby
+  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
+      }
+
+      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