qat-reporter-xray 6.0.0

data/lib/qat/reporter/xray/publisher/base.rb

@@ -0,0 +1,229 @@
+require 'rest-client'
+require 'json'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
+require 'qat/logger'
+
+module QAT
+  module Reporter
+    class Xray
+      # QAT::Reporter::Xray::Publisher integrator module
+      module Publisher
+        # QAT::Reporter::Xray::Publisher::Base integrator class
+        class Base
+          include QAT::Logger
+
+          attr_reader :base_url, :default_headers, :login_credentials, :default_cloud_api_url, :cloud_xray_api_credentials
+
+          # Initializes Xray Publisher url and login information
+          def initialize
+            @base_url                   = QAT::Reporter::Xray::Config.jira_url
+            @login_credentials          = QAT::Reporter::Xray::Config.login_credentials
+            @default_cloud_api_url      = QAT::Reporter::Xray::Config.xray_default_api_url
+            @cloud_xray_api_credentials = QAT::Reporter::Xray::Config.cloud_xray_api_credentials
+          end
+
+          # Creates a Jira issue
+          def create_issue(data)
+            Client.new(base_url).post('/rest/api/2/issue', data.to_json, default_headers)
+          end
+
+
+          # Get the default headers for Xray ('password' in Xray API is password)
+          def default_headers
+            headers = if QAT::Reporter::Xray::Config.jira_type == 'cloud'
+                        auth_headers_jira_cloud
+                      else
+                        auth_headers
+                      end
+            {
+              'Content-Type': 'application/json'
+            }.merge(headers)
+          end
+
+
+          private
+          # Authentication header for xray, Basic authentication done with: username, password
+          def auth_headers
+            username = login_credentials[0]
+            password = login_credentials[1]
+            {
+              Authorization: "Basic #{::Base64::encode64("#{username}:#{password}").delete("\n")}"
+            }
+          end
+
+          # Authentication header for jira, Basic authentication done with: username, apiToken
+          def auth_headers_jira_cloud
+            username  = login_credentials[0]
+            api_token = login_credentials[2]
+            {
+              Authorization: "Basic #{::Base64::encode64("#{username}:#{api_token}").delete("\n")}"
+            }
+          end
+
+          #Gets a zip file from a response and extracts features to 'Feature' folder
+          def extract_feature_files(rsp)
+            Zip::InputStream.open(StringIO.new(rsp)) do |io|
+              while entry = io.get_next_entry
+                entry_path = File.join('features', entry.name)
+                log.info 'Feature ' + entry.name + ' was found, extracting...'
+                entry.extract(File.join(Dir.pwd, entry_path)) unless File.exist?(entry_path)
+              end
+            end
+              #See https://github.com/rubyzip/rubyzip#notice-about-zipinputstream
+          rescue Zip::GPFBit3Error
+            Tempfile.open do |file|
+              File.write(file.path, rsp)
+
+              Zip::File.open(file.path) do |zip_file|
+                # Handle entries one by one
+                zip_file.each do |entry|
+                  # Extract to file/directory/symlink
+                  log.info 'Feature ' + entry.name + ' was found, extracting...'
+                  entry_path = File.join('features', entry.name)
+                  entry.extract(entry_path)
+                end
+              end
+            end
+          end
+
+          # REST Base Client implementation
+          class Client
+            include QAT::Logger
+
+            # Service Unavailable Error class
+            class ServiceUnavailableError < StandardError
+            end
+            # Connection Error class
+            class ConnectionError < StandardError
+            end
+
+            # No Connection Error class
+            class NoConnectionFound < StandardError
+            end
+
+            attr_reader :base_uri
+
+            # Returns a new REST Base Client
+            # @return [RestClient::Response]
+            def initialize(base_uri)
+              #sets the ip:port/base_route
+              @base_uri = case base_uri
+                            when Hash
+                              URI::HTTP.build(base_uri).to_s
+                            when URI::HTTP
+                              base_uri.to_s
+                            when String
+                              base_uri
+                            else
+                              raise ArgumentError.new "Invalid URI class: #{base_uri.class}"
+                          end
+            end
+
+            [:put, :post, :get, :delete, :patch].each do |operation|
+              define_method operation do |url, *args|
+                final_url = base_uri + url
+
+                log_request operation, final_url, args
+                begin
+                  response = RestClient.method(operation).call(final_url, *args)
+                  log_response response
+                  validate response
+                rescue RestClient::ExceptionWithResponse => e
+                  log.error e.response
+                  raise NoConnectionFound.new ('Jira was not found!!!')
+                rescue => exception
+                  log.error "#{exception.class} #{exception.message.to_s}"
+                  raise NoConnectionFound.new ('Jira was not found!!!')
+                end
+              end
+            end
+
+            protected
+
+            # Validates the response and raises a HTTP Error
+            #@param response [RestClient::Response] response
+            def validate(response)
+              error_klass = case response.code
+                              when 400 then
+                                Error::BadRequest
+                              when 401 then
+                                Error::Unauthorized
+                              when 403 then
+                                Error::Forbidden
+                              when 404 then
+                                Error::NotFound
+                              when 405 then
+                                Error::MethodNotAllowed
+                              when 409 then
+                                Error::Conflict
+                              when 422 then
+                                Error::Unprocessable
+                              when 500 then
+                                Error::InternalServerError
+                              when 502 then
+                                Error::BadGateway
+                              when 503 then
+                                Error::ServiceUnavailable
+                            end
+
+              raise error_klass.new response if error_klass
+              response
+            end
+
+            # Logs the request information
+            #@param operation [String] HTTP operation called
+            #@param url [String] target URL
+            #@param args [String] request arguments
+            #@see RestClient#get
+            def log_request(operation, url, args)
+              log.info { "#{operation.upcase}: #{url}" }
+
+              args.each do |options|
+                log_http_options options
+              end
+            end
+
+            # Logs the received response
+            #@param response [RestClient::Response] response
+            def log_response(response)
+              log.info "Response HTTP #{response.code} (#{response.body})"
+
+              log_http_options({ headers: response.headers.to_h,
+                                 body:    response.body }.select { |_, value| !value.nil? })
+            end
+
+            # Logs the request's HTTP options
+            #@param options [Hash|String] http options to log
+            def log_http_options(options)
+              if log.debug?
+                temp = if options.is_a?(String)
+                         { payload: JSON.parse(options) }
+                       else
+                         options.map do |k, v|
+                           if k == :body
+                             begin
+                               [k, JSON.pretty_generate(JSON.parse(v))]
+                                 #if body is not JSON by some unknown reason, we still want to print
+                             rescue JSON::ParserError
+                               [k, v]
+                             end
+                           else
+                             [k, v]
+                           end
+                         end.to_h
+                       end
+
+                temp.each do |key, value|
+                  log.debug "#{key.to_s.humanize}:"
+                  log.debug value
+                end
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qat/reporter/xray/publisher/cloud.rb

