fastlane-plugin-retry_tests 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df60241959a25db457f558cb0ef71b6f53a3c4f8
-  data.tar.gz: 9c6af86f03d780aec30c117ca2e9855e8723b22d
+  metadata.gz: 365832dd6472ba1a347a30744ed61d39c9df4290
+  data.tar.gz: 6e2efd77e21cec3df9f7cd06e9a3c93754c86680
 SHA512:
-  metadata.gz: df54104e6ea929e5677fa6e5d24657ed7e6693ba327323caa0d0eb88155f32fad5bc0aa7197c56a3aeddd5af1b7ed9c9ff8c38529ddd7f4aecbc13fc9f0b2c1e
-  data.tar.gz: 7fad586dff6e97dd66889d384ab810dec364f7d7a6a308adc9b18dd086b001f40911b9e497c2779a1a6a1aee9f37687592e8813dc781e39a92fc8ae53b0dac63
+  metadata.gz: f13887c8852db136a3267e4c6723226337e0cabc617fc51b5ed2d568542fef8aa812cba646dcace661d2162bc649c8e16cbc33e752ce7b006248faaa2264d972
+  data.tar.gz: 1cdd26937449d5a2af8f001866af143876e35a83db33550aa3e4e4bfa3769885f2c259798ccfb741d47bddc35b17c8e5ba6cad076eeef89796f3c5dce6b32035

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-retry_tests
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.2.6
 platform: ruby
 authors:
 - Gloria Chow
@@ -180,20 +180,6 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- lib/fastlane/plugin/retry_tests.rb
-- lib/fastlane/plugin/retry_tests/actions/collate_junit_reports.rb
-- lib/fastlane/plugin/retry_tests/actions/multi_scan.rb
-- lib/fastlane/plugin/retry_tests/actions/suppress_tests.rb
-- lib/fastlane/plugin/retry_tests/actions/suppress_tests_from_junit.rb
-- lib/fastlane/plugin/retry_tests/actions/suppressed_tests.rb
-- lib/fastlane/plugin/retry_tests/actions/tests_from_junit.rb
-- lib/fastlane/plugin/retry_tests/actions/tests_from_xctestrun.rb
-- lib/fastlane/plugin/retry_tests/helper/correcting_scan_helper.rb
-- lib/fastlane/plugin/retry_tests/helper/junit_helper.rb
-- lib/fastlane/plugin/retry_tests/helper/reportname_helper.rb
-- lib/fastlane/plugin/retry_tests/helper/test_collector.rb
-- lib/fastlane/plugin/retry_tests/helper/xcodebuild_string.rb
-- lib/fastlane/plugin/retry_tests/version.rb
 homepage: https://github.com/kouzoh/fastlane-plugin-retry_tests
 licenses:
 - MIT

data/lib/fastlane/plugin/retry_tests.rb

@@ -1,16 +0,0 @@
-#require 'fastlane/plugin/retry_tests/version'
-
-module Fastlane
-  module TestCenter
-    # Return all .rb files inside the "actions" and "helper" directory
-    def self.all_classes
-      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
-    end
-  end
-end
-
-# By default we want to import all available actions and helpers
-# A plugin can contain any number of actions and plugins
-Fastlane::TestCenter.all_classes.each do |current|
-  require current
-end

data/lib/fastlane/plugin/retry_tests/actions/collate_junit_reports.rb

