fastlane-plugin-test_center 3.6.2 → 3.6.3.parallelizing

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 901809f6e0b7d7470ce1ab5a04924758f8f98eac
-  data.tar.gz: 3f1d8f95951101eb038cd3a35f84665f423bec77
+SHA256:
+  metadata.gz: '09726aaa2b1ba6691e8738682e25aebc1dab29e1bcbb9eef7672b33fac880fec'
+  data.tar.gz: a970fc5ed7a5c8dd05ddd11a2b7865bcc83154469da7e0d336da5f8e6a4e7c20
 SHA512:
-  metadata.gz: ce2ab1c98302b0bcaf9c05e743968fb3c76eff16f691dac0d33f354f0ddd8228fcd422c5f54880b4688b728cdbcf752890c9b6849a9a38450b966e998e577487
-  data.tar.gz: f2fdd270f3bb7fc6ccdb101cb621a9dd4ff56a2fe02330a92dc3842efe636c41cfca52562422be5562cff9a691786ab8d6d5ac38697a92153f3d53302127719b
+  metadata.gz: 6d3ad1b1f6854500f9472bdd4e74a5997e7554c04eda123a9d3adf1ce306f522b3f0d7f37dac34895dbf142e4476db5bb34681ad70c6c339e1b976271b518ca2
+  data.tar.gz: f421b8d3548e0c16abcac15ded2f5a8fa8013946f85bb131b68dc5b2ee6d6e4548b029f00ff1e5bacfa5714266feb29db2c2ed8efa3e83e31f563bbf71efd542

data/lib/fastlane/plugin/test_center.rb

@@ -4,7 +4,7 @@ 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__))]
+      Dir[File.expand_path('**/{actions,helper}/**/*.rb', File.dirname(__FILE__))]
     end
   end
 end

data/lib/fastlane/plugin/test_center/actions/collate_test_result_bundles.rb

@@ -14,7 +14,7 @@ module Fastlane
             collate_bundles(base_bundle_path, other_bundlepath)
           end
         end
-        FileUtils.rm_rf(params[:collated_bundle])
+        # FileUtils.rm_rf(params[:collated_bundle])
         FileUtils.cp_r(base_bundle_path, params[:collated_bundle])
         UI.message("Finished collating test_result bundle to '#{params[:collated_bundle]}'")
       end

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

@@ -5,6 +5,7 @@ module Fastlane
     require 'shellwords'
     require 'xctest_list'
     require 'plist'
+    require_relative '../helper/multi_scan_manager/runner'
 
     class MultiScanAction < Action
       def self.run(params)
@@ -19,9 +20,13 @@ module Fastlane
             params._values
           )
         end
-        smart_scanner = ::TestCenter::Helper::CorrectingScanHelper.new(params.values)
-        tests_passed = smart_scanner.scan
-        summary = run_summary(params, tests_passed, smart_scanner.retry_total_count)
+        runner = ::TestCenter::Helper::MultiScanManager::Runner.new(params.values)
+        tests_passed = runner.scan
+        if params[:fail_build] && !tests_passed
+          raise UI.test_failure!('Tests have failed')
+        end
+
+        summary = run_summary(params, tests_passed, runner.retry_total_count)
         unless Helper.test?
           FastlaneCore::PrintTable.print_values(
             config: summary,
@@ -84,17 +89,19 @@ module Fastlane
         options_to_remove = %i[
           try_count
           batch_count
+          output_files
+          parallelize
           quit_simulators
           testrun_completed_block
           test_without_building
           output_types
-          output_files
         ]
         config = FastlaneCore::Configuration.create(
           Fastlane::Actions::ScanAction.available_options,
           scan_options.merge(build_for_testing: true).reject { |k, _| options_to_remove.include?(k) }
         )
         Fastlane::Actions::ScanAction.run(config)
+        remove_build_report_files
 
         scan_options.merge!(
           test_without_building: true,
@@ -102,6 +109,16 @@ module Fastlane
         ).delete(:build_for_testing)
       end
 
+      def self.remove_build_report_files
+        report_options = Scan::XCPrettyReporterOptionsGenerator.generate_from_scan_config
+        output_files = report_options.instance_variable_get(:@output_files)
+        output_directory = report_options.instance_variable_get(:@output_directory)
+
+        output_files.each do |output_file|
+          FileUtils.rm_f(File.join(output_directory, output_file))
+        end
+      end
+
       #####################################################
       # @!group Documentation
       #####################################################
@@ -172,6 +189,13 @@ module Fastlane
             description: "Comma separated list of the output types (e.g. html, junit, json, json-compilation-database)",
             default_value: "html,junit"
           ),