@@ -0,0 +1,74 @@
+require_relative 'base'
+require 'zip'
+
+module QAT
+  module Reporter
+    class Xray
+      module Publisher
+        # QAT::Reporter::Xray::Publisher::Cloud integrator class
+        class Cloud < Base
+
+          # Posts the execution json results in Xray
+          def send_execution_results(results)
+            headers = { 'Content-Type': 'application/json' }.merge(auth_token)
+            Client.new(default_cloud_api_url).post('/api/v1/import/execution', results.to_json, headers)
+          end
+
+          # Get the Authorization Token based on client_id & client_secret (ONLY FOR CLOUD XRAY)
+          def auth_token
+            return @auth_token if @auth_token
+
+            client_id         = cloud_xray_api_credentials[0]
+            client_secret     = cloud_xray_api_credentials[1]
+            auth_header_cloud = {
+              client_id:     client_id,
+              client_secret: client_secret
+            }
+
+            response    = Client.new(default_cloud_api_url).post('/api/v1/authenticate', auth_header_cloud).body
+            bearer      = JSON.parse(response)
+            @auth_token = {
+              Authorization: "Bearer #{bearer}"
+            }
+          end
+
+          # Import Cucumber features files as a zip file via API
+          # @param project_key [String] JIRA's project key
+          # @param file_path [String]  Cucumber features files' zip file
+          # @see https://confluence.xpand-it.com/display/XRAYCLOUD/Importing+Cucumber+Tests+-+REST
+          def import_cucumber_tests(project_key, file_path, project_id = nil)
+            headers = auth_token.merge({
+                                         multipart: true,
+                                         params:    {
+                                           projectKey: project_key,
+                                           projectId:  project_id,
+                                           source:     project_key
+                                         }
+                                       })
+            payload = { file: File.new(file_path, 'rb') }
+
+            Client.new(default_cloud_api_url).post('/api/v1/import/feature', payload, headers)
+          end
+
+          # Export Xray test scenarios to a zip file via API
+          # @param keys [String] test scenarios
+          # @param filter [String] project filter
+          # @see https://confluence.xpand-it.com/display/XRAYCLOUD/Exporting+Cucumber+Tests+-+REST
+          def export_test_scenarios(keys, filter)
+            params          = {
+              keys: keys,
+            }
+            params[:filter] = filter unless filter == 'nil'
+
+            headers = auth_token.merge(params: params)
+
+            log.info "Exporting features from: #{default_cloud_api_url}/api/v1/export/cucumber"
+            rsp = RestClient.get("#{default_cloud_api_url}/api/v1/export/cucumber", headers)
+
+            extract_feature_files(rsp)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qat/reporter/xray/publisher/hosted.rb