@@ -1,178 +0,0 @@
-
-require 'nokogiri'
-require 'nokogiri-plist'
-require 'FileUtils'
-module Fastlane
-  module Actions
-    class CollateJunitReportsAction < Action
-
-      def self.run(params)
-        report_filepaths = params[:reports].reverse
-        if report_filepaths.size == 1
-          FileUtils.cp(report_filepaths[0], params[:collated_report])
-        else
-          target_report = File.open(report_filepaths.shift) {|f| Nokogiri::XML(f)}
-          file_name = params[:collated_report] + "/#{params[:scheme]}.test_result/1_Test/action_TestSummaries.plist"
-          reports = report_filepaths.map { |report_filepath| Nokogiri::XML(Nokogiri::PList(open(report_filepath)).to_plist_xml) }
-          reports.each do |retry_report|
-            mergeLists(target_report, retry_report, params)
-          end
-        end
-        merge_assets(params[:assets], params[:collated_report] + "/Attachments")
-        copy_log(params[:logs], params[:collated_report] + "/")
-      end
-
-      def self.clean_report(report)
-        report = report.gsub(/<(\w+): 0x(\w+)>/, '(\1: 0x\2)')
-        report = report.gsub(/<XCAccessibilityElement:\/>0x(\w+)/, '(XCAccessibilityElement): 0x\1')
-        report
-      end
-
-      def self.copy_log(log_files, logs_folder)
-        target_log = log_files.shift
-        FileUtils.cp_r(target_log, logs_folder)
-      end
-
-      def self.mergeLists(target_report, retry_report, params)
-        retry_report = clean_report(retry_report)
-        UI.verbose("Merging retried results...")
-        Dir.mkdir(params[:collated_report]) unless File.exists?(params[:collated_report])
-        file_name = params[:collated_report] + "/action_TestSummaries.plist"
-        retried_tests = retry_report.xpath("//key[contains(.,'TestSummaryGUID')]/..")
-        current_node = retried_tests.shift
-        while (current_node != nil)
-          testName = get_test_name(current_node)
-          matching_node = target_report.at_xpath("//string[contains(.,'#{testName}')]/..")
-
-          if (!matching_node.nil?)
-            matching_node.previous.next.replace(current_node)
-            write_report_to_file(target_report, file_name)
-          end
-          current_node = retried_tests.shift
-        end
-      end
-
-      def self.merge_assets(asset_files, assets_folder)
-        UI.verbose ("Merging screenshot folders...")
-        Dir.mkdir(assets_folder) unless File.exists?(assets_folder)
-        asset_files.each do |folder|
-          FileUtils.cp_r(Dir[folder + '/*'], assets_folder)
-        end
-      end
-
-      def self.merge_logs(log_files, logs_folder)
-        UI.verbose("Merging console logs...")
-        target_log = log_files.shift
-        log_files.each do |log|
-          to_append = File.read(log)
-          File.open(target_log, "a") do |handle|
-            handle.puts to_append
-          end
-          FileUtils.cp_r(target_log, logs_folder)
-        end
-      end
-
-      def self.write_report_to_file(report, file_name)
-        UI.verbose("Writing merged results to file...")
-        File.new(file_name, 'w')
-        File.open(file_name, 'w') do |f|
-          f.write(report.to_xml)
-        end
-      end
-
-      def self.get_test_name(test_data)
-        test_name = test_data.xpath("(//key[contains(.,'TestSummaryGUID')])/../key[contains(.,'TestName')]/following-sibling::string").to_a[0].to_s
-        test_name = test_name[8..-10]
-        test_name
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Combines and combines tests from multiple junit report files"
-      end
-
-      def self.details
-        "The first junit report is used as the base report. Testcases " \
-        "from other reports are added if they do not already exist, or " \
-        "if the testcases already exist, they are replaced." \
-        "" \
-        "This is done because it is assumed that fragile tests, when " \
-        "re-run will often succeed due to less interference from other " \
-        "tests and the subsequent junit reports will have more passed tests." \
-        "" \
-        "Inspired by Derek Yang's fastlane-plugin-merge_junit_report"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(
-            key: :scheme,
-            env_name: 'SCHEME',
-            description: 'The test scheme being run',
-            optional: false,
-            default_value: '',
-            type: String
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :reports,
-            env_name: 'COLLATE_JUNIT_REPORTS_REPORTS',
-            description: 'An array of junit reports to collate. The first report is used as the base into which other reports are merged in',
-            optional: false,
-            type: Array,
-            verify_block: proc do |reports|
-              UI.user_error!('No junit report files found') if reports.empty?
-              reports.each do |report|
-                UI.user_error!("Error: junit report not found: '#{report}'") unless File.exist?(report)
-              end
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :collated_report,
-            env_name: 'COLLATE_JUNIT_REPORTS_COLLATED_REPORT',
-            description: 'The final junit report file where all testcases will be merged into',
-            optional: true,
-            default_value: 'result.xml',
-            type: String
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :assets,
-            env_name: 'COLLATE_JUNIT_REPORTS_ASSETS',
-            description: 'An array of junit reports to collate. The first report is used as the base into which other reports are merged in',
-            optional: false,
-            type: Array,
-            verify_block: proc do |assets|
-              UI.user_error!('No junit report files found') if assets.empty?
-              assets.each do |asset|
-                UI.user_error!("Error: junit report not found: '#{asset}'") unless File.exist?(asset)
-              end
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :logs,
-            env_name: 'COLLATE_JUNIT_REPORTS_LOGS',
-            description: 'An array of junit reports to collate. The first report is used as the base into which other reports are merged in',
-            optional: false,
-            type: Array,
-            verify_block: proc do |logs|
-              UI.user_error!('No junit report files found') if logs.empty?
-              logs.each do |log|
-                UI.user_error!("Error: junit report not found: '#{log}'") unless File.exist?(log)
-              end
-            end
-          )
-        ]
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/@lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/actions/multi_scan.rb

