tms-cli 0.0.pre.beta

data/lib/preprocessing.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require_relative 'testrail/testrail'
+require_relative 'testrail/milestone'
+require_relative 'testrail/testcase'
+require_relative 'testrail/testrun'
+require_relative 'testrail/dataprep'
+require_relative 'testrail/testsuite'
+require_relative 'testrail/report'
+require_relative 'testrail/cleanup'
+require_relative 'testrail/attachment'
+require_relative 'testrail/log'
+require_relative 'testrail/results'
+require_relative 'testrail/sections'
+require_relative 'testrail/testbdd.rb'
+
+require_relative 'import/importflutter'
+require_relative 'import/importgolang'
+require_relative 'import/importjest'
+require_relative 'import/importrspec'
+require_relative 'import/importjunit'
+require_relative 'import/importcucumber'
+require_relative 'import/importfeature'
+
+require_relative 'db/mysql'
+require_relative '../util/script/generatereport'
+
+require 'json'
+require 'fileutils'
+require 'dotenv'
+require 'colorize'
+require 'open-uri'
+require 'mysql2'
+require 'thor'
+require 'highline'
+require 'gitlab'
+
+module Tms
+  module Preprocessing
+    module_function
+
+    include Dataprep
+    include Milestone
+    include Testcase
+    include Testrun
+    include Testsuite
+    include Report
+    include Log
+    include Sections
+    
+    include Flutter
+    include Golang
+    include Jest
+    include Rspec
+    include JUnit
+    include Cucumber
+    include Cleanup
+    include Attachment
+    include GenerateReport
+
+    # variable to store Run ID of current tests
+    @@run_id = ''
+
+    # This method will process json report and put the result into testrail
+    def execute_preprocessing(report_file, milestone_name, attachment_dir, runner_type)
+      puts 'Execute preprocessing, NOT handle TEST ID'
+      client = Dataprep.client_tr
+      file_name = report_file.size > 1 ? File.basename(report_file[0])[0...-7].concat(".json") : File.basename(report_file[0])
+      tr_version = Dataprep.testrail_version(client, ENV['TR_BASEURL'])
+      project_id = Dataprep.project_id_by_report_file(client, file_name, tr_version)
+      puts "PROJECT ID : #{project_id}"
+      section_name = Dataprep.section_name(file_name)
+      puts "SECTION NAME : #{section_name}"
+      env = Dataprep.test_env(file_name)
+      platform_name = Dataprep.platform_name(file_name)
+      suite_id = Testsuite.testsuite_id(client, project_id, "master")[0]['id']
+      puts "SUITE ID : #{suite_id}"
+      raise "Error suite id not found" if suite_id.nil?
+      section_id = Dataprep.section_id(client, project_id, suite_id, section_name, tr_version)
+      puts "SECTION ID : #{section_id}"
+      
+      # handle legacy cli without runner type parameter
+      if runner_type.eql? ''
+        # read json runner type for legacy
+        runner_type_file = if ENV['CI']
+                            File.read('/testrail/runner_type.json')
+                          else
+                            File.read('./runner_type.json')
+                          end 
+        runner_type_data = JSON.parse(runner_type_file)
+
+        filtererd_runner_type_data = runner_type_data.find do |obj|
+          obj['project_id'] == project_id && obj['test_type'].casecmp?(section_name)
+        end
+        raise 'No runner found with project and test type' if filtererd_runner_type_data.nil?
+
+        runner_type = filtererd_runner_type_data['runner']
+      end
+
+      @@cases = Testcase.get_cases(client, project_id, suite_id, section_id, offset = 0)
+
+      report_file.each do |report|
+        puts "Start #{report}"
+        file = File.read("#{report}")
+        data_hash = JSON.parse(file) unless report.include? ".xml"
+
+        case runner_type
+        when 'rspec'
+          Rspec.import_data(client, project_id, suite_id, section_id, data_hash, tr_version)
+        when 'dart'
+          Flutter.import_data(client, project_id, suite_id, section_id, data_hash, tr_version)
+        when 'jest'
+          Jest.import_data(client, project_id, suite_id, section_id, data_hash, tr_version)
+        when 'go'
+          Golang.import_data(client, project_id, suite_id, section_id, data_hash, tr_version)
+        when 'junit'
+          JUnit.import_data(client, project_id, suite_id, section_id, report, tr_version)
+        when 'cucumber'
+          Cucumber.import_data(client, project_id, suite_id, section_id, data_hash, tr_version)
+        else
+          abort("invalid runner type - #{runner_type}")
+        end
+      end
+
+      tc_ids = Testcase.test_ids
+      test_results = Testcase.test_results
+      milestone_id = Milestone.milestone_id(client, project_id, milestone_name, tr_version)
+      puts "Updating milestone #{milestone_name} with ID #{milestone_id}..."
+      list_platform = ['dweb', 'mweb', 'api', 'android', 'ios']
+      if list_platform.include?(platform_name.downcase)
+        run_id = Testrun.testrun_id(client, project_id, suite_id, milestone_id, section_id, section_name, tc_ids, env, platform_name)
+      else
+        run_id = Testrun.testrun_id(client, project_id, suite_id, milestone_id, section_id, section_name, tc_ids, env, platform_name='')
+      end
+
+      Report.post(client, test_results, run_id)
+      # remove to prevent milestone is not show when create tc
+      # Milestone.completed_old_milestone(client, project_id)
+
+      unless attachment_dir.eql?('')
+        puts 'attach files to test cases result...'
+        result_ids = {}
+        Report.results(client, run_id).each { |result| result_ids.store("#{result['test_id']}".to_sym, "#{result['id']}") }
+        Testrun.test_ids(client, run_id).each do |data|
+          refs = data['refs'].nil? ? '' : data['refs']
+          title = data['title'].gsub(':', '').gsub('\'','').gsub(' ', '_')
+          folder_path = attachment_dir.to_s.tr('*', '')
+          Dir["#{attachment_dir}"].select do |file|
+            if File.basename(file).include?(title) && File.basename(file).include?(refs)
+              begin
+                temp_file = folder_path + refs.to_s + "_" + title.to_s + File.extname(file)
+                File.rename(file, temp_file)
+                Attachment.attach_file(client, result_ids[data['id'].to_s.to_sym], temp_file)
+                puts "#{temp_file} uploaded successfully"
+              rescue => e
+                puts "#{temp_file} not uploaded"
+                puts e.message
+              end
+            end
+          end
+        end
+      end
+
+      Testrun.close_test_run(client, run_id)
+      Milestone.completed_milestone(client, milestone_id)
+    end
+
+    def execute_preprocessing_bdd(report_file, suite_name, section_name)
+      puts 'Execute preprocessing BDD automation results, handle TEST ID'
+      client = Dataprep.client_tr
+      file_name = report_file.size > 1 ? File.basename(report_file[0])[0...-7].concat(".json") : File.basename(report_file[0])
+      tr_version = Dataprep.testrail_version(client, ENV['TR_BASEURL'])
+      project_id = Dataprep.project_id_by_report_file(client, file_name, tr_version)
+      puts "PROJECT ID : #{project_id}"
+      env = Dataprep.test_env(file_name)
+      puts "PLATFORM/SUITE NAME : #{suite_name}"
+      suite_id = Testsuite.testsuite_id(client, project_id, suite_name)[0]['id']
+      puts "SUITE ID : #{suite_id}"
+      raise "Error suite id not found" if suite_id.nil?
+      section_id = Dataprep.section_id(client, project_id, suite_id, section_name, tr_version)
+      puts "SECTION ID : #{section_id}"
+
+      report_file.each do |report|
+        puts "Start #{report}"
+        file = File.read("#{report}")
+        data_hash = JSON.parse(file) unless report.include? ".xml"
+
+        Cucumber.import_data_bdd(client, project_id, suite_id, section_id, data_hash, tr_version)
+      end
+
+      test_type = ENV['TESTRAIL_TEST_TYPE']
+      milestone_id = ENV["TESTRAIL_#{test_type}_MILESTONE_ID"]
+      run_id = ENV["TESTRAIL_#{test_type}_RUN_ID"]
+      puts "Test Type: #{test_type}"
+
+      unless test_type.downcase.eql? 'regression'
+        unless milestone_id.nil? || milestone_id.empty?
+          state = Milestone.get_milestone_state(client, milestone_id)
+          unless state == true
+            Milestone.completed_milestone(client, milestone_id)
+          end
+        end
+
+        unless run_id.nil? || run_id.empty?
+          Testrun.close_test_run(client, run_id)
+        end
+      end
+    end
+
+    # This method will clean up refs on testrail
+    def execute_clean_testcase(project_id)
+      client = Dataprep.client_tr
+      Cleanup.cleanup_tc(client, project_id)
+    end
+
+    # This method will generate traceability metric and coverage report
+    def execute_generate_report(project_name, milestone_name)
+      client = Dataprep.client_tr
+      tr_version = Dataprep.testrail_version(client, ENV['TR_BASEURL'])
+      project_id = Dataprep.project_id_by_name(client, project_name, tr_version)
+      GenerateReport.generate(project_id, milestone_name)
+    end
+
+    # This method will capture test report of current milestone
+    def execute_capture_result(project_name, milestone_name)
+      client = Dataprep.client_tr
+      tr_version = Dataprep.testrail_version(client, ENV['TR_BASEURL'])
+      project_id = Dataprep.project_id_by_name(client, project_name, tr_version)
+      milestone_id = Milestone.get_milestone_id(client, project_id, milestone_name)
+      
+      @@run_id = Testrun.testrun_id_by_milestone(client, project_id, milestone_id)
+      GenerateReport.capture_dashboard(project_id, milestone_name)
+    end
+
+    # This method will delete milestone for merge request test
+    def delete_milestones_runs(project_name, milestone_name)
+      client = Dataprep.client_tr
+      tr_version = Dataprep.testrail_version(client, ENV['TR_BASEURL'])
+      project_id = Dataprep.project_id_by_name(client, project_name, tr_version)
+      milestone_id = Milestone.get_milestone_id(client, project_id, milestone_name)
+      Milestone.delete_milestone(client, milestone_id)
+      
+      # Delete test runs associated to the milestone
+      run_ids = @@run_id.map { |run| run["id"] }
+
+      unless run_ids.nil?
+        run_ids.each do |run_id|
+          Testrun.delete_testrun(client, run_id)
+        end
+      end
+      puts "Milestone #{milestone_name} and #{@@run_id.size} associated test runs are deleted!"
+    end
+
+    # Returns Run ID of current tests (by provide Project ID and Milestone ID), the enable next funciton to get what test type included (ex: UT, E2E)
+    def run_id
+      @@run_id
+    end
+
+    # This method will delete all cases from desired section
+    def delete_cases_from_section(suite_id, group_name, limit)
+      client = Dataprep.client_tr
+
+      # find cases from a section
+      suite = Testsuite.suite_id(client, suite_id)
+      project_id = suite['project_id']
+      suite_sections = Sections.get_sections(client, project_id, suite_id)
+      section = suite_sections['sections'].find { |section| section['name'].downcase.eql? group_name }
+      raise "no group name found" if section.nil?
+
+      # get all existing test cases and delete it with pagination
+      puts 'Retrieving cases from Testrail...'
+      puts "Deleting in batch with limit = #{limit}\n"
+      page = 0
+      loop do 
+        page += 1
+        get_cases = Testcase.get_cases(client, project_id, suite_id, section['id'], offset = 0)
+        case_ids = get_cases.map { |case_object| case_object['id']}
+        puts "deleting cases for page: #{page}"
+        delete_cases = Testcase.delete_cases_from_suite(client, suite_id, case_ids)
+        puts "cases deleted #{case_ids.to_s}"
+
+        break if get_cases['_links']['next'].nil?
+
+        sleep(5)
+      end
+    end
+
+    # This method will upload feature to testrail
+    def upload_feature(dir)
+      # Filter out entries that are not files (directories, ".", and "..")
+      work_dir = Dir.entries(dir).reject { |entry| File.directory?(File.join(dir, entry)) || entry == '.' || entry == '..' }
+      files_to_upload = []
+
+      work_dir.each do |file_name|
+        if file_name.end_with?('.feature')
+          puts "Processing file #{file_name}"
+          client = Dataprep.client_tr
+          file_path =  File.join(dir, file_name)
+
+          # Handle creation new test cases
+          if file_name.include?('_')
+            parts = file_name.split('_')
+            project_name = parts[0].gsub("-", " ")
+            suite_name = parts[1] + " Automation"
+            group_name = parts[2].sub('.feature', '')
+
+            project_id = Cucumber.search_project(client, project_name)
+            suite_id = Cucumber.search_suite(client, project_id, suite_name)
+            section_list = Sections.get_sections(client, project_id, suite_id)
+            section_id = section_list['sections'].find { |section| section['name'].downcase.eql? group_name }['id']
+            
+            # Handle post body that contains json
+            if File.read(file_path).include? ('"""')
+              Feature.add_case(client, section_id, file_path)
+            else
+              Testbdd.add_bdd(client, section_id, file_path)
+            end
+
+            files_to_upload << file_name
+          else 
+            # Handle updating existing test cases
+            case_id = file_name.sub('.feature', '')
+            Feature.update_bdd(client, case_id, file_path)
+            files_to_upload << file_name
+          end
+        
+          # log separator for each file
+          puts "----------------------------"
+        end
+      end
+      puts "Successfully processed #{files_to_upload.length} feature files"
+    end
+  end
+end