@@ -0,0 +1,56 @@
+require 'base64'
+require 'zip'
+require_relative 'base'
+
+module QAT
+  module Reporter
+    class Xray
+      module Publisher
+        # QAT::Reporter::Xray::Publisher::Hosted integrator class
+        class Hosted < Base
+
+          # Posts the execution json results in Xray
+          # @param results [String] Execution results
+          def send_execution_results(results)
+            Client.new(base_url).post('/rest/raven/1.0/import/execution', results.to_json, default_headers)
+          end
+
+          # Import Cucumber features files as a zip file via API
+          # @param project_key [String] JIRA's project key
+          # @param file_path [String]  Cucumber features files' zip file
+          # @see https://confluence.xpand-it.com/display/public/XRAY/Importing+Cucumber+Tests+-+REST
+          def import_cucumber_tests(project_key, file_path)
+            headers = default_headers.merge({
+                                              multipart: true,
+                                              params:    {
+                                                projectKey: project_key
+                                              }
+                                            })
+            payload = { file: File.new(file_path, 'rb') }
+
+            Client.new(base_url).post('/rest/raven/1.0/import/feature', payload, headers)
+          end
+
+          # Export Xray test scenarios to a zip file via API
+          # @param keys [String] test scenarios
+          # @param filter [String] project filter
+          # @see https://confluence.xpand-it.com/display/public/XRAY/Exporting+Cucumber+Tests+-+REST
+          def export_test_scenarios(keys, filter)
+            params          = {
+              keys: keys,
+              fz:   true
+            }
+
+            params[:filter] = filter unless filter == 'nil'
+
+            headers = default_headers.merge(params: params)
+
+            rsp = RestClient.get("#{base_url}/rest/raven/1.0/export/test", headers)
+
+            extract_feature_files(rsp)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qat/reporter/xray/publisher.rb

@@ -0,0 +1,3 @@
+require_relative 'publisher/base'
+require_relative 'publisher/cloud'
+require_relative 'publisher/hosted'

data/lib/qat/reporter/xray/tasks/tests/helpers.rb