@@ -1,143 +0,0 @@
-module Fastlane
-  module Actions
-    require 'fastlane/actions/scan'
-    require 'shellwords'
-
-    class MultiScanAction < Action
-      def self.run(params)
-        try_count = 0
-        scan_options = params.values.reject { |k| k == :try_count }
-        final_report_path = scan_options[:result_bundle]
-        unless Helper.test?
-          FastlaneCore::PrintTable.print_values(
-            config: params._values.reject { |k, v| scan_options.key?(k) },
-            title: "Summary for multi_scan (test_center v#{Fastlane::TestCenter::VERSION})"
-          )
-        end
-
-        scan_options = config_with_junit_report(scan_options)
-
-        begin
-          try_count += 1
-          scan_options = config_with_retry(scan_options, try_count)
-          config = FastlaneCore::Configuration.create(Fastlane::Actions::ScanAction.available_options, scan_options)
-          Fastlane::Actions::ScanAction.run(config)
-        rescue FastlaneCore::Interface::FastlaneTestFailure => e
-          UI.verbose("Scan failed with #{e}")
-          if try_count < params[:try_count]
-            report_filepath = junit_report_filepath(scan_options)
-            failed_tests = other_action.tests_from_junit(junit: report_filepath)[:failed]
-            scan_options[:only_testing] = failed_tests.map(&:shellescape)
-            retry
-          end
-        end
-        merge_reports(scan_options, final_report_path)
-      end
-
-      def self.merge_reports(scan_options, final_report_path)
-        folder = get_folder_root(scan_options[:output_directory])
-        report_files = Dir.glob("#{folder}*/#{scan_options[:scheme]}.test_result/1_Test/action_TestSummaries.plist")
-        asset_files = Dir.glob("#{folder}*/#{scan_options[:scheme]}.test_result/1_Test/Attachments")
-        log_files = Dir.glob("#{folder}*/#{scan_options[:scheme]}.test_result/1_Test/action.xcactivitylog")
-        #Merge all reports, screenshots, and logs if there were retried tests
-
-        if report_files.size > 1
-          other_action.collate_junit_reports(
-            scheme: scan_options[:scheme],
-            reports: report_files,
-            collated_report: final_report_path,
-            assets: asset_files,
-            logs: log_files,
-          )
-        end
-      end
-
-      def self.config_has_junit_report(config)
-        output_types = config.fetch(:output_types, '').to_s.split(',')
-        output_filenames = config.fetch(:output_files, '').to_s.split(',')
-
-        output_type_file_count_match = output_types.size == output_filenames.size
-        output_types.include?('junit') && (output_type_file_count_match || config[:custom_report_file_name].to_s.strip.length > 0)
-      end
-
-      def self.config_with_retry(config, count)
-        folder = get_folder_root(config[:result_bundle])
-        config[:result_bundle] = (folder + count.to_s)
-        config[:output_directory] = (folder + count.to_s)
-        config
-      end
-
-      def self.get_folder_root(folder)
-        folder = folder.gsub(/ *\d+$/, '')
-        folder
-      end
-
-      def self.config_with_junit_report(config)
-        return config if config_has_junit_report(config)
-
-        if config[:output_types].to_s.strip.empty? || config[:custom_report_file_name]
-          config[:custom_report_file_name] ||= 'report.xml'
-          config[:output_types] = 'junit'
-        elsif config[:output_types].strip == 'junit' && config[:output_files].to_s.strip.empty?
-          config[:custom_report_file_name] ||= 'report.xml'
-        elsif !config[:output_types].split(',').include?('junit')
-          config[:output_types] << ',junit'
-          config[:output_files] << ',report.xml'
-        elsif config[:output_files].nil?
-          config[:output_files] = config[:output_types].split(',').map { |type| "report.#{type}" }.join(',')
-        end
-        config
-      end
-
-      def self.junit_report_filename(config)
-        report_filename = config[:custom_report_file_name]
-        if report_filename.nil?
-          junit_index = config[:output_types].split(',').find_index('junit')
-          report_filename = config[:output_files].to_s.split(',')[junit_index]
-        end
-        report_filename
-      end
-
-      def self.junit_report_filepath(config)
-        File.absolute_path(File.join(config[:output_directory], junit_report_filename(config)))
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Uses scan to run Xcode tests a given number of times: only re-testing failing tests."
-      end
-
-      def self.details
-        "Use this action to run your tests if you have fragile tests that fail sporadically."
-      end
-
-      def self.scan_options
-        ScanAction.available_options
-      end
-
-      def self.available_options
-        scan_options + [
-          FastlaneCore::ConfigItem.new(
-            key: :try_count,
-            env_name: "FL_MULTI_SCAN_TRY_COUNT",
-            description: "The number of times to retry running tests via scan",
-            type: Integer,
-            is_string: false,
-            default_value: 1
-          )
-        ]
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/@lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/actions/suppress_tests.rb