data/lib/regression.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative 'testrail/testrail'
+require_relative 'testrail/milestone'
+require_relative 'testrail/testcase'
+require_relative 'testrail/testrun'
+require_relative 'testrail/dataprep'
+require_relative 'testrail/testsuite'
+require_relative 'testrail/testplan'
+require_relative 'testrail/sections'
+require_relative 'testrail/log'
+
+
+module Tms
+  module Regression
+    module_function
+
+    include Dataprep
+    include Milestone
+    include Testcase
+    include Testrun
+    include Testsuite
+    include Testplan
+    include Sections
+    include Log
+  
+    # Preparation for regression:
+    # creating milestone, test plans, and test runs 
+    # @param app name. ex: android_marketplace
+    # @param version name. ex: v16.8
+    def execute_regression_prep(app_name, version_name)
+      # getting app name
+      @platform, @app_name = app_name.split('_')
+
+      project_id = get_app_project_id(app_name)
+      client = Dataprep.client_tr
+
+      main_version = version_name.match(/^v\d+\.\d+/)[0]
+      milestone_name = "#{@platform} #{@app_name} #{main_version}"
+      puts "Creating milestone regression for #{milestone_name}"
+
+      milestone = create_regression_milestone(client, project_id, milestone_name)
+      test_plans = create_squad_test_plan(client, project_id, milestone, main_version)
+      puts generate_json_output(app_name, main_version, test_plans)
+    end
+
+    # Returns project id for the app project
+    # @param app name. ex: android_marketplace
+    def get_app_project_id(app_name)
+      project_id = if app_name.include? 'android'
+                    ENV['TR_ANDROID_PROJECT_ID']
+                   elsif app_name.include? 'ios'
+                    ENV['TR_IOS_PROJECT_ID']
+                   else
+                    raise 'Incorrect app name!'
+                   end
+      return project_id
+    end
+
+    # Create a new milestone for regresion
+    # @param client testrail
+    # @param project id
+    # @param version name
+    def create_regression_milestone(client, project_id, version_name)
+      # check if the same milstone is already created
+      response = Milestone.get_milestones(client, project_id)
+      same_milestone = response.select { |milestone| milestone['name'].include? version_name }
+
+      if !same_milestone.eql? []
+        puts "Same milestone is exist. Skipping regression preparation..."
+        exit 1
+      end
+
+      response = Milestone.create_milestone(client, project_id, version_name)
+      puts "Milestone " + version_name + " Created!"
+      return response
+    end
+
+    # Create squads test plans and its test runs for regression
+    # @param client testrail
+    # @param project id
+    # @param version name
+    def create_squad_test_plan(client, project_id, milestone_id, version_name)
+      suites = Testsuite.suites(client, project_id)
+      test_plans = []
+      suites.each do |squad|  
+        sections = Sections.get_sections(client, project_id, squad['id'])
+        test_runs = generate_test_run_titles(sections['sections'])
+        puts "\nCreating test runs for #{squad['name']}..."
+        test_runs.each_with_index do |data, index|
+          puts "#{index + 1}. ID: #{data[:id]}, Title: #{data[:title]}"
+        end
+        runs = test_runs.map do |test_run|
+          cases = Testcase.get_cases(client, project_id, squad['id'], test_run[:id])
+          next if cases.eql? []
+          {
+            name: "#{squad['name']} #{test_run[:title]} #{version_name}",
+            suite_id: squad['id'],
+            include_all: false,
+            case_ids: cases.map { |c| c['id'] }
+          }
+        end.compact
+
+        payload = {
+          name: "#{squad['name']} Regression #{@app_name} #{version_name}",
+          milestone_id: milestone_id,
+          entries: runs
+        }
+        test_plans << Testplan.create_testplan(client, project_id, payload) unless payload[:entries].eql? []
+      end
+      return test_plans
+    end
+
+    # Generate test runs titles based on suite sections
+    # @param array of sections
+    def generate_test_run_titles(test_sections)
+      test_runs = []
+      test_sections.each do |section|
+        if !test_sections.any? { |s| s['parent_id'] == section['id'] }
+          parent_ids = []
+          parent_id = section['parent_id']
+          while parent_id
+            parent_ids << parent_id
+            parent_id = test_sections.find { |s| s['id'] == parent_id }['parent_id']
+          end
+          test_run = parent_ids.reverse.map { |id| test_sections.find { |s| s['id'] == id }['name'] }.join(' ')
+          test_run = "#{test_run} #{section['name']}"
+          test_runs << { id: section['id'], title: test_run } if test_run.downcase.include? @app_name
+        end
+      end
+      test_runs
+    end
+
+    # Generate json result of test runs creation
+    # @param array of test plans
+    def generate_json_output(app_name, version_name, test_plans)
+      squads_test_plans = test_plans.map do |test_plan|
+        {
+          squad: test_plan['name'].split(" ").first,
+          test_runs: test_plan['entries'].map do |entry|
+            {
+              id: (entry['runs'][0])['id'],
+              name: (entry['runs'][0])['name'],
+              url: (entry['runs'][0])['url'],
+            }
+          end
+        }
+      end
+
+      regression_output = {
+        app: app_name,
+        version: version_name,
+        test_plans: squads_test_plans,
+      }
+
+      json_data = JSON.pretty_generate(regression_output)
+      folder_path = 'output'
+      file_name = 'output_regression.json'
+      file_path = File.join(folder_path, file_name)
+      
+      FileUtils.mkdir_p(folder_path) # Create the folder if it doesn't exist
+      File.write(file_path, json_data)
+
+      puts "\nOutput JSON file created at #{file_path}"
+    end
+
+
+    # Returns latest automation test runs for regression
+    # @param app name
+    # @param squad name
+    # @param environment name
+    def get_latest_automation_run(app_name, squad_name, environment_name, custom_section)
+      client = Dataprep.client_tr
+      
+      # get app project id 
+      project_id = get_app_project_id(app_name)
+      app = app_name.split('_')[1]
+      puts app
+
+      # get test plan from 2 months earlier
+      two_months_before = Dataprep.get_timestamp_prev_month(2)    
+      filter = "created_after=#{two_months_before}"
+      plans = Testplan.get_plans(client, project_id, filter)
+      
+      # get test plan from latest version and squad name
+      app_version = get_latest_version(app_name)
+      puts 'App version: ' + app_version
+      test_plan_name="#{app} #{app_version}"
+      plans_version = plans.select { |plan| plan['name'].include? test_plan_name }
+      squad_plan = plans_version.find { |plan| plan['name'].downcase.include? squad_name }
+      if !squad_plan.nil?
+        puts 'Found squad plan id: ' + squad_plan['id'].to_s
+        puts squad_plan['name']  
+      else
+        raise 'Squad plan not found!'
+      end
+
+      plan = Testplan.get_plan(client, squad_plan['id'])
+      # get automation test run
+      custom_section = custom_section.gsub('/', ' ')
+      automation_run = plan['entries'].find { |run| run['name'].downcase.include? "automation #{environment_name.downcase} #{custom_section.downcase}"}
+      if !automation_run.nil?
+        puts 'Found squad automation run id: ' + automation_run['id'].to_s
+        puts automation_run['name']  
+      else
+        raise "No Automation Runs Found for: automation #{environment_name} #{custom_section}"
+      end
+
+      return automation_run['runs'].first['id']
+    end
+
+    # get latest version from env
+    def get_latest_version(app_name)
+      case app_name
+      when 'android_marketplace'
+        ENV['ANDROID_MARKETPLACE_REGRESSION_VERSION']
+      when 'android_mitra'
+        ENV['ANDROID_MITRA_REGRESSION_VERSION']
+      when 'android_mitra-b2b'
+        ENV['ANDROID_MITRAB2B_REGRESSION_VERSION']
+      when 'android_bmoney'
+        ENV['ANDROID_BMONEY_REGRESSION_VERSION']
+      when 'ios_marketplace'
+        ENV['IOS_MARKETPLACE_REGRESSION_VERSION']
+      when 'ios_bmoney'
+        ENV['IOS_BMONEY_REGRESSION_VERSION']
+      else
+        raise 'No app found'
+      end
+    end
+  end
+end

