parallel_report_portal 2.0.0

data/lib/parallel_report_portal/clock.rb

@@ -0,0 +1,13 @@
+module ParallelReportPortal
+  # This module is responsilbe for the timekeeping for the tests.
+  module Clock
+    # Get the current time.
+    # 
+    # This is based on the Unix time stamp and is in milliseconds.
+    # 
+    # @return [Integer] the number of milliseconds since the Unix epoc.
+    def clock
+      (Time.now.to_f * 1000).to_i
+    end		
+  end
+end

data/lib/parallel_report_portal/configuration.rb

@@ -0,0 +1,138 @@
+module ParallelReportPortal
+  # The Configuration class holds the connection properties to communicate with
+  # Report Portal and to identify the user and project for reporting.
+  # 
+  # It attempts to load a configuration file called +report_portal.yml+ first in a
+  # local directory called +config+ and if that's not found in the current directory.
+  # (Report Portal actually tells you to create a files called +REPORT_PORTAL.YML+ in
+  # uppercase -- for this reason the initializer is case insensitive with regards to 
+  # the file name)
+  # 
+  # It will then try an apply the following environment variables, if present (these
+  # can be specified in either lowercase for backwards compatibility with the official
+  # gem or in uppercase for reasons of sanity)
+  # 
+  # == Environment variables
+  # 
+  # RP_UUID:: The UUID of the user associated with this launch
+  # RP_ENDPOINT:: the URL of the Report Portal API endpoint
+  # RP_PROJECT:: the Report Portal project name -- this must already exist within Report Port and this user must be a member of the project
+  # RP_LAUNCH:: The name of this launch 
+  # RP_DESCRIPTION:: A textual string describing this launch
+  # RP_TAGS:: A set of tags to pass to Report Portal for this launch. If these are set via an environment variable, provide a comma-separated string of tags
+  # RP_ATTRIBUTES:: A set of attribute tags to pass to Report Portal for this launch. If these are set via an environment variable, provide a comma-separated string of attributes
+  class Configuration
+    ATTRIBUTES = [:uuid, :endpoint, :project, :launch, :debug, :description, :tags, :attributes]
+
+    # @return [String] the Report Portal user UUID
+    attr_accessor :uuid
+    # @return [String] the Report Portal URI - this should include the scheme
+    #   e.g. +https://reportportal.local/api/v1+
+    attr_accessor :endpoint
+    # @return [String] the Report Portal project name.
+    #   This must exist and match the project name within
+    #   Report Portal.
+    attr_accessor :project
+    #  @return [String] the launch name for this test run.
+    attr_accessor :launch
+    # @return [Array<String>] an array of tags to attach to this launch.
+    attr_reader :tags
+    # @return [Boolean] true if this is a debug run (this launch will appear
+    #   on the debug tab in Report Portal).
+    attr_reader :debug
+    # @return [String] a textual description of this launch.
+    attr_accessor :description
+    # @return [Array<String>] an array of attributes to attach to this launch
+    #   (Report Portal 5)
+    attr_reader :attributes
+  
+
+    # Create an instance of Configuration.
+    # 
+    # The initializer will first attempt to load a configuration files called
+    # +report_portal.yml+ (case insensitive) in the both the +config+ and current
+    # working directory (the former takes precidence). It will then apply
+    # any of the environment variable values.
+    def initialize
+      load_configuration_file
+      ATTRIBUTES.each do |attr|
+        env_value = get_env("rp_#{attr.to_s}")
+        send(:"#{attr}=", env_value) if env_value
+      end
+    end
+
+    # Sets the tags for the launch. If an array is provided, the array is used,
+    # if a string is provided, the string is broken into components by splitting
+    # on a comma.
+    # 
+    # e.g.
+    #   configuration.tags="one,two, three"
+    #   #=> ["one", "two", "three"]
+    # 
+    # param [String | Array<String>] taglist a list of tags to set
+    def tags=(taglist)
+      if taglist.is_a?(String)
+        @tags = taglist.split(',').map(&:strip)
+      elsif taglist.is_a?(Array)
+        @tags = taglist
+      else 
+        @tags = []
+      end
+      tags
+    end
+
+
+    # Enables the debug flag which is sent to Report Portal. If this flag is set
+    # Report Portal will include this launch in its 'debug' tab.
+    # 
+    # param [Boolean | String] value if the value is a Boolean, it will take that value
+    #   if it is a String, it will set values of 'true' to +true+, else all values will be false.
+    def debug=(value)
+      @debug = if [true, false].include?(value)
+                 value
+               else
+                 value.to_s.downcase.strip == 'true'
+               end
+    end
+
+    # Sets the attributes for the launch. If an array is provided, the array is used,
+    # if a string is provided, the string is broken into components by splitting
+    # on a comma.
+    # 
+    # e.g.
+    #   configuration.tags="one,two, three"
+    #   #=> ["one", "two", "three"]
+    # 
+    # param [String | Array<String>] taglist a list of tags to set
+    def attributes=(attrlist)
+      if attrlist.is_a?(String)
+        @attributes = attrlist.split(',').map(&:strip)
+      elsif attrlist.is_a?(Array)
+        @attributes = attrlist
+      else 
+        @attributes = []
+      end
+      attributes
+    end
+
+    private
+
+    def get_env(name)
+      ENV[name.upcase] || ENV[name.downcase]
+    end
+
+    def load_configuration_file
+      files = Dir['./config/*'] + Dir['./*']
+      files
+        .filter { |fn| fn.downcase.end_with?('/report_portal.yml') }
+        .first
+        .then { |fn| fn ? File.read(fn) : '' }
+        .then { |ys| YAML.safe_load(ys, symbolize_names: true) }
+        .then do |yaml|
+          ATTRIBUTES.each do |attr|
+            send(:"#{attr}=", yaml[attr]) if yaml&.fetch(attr, nil)
+          end
+        end
+    end
+  end
+end