@@ -1,93 +0,0 @@
-module Fastlane
-  module Actions
-    class SuppressTestsAction < Action
-      require 'xcodeproj'
-
-      def self.run(params)
-        project_path = params[:xcodeproj]
-        all_tests_to_skip = params[:tests]
-        scheme = params[:scheme]
-
-        scheme_filepaths = Dir.glob("#{project_path}/{xcshareddata,xcuserdata}/**/xcschemes/#{scheme || '*'}.xcscheme")
-        if scheme_filepaths.length.zero?
-          UI.user_error!("Error: cannot find any scheme named #{scheme}") unless scheme.nil?
-          UI.user_error!("Error: cannot find any schemes in the Xcode project")
-        end
-
-        scheme_filepaths.each do |scheme_filepath|
-          is_dirty = false
-          xcscheme = Xcodeproj::XCScheme.new(scheme_filepath)
-          xcscheme.test_action.testables.each do |testable|
-            buildable_name = File.basename(testable.buildable_references[0].buildable_name, '.xctest')
-
-            tests_to_skip = all_tests_to_skip.select { |test| test.start_with?(buildable_name) }
-                                             .map { |test| test.sub("#{buildable_name}/", '') }
-
-            tests_to_skip.each do |test_to_skip|
-              skipped_test = Xcodeproj::XCScheme::TestAction::TestableReference::SkippedTest.new
-              skipped_test.identifier = test_to_skip
-              testable.add_skipped_test(skipped_test)
-              is_dirty = true
-            end
-          end
-          xcscheme.save! if is_dirty
-        end
-        nil
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Suppresses specific tests in a specific or all Xcode Schemes in a given project"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(
-            key: :xcodeproj,
-            env_name: "FL_SUPPRESS_TESTS_XCODE_PROJECT",
-            description: "The file path to the Xcode project file to modify",
-            verify_block: proc do |path|
-              UI.user_error!("Error: Xcode project file path not given!") unless path and !path.empty?
-              UI.user_error!("Error: Xcode project '#{path}' not found!") unless Dir.exist?(path)
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :tests,
-            env_name: "FL_SUPPRESS_TESTS_TESTS_TO_SUPPRESS",
-            description: "A list of tests to suppress",
-            verify_block: proc do |tests|
-              UI.user_error!("Error: no tests were given to suppress!") unless tests and !tests.empty?
-              tests.each do |test_identifier|
-                is_valid_test_identifier = %r{^[a-zA-Z][a-zA-Z0-9]+\/[a-zA-Z][a-zA-Z0-9]+(\/test[a-zA-Z0-9]+)?$} =~ test_identifier
-                unless is_valid_test_identifier
-                  UI.user_error!("Error: invalid test identifier '#{test_identifier}'. It must be in the format of 'Testable/TestSuiteToSuppress' or 'Testable/TestSuiteToSuppress/testToSuppress'")
-                end
-              end
-            end,
-            type: Array
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :scheme,
-            optional: true,
-            env_name: "FL_SUPPRESS_TESTS_SCHEME_TO_UPDATE",
-            description: "The Xcode scheme where the tests should be suppressed",
-            verify_block: proc do |scheme_name|
-              UI.user_error!("Error: Xcode Scheme '#{scheme_name}' is not valid!") if scheme_name and scheme_name.empty?
-            end
-          )
-        ]
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/@lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/actions/suppress_tests_from_junit.rb

@@ -1,102 +0,0 @@
-module Fastlane
-  module Actions
-    class SuppressTestsFromJunitAction < Action
-      def self.run(params)
-        project_path = params[:xcodeproj]
-        scheme = params[:scheme]
-
-        scheme_filepaths = Dir.glob("#{project_path}/{xcshareddata,xcuserdata}/**/xcschemes/#{scheme || '*'}.xcscheme")
-        if scheme_filepaths.length.zero?
-          UI.user_error!("Error: cannot find any scheme named #{scheme}") unless scheme.nil?
-          UI.user_error!("Error: cannot find any schemes in the Xcode project")
-        end
-
-        testables = Hash.new([])
-        desired_passed_status = (params[:suppress_type] == :passing)
-
-        report = ::TestCenter::Helper::XcodeJunit::Report.new(params[:junit])
-
-        report.testables.each do |testable|
-          testables[testable.name] = []
-          testable.testsuites.each do |testsuite|
-            testsuite.testcases.each do |testcase|
-              if testcase.passed? == desired_passed_status
-                testables[testable.name] << testcase.skipped_test
-              end
-            end
-          end
-        end
-
-        scheme_filepaths.each do |scheme_filepath|
-          is_dirty = false
-          xcscheme = Xcodeproj::XCScheme.new(scheme_filepath)
-
-          xcscheme.test_action.testables.each do |testable|
-            buildable_name = testable.buildable_references[0].buildable_name
-            testables[buildable_name].each do |skipped_test|
-              testable.add_skipped_test(skipped_test)
-              is_dirty = true
-            end
-          end
-          xcscheme.save! if is_dirty
-        end
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Uses a junit xml report file to suppress either passing or failing tests in an Xcode Scheme"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(
-            key: :xcodeproj,
-            env_name: "FL_SUPPRESS_TESTS_FROM_JUNIT_XCODE_PROJECT",
-            description: "The file path to the Xcode project file to modify",
-            verify_block: proc do |path|
-              UI.user_error!("Error: Xcode project file path not given!") unless path and !path.empty?
-              UI.user_error!("Error: Xcode project '#{path}' not found!") unless Dir.exist?(path)
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :junit,
-            env_name: "FL_SUPPRESS_TESTS_FROM_JUNIT_JUNIT_REPORT",
-            description: "The junit xml report file from which to collect the tests to suppress",
-            verify_block: proc do |path|
-              UI.user_error!("Error: cannot find the junit xml report file '#{path}'") unless File.exist?(path)
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :scheme,
-            optional: true,
-            env_name: "FL_SUPPRESS_TESTS_FROM_JUNIT_SCHEME_TO_UPDATE",
-            description: "The Xcode scheme where the tests should be suppressed",
-            verify_block: proc do |scheme_name|
-              UI.user_error!("Error: Xcode Scheme '#{scheme_name}' is not valid!") if scheme_name and scheme_name.empty?
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :suppress_type,
-            type: Symbol,
-            env_name: "FL_SUPPRESS_TESTS_FROM_JUNIT_SUPPRESS_TYPE",
-            description: "Tests to suppress are either :failed or :passing",
-            verify_block: proc do |type|
-              UI.user_error!("Error: suppress type ':#{type}' is invalid! Only :failed or :passing are valid types") unless %i[failed passing].include?(type)
-            end
-          )
-        ]
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/@lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/actions/suppressed_tests.rb