+          FastlaneCore::ConfigItem.new(
+            key: :parallelize,
+            description: 'Run each batch of tests and/or each test target in parallel on its own Simulator',
+            optional: true,
+            is_string: false,
+            default_value: false
+          ),
           FastlaneCore::ConfigItem.new(
             key: :testrun_completed_block,
             description: 'A block invoked each time a test run completes',

data/lib/fastlane/plugin/test_center/actions/restart_core_simulator_service.rb

@@ -0,0 +1,37 @@
+module Fastlane
+  module Actions
+    class RestartCoreSimulatorServiceAction < Action
+      def self.run(params)
+        launchctl_list_count = 0
+        while Actions.sh('launchctl list | grep com.apple.CoreSimulator.CoreSimulatorService || true', log: false) != ''
+          UI.crash!('Unable to quit com.apple.CoreSimulator.CoreSimulatorService after 10 tries') if (launchctl_list_count += 1) > 10
+          commands << Actions.sh('launchctl stop com.apple.CoreSimulator.CoreSimulatorService &> /dev/null || true', log: false)
+          UI.verbose('Waiting for com.apple.CoreSimulator.CoreSimulatorService to quit')
+          sleep(0.25)
+        end
+        commands << Actions.sh('launchctl start com.apple.CoreSimulator.CoreSimulatorService &> /dev/null || true', log: false)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Restarts the com.apple.CoreSimulator.CoreSimulatorService."
+      end
+
+      def self.details
+        "Sometimes the com.apple.CoreSimulator.CoreSimulatorService can hang. " \
+        "Use this action to force-restart it."
+      end
+
+      def self.authors
+        ["lyndsey-ferguson/@lyndseydf"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

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

@@ -28,7 +28,7 @@ module Fastlane
             UI.important("Is the Build Setting, `ENABLE_TESTABILITY` enabled for the test target #{testable_name}?")
           end
           tests[testable_name] = test_identifiers.map do |test_identifier|
-            "#{testable_name.shellescape}/#{test_identifier}"
+            "#{testable_name.shellsafe_testidentifier}/#{test_identifier}"
           end
         end
         tests

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

@@ -0,0 +1,5 @@
+require_relative 'multi_scan_manager/interstitial'
+require_relative 'multi_scan_manager/report_collator'
+require_relative 'multi_scan_manager/simulator_manager'
+require_relative 'multi_scan_manager/runner'
+require_relative 'xctestrun_info'

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

@@ -0,0 +1,26 @@
+module FastlaneCore
+  class DeviceManager
+    class Device
+      def clone
+        raise 'Can only clone iOS Simulators' unless self.is_simulator
+        Device.new(
+          name: self.name,
+          udid: `xcrun simctl clone #{self.udid} '#{self.name}'`.chomp,
+          os_type: self.os_type,
+          os_version: self.os_version,
+          state: self.state,
+          is_simulator: self.is_simulator
+        )
+      end
+
+      def rename(newname)
+        `xcrun simctl rename #{self.udid} '#{newname}'`
+        self.name = newname
+      end
+
+      def boot
+        `xcrun simctl boot #{self.udid}`
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+module TestCenter
+  module Helper
+    module MultiScanManager
+      class Interstitial
+
+        attr_writer :output_directory
+        attr_writer :batch
+
+        def initialize(options)
+          @output_directory = options[:output_directory]
+          @testrun_completed_block = options[:testrun_completed_block]
+          @result_bundle = options[:result_bundle]
+          @scheme = options[:scheme]
+          @batch = options[:batch]
+          @reportnamer = options[:reportnamer]
+          @xcpretty_json_file_output = ENV['XCPRETTY_JSON_FILE_OUTPUT']
+          @parallelize = options[:parallelize]
+
+          before_all
+        end
+
+        # TODO: Should we be creating a new interstitial for each batch? yes.
+        # Should we clear out the result bundles before each batch? --> should
+        # it not be done before all batches? Same with env var for json resports.
+        def before_all
+          if @result_bundle
+            remove_preexisting_test_result_bundles
+          end
+          set_json_env_if_necessary
+          if @parallelize
+            @original_derived_data_path = ENV['SCAN_DERIVED_DATA_PATH']
+            FileUtils.mkdir_p(@output_directory)
+            ENV['SCAN_DERIVED_DATA_PATH'] = Dir.mktmpdir(nil, @output_directory)
+          end
+        end
+
+        def after_all
+          FastlaneCore::UI.message("resetting JSON ENV var to #{@xcpretty_json_file_output}")
+          ENV['XCPRETTY_JSON_FILE_OUTPUT'] = @xcpretty_json_file_output
+          if @parallelize
+            ENV['SCAN_DERIVED_DATA_PATH'] = @original_derived_data_path
+          end
+        end
+
+        def remove_preexisting_test_result_bundles
+          glob_pattern = "#{@output_directory}/.*\.test_result"
+          preexisting_test_result_bundles = Dir.glob(glob_pattern)
+          FileUtils.rm_rf(preexisting_test_result_bundles)
+        end
+
+        def move_test_result_bundle_for_next_run
+          if @result_bundle
+            built_test_result, moved_test_result = test_result_bundlepaths
+            FileUtils.mv(built_test_result, moved_test_result)
+          end
+        end
+
+        def test_result_bundlepaths
+          [
+            File.join(@output_directory, @scheme) + '.test_result',
+            File.join(@output_directory, @scheme) + "_#{@reportnamer.report_count}.test_result"
+          ]
+        end
+
+        def reset_simulators
+          destinations = Scan.config[:destination]
+          simulators = FastlaneCore::DeviceManager.simulators('iOS')
+          simulator_ids_to_reset = []
+          destinations.each do |destination|
+            destination.split(',').each do |destination_pair|
+              key, value = destination_pair.split('=')
+              if key == 'id'
+                simulator_ids_to_reset << value
+              end
+            end
+          end
+          simulators_to_reset = simulators.each.select { |simulator| simulator_ids_to_reset.include?(simulator.udid) }
+          simulators_to_reset.each do |simulator|
+            simulator.reset
+          end
+        end
+
+        def send_info_for_try(try_count)
+          puts "in send_info_for_try for #{@batch}"
+          return unless @testrun_completed_block
+
+          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)
+          info = {
+            failed: junit_results[:failed],
+            passing: junit_results[:passing],
+            batch: @batch,
+            try_count: try_count,
+            report_filepath: report_filepath
+          }
+
+          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 @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, @scheme) + test_result_suffix
+            info[:test_result_bundlepath] = test_result_bundlepath
+          end
+          puts "interstitial about to call #{@testrun_completed_block} for batch #{@batch}"
+          @testrun_completed_block.call(info)
+        end
+
+        def set_json_env_if_necessary
+          if @reportnamer && @reportnamer.includes_json?
+            ENV['XCPRETTY_JSON_FILE_OUTPUT'] = File.join(
+              @output_directory,
+              @reportnamer.json_last_reportname
+            )
+          end
+        end
+
+        def finish_try(try_count)
+          send_info_for_try(try_count)
+          reset_simulators
+          ENV['SCAN_DERIVED_DATA_PATH'] = Dir.mktmpdir(nil, @output_directory) if @parallelize
+          move_test_result_bundle_for_next_run
+          set_json_env_if_necessary
+          @reportnamer && @reportnamer.increment
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,113 @@
+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
+            config = create_config(
+              CollateJunitReportsAction,
+              {
+                reports: report_files,
+                collated_report: File.absolute_path(File.join(@output_directory, @reportnamer.junit_reportname(@suffix)))
+              }
+            )
+            CollateJunitReportsAction.run(config)
+            delete_globbed_intermediatefiles("#{@source_reports_directory_glob}/#{@reportnamer.junit_numbered_fileglob}")
+          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
+            config = create_config(
+              CollateJunitReportsAction,
+              {
+                reports: report_files,
+                collated_report: File.absolute_path(File.join(@output_directory, @reportnamer.html_reportname(@suffix)))
+              }
+            )
+            CollateHtmlReportsAction.run(config)
+            delete_globbed_intermediatefiles("#{@source_reports_directory_glob}/#{@reportnamer.html_numbered_fileglob}")
+          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
+            config = create_config(
+              CollateJsonReportsAction,
+              {
+                reports: report_files,
+                collated_report: File.absolute_path(File.join(@output_directory, @reportnamer.json_reportname(@suffix)))
+              }
+            )
+            CollateJsonReportsAction.run(config)
+            delete_globbed_intermediatefiles("#{@source_reports_directory_glob}/#{@reportnamer.json_numbered_fileglob}")
+          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
+            config = create_config(
+              CollateTestResultBundlesAction,
+              {
+                bundles: test_result_bundlepaths,
+                collated_bundle: "#{File.join(@output_directory, @scheme)}.test_result'"
+              }
+            )
+            CollateTestResultBundlesAction.run(config)
+            delete_globbed_intermediatefiles("#{@source_reports_directory_glob}/#{@scheme}-[1-9]*.test_result")
+          end
+        end
+      end
+    end
+  end
+end