fastlane-plugin-test_center 3.7.0.parallelizing.alpha.4 → 3.7.0

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/parallel_test_batch_worker.rb

@@ -1,27 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      class ParallelTestBatchWorker < TestBatchWorker
-        attr_reader :pid
-
-        def state=(new_state)
-          super(new_state)
-          @pid = nil unless new_state == :working
-        end
-
-        def run(run_options)
-          self.state = :working
-          @pid = Process.fork do
-            begin
-              super(run_options)
-            ensure
-              exit!
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/report_collator.rb

@@ -1,115 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      class ReportCollator
-        CollateJunitReportsAction = Fastlane::Actions::CollateJunitReportsAction
-        CollateHtmlReportsAction = Fastlane::Actions::CollateHtmlReportsAction
-        CollateJsonReportsAction = Fastlane::Actions::CollateJsonReportsAction
-        CollateTestResultBundlesAction = Fastlane::Actions::CollateTestResultBundlesAction
-
-        def initialize(params)
-          @source_reports_directory_glob = params[:source_reports_directory_glob]
-          @output_directory = params[:output_directory]
-          @reportnamer = params[:reportnamer]
-          @scheme = params[:scheme]
-          @result_bundle = params[:result_bundle]
-          @suffix = params[:suffix] || ''
-        end
-
-        def collate
-          collate_junit_reports
-          collate_html_reports
-          collate_json_reports
-          collate_test_result_bundles
-        end
-
-        def sort_globbed_files(glob)
-          files = Dir.glob(glob).map do |relative_filepath|
-            File.absolute_path(relative_filepath)
-          end
-          files.sort! { |f1, f2| File.mtime(f1) <=> File.mtime(f2) }
-        end
-
-        def delete_globbed_intermediatefiles(glob)
-          retried_reportfiles = Dir.glob(glob)
-          FileUtils.rm_f(retried_reportfiles)
-        end
-
-        def create_config(klass, options)
-          FastlaneCore::Configuration.create(klass.available_options, options)
-        end
-
-        def collate_junit_reports
-          glob = "#{@source_reports_directory_glob}/#{@reportnamer.junit_fileglob}"
-          report_files = sort_globbed_files(glob)
-          if report_files.size > 1
-            collated_file =  File.absolute_path(File.join(@output_directory, @reportnamer.junit_reportname(@suffix)))
-            config = create_config(
-              CollateJunitReportsAction,
-              {
-                reports: report_files,
-                collated_report: collated_file
-              }
-            )
-            CollateJunitReportsAction.run(config)
-            FileUtils.rm_rf(report_files - [collated_file])
-          end
-        end
-
-        def collate_html_reports
-          return unless @reportnamer.includes_html?
-
-          report_files = sort_globbed_files("#{@source_reports_directory_glob}/#{@reportnamer.html_fileglob}")
-          if report_files.size > 1
-            collated_file = File.absolute_path(File.join(@output_directory, @reportnamer.html_reportname(@suffix)))
-            config = create_config(
-              CollateJunitReportsAction,
-              {
-                reports: report_files,
-                collated_report: collated_file
-              }
-            )
-            CollateHtmlReportsAction.run(config)
-            FileUtils.rm_rf(report_files - [collated_file])
-          end
-        end
-
-        def collate_json_reports
-          return unless @reportnamer.includes_json?
-
-          report_files = sort_globbed_files("#{@source_reports_directory_glob}/#{@reportnamer.json_fileglob}")
-          if report_files.size > 1
-            collated_file = File.absolute_path(File.join(@output_directory, @reportnamer.json_reportname(@suffix)))
-            config = create_config(
-              CollateJsonReportsAction,
-              {
-                reports: report_files,
-                collated_report: collated_file
-              }
-            )
-            CollateJsonReportsAction.run(config)
-            FileUtils.rm_rf(report_files - [collated_file])
-          end
-        end
-
-        def collate_test_result_bundles
-          return unless @result_bundle
-
-          test_result_bundlepaths = sort_globbed_files("#{@source_reports_directory_glob}/#{@scheme}*.test_result")
-          if test_result_bundlepaths.size > 1
-            collated_test_result_bundlepath = File.absolute_path("#{File.join(@output_directory, @scheme)}.test_result")
-            config = create_config(
-              CollateTestResultBundlesAction,
-              {
-                bundles: test_result_bundlepaths,
-                collated_bundle: collated_test_result_bundlepath
-              }
-            )
-            CollateTestResultBundlesAction.run(config)
-            FileUtils.rm_rf(test_result_bundlepaths - [collated_test_result_bundlepath])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/retrying_scan.rb