@@ -1,72 +0,0 @@
-module Fastlane
-  module Actions
-    class SuppressedTestsAction < Action
-      require 'set'
-
-      def self.run(params)
-        project_path = params[:xcodeproj]
-        scheme = params[:scheme]
-
-        scheme_filepaths = Dir.glob("#{project_path}/{xcshareddata,xcuserdata}/**/xcschemes/#{scheme || '*'}.xcscheme")
-        if scheme_filepaths.length.zero?
-          UI.user_error!("Error: cannot find any scheme named #{scheme}") unless scheme.nil?
-          UI.user_error!("Error: cannot find any schemes in the Xcode project")
-        end
-
-        skipped_tests = Set.new
-        scheme_filepaths.each do |scheme_filepath|
-          xcscheme = Xcodeproj::XCScheme.new(scheme_filepath)
-          xcscheme.test_action.testables.each do |testable|
-            buildable_name = testable.buildable_references[0]
-                                     .buildable_name
-
-            buildable_name = File.basename(buildable_name, '.xctest')
-            testable.skipped_tests.map do |skipped_test|
-              skipped_tests.add("#{buildable_name}/#{skipped_test.identifier}")
-            end
-          end
-        end
-        skipped_tests.to_a
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Retrieves a list of tests that are suppressed in a specific or all Xcode Schemes in a project"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(
-            key: :xcodeproj,
-            env_name: "FL_SUPPRESSED_TESTS_XCODE_PROJECT",
-            description: "The file path to the Xcode project file to read the skipped tests from",
-            verify_block: proc do |path|
-              UI.user_error!("Error: Xcode project file path not given!") unless path and !path.empty?
-              UI.user_error!("Error: Xcode project '#{path}' not found!") unless Dir.exist?(path)
-            end
-          ),
-          FastlaneCore::ConfigItem.new(
-            key: :scheme,
-            optional: true,
-            env_name: "FL_SUPPRESSED_TESTS_SCHEME_TO_UPDATE",
-            description: "The Xcode scheme where the suppressed tests may be",
-            verify_block: proc do |scheme_name|
-              UI.user_error!("Error: Xcode Scheme '#{scheme_name}' is not valid!") if scheme_name and scheme_name.empty?
-            end
-          )
-        ]
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/@lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/actions/tests_from_junit.rb

@@ -1,59 +0,0 @@
-module Fastlane
-  module Actions
-    class TestsFromJunitAction < Action
-      def self.run(params)
-        report = ::TestCenter::Helper::XcodeJunit::Report.new(params[:junit])
-        passing = []
-        failed = []
-        report.testables.each do |testable|
-          testable.testsuites.each do |testsuite|
-            testsuite.testcases.each do |testcase|
-              if testcase.passed?
-                passing << testcase.identifier
-              else
-                failed << testcase.identifier
-              end
-            end
-          end
-        end
-        {
-          failed: failed,
-          passing: passing
-        }
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Retrieves the failing and passing tests as reported in a junit xml file"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(
-            key: :junit,
-            env_name: "FL_SUPPRESS_TESTS_FROM_JUNIT_JUNIT_REPORT", # The name of the environment variable
-            description: "The junit xml report file from which to collect the tests to suppress",
-            verify_block: proc do |path|
-              UI.user_error!("Error: cannot find the junit xml report file '#{path}'") unless File.exist?(path)
-            end
-          )
-        ]
-      end
-
-      def self.return_value
-        "A Hash with an Array of :passing and :failed tests"
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/actions/tests_from_xctestrun.rb

