reportportal 0.7

data/lib/report_portal/cucumber/parallel_formatter.rb

@@ -0,0 +1,53 @@
+# Copyright 2015 EPAM Systems
+# 
+# 
+# This file is part of Report Portal.
+# 
+# Report Portal is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ReportPortal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Report Portal.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative 'formatter'
+require_relative 'parallel_report'
+require 'parallel_tests/gherkin/io'
+
+module ReportPortal
+  module Cucumber
+    class ParallelFormatter < Formatter
+      #include ::ParallelTests::Gherkin::Io
+
+      # @api private
+      def initialize(config)
+        ENV['REPORT_PORTAL_USED'] = 'true'
+
+        @queue = Queue.new
+        @thread = Thread.new do
+          @report = ReportPortal::Cucumber::ParallelReport.new
+          loop do
+            method_arr = @queue.pop
+            @report.public_send(*method_arr)
+          end
+        end
+        @thread.abort_on_exception = true
+
+        @io = config.out_stream
+
+        [:test_case_started, :test_case_finished, :test_step_started, :test_step_finished].each do |event_name|
+          config.on_event event_name do |event|
+            @queue.push([event_name, event, ReportPortal.now])
+          end
+        end
+        config.on_event :test_run_finished, &method(:on_test_run_finished)
+      end
+    end
+  end
+end

data/lib/report_portal/cucumber/parallel_report.rb

@@ -0,0 +1,69 @@
+# Copyright 2015 EPAM Systems
+# 
+# 
+# This file is part of Report Portal.
+# 
+# Report Portal is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ReportPortal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Report Portal.  If not, see <http://www.gnu.org/licenses/>.
+
+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('')
+        @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 done(desired_time = ReportPortal.now)
+        end_feature(desired_time) if @feature_node
+
+        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,232 @@
+# Copyright 2015 EPAM Systems
+# 
+# 
+# This file is part of Report Portal.
+# 
+# Report Portal is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ReportPortal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Report Portal.  If not, see <http://www.gnu.org/licenses/>.
+
+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('')
+        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
+
+      def test_case_started(event, desired_time = ReportPortal.now) # TODO: time should be a required argument
+        test_case = event.test_case
+        feature = test_case.feature
+        unless same_feature_as_previous_test_case?(feature)
+          end_feature(desired_time) if @feature_node
+          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, type, nil, time_to_send(desired_time), description, false, tags)
+        scenario_node = Tree::TreeNode.new(SecureRandom.hex, ReportPortal.current_scenario)
+        @feature_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 [: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 [:failed, :pending, :undefined].include?(status)
+          exception_info = 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
+          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 done(desired_time = ReportPortal.now)
+        end_feature(desired_time) if @feature_node
+
+        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(src, mime_type, label, desired_time = ReportPortal.now)
+        ReportPortal.send_file(:info, 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)
+        @feature_node && @feature_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, type, id_of_created_item, time_to_send(desired_time), description, false, tags)
+              child_node = Tree::TreeNode.new(path_component, item)
+              parent_node << child_node
+            else
+              item = ReportPortal::TestItem.new(name, type, nil, time_to_send(desired_time), description, false, 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
+        @feature_node = child_node
+      end
+
+      def end_feature(desired_time)
+        ReportPortal.finish_item(@feature_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
+    end
+  end
+end

data/lib/report_portal/logging/log4r_outputter.rb

@@ -0,0 +1,34 @@
+# Copyright 2015 EPAM Systems
+# 
+# 
+# This file is part of Report Portal.
+# 
+# Report Portal is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ReportPortal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Report Portal.  If not, see <http://www.gnu.org/licenses/>.
+
+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,54 @@
+# Copyright 2015 EPAM Systems
+# 
+# 
+# This file is part of Report Portal.
+# 
+# Report Portal is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ReportPortal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Report Portal.  If not, see <http://www.gnu.org/licenses/>.
+
+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,36 @@
+# Copyright 2015 EPAM Systems
+# 
+# 
+# This file is part of Report Portal.
+# 
+# Report Portal is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# ReportPortal is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with Report Portal.  If not, see <http://www.gnu.org/licenses/>.
+
+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