@@ -1,74 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-
-      class RetryingScan
-        def initialize(options = {})
-          @options = options
-          @retrying_scan_helper = RetryingScanHelper.new(options)
-        end
-
-        def scan_config
-          Scan.config
-        end
-
-        def scan_cache
-          Scan.cache
-        end
-
-        def prepare_scan_config_for_destination
-          # this allows multi_scan's `destination` option to be picked up by `scan`
-          scan_config._values.delete(:device)
-          scan_config._values.delete(:devices)
-          scan_cache.clear
-        end
-
-        def update_scan_options
-          valid_scan_keys = Fastlane::Actions::ScanAction.available_options.map(&:key)
-          scan_options = @options.select { |k,v| valid_scan_keys.include?(k) }
-                                  .merge(@retrying_scan_helper.scan_options)
-
-          prepare_scan_config_for_destination
-          scan_options.each do |k,v|
-            scan_config.set(k,v) unless v.nil?
-          end
-        end
-
-        def self.run(options)
-          RetryingScan.new(options).run
-        end
-
-        def run
-          try_count = @options[:try_count] || 1
-          begin
-            # TODO move delete_xcresults to `before_testrun`
-            @retrying_scan_helper.before_testrun
-            update_scan_options
-            
-            values = scan_config.values(ask: false)
-            values[:xcode_path] = File.expand_path("../..", FastlaneCore::Helper.xcode_path)
-            FastlaneCore::PrintTable.print_values(
-              config: values,
-              hide_keys: [:destination, :slack_url],
-              title: "Summary for scan #{Fastlane::VERSION}"
-            ) unless FastlaneCore::Helper.test?
-
-            Scan::Runner.new.run
-            @retrying_scan_helper.after_testrun
-            true
-          rescue FastlaneCore::Interface::FastlaneTestFailure => e
-            FastlaneCore::UI.message("retrying_scan after test failure")
-            @retrying_scan_helper.after_testrun(e)
-            retry if @retrying_scan_helper.testrun_count < try_count
-            false
-          rescue FastlaneCore::Interface::FastlaneBuildFailure => e
-            FastlaneCore::UI.message("retrying_scan after build failure")
-            @retrying_scan_helper.after_testrun(e)
-            retry if @retrying_scan_helper.testrun_count < try_count
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fastlane/plugin/test_center/helper/multi_scan_manager/retrying_scan_helper.rb