@@ -1,65 +0,0 @@
-require 'plist'
-
-module Fastlane
-  module Actions
-    class TestsFromXctestrunAction < Action
-      def self.run(params)
-        return xctestrun_tests(params[:xctestrun])
-      end
-
-      def self.xctestrun_tests(xctestrun_path)
-        xctestrun = Plist.parse_xml(xctestrun_path)
-        xctestrun_rootpath = File.dirname(xctestrun_path)
-        tests = Hash.new([])
-        xctestrun.each do |testable_name, xctestrun_config|
-          test_identifiers = XCTestList.tests(xctest_bundle_path(xctestrun_rootpath, xctestrun_config))
-          if xctestrun_config.key?('SkipTestIdentifiers')
-            test_identifiers.reject! { |test_identifier| xctestrun_config['SkipTestIdentifiers'].include?(test_identifier) }
-          end
-          tests[testable_name] = test_identifiers.map do |test_identifier|
-            "#{testable_name.shellescape}/#{test_identifier}"
-          end
-        end
-        tests
-      end
-
-      def self.xctest_bundle_path(xctestrun_rootpath, xctestrun_config)
-        xctest_host_path = xctestrun_config['TestHostPath'].sub('__TESTROOT__', xctestrun_rootpath)
-        xctestrun_config['TestBundlePath'].sub('__TESTHOST__', xctest_host_path).sub('__TESTROOT__', xctestrun_rootpath)
-      end
-
-      #####################################################
-      # @!group Documentation
-      #####################################################
-
-      def self.description
-        "Retrieves all of the tests from xctest bundles referenced by the xctestrun file"
-      end
-
-      def self.available_options
-        [
-          FastlaneCore::ConfigItem.new(
-            key: :xctestrun,
-            env_name: "FL_SUPPRESS_TESTS_FROM_XCTESTRUN_FILE",
-            description: "The xctestrun file to use to find where the xctest bundle file is for test retrieval",
-            verify_block: proc do |path|
-              UI.user_error!("Error: cannot find the xctestrun file '#{path}'") unless File.exist?(path)
-            end
-          )
-        ]
-      end
-
-      def self.return_value
-        "A Hash of testable => tests, where testable is the name of the test target and tests is an array of test identifiers"
-      end
-
-      def self.authors
-        ["lyndsey-ferguson/lyndseydf"]
-      end
-
-      def self.is_supported?(platform)
-        platform == :ios
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/helper/correcting_scan_helper.rb

@@ -1,164 +0,0 @@
-module TestCenter
-  module Helper
-    require 'fastlane_core/ui/ui.rb'
-    require 'plist'
-
-    class CorrectingScanHelper
-      attr_reader :retry_total_count
-
-      def initialize(multi_scan_options)
-        @batch_count = multi_scan_options[:batch_count] || 1
-        @output_directory = multi_scan_options[:output_directory] || 'test_results'
-        @try_count = multi_scan_options[:try_count]
-        @retry_total_count = 0
-        @testrun_completed_block = multi_scan_options[:testrun_completed_block]
-        @given_custom_report_file_name = multi_scan_options[:custom_report_file_name]
-        @given_output_types = multi_scan_options[:output_types]
-        @given_output_files = multi_scan_options[:output_files]
-        @scan_options = multi_scan_options.reject do |option, _|
-          %i[
-            output_directory
-            only_testing
-            skip_testing
-            clean
-            try_count
-            batch_count
-            custom_report_file_name
-            fail_build
-            testrun_completed_block
-          ].include?(option)
-        end
-        @test_collector = TestCollector.new(multi_scan_options)
-      end
-
-      def scan
-        tests_passed = true
-        @testables_count = @test_collector.testables.size
-        @test_collector.testables.each do |testable|
-          tests_passed = scan_testable(testable) && tests_passed
-        end
-        tests_passed
-      end
-
-      def scan_testable(testable)
-        tests_passed = true
-        reportnamer = ReportNameHelper.new(
-          @given_output_types,
-          @given_output_files,
-          @given_custom_report_file_name
-        )
-        output_directory = @output_directory
-        testable_tests = @test_collector.testables_tests[testable]
-        if @batch_count > 1 || @testables_count > 1
-          current_batch = 1
-          testable_tests.each_slice((testable_tests.length / @batch_count.to_f).round).to_a.each do |tests_batch|
-            if @testables_count > 1
-              output_directory = File.join(@output_directory, "results-#{testable}")
-            end
-            FastlaneCore::UI.header("Starting test run on testable '#{testable}'")
-            tests_passed = correcting_scan(
-              {
-                only_testing: tests_batch,
-                output_directory: output_directory
-              },
-              current_batch,
-              reportnamer
-            ) && tests_passed
-            current_batch += 1
-            reportnamer.increment
-          end
-        else
-          options = {
-            output_directory: output_directory,
-            only_testing: testable_tests
-          }
-          tests_passed = correcting_scan(options, 1, reportnamer) && tests_passed
-        end
-        collate_reports(output_directory, reportnamer)
-        tests_passed
-      end
-
-      def collate_reports(output_directory, reportnamer)
-        report_files = Dir.glob("#{output_directory}/*#{reportnamer.junit_filextension}").map do |relative_filepath|
-          File.absolute_path(relative_filepath)
-        end
-        if report_files.size > 1
-          config = FastlaneCore::Configuration.create(
-            Fastlane::Actions::CollateJunitReportsAction.available_options,
-            {
-              reports: report_files.sort { |f1, f2| File.mtime(f1) <=> File.mtime(f2) },
-              collated_report: File.absolute_path(File.join(output_directory, reportnamer.junit_reportname))
-            }
-          )
-          Fastlane::Actions::CollateJunitReportsAction.run(config)
-        end
-        retried_junit_reportfiles = Dir.glob("#{output_directory}/**/*-[1-9]*#{reportnamer.junit_filextension}")
-        FileUtils.rm_f(retried_junit_reportfiles)
-      end
-
-      def correcting_scan(scan_run_options, batch, reportnamer)
-        scan_options = @scan_options.merge(scan_run_options)
-        try_count = 0
-        tests_passed = true
-        begin
-          try_count += 1
-          config = FastlaneCore::Configuration.create(
-            Fastlane::Actions::ScanAction.available_options,
-            scan_options.merge(reportnamer.scan_options)
-          )
-          quit_simulators
-          Fastlane::Actions::ScanAction.run(config)
-          @testrun_completed_block && @testrun_completed_block.call(
-            testrun_info(batch, try_count, reportnamer, scan_options[:output_directory])
-          )
-          tests_passed = true
-        rescue FastlaneCore::Interface::FastlaneTestFailure => e
-          FastlaneCore::UI.verbose("Scan failed with #{e}")
-          if try_count < @try_count
-            @retry_total_count += 1
-
-            info = testrun_info(batch, try_count, reportnamer, scan_options[:output_directory])
-            @testrun_completed_block && @testrun_completed_block.call(
-              info
-            )
-            scan_options[:only_testing] = info[:failed].map(&:shellescape)
-            FastlaneCore::UI.message('Re-running scan on only failed tests')
-            reportnamer.increment
-            retry
-          end
-          tests_passed = false
-        end
-        tests_passed
-      end
-
-      def testrun_info(batch, try_count, reportnamer, output_directory)
-        report_filepath = File.join(output_directory, reportnamer.junit_last_reportname)
-        config = FastlaneCore::Configuration.create(
-          Fastlane::Actions::TestsFromJunitAction.available_options,
-          {
-            junit: File.absolute_path(report_filepath)
-          }
-        )
-        junit_results = Fastlane::Actions::TestsFromJunitAction.run(config)
-
-        {
-          failed: junit_results[:failed],
-          passing: junit_results[:passing],
-          batch: batch,
-          try_count: try_count,
-          report_filepath: report_filepath
-        }
-      end
-
-      def quit_simulators
-        Fastlane::Actions.sh("killall -9 'iPhone Simulator' 'Simulator' 'SimulatorBridge' &> /dev/null || true", log: false)
-        launchctl_list_count = 0
-        while Fastlane::Actions.sh('launchctl list | grep com.apple.CoreSimulator.CoreSimulatorService || true', log: false) != ''
-          break if (launchctl_list_count += 1) > 10
-          Fastlane::Actions.sh('launchctl remove com.apple.CoreSimulator.CoreSimulatorService &> /dev/null || true', log: false)
-          sleep(1)
-        end
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/helper/junit_helper.rb