data/lib/parallel_report_portal/cucumber/formatter.rb

@@ -0,0 +1,73 @@
+require_relative 'report'
+
+module ParallelReportPortal
+  module Cucumber
+    # Formatter supporting the Cucumber formatter API.
+    # This is the class which does the heavy-lifting by
+    # integrating with cucumber.
+    class Formatter
+
+      CucumberMessagesVersion=[4,0,0]
+
+      # Create a new formatter instance
+      # 
+      # @param [Cucumber::Configuration] cucumber_config the cucumber configuration environment
+      def initialize(cucumber_config)
+        @ast_lookup = if (::Cucumber::VERSION.split('.').map(&:to_i) <=> CucumberMessagesVersion) > 0
+          require 'cucumber/formatter/ast_lookup'
+          ::Cucumber::Formatter::AstLookup.new(cucumber_config)
+        else
+          nil
+        end
+        start_background_thread.priority = Thread.main.priority + 1 
+        register_event_handlers(cucumber_config)
+      end
+
+      private
+
+      def report
+        @report ||= Report.new(@ast_lookup)
+      end
+
+      def register_event_handlers(config)
+        [:test_case_started, 
+         :test_case_finished, 
+         :test_step_started, 
+         :test_step_finished].each do |event_name|
+          config.on_event(event_name) do |event|
+            background_queue << -> { report.public_send(event_name, event, ParallelReportPortal.clock) }
+          end
+        end
+        config.on_event :test_run_started,  &method(:handle_test_run_started )
+        config.on_event :test_run_finished, &method(:handle_test_run_finished)
+      end
+      
+      def handle_test_run_started(event)
+        background_queue << proc { report.launch_started(ParallelReportPortal.clock) }
+      end
+      
+      def background_queue
+        @background_queue ||= Queue.new
+      end
+      
+      def start_background_thread
+        @background_thread ||= Thread.new do
+          loop do
+            code = background_queue.shift
+            code.call
+          end
+        end
+      end
+      
+      def handle_test_run_finished(event)
+        background_queue << proc do
+          report.feature_finished(ParallelReportPortal.clock)
+          report.launch_finished(ParallelReportPortal.clock)
+        end
+        sleep 0.01 while !background_queue.empty? || background_queue.num_waiting == 0
+        @background_thread.kill
+      end
+    
+    end
+  end
+end

data/lib/parallel_report_portal/cucumber/report.rb