@@ -0,0 +1,112 @@
+module QAT
+  module Reporter
+    class Xray
+      # namespace for test ids utility methods and objects
+      module Tests
+        # helper methods for test id manipulation
+        module Helpers
+          # Tags all untagged scenarios present in the test id report
+          #@param report [Tests::Report] test id report
+          def tag_untagged(report)
+            max_test_id = report.max_id
+            untagged    = report.untagged
+
+            if untagged.any?
+              files = map_untagged(untagged)
+
+              announce_changes(files)
+
+              update_test_ids(files, max_test_id)
+            else
+              puts "There are no scenarios without test id. Last test id given was '@test##{max_test_id}'."
+            end
+          end
+
+          private
+
+          # Returns all files containing untagged scenarios and their respective scenario line
+          #@param untagged [Array] list of untagged scenarios
+          #@return [Array]
+          def map_untagged(untagged)
+            files = {}
+
+            untagged.values.each do |file_colon|
+              file, colon = file_colon.split(':')
+              files[file] ||= []
+              files[file] << colon.to_i
+            end
+
+            files
+          end
+
+          # Announces to STDOUT the files that will be changed (test ids added)
+          #@param files [Array] list of files to change
+          #@see TestIds::Helpers#map_untaged
+          def announce_changes(files)
+            puts "Giving test ids to scenarios:"
+            puts files.to_json({
+                                 indent:    ' ',
+                                 space:     ' ',
+                                 object_nl: "\n"
+                               })
+          end
+
+          # Rewrites the untagged files adding the missing test ids
+          #@param files [Array] list of files to change
+          #@param max_test_id [Integer] current max test id
+          def update_test_ids(files, max_test_id)
+            #iterate in file to give test id
+            begin
+              file_lines = []
+              files.each { |file, lines| max_test_id = rewrite_file(file, lines, max_test_id) }
+            rescue
+              path = File.join(Dir.pwd, 'public', 'test_ids_failed.feature')
+              puts "Tag attribution failed! Check '#{path}' for more information!"
+              File.write(path, file_lines.join)
+            end
+          end
+
+          # Rewrites the target file in the identified lines.
+          # Returns the max test id after the file update.
+          #@param file [String] file to rewrite
+          #@param lines [Array] lines to edit (add test id)
+          #@param max_test_id [Integer] current max test id
+          #@return [Integer]
+          def rewrite_file(file, lines, max_test_id)
+            norm_lines = lines.map { |line| line - 1 }
+            file_path  = File.join(Dir.pwd, file)
+            file_lines = File.readlines(file_path)
+
+            norm_lines.size.times do
+              line = norm_lines.shift
+              puts "Editing file #{file} @ line #{line}."
+              max_test_id = add_tags(file_lines, line, max_test_id)
+            end
+
+            File.write(file_path, file_lines.join)
+
+            max_test_id
+          end
+
+          # Adds the test id tag to the identified line to edit
+          # Returns the max test id after the file update.
+          #@param file_lines [Array] Set of file lines
+          #@param line [Integer] index of line to edit
+          #@param max_test_id [Integer] current max test id
+          #@return [Integer]
+          def add_tags(file_lines, line, max_test_id)
+            if file_lines[line - 1].match(/^\s*@\w+/)
+              file_lines[line - 1] = "  #{file_lines[line - 1].strip} @id:#{max_test_id += 1}\n"
+            else
+              file_lines[line] = "  @id:#{max_test_id += 1}\n#{file_lines[line]}"
+            end
+
+            max_test_id
+          end
+
+          extend self
+        end
+      end
+    end
+  end
+end

data/lib/qat/reporter/xray/tasks/tests/report.rb