@@ -1,94 +0,0 @@
-require_relative 'xcodebuild_string'
-
-module TestCenter
-  module Helper
-    module XcodeJunit
-      require 'xcodeproj'
-
-      class Report
-        def initialize(junit_report_filepath)
-          report_file = File.open(junit_report_filepath) { |f| REXML::Document.new(f) }
-          UI.user_error!("Malformed XML test report file given") if report_file.root.nil?
-          UI.user_error!("Valid XML file is not an Xcode test report") if report_file.get_elements('testsuites').empty?
-
-          @testables = []
-          report_file.elements.each('testsuites') do |testsuites_element|
-            @testables << Testable.new(testsuites_element)
-          end
-        end
-
-        def testables
-          return @testables
-        end
-      end
-
-      class Testable
-        def initialize(xml_element)
-          @root = xml_element
-          @testsuites = []
-          @root.elements.each('testsuite') do |testsuite_element|
-            @testsuites << TestSuite.new(testsuite_element)
-          end
-        end
-
-        def name
-          return @root.attributes['name']
-        end
-
-        def testsuites
-          return @testsuites
-        end
-      end
-
-      class TestSuite
-        def initialize(xml_element)
-          @root = xml_element
-          @testcases = []
-          @root.elements.each('testcase') do |testcase_element|
-            @testcases << TestCase.new(testcase_element)
-          end
-        end
-
-        def name
-          return @root.attributes['name']
-        end
-
-        def identifier
-          name.testsuite
-        end
-
-        def is_swift?
-          return name.include?('.')
-        end
-
-        def testcases
-          return @testcases
-        end
-      end
-
-      class TestCase
-        attr_reader :identifier
-        attr_reader :skipped_test
-
-        def initialize(xml_element)
-          @root = xml_element
-          name = xml_element.attributes['name']
-          full_testsuite = xml_element.parent.attributes['name']
-          testsuite = full_testsuite.testsuite
-          is_swift = full_testsuite.testsuite_swift?
-
-          testable_filename = xml_element.parent.parent.attributes['name']
-          testable = File.basename(testable_filename, '.xctest')
-          @identifier = "#{testable}/#{testsuite}/#{name}"
-          @skipped_test = Xcodeproj::XCScheme::TestAction::TestableReference::SkippedTest.new
-          @skipped_test.identifier = "#{testsuite}/#{name}#{'()' if is_swift}"
-          @passed = xml_element.get_elements('failure').size.zero?
-        end
-
-        def passed?
-          @passed
-        end
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/helper/reportname_helper.rb