@@ -0,0 +1,226 @@
+require 'faraday'
+require 'tree'
+
+module ParallelReportPortal
+  module Cucumber
+    # Report object. This handles the management of the state heirarchy and
+    # the issuing of the requests to the HTTP module. 
+    class Report
+      
+      attr_reader :launch_id
+      
+      Feature = Struct.new(:feature, :id)
+      
+      LOG_LEVELS = { 
+        error: 'ERROR', 
+        warn: 'WARN', 
+        info: 'INFO', 
+        debug: 'DEBUG', 
+        trace: 'TRACE', 
+        fatal: 'FATAL', 
+        unknown: 'UNKNOWN' 
+      }
+
+      
+      # Create a new instance of the report
+      def initialize(ast_lookup = nil)
+        @feature = nil
+        @tree = Tree::TreeNode.new( 'root' ) 
+        @ast_lookup = ast_lookup
+      end
+      
+      # Issued to start a launch. It is possilbe that this method could be called
+      # from multiple processes for the same launch if this is being run with
+      # parallel tests enabled. A temporary launch file will be created (using
+      # exclusive locking). The first time this method is called it will write the
+      # launch id to the launch file, subsequent calls by other processes will read
+      # this launch id and use that.
+      # 
+      # @param start_time [Integer] the millis from the epoch 
+      # @return [String] the UUID of this launch
+      def launch_started(start_time)
+        ParallelReportPortal.file_open_exlock_and_block(ParallelReportPortal.launch_id_file, 'a+' ) do |file|
+          if file.size == 0
+            @launch_id = ParallelReportPortal.req_launch_started(start_time)
+            file.write(@launch_id)
+            file.flush
+          else
+             @launch_id = file.readline
+          end
+          @launch_id
+        end
+      end
+      
+      # Called to finish a launch. Any open children items will be closed in the process.
+      # 
+      # @param clock [Integer] the millis from the epoch
+      def launch_finished(clock)
+        @tree.postordered_each do |node|
+          ParallelReportPortal.req_feature_finished(node.content, clock) unless node.is_root?
+        end
+        ParallelReportPortal.req_launch_finished(launch_id, clock)
+      end
+      
+      # Called to indicate that a feature has started.
+      # 
+      # @param 
+      def feature_started(feature, clock)
+        parent_id = hierarchy(feature, clock)
+        feature = feature.feature if using_cucumber_messages?
+        ParallelReportPortal.req_feature_started(launch_id, parent_id, feature, clock)
+      end
+      
+      def feature_finished(clock)
+        if @feature
+          resp = ParallelReportPortal.req_feature_finished(@feature.id, clock)
+        end
+      end
+            
+      def test_case_started(event, clock)
+        test_case = lookup_test_case(event.test_case)
+        feature = lookup_feature(event.test_case)
+        feature = current_feature(feature, clock)
+        @test_case_id = ParallelReportPortal.req_test_case_started(launch_id, feature.id, test_case, clock)
+      end
+      
+      def test_case_finished(event, clock)
+        result = event.result
+        status = result.to_sym
+        failure_message = nil
+        if [:undefined, :pending].include?(status)
+          status = :failed
+          failure_message = result.message
+        end
+        resp = ParallelReportPortal.req_test_case_finished(@test_case_id, status, clock)
+      end
+      
+      def test_step_started(event, clock)
+        test_step = event.test_step
+        if !hook?(test_step)
+          step_source = lookup_step_source(test_step)
+          detail = "#{step_source.keyword} #{step_source.text}"
+          if (using_cucumber_messages? ? test_step : step_source).multiline_arg.doc_string?
+            detail << %(\n"""\n#{(using_cucumber_messages? ? test_step : step_source).multiline_arg.content}\n""")
+          elsif (using_cucumber_messages? ? test_step : step_source).multiline_arg.data_table?
+            detail << (using_cucumber_messages? ? test_step : step_source).multiline_arg.raw.reduce("\n") {|acc, row| acc << "| #{row.join(' | ')} |\n"}
+          end
+          
+          ParallelReportPortal.req_log(@test_case_id, detail, status_to_level(:trace), clock)
+        end
+      end
+      
+      def test_step_finished(event, clock)
+        test_step = event.test_step
+        result = event.result
+        status = result.to_sym
+        if !hook?(test_step)
+          step_source = lookup_step_source(test_step)
+          detail = "#{step_source.text}"
+        
+          if [:failed, :pending, :undefined].include?(status)
+            level = :error
+            detail = if [:failed, :pending].include?(status)
+                       ex = result.exception
+                       sprintf("%s: %s\n  %s", ex.class.name, ex.message, ex.backtrace.join("\n  "))
+                     else
+                       sprintf("Undefined step: %s:\n%s", test_step.text, test_step.source.last.backtrace_line)
+                     end
+            
+            ParallelReportPortal.req_log(@test_case_id, detail, level, clock)
+          end
+        end
+      end
+    
+      private
+
+      def using_cucumber_messages?
+        @ast_lookup != nil
+      end
+      
+      def hierarchy(feature, clock)
+        node = nil
+        path_components = if using_cucumber_messages?
+                            feature.uri.split(File::SEPARATOR)
+                          else
+                            feature.location.file.split(File::SEPARATOR)
+                          end
+        ParallelReportPortal.file_open_exlock_and_block(ParallelReportPortal.hierarchy_file, 'a+b' ) do |file|
+          @tree = Marshal.load(File.read(file)) if file.size > 0 
+          node = @tree.root
+          path_components[0..-2].each do |component|
+            next_node = node[component]
+            unless next_node
+              id = ParallelReportPortal.req_hierarchy(launch_id, "Folder: #{component}", node.content, 'SUITE', [], nil, clock )
+              next_node = Tree::TreeNode.new(component, id)
+              node << next_node
+              node = next_node
+            else
+              node = next_node
+            end
+          end
+          file.truncate(0)
+          file.write(Marshal.dump(@tree))
+          file.flush
+        end
+        
+        node.content
+      end
+
+      def lookup_feature(test_case)
+        if using_cucumber_messages?
+          @ast_lookup.gherkin_document(test_case.location.file)
+        else
+          test_case.feature
+        end
+      end
+
+      def lookup_test_case(test_case)
+        if using_cucumber_messages?
+          @ast_lookup.gherkin_document(test_case.location.file).feature
+        else
+          test_case
+        end
+      end
+
+      def lookup_step_source(step)
+        if using_cucumber_messages?
+          @ast_lookup.step_source(step).step
+        else
+          step.source.last
+        end
+      end
+      
+      def current_feature(feature, clock)
+        if @feature&.feature == feature
+          @feature
+        else
+          feature_finished(clock)
+          @feature = Feature.new(feature, feature_started(feature, clock))
+        end
+      end
+      
+      def hook?(test_step)
+        if using_cucumber_messages?
+          test_step.hook?
+        else
+          ! test_step.source.last.respond_to?(:keyword)
+        end
+      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
+      
+    
+    end
+  end
+end