qat-reporter-xray-sa 1.0.0

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

@@ -0,0 +1,142 @@
+require_relative 'publisher'
+
+module QAT
+  module Reporter
+    class Xray
+      # QAT::Reporter::Xray configuration module
+      module Config
+        class << self
+
+          attr_accessor :project_key, :jira_url, :xray_default_api_url, :login_credentials, :publisher, :jira_type,
+                        :cloud_xray_api_credentials, :xray_test_environment, :xray_test_version, :xray_test_revision, :xray_export_test_keys, :xray_export_test_filter
+
+          # Default xray API url (Jira Cloud)
+          DEFAULT_XRAY_URL = 'https://xray.cloud.getxray.app'
+
+          # Returns the xray instanced type (hosted or cloud)
+          def jira_type
+            @jira_type
+          end
+
+          # Returns the jira url
+          def jira_url
+            @jira_url
+          end
+
+          # Returns the default xray jira url for cloud api
+          def xray_default_api_url
+            DEFAULT_XRAY_URL
+          end
+
+          # Returns the login credentials array could -> [username, password, apiToken]
+          def login_credentials
+            @login_credentials
+          end
+
+          # Returns the login credentials array for cloud api [client_id, client_secret]
+          def cloud_xray_api_credentials
+            @cloud_xray_api_credentials || nil
+          end
+
+          # Returns the test keys to export
+          def xray_export_test_keys
+            @keys || nil
+          end
+
+          # Returns the test filter to export
+          def xray_export_test_filter
+            @filter || nil
+          end
+
+          # Returns the project key value
+          def project_key
+            @project_key
+          end
+
+          # Returns the xray test environment value
+          def xray_test_environment
+            @xray_test_environment || get_env_from_qat_config
+          end
+
+          # Returns the xray test version value
+          def xray_test_version
+            @xray_test_version || get_version_from_qat_config
+          end
+
+          # Returns the xray test revision value
+          def xray_test_revision
+            @xray_test_revision || get_revision_from_qat_config
+          end
+
+          def publisher=(publisher)
+            @publisher = publisher
+          end
+
+          def publisher
+            @publisher
+          end
+
+
+          private
+
+          def get_env_from_qat_config
+            begin
+              QAT.configuration.dig(:xray, :environment_name)
+            rescue ArgumentError
+              raise(NoEnvironmentDefined, 'JIRA\'s environment must be defined!')
+            end
+          end
+
+          def get_version_from_qat_config
+            begin
+              QAT.configuration.dig(:xray, :version)
+            rescue ArgumentError
+              raise(NoVersionDefined, 'JIRA\'s version must be defined!')
+            end
+          end
+
+          def get_revision_from_qat_config
+            begin
+              QAT.configuration.dig(:xray, :revision)
+            rescue ArgumentError
+              raise(NoRevisionDefined, 'JIRA\'s revision must be defined!')
+            end
+          end
+
+          # Error returned when the QAT project has not defined the Jira Environment
+          class NoEnvironmentDefined < StandardError
+          end
+          # Error returned when the QAT project has not defined the Jira Version
+          class NoVersionDefined < StandardError
+          end
+          # Error returned when the QAT project has not defined the Jira Revision
+          class NoRevisionDefined < StandardError
+          end
+        end
+      end
+
+      class << self
+        # Configures the QAT::Formatter::Xray
+        def configure(&block)
+          yield Config
+
+          QAT::Reporter::Xray::Config.publisher = QAT::Reporter::Xray::Publisher.const_get(QAT::Reporter::Xray::Config.jira_type.capitalize).new
+          
+          raise(LoginCredentialsUndefinedError, 'JIRA\'s login credentials must be defined!') unless QAT::Reporter::Xray::Config.login_credentials
+          raise(PublisherUndefinedError, 'XRAY\'s publisher is not defined!') unless QAT::Reporter::Xray::Config.publisher.present?
+          return QAT::Reporter::Xray::Config.publisher
+        end
+
+        # Error returned when the the JIRA project key is not defined
+        class ProjectKeyUndefinedError < StandardError
+        end
+        # Error returned when the the JIRA login credentials is not defined
+        class LoginCredentialsUndefinedError < StandardError
+        end
+        # Error returned when not publisher was defined
+        class PublisherUndefinedError < StandardError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'rest-client'
+require 'json'
+
+module QAT
+  module Reporter
+    class Xray
+      # QAT::Reporter::Xray::Issue represents an abstract Xray issue
+      class Issue
+
+        attr_reader :jira_id
+
+        # Initializes Xray Publisher url and login information
+        def initialize(jira_id = nil)
+          @jira_id = jira_id
+          if jira_id
+            raise(InvalidIssueType, "The given issue '#{jira_id}' type does not correspond!") unless valid_test_execution?
+          end
+        end
+
+        # Creates a issue
+        def create(data)
+          QAT::Reporter::Xray::Config.publisher.create_issue(data)
+        end
+
+        # Error returned when the the JIRA Issue does not correspond
+        class InvalidIssueType < StandardError
+        end
+        # Error returned when publisher string is not known
+        class PublisherNotKnownError < StandardError
+        end
+
+        private
+
+        def valid_test_execution?
+          base     = Publisher::Base.new
+          response = JSON.parse(Publisher::Base::Client.new(base.base_url).get("/rest/api/2/issue/#{jira_id}", base.default_headers))
+          if response.dig('fields', 'issuetype', 'name').eql? 'Test Execution'
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,198 @@
+require 'rest-client'
+require 'json'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
+
+module QAT
+	module Reporter
+		class Xray
+			# QAT::Reporter::Xray::Publisher integrator module
+			module Publisher
+				# QAT::Reporter::Xray::Publisher::Base integrator class
+				class Base
+					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
+					
+					# REST Base Client implementation
+					class Client
+						
+						# 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
+								response
+								# 	validate response
+								# rescue RestClient::ExceptionWithResponse => e
+								# 	puts e.response
+								# 	raise NoConnectionFound.new ('Jira was not found!!!')
+								# rescue => exception
+								# 	puts "#{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)
+							puts { "#{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)
+							puts "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)
+							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|
+								puts "#{key.to_s.humanize}:"
+								puts value
+							end
+						end
+					
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,123 @@
+require_relative 'base'
+require 'zip'
+
+module QAT
+	module Reporter
+		class Xray
+			module Publisher
+				# QAT::Reporter::Xray::Publisher::Cloud integrator class
+				class Cloud < Base
+					
+					def get_jira_issue(issue_key)
+						headers = { 'Content-Type': 'application/json' }.merge(auth_headers)
+						Client.new(base_url).get("/rest/api/3/issue/#{issue_key}", headers)
+					end
+					
+					def update_jira_issue(issue_key, payload)
+						headers = { 'Content-Type': 'application/json' }.merge(auth_headers)
+						Client.new(base_url).put("/rest/api/2/issue/#{issue_key}", payload.to_json, headers)
+					end
+					
+					def get_jira_linked_issue(linked_issue_id)
+						headers = { 'Content-Type': 'application/json' }.merge(auth_headers)
+						Client.new(base_url).get("/rest/api/3/issueLink/#{linked_issue_id}", headers)
+					end
+					
+					def get_project(project_key)
+						headers = { 'Content-Type': 'application/json' }.merge(auth_headers)
+						Client.new(base_url).get("/rest/api/3/project/#{project_key}", headers)
+					end
+					
+					# Get workflow transitions of an issue
+					def get_transitions(issue_key)
+						headers = { 'Content-Type': 'application/json' }.merge(auth_headers)
+						Client.new(base_url).get("/rest/api/2/issue/#{issue_key}/transitions", headers)
+					end
+					
+					# Change transition issue
+					def transitions_issue(issue_key, payload)
+						headers = { 'Content-Type': 'application/json' }.merge(auth_headers)
+						Client.new(base_url).post("/rest/api/2/issue/#{issue_key}/transitions", payload.to_json, headers)
+					end
+					
+					# 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
+					
+					def import_cucumber_behave_tests(info, results)
+						headers = { 'Content-Type': 'multipart/form-data' }.merge(auth_token)
+						payload = {
+							info:    File.new(info, 'rb'),
+							results: File.new(results, 'rb')
+						}
+						
+						Client.new(default_cloud_api_url).post('/api/v2/import/execution/behave/multipart', payload, 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/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 = nil)
+						params          = {
+							keys: keys,
+						}
+						params[:filter] = filter if filter.present?
+						
+						headers = auth_token.merge(params: params)
+						
+						puts "Exporting features from: #{default_cloud_api_url}/api/v1/export/cucumber"
+						all_tests = RestClient.get("#{default_cloud_api_url}/api/v1/export/cucumber", headers)
+						raise(NoTestsFoundError, "No Tests found for keys: #{keys}") if all_tests.code != 200
+						all_test_keys = all_tests.body.to_s.scan(/(@TEST_\w+-\d+)/).flatten
+						(0...all_test_keys.count).to_a.map do |index|
+							{ test_issue_key: all_test_keys[index].gsub('@TEST_', '') }
+						end
+					end
+				end
+				
+				# Error returned when no tests are found
+				class NoTestsFoundError < StandardError
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,54 @@
+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 = nil)
+						params          = {
+							keys: keys,
+							fz:   true
+						}
+						
+						params[:filter] = filter if filter.present?
+						
+						headers = default_headers.merge(params: params)
+						
+						RestClient.get("#{base_url}/rest/raven/1.0/export/test", headers)
+					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