@@ -1,70 +0,0 @@
-module TestCenter
-  module Helper
-    require 'fastlane_core/ui/ui.rb'
-
-    class ReportNameHelper
-      def initialize(output_types = nil, output_files = nil, custom_report_file_name = nil)
-        @output_types = output_types || 'junit'
-        @output_files = output_files || custom_report_file_name
-        @report_count = 0
-
-        if @output_types && @output_files.nil?
-          @output_files = @output_types.split(',').map { |type| "report.#{type}" }.join(',')
-        end
-        unless @output_types.include?('junit')
-          FastlaneCore::UI.important('Scan output types missing \'junit\', adding it')
-          @output_types = @output_types.split(',').push('junit').join(',')
-          if @output_types.split(',').size == @output_files.split(',').size + 1
-            @output_files = @output_files.split(',').push('report.xml').join(',')
-            FastlaneCore::UI.message('As output files has one less than the new number of output types, assumming the filename for the junit was missing and added it')
-          end
-        end
-
-        types = @output_types.split(',').each(&:chomp)
-        files = @output_files.split(',').each(&:chomp)
-        unless files.size == types.size
-          raise ArgumentError, "Error: count of :output_types, #{types}, does not match the output filename(s) #{files}"
-        end
-      end
-
-      def numbered_filename(filename)
-        if @report_count > 0
-          basename = File.basename(filename, '.*')
-          extension = File.extname(filename)
-          filename = "#{basename}-#{@report_count + 1}#{extension}"
-        end
-        filename
-      end
-
-      def scan_options
-        files = @output_files.split(',').each(&:chomp)
-        files.map! do |filename|
-          filename.chomp
-          numbered_filename(filename)
-        end
-        {
-          output_types: @output_types,
-          output_files: files.join(',')
-        }
-      end
-
-      def junit_last_reportname
-        junit_index = @output_types.split(',').find_index('junit')
-        numbered_filename(@output_files.to_s.split(',')[junit_index])
-      end
-
-      def junit_reportname
-        junit_index = @output_types.split(',').find_index('junit')
-        @output_files.to_s.split(',')[junit_index]
-      end
-
-      def junit_filextension
-        File.extname(junit_reportname)
-      end
-
-      def increment
-        @report_count += 1
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/helper/test_collector.rb

@@ -1,60 +0,0 @@
-module TestCenter
-  module Helper
-    require 'fastlane_core/ui/ui.rb'
-    require 'plist'
-
-    class TestCollector
-      def initialize(options)
-        @xctestrun_path = options[:xctestrun] || derived_testrun_path(options[:derived_data_path], options[:scheme])
-        @only_testing = options[:only_testing]
-        @skip_testing = options[:skip_testing]
-      end
-
-      def derived_testrun_path(derived_data_path, scheme)
-        Dir.glob("#{derived_data_path}/Build/Products/#{scheme}*.xctestrun").first
-      end
-
-      def testables
-        unless @testables
-          if @only_testing
-            @testables ||= only_testing_to_testables_tests.keys
-          else
-            @testables ||= Plist.parse_xml(@xctestrun_path).keys
-          end
-        end
-        @testables
-      end
-
-      def only_testing_to_testables_tests
-        tests = Hash.new { |h, k| h[k] = [] }
-        @only_testing.sort.each do |test_identifier|
-          testable = test_identifier.split('/', 2)[0]
-          tests[testable] << test_identifier
-        end
-        tests
-      end
-
-      def testables_tests
-        unless @testables_tests
-          if @only_testing
-            @testables_tests = only_testing_to_testables_tests
-          else
-            config = FastlaneCore::Configuration.create(::Fastlane::Actions::TestsFromXctestrunAction.available_options, xctestrun: @xctestrun_path)
-            @testables_tests = ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
-            if @skip_testing
-              skipped_testable_tests = Hash.new { |h, k| h[k] = [] }
-              @skip_testing.sort.each do |skipped_test_identifier|
-                testable = skipped_test_identifier.split('/', 2)[0]
-                skipped_testable_tests[testable] << skipped_test_identifier
-              end
-              @testables_tests.each_key do |testable|
-                @testables_tests[testable] -= skipped_testable_tests[testable]
-              end
-            end
-          end
-        end
-        @testables_tests
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/helper/xcodebuild_string.rb

@@ -1,14 +0,0 @@
-
-class String
-  def testsuite_swift?
-    self.include?('.')
-  end
-
-  def testsuite
-    if self.testsuite_swift?
-      self.split('.')[1]
-    else
-      self
-    end
-  end
-end

data/lib/fastlane/plugin/retry_tests/version.rb

@@ -1,5 +0,0 @@
-module Fastlane
-  module TestCenter
-    VERSION = "3.0.6"
-  end
-end