@@ -0,0 +1,47 @@
+require_relative 'helpers'
+
+module QAT
+  module Reporter
+    class Xray
+      # namespace for test ids utility methods and objects
+      module Tests
+        # the test id report wrapper
+        class Report
+          include Helpers
+
+          attr_reader :path, :content
+
+          def initialize(path)
+            @path    = path
+            @content = JSON.parse(File.read(path))
+          end
+
+          # Returns the report max test id
+          def max_id
+            @max_id ||= @content['max']
+          end
+
+          # Returns the report untagged tests information
+          def untagged
+            @untagged ||= @content['untagged']
+          end
+
+          # Returns the report test id mapping to scenarios information
+          def mapping
+            @mapping ||= @content['mapping']
+          end
+
+          # Returns the report duplicate test id information
+          def duplicate
+            @duplicate ||= @content['duplicate']
+          end
+
+          # Tags all untagged scenario with a test id
+          def tag_untagged!
+            tag_untagged(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qat/reporter/xray/tasks/tests.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env rake
+#encoding: utf-8
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rake/testtask'
+require 'json'
+require 'fileutils'
+require 'awesome_print'
+require 'fileutils'
+require 'active_support/core_ext/string/inflections'
+require_relative '../../../formatter/xray/test_ids'
+require_relative 'tests/report'
+require_relative 'tests/helpers'
+
+namespace :qat do
+  namespace :reporter do
+    namespace :xray do
+      namespace :tests do
+        # Run a rake task by name
+        def run_task!(task_name)
+          begin
+            Rake::Task["qat:reporter:xray:tests:#{task_name}"].invoke
+          rescue SystemExit => exception
+            exitstatus = exception.status
+            @kernel.exit(exitstatus) unless exitstatus == 0
+          end
+        end
+
+        desc 'Generates the test id report in JSON'
+        task :report_test_ids do
+          FileUtils.mkdir('public') unless File.exists?(File.join(Dir.pwd, 'public'))
+          ENV['CUCUMBER_OPTS'] = nil
+          Cucumber::Rake::Task.new('test_ids', 'Generates test ids as tags for tests without test id') do |task|
+            task.bundler       = false
+            task.fork          = false
+            task.cucumber_opts = ['--no-profile',
+                                  '--dry-run',
+                                  '--format', 'QAT::Formatter::Xray::TestIds',
+                                  '--out', 'public/xray_test_ids.json']
+          end.runner.run
+        end
+
+        desc 'Validates the existing test ids and checks for duplicates'
+        task :validate_test_ids do
+          run_task!('report_test_ids')
+          #read json file
+          file_path = File.realpath(File.join(Dir.pwd, 'public', 'xray_test_ids.json'))
+          report    = QAT::Reporter::Xray::Tests::Report.new(file_path)
+
+          exit(1) if report.duplicate.any?
+        end
+
+        desc 'Generates test ids as tags for tests without test id'
+        task :generate_test_ids do
+          run_task!('report_test_ids')
+          #read json file
+          file_path = File.realpath(File.join(Dir.pwd, 'public', 'xray_test_ids.json'))
+          report    = QAT::Reporter::Xray::Tests::Report.new(file_path)
+
+          report.tag_untagged!
+        end
+
+        desc 'Generate features zip file to import in Xray'
+        task :zip_features do
+          require 'zip'
+
+          file_mask     = File.join('features', '**', '*.feature')
+          feature_files = Dir.glob(file_mask)
+          puts feature_files
+
+          zipfile_name = 'features.zip'
+
+          FileUtils.rm_f(zipfile_name) if File.exists?(zipfile_name)
+
+          Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+            feature_files.each do |file|
+              zipfile.add(file, file)
+            end
+          end
+        end
+
+        # Validates the import task arguments
+        def validate_import_args(args)
+          [:xray_username, :jira_url, :jira_type, :project_key].each do |key|
+            raise ArgumentError.new "No #{key.to_s.humanize} was provided" unless args[key]
+          end
+        end
+
+        desc 'Import Cucumber tests to Xray'
+        task :import_features, [:xray_username, :jira_url, :jira_type, :project_key, :file_path] do |_, args|
+          run_task!('generate_test_ids')
+          run_task!('zip_features')
+
+          require 'qat/reporter/xray'
+
+          file_path = args.delete(:file_path) || 'features.zip'
+
+          validate_import_args(args)
+          project_key = args[:project_key] or raise ArgumentError.new 'No project key was provided'
+          login_credentials = [args[:xray_username], ENV['JIRA_PASSWORD']] or raise ArgumentError.new 'No login credentials were provided'
+          jira_type = args[:jira_type] or raise ArgumentError.new 'No jira type key was provided'
+          jira_url = args[:jira_url] or raise ArgumentError.new 'No jira url key was provided'
+
+          QAT::Reporter::Xray.configure do |c|
+            c.project_key                = project_key
+            c.login_credentials          = login_credentials
+            c.cloud_xray_api_credentials = login_credentials if jira_type.eql? 'cloud'
+            c.jira_type                  = jira_type
+            c.jira_url                   = jira_url
+          end
+
+          QAT::Reporter::Xray::Config.publisher.import_cucumber_tests(project_key, file_path)
+        end
+
+        desc 'Export Xray test scenarios '
+        task :export_xray_test_scenarios, [:xray_username, :jira_url, :jira_type, :project_key, :keys, :filter] do |_, args|
+
+          require 'qat/reporter/xray'
+
+          project_key = args[:project_key] or raise ArgumentError.new 'No project key was provided'
+          login_credentials = [args[:xray_username], ENV['JIRA_PASSWORD']] or raise ArgumentError.new 'No login credentials were provided'
+          jira_type = args[:jira_type] or raise ArgumentError.new 'No jira type was provided'
+          jira_url = args[:jira_url] or raise ArgumentError.new 'No jira url was provided'
+          xray_export_test_filter = args[:filter] or raise ArgumentError.new 'No filter key was provided'
+          xray_export_test_keys = args[:keys] or raise ArgumentError.new 'No test issue key was provided'
+
+          QAT::Reporter::Xray.configure do |c|
+            c.project_key                = project_key
+            c.login_credentials          = login_credentials
+            c.cloud_xray_api_credentials = login_credentials if jira_type.eql? 'cloud'
+            c.jira_type                  = jira_type
+            c.jira_url                   = jira_url
+            c.xray_export_test_filter    = xray_export_test_filter
+            c.xray_export_test_keys      = xray_export_test_keys
+          end
+
+          QAT::Reporter::Xray::Config.publisher.export_test_scenarios(xray_export_test_keys, xray_export_test_filter)
+        end
+      end
+    end
+  end
+end

data/lib/qat/reporter/xray/tasks.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env rake
+#encoding: utf-8
+#@version 1.0
+require_relative '../../cucumber/core_ext/result'
+require_relative 'tasks/tests'