data/lib/testrail/attachment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative './testrail'
+
+module Tms
+  module Attachment
+    module_function
+
+    # This method will put file to test result
+    # @param client testrail
+    # @param result_id is test result id get from test run
+    # @param file image or video
+    def attach_file(client, result_id, file)
+      client.send_post("add_attachment_to_result/#{result_id}", file)
+    end
+  end
+end

data/lib/testrail/cleanup.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative './testrail'
+
+module Tms
+  module Cleanup
+    module_function
+
+    # This method will clean invalid reference on testcase
+    # @param client testrail
+    # @param project id
+    def cleanup_tc(client, project_id)
+      suite_id = suite_id(client, project_id)
+      cases = set_cases(client, project_id, suite_id)
+      validate_reff(client, cases)
+    end
+  
+    # This method will get suite id
+    # @param client testrail
+    # @param project id
+    def suite_id(client, project_id)
+      response = client.send_get("get_suites/#{project_id}")
+      response.empty? ? nil : response[0]['id']
+    end
+  
+    # This method will get all test case based on project id and suite id
+    # @param client testrail
+    # @param project id
+    # @param suite id
+    def set_cases(client, project_id, suite_id)
+      client.send_get("get_cases/#{project_id}&suite_id=#{suite_id}")
+    end
+  
+    # This method will set reference into '' on test case
+    # @param client testrail
+    # @param test case id
+    def update_case_clean_refs(client, tc_id)
+      payload = { refs: '' }
+      client.send_post("update_case/#{tc_id}", payload)
+    end
+  
+    # This method will validate the reference is valid format story id and then update when is invalid
+    # @param client testrail
+    # @param cases
+    def validate_reff(client, cases)
+      cases.each do |tcase|
+        next if tcase['refs'].to_s.eql?('')
+  
+        tcase['refs'].split(',').each do |ref|
+          update_case_clean_refs(client, tcase['id']) unless valid_refs(ref)
+        end
+      end
+    end
+  
+    # This method will validate the reference is valid format story id
+    # @param client testrail
+    # @return
+    def valid_refs(refs)
+      refs.include?('-') && 
+        refs.split('-').size.eql?(2) && 
+        (refs.split('-')[1] =~ /[^0-9]/).nil?
+    end
+  end
+end