@@ -1,255 +0,0 @@
-module TestCenter
-  module Helper
-    module MultiScanManager
-      require_relative 'device_manager'
-
-      class RetryingScanHelper
-
-        attr_reader :testrun_count
-
-        def initialize(options)
-          raise ArgumentError, 'Do not use the :device or :devices option. Instead use the :destination option.' if (options.key?(:device) or options.key?(:devices))
-
-          @options = options
-          @testrun_count = 0
-          @xcpretty_json_file_output = ENV['XCPRETTY_JSON_FILE_OUTPUT']
-          @reportnamer = ReportNameHelper.new(
-            @options[:output_types],
-            @options[:output_files],
-            @options[:custom_report_file_name]
-          )
-        end
-        
-        def before_testrun
-          remove_preexisting_test_result_bundles
-          delete_xcresults # has to be performed _after_ moving a *.test_result
-
-          set_json_env
-          print_starting_scan_message
-        end
-
-        def delete_xcresults
-          derived_data_path = File.expand_path(@options[:derived_data_path] || Scan.config[:derived_data_path])
-          xcresults = Dir.glob("#{derived_data_path}/Logs/Test/*.xcresult")
-          FastlaneCore::UI.message("Deleting xcresults: #{xcresults}")
-          FileUtils.rm_rf(xcresults)
-        end
-
-        def output_directory
-          absolute_output_directory = File.absolute_path(@options[:output_directory])
-          if @options[:batch]
-            testable = @options.fetch(:only_testing, ['']).first.split('/').first || ''
-            absolute_output_directory = File.join(absolute_output_directory, "#{testable}-batch-#{@options[:batch]}")
-          end
-          absolute_output_directory
-        end
-
-        def print_starting_scan_message
-          scan_message = "Starting scan ##{@testrun_count + 1} with #{@options.fetch(:only_testing, []).size} tests"
-          scan_message << " for batch ##{@options[:batch]}" unless @options[:batch].nil?
-          FastlaneCore::UI.message("#{scan_message}.")
-        end
-
-        def set_json_env
-          return unless @reportnamer.includes_json?
-
-          ENV['XCPRETTY_JSON_FILE_OUTPUT'] = File.join(
-            output_directory,
-            @reportnamer.json_last_reportname
-          )
-        end
-
-        def reset_json_env
-          return unless @reportnamer.includes_json?
-
-          ENV['XCPRETTY_JSON_FILE_OUTPUT'] = @xcpretty_json_file_output
-        end
-
-        def remove_preexisting_test_result_bundles
-          return unless @options[:result_bundle]
-
-          glob_pattern = "#{output_directory}/*.test_result"
-          preexisting_test_result_bundles = Dir.glob(glob_pattern)
-          FileUtils.rm_rf(preexisting_test_result_bundles)
-        end
-
-        def scan_options
-          valid_scan_keys = Fastlane::Actions::ScanAction.available_options.map(&:key)
-          @options.select { |k,v| valid_scan_keys.include?(k) }
-                  .merge(@reportnamer.scan_options)
-                  .merge(output_directory: output_directory)
-        end
-
-        # after_testrun methods
-
-        def after_testrun(exception = nil)
-          @testrun_count = @testrun_count + 1
-          if exception.kind_of?(FastlaneCore::Interface::FastlaneTestFailure)
-            handle_test_failure
-          elsif exception.kind_of?(FastlaneCore::Interface::FastlaneBuildFailure)
-            handle_build_failure(exception)
-          else
-            handle_success
-          end
-          collate_reports
-        end
-
-        def handle_success
-          send_callback_testrun_info
-          move_test_result_bundle_for_next_run
-          reset_json_env
-        end
-        
-        def collate_reports
-
-          report_collator_options = {
-            source_reports_directory_glob: output_directory,
-            output_directory: output_directory,
-            reportnamer: @reportnamer,
-            scheme: @options[:scheme],
-            result_bundle: @options[:result_bundle]
-          }
-          TestCenter::Helper::MultiScanManager::ReportCollator.new(report_collator_options).collate
-        end
-
-        def handle_test_failure
-          send_callback_testrun_info
-          reset_simulators
-          move_test_result_bundle_for_next_run
-          update_scan_options
-          @reportnamer.increment
-        end
-
-        def send_callback_testrun_info(additional_info = {})
-          return unless @options[:testrun_completed_block]
-
-          report_filepath = nil
-          junit_results = {}
-          unless additional_info.key?(:test_operation_failure)
-            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)
-          end
-
-          info = {
-            failed: junit_results[:failed],
-            passing: junit_results[:passing],
-            batch: @options[:batch] || 1,
-            try_count: @testrun_count,
-            report_filepath: report_filepath
-          }.merge(additional_info)
-
-          if @reportnamer.includes_html?
-            html_report_filepath = File.join(output_directory, @reportnamer.html_last_reportname)
-            info[:html_report_filepath] = html_report_filepath
-          end
-          if @reportnamer.includes_json?
-            json_report_filepath = File.join(output_directory, @reportnamer.json_last_reportname)
-            info[:json_report_filepath] = json_report_filepath
-          end
-          if @options[:result_bundle]
-            test_result_suffix = '.test_result'
-            test_result_suffix.prepend("-#{@reportnamer.report_count}") unless @reportnamer.report_count.zero?
-            test_result_bundlepath = File.join(output_directory, @options[:scheme]) + test_result_suffix
-            info[:test_result_bundlepath] = test_result_bundlepath
-          end
-          @options[:testrun_completed_block].call(info)
-        end
-
-        def update_scan_options
-          update_only_testing
-          turn_off_code_coverage
-        end
-
-        def turn_off_code_coverage
-          # Turn off code coverage as code coverage reports are not merged and
-          # the first, more valuable, report will be overwritten
-          @options.delete(:code_coverage)
-        end
-
-        def update_only_testing
-          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)
-            }
-          )
-          @options[:only_testing] = Fastlane::Actions::TestsFromJunitAction.run(config)[:failed]
-          if @options[:invocation_based_tests]
-            @options[:only_testing] = @options[:only_testing].map(&:strip_testcase).uniq
-          end
-        end
-        
-        def reset_simulators
-          return unless @options[:reset_simulators]
-
-          @options[:simulators].each(&:reset)
-        end
-
-        def handle_build_failure(exception)
-          test_operation_failure = ''
-
-          test_session_last_messages = last_lines_of_test_session_log
-          test_operation_failure_match = /Test operation failure: (?<test_operation_failure>.*)$/ =~ test_session_last_messages
-          if test_operation_failure_match.nil?
-            test_operation_failure = 'Unknown test operation failure'
-          end
-          
-          case test_operation_failure
-          when /Test runner exited before starting test execution/
-            FastlaneCore::UI.error(test_operation_failure)
-          when /Lost connection to testmanagerd/
-            FastlaneCore::UI.error(test_operation_failure)
-            FastlaneCore::UI.important("com.apple.CoreSimulator.CoreSimulatorService may have become corrupt, consider quitting it")
-            if @options[:quit_core_simulator_service]
-              Fastlane::Actions::RestartCoreSimulatorServiceAction.run
-            end
-          else
-            FastlaneCore::UI.error(test_operation_failure)
-            send_callback_testrun_info(test_operation_failure: test_operation_failure)
-            raise exception
-          end
-          if @options[:reset_simulators]
-            @options[:simulators].each do |simulator|
-              simulator.reset
-            end
-          end
-          send_callback_testrun_info(test_operation_failure: test_operation_failure)
-        end
-
-        def last_lines_of_test_session_log
-          derived_data_path = File.expand_path(@options[:derived_data_path])
-          test_session_logs = Dir.glob("#{derived_data_path}/Logs/Test/*.xcresult/*_Test/Diagnostics/**/Session-*.log")
-          test_session_logs.sort! { |logfile1, logfile2| File.mtime(logfile1) <=> File.mtime(logfile2) }
-          test_session = File.open(test_session_logs.last)
-          backwards_seek_offset = -1 * [1000, test_session.stat.size].min
-          test_session.seek(backwards_seek_offset, IO::SEEK_END)
-          test_session_last_messages = test_session.read
-        end
-
-        def move_test_result_bundle_for_next_run
-          return unless @options[:result_bundle]
-
-          glob_pattern = "#{output_directory}/*.test_result"
-          preexisting_test_result_bundles = Dir.glob(glob_pattern)
-          unnumbered_test_result_bundles = preexisting_test_result_bundles.reject do |test_result|
-            test_result =~ /.*-\d+\.test_result/
-          end
-          src_test_bundle = unnumbered_test_result_bundles.first
-          dst_test_bundle_parent_dir = File.dirname(src_test_bundle)
-          dst_test_bundle_basename = File.basename(src_test_bundle, '.test_result')
-          dst_test_bundle = "#{dst_test_bundle_parent_dir}/#{dst_test_bundle_basename}-#{@testrun_count}.test_result"
-          FileUtils.mkdir_p(dst_test_bundle)
-          FileUtils.mv(src_test_bundle, dst_test_bundle)
-        end
-      end
-    end
-  end
-end