fastlane-plugin-test_center 3.14.3 → 3.14.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e081e2a0d9d6bcb59c38f24072eb0059edef4457f03fed6e2318930260e9f5a4
-  data.tar.gz: 681403d6200f5d943e28f9c3fa6b90a6f450d7a9252c476eb7cf77c7e0c6101d
+  metadata.gz: 290ab3e6fb5932555e74d834784e80cb441dc4b7e4feb49eda479382a603a1e5
+  data.tar.gz: f46250359e1d156d283dd033e6e8db8c851297ea7a6385d78da4e72a014d0ebd
 SHA512:
-  metadata.gz: 98e979a4fbafe31e6dc33bd1a3a94a1e1da316ce8226c3688e9d223461a33c5d75c9291dc837e256c227915959547f8964df38c524e40b45742408235ee94713
-  data.tar.gz: 3049728d26e108dea44480f7445e41be419f4189e3bb2b63b8cef7871a9d7bf58b5edcee01351dc40496209f6805706bfcb0b6cf08b9fee6c43bba1decbfecda
+  metadata.gz: aaf987944f48d6511755077c7e4e1c564f722ad8c7f69f8c4e0f24b7c5db62590edc9fc69372e98d19e0cc8b7466f8b3fd2ef2a1ddba472b37bc45c3ee0b12a5
+  data.tar.gz: e1eb52e0b8b396019fe9727af6895948ad675c574b80293c866dfd627752d0e2dc3c8dd11b3e8f7508a40f1f64732a4b2987b1f92938aa6cf21b98d9c0d731d7

data/README.md

@@ -99,7 +99,7 @@ _fastlane_ is the easiest way to automate beta deployments and releases for your
 ## Supporters
 
 ![Владислав Давыдов](https://avatars1.githubusercontent.com/u/47553334?s=44&u=4691860dba898943b947180b3d28bb85851b0d7c&v=4)
-[vdavydovHH](https://github.com/vdavydovHH)
+[vdavydovHH](https://github.com/vdavydovHH)  ![amelendezSGY](https://avatars1.githubusercontent.com/u/28657466?s=44&v=4)[amelendezSGY](https://github.com/amelendezSGY)
 
 ## License
 

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

@@ -8,7 +8,7 @@ module Fastlane
         if report_filepaths.size == 1
           FileUtils.cp(report_filepaths[0], params[:collated_report])
         else
-          UI.verbose("collate_junit_reports with #{report_filepaths}")
+          verbose("collate_junit_reports with #{report_filepaths}")
           reports = report_filepaths.map { |report_filepath| REXML::Document.new(File.new(report_filepath)) }
           packages = reports.map { |r| r.root.attribute('name').value }.uniq
           combine_multiple_targets = packages.size > 1 
@@ -23,7 +23,7 @@ module Fastlane
             increment_testable_tries(target_report.root, report.root)
             package = report.root.attribute('name').value
             preprocess_testsuites(report, package, combine_multiple_targets)
-            UI.verbose("> collating last report file #{report_filepaths.last}")
+            verbose("> collating last report file #{report_filepaths.last}")
             report.elements.each('//testsuite') do |testsuite|
               testsuite_name = testsuite.attribute('name').value
               package_attribute = ''
@@ -32,15 +32,15 @@ module Fastlane
               end
               target_testsuite = REXML::XPath.first(target_report, "//testsuite[@name='#{testsuite_name}' #{package_attribute}]")
               if target_testsuite
-                UI.verbose("  > collating testsuite #{testsuite_name}")
+                verbose("  > collating testsuite #{testsuite_name}")
                 collate_testsuite(target_testsuite, testsuite)
-                UI.verbose("  < collating testsuite #{testsuite_name}")
+                verbose("  < collating testsuite #{testsuite_name}")
               else
                 testable = REXML::XPath.first(target_report, "//testsuites")
                 testable << testsuite
               end
             end
-            UI.verbose("< collating last report file #{report_filepaths.last}")
+            verbose("< collating last report file #{report_filepaths.last}")
           end
           target_report.elements.each('//testsuite') do |testsuite|
             update_testsuite_counts(testsuite)
@@ -83,12 +83,12 @@ module Fastlane
         testsuite_name = testsuite.attribute('name').value
         duplicate_testsuites = REXML::XPath.match(report, "//testsuite[@name='#{testsuite_name}']")
         if duplicate_testsuites.size > 1
-          UI.verbose("    > flattening_duplicate_testsuites")
+          verbose("    > flattening_duplicate_testsuites")
           duplicate_testsuites.drop(1).each do |duplicate_testsuite|
             collate_testsuite(testsuite, duplicate_testsuite)
             duplicate_testsuite.parent.delete_element(duplicate_testsuite)
           end
-          UI.verbose("    < flattening_duplicate_testsuites")
+          verbose("    < flattening_duplicate_testsuites")
         end
         update_testsuite_counts(testsuite)
       end
@@ -108,14 +108,14 @@ module Fastlane
           target_testcase = REXML::XPath.first(target_testsuite, "testcase[@name='#{name}' and @classname='#{classname}']")
           # Replace target_testcase with testcase
           if target_testcase
-            UI.verbose("      collate_testsuite with testcase #{name}")
-            UI.verbose("      replacing \"#{target_testcase}\" with \"#{testcase}\"")
+            verbose("      collate_testsuite with testcase #{name}")
+            verbose("      replacing \"#{target_testcase}\" with \"#{testcase}\"")
             parent = target_testcase.parent
             increment_testcase_tries(target_testcase, testcase) unless testcase.root == target_testcase.root 
             parent.insert_after(target_testcase, testcase)
             parent.delete_element(target_testcase)
-            UI.verbose("")
-            UI.verbose("      target_testcase after replacement \"#{parent}\"")
+            verbose("")
+            verbose("      target_testcase after replacement \"#{parent}\"")
           else
             target_testsuite << testcase
           end
@@ -165,6 +165,12 @@ module Fastlane
         (value1 + value2).to_s
       end
 
+      def self.verbose(message)
+        return if ENV.fetch('COLLATE_JUNIT_REPORTS_VERBOSITY', 1).to_i.zero?
+
+        UI.verbose(message)
+      end
+
       #####################################################
       # @!group Documentation
       #####################################################

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

@@ -28,16 +28,23 @@ module Fastlane
         force_quit_simulator_processes if params[:quit_simulators]
 
         prepare_for_testing(params.values)
+        
+        tests_passed = true
+        summary = {}
+        if params[:build_for_testing]
+          summary = build_summary
+        else
+          coerce_destination_to_array(params)
+          platform = :mac
+          platform = :ios_simulator if Scan.config[:destination].any? { |d| d.include?('platform=iOS Simulator') }
 
-        coerce_destination_to_array(params)
-        platform = :mac
-        platform = :ios_simulator if Scan.config[:destination].any? { |d| d.include?('platform=iOS Simulator') }
+          runner_options = params.values.merge(platform: platform)
+          runner = ::TestCenter::Helper::MultiScanManager::Runner.new(runner_options)
+          tests_passed = runner.run
 
-        runner_options = params.values.merge(platform: platform)
-        runner = ::TestCenter::Helper::MultiScanManager::Runner.new(runner_options)
-        tests_passed = runner.run
+          summary = run_summary(params, tests_passed)
+        end
 
-        summary = run_summary(params, tests_passed)
         print_run_summary(summary)
 
         if params[:fail_build] && !tests_passed
@@ -101,6 +108,16 @@ module Fastlane
         # :nocov:
       end
 
+      def self.build_summary
+        {
+          result: true,
+          total_tests: 0,
+          passing_testcount: 0,
+          failed_testcount: 0,
+          total_retry_count: 0
+        }
+      end
+
       def self.run_summary(scan_options, tests_passed)
         scan_options = scan_options.clone
 
@@ -361,6 +378,14 @@ module Fastlane
               UI.user_error!("Error: Batch counts must be greater than zero") unless count > 0
             end
           ),
+          FastlaneCore::ConfigItem.new(
+            key: :batches,
+            env_name: "FL_MULTI_SCAN_BATCHES",
+            description: "The explicit batches (an Array of Arrays of test identifiers) to run either serially, or each batch on a simulator in parallel if :parallel_testrun_count is given",
+            type: Array,
+            optional: true,
+            conflicting_options: [:batch_count]
+          ),
           FastlaneCore::ConfigItem.new(
             key: :retry_test_runner_failures,
             description: "Set to true If you want to treat build failures during testing, like 'Test runner exited before starting test execution', as 'all tests failed'",
@@ -375,7 +400,7 @@ module Fastlane
             is_string: false,
             default_value: false,
             optional: true,
-            conflicting_options: [:batch_count],
+            conflicting_options: %i[batch_count batches],
             conflict_block: proc do |value|
               UI.user_error!(
                 "Error: Can't use 'invocation_based_tests' and 'batch_count' options in one run, "\
@@ -433,7 +458,7 @@ module Fastlane
           ),
           FastlaneCore::ConfigItem.new(
             key: :testrun_completed_block,
-            description: 'A block invoked each time a test run completes. When combined with :parallel_testrun_count, will be called separately in each child process',
+            description: 'A block invoked each time a test run completes. When combined with :parallel_testrun_count, will be called separately in each child process. Return a Hash with :continue set to false to stop retrying tests, or :only_testing to change which tests will be run in the next try',
             optional: true,
             is_string: false,
             default_value: nil,
@@ -461,6 +486,10 @@ module Fastlane
 
             # UI.abort_with_message!('You could conditionally abort')
             UI.message(\"\\\u1F60A everything is fine, let's continue try \#{try_attempt + 1} for batch \#{batch}\")
+            {
+              continue: true,
+              only_testing: ['AtomicBoyUITests/AtomicBoyUITests/testExample17']
+            }
           end
 
           multi_scan(
@@ -486,6 +515,120 @@ module Fastlane
             output_files: 'report.json',
             fail_build: false
           )
+          ",
+          "
+          UI.header('batches feature')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            try_count: 3,
+            fail_build: false,
+            batches: [
+              [
+                'AtomicBoyUITests/AtomicBoyUITests/testExample5',
+                'AtomicBoyUITests/AtomicBoyUITests/testExample10',
+                'AtomicBoyUITests/AtomicBoyUITests/testExample15'
+              ],
+              [
+                'AtomicBoyUITests/AtomicBoyUITests/testExample6',
+                'AtomicBoyUITests/AtomicBoyUITests/testExample12',
+                'AtomicBoyUITests/AtomicBoyUITests/testExample18'
+              ]
+            ]
+          )
+          "
+        ]
+      end
+
+      def self.integration_tests
+        [
+          "
+          UI.header('Basic test')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            disable_xcpretty: true
+          )
+          ",
+          "
+          UI.header('Basic test with 1 specific test')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            only_testing: ['AtomicBoyUITests/AtomicBoyUITests/testExample']
+          )
+          ",
+          "
+          UI.header('Basic test with test target expansion')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            only_testing: ['AtomicBoyUITests', 'AtomicBoyTests']
+          )
+          ",
+          "
+          UI.header('Parallel test run')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            parallel_testrun_count: 2
+          )
+          ",
+          "
+          UI.header('Parallel test run with fewer tests than parallel test runs')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            parallel_testrun_count: 4,
+            only_testing: ['AtomicBoyUITests/AtomicBoyUITests/testExample']
+          )
+          ",
+          "
+          UI.header('Basic test with batch count')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            batch_count: 2
+          )
+          ",
+          "
+          UI.header('Basic test with batches')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            fail_build: false,
+            try_count: 2,
+            batches: [
+              ['AtomicBoyUITests/AtomicBoyUITests/testExample', 'AtomicBoyUITests/AtomicBoyUITests/testExample2'],
+              ['AtomicBoyUITests/AtomicBoyUITests/testExample3', 'AtomicBoyUITests/AtomicBoyUITests/testExample4']
+            ],
+            parallel_testrun_count: 2
+          )
+          ",
+          "
+          UI.header('Basic test with xcresult')
+          multi_scan(
+            workspace: File.absolute_path('../AtomicBoy/AtomicBoy.xcworkspace'),
+            scheme: 'AtomicBoy',
+            output_types: 'xcresult',
+            output_files: 'result.xcresult',
+            collate_reports: false,
+            fail_build: false,
+            try_count: 2,
+            batch_count: 2
+          )
           "
         ]
       end

data/lib/fastlane/plugin/test_center/helper/fastlane_core/device_manager/simulator_extensions.rb

@@ -1,6 +1,7 @@
 
 module FixedCopyLogarchiveFastlaneSimulator
   def self.included(base)
+    @@log_collection_start_time = DateTime.now
     base.instance_eval do
       def copy_logarchive(device, log_identity, logs_destination_dir)
         require 'shellwords'
@@ -8,7 +9,11 @@ module FixedCopyLogarchiveFastlaneSimulator
         logarchive_dst = File.join(logs_destination_dir, "system_logs-#{log_identity}.logarchive")
         FileUtils.rm_rf(logarchive_dst)
         FileUtils.mkdir_p(File.expand_path("..", logarchive_dst))
-        command = "xcrun simctl spawn #{device.udid} log collect --output #{logarchive_dst.shellescape} 2>/dev/null"
+
+        logs_collection_start = @@log_collection_start_time.strftime('%Y-%m-%d %H:%M:%S')
+        command = "xcrun simctl spawn #{device.udid} log collect "
+        command << "--start '#{logs_collection_start}' "
+        command << "--output #{logarchive_dst.shellescape} 2>/dev/null"
         FastlaneCore::CommandExecutor.execute(command: command, print_all: false, print_command: true)
       end
     end

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

@@ -1,6 +1,13 @@
 module TestCenter
   module Helper
     module HtmlTestReport
+
+      def self.verbose(message)
+        return if ENV.fetch('COLLATE_HTML_REPORTS_VERBOSITY', 1).to_i.zero?
+
+        FastlaneCore::UI.verbose(message)
+      end
+
       class Report
         require 'rexml/formatters/transitive'
 
@@ -24,16 +31,16 @@ module TestCenter
         def collate_report(report)
           testsuites.each(&:remove_duplicate_testcases)
           report.testsuites.each(&:remove_duplicate_testcases)
-          FastlaneCore::UI.verbose("TestCenter::Helper::HtmlTestReport::Report.collate_report to report:\n\t#{@root}")
+          HtmlTestReport.verbose("TestCenter::Helper::HtmlTestReport::Report.collate_report to report:\n\t#{@root}")
           report.testsuites.each do |given_testsuite|
             existing_testsuite = testsuite_with_title(given_testsuite.title)
             if existing_testsuite.nil?
-              FastlaneCore::UI.verbose("\tadding testsuite\n\t\t#{given_testsuite}")
+              HtmlTestReport.verbose("\tadding testsuite\n\t\t#{given_testsuite}")
               add_testsuite(given_testsuite)
             else
-              FastlaneCore::UI.verbose("\tcollating testsuite\n\t\t#{given_testsuite.root}")
+              HtmlTestReport.verbose("\tcollating testsuite\n\t\t#{given_testsuite.root}")
               existing_testsuite.collate_testsuite(given_testsuite)
-              FastlaneCore::UI.verbose("\tafter collation exiting testsuite\n\t\t#{existing_testsuite.root}")
+              HtmlTestReport.verbose("\tafter collation exiting testsuite\n\t\t#{existing_testsuite.root}")
             end
           end
           update_test_count
@@ -210,15 +217,15 @@ module TestCenter
           given_testcases.each do |given_testcase|
             existing_testcase = testcase_with_title(given_testcase.title)
             if existing_testcase.nil?
-              FastlaneCore::UI.verbose("\t\tadding testcase\n\t\t\t#{given_testcase.root}")
+              HtmlTestReport.verbose("\t\tadding testcase\n\t\t\t#{given_testcase.root}")
               unless given_testcase.passing?
-                FastlaneCore::UI.verbose("\t\t\twith failure:\n\t\t\t\t#{given_testcase.failure_details}")
+                HtmlTestReport.verbose("\t\t\twith failure:\n\t\t\t\t#{given_testcase.failure_details}")
               end
               add_testcase(given_testcase)
             else
-              FastlaneCore::UI.verbose("\t\tupdating testcase\n\t\t\t#{existing_testcase.root}")
+              HtmlTestReport.verbose("\t\tupdating testcase\n\t\t\t#{existing_testcase.root}")
               unless given_testcase.passing?
-                FastlaneCore::UI.verbose("\t\t\twith failure:\n\t\t\t\t#{given_testcase.failure_details}")
+                HtmlTestReport.verbose("\t\t\twith failure:\n\t\t\t\t#{given_testcase.failure_details}")
               end
               existing_testcase.update_testcase(given_testcase)
             end
@@ -275,7 +282,7 @@ module TestCenter
           color = row_color
           failure = failure_details
           if failure.nil? && !passing?
-            FastlaneCore::UI.error("\t\t\t\tupdating failing test case that does not have failure_details")
+            HtmlTestReport.error("\t\t\t\tupdating failing test case that does not have failure_details")
           end
           parent = @root.parent
 
@@ -283,7 +290,7 @@ module TestCenter
 
           new_failure = testcase.failure_details
           if new_failure && testcase.passing?
-            FastlaneCore::UI.error("\t\t\t\tswapping passing failing test case that _does_have_ failure_details")
+            HtmlTestReport.error("\t\t\t\tswapping passing failing test case that _does_have_ failure_details")
           end
 
           parent.replace_child(@root, testcase.root)

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

@@ -50,7 +50,11 @@ module TestCenter
           if @options[:scan_devices_override]
             scan_device_names = @options[:scan_devices_override].map { |device| device.name }
             FastlaneCore::UI.verbose("\tSetting Scan.devices to #{scan_device_names}")
-            Scan.devices.replace(@options[:scan_devices_override])
+            if Scan.devices
+              Scan.devices.replace(@options[:scan_devices_override])
+            else
+              Scan.devices = @options[:scan_devices_override]
+            end
           end
         end
 

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

@@ -16,6 +16,7 @@ module TestCenter
             @options[:output_files],
             @options[:custom_report_file_name]
           )
+          @callback_overrides_only_testing = false
         end
 
         def before_testrun
@@ -189,7 +190,26 @@ module TestCenter
           update_json_failure_details(info)
           update_test_result_bundle_details(info)
 
-          @options[:testrun_completed_block].call(info)
+          @callback_overrides_only_testing = false
+          callback_result = @options[:testrun_completed_block].call(info)
+          if callback_result.kind_of?(Hash)
+            should_continue = callback_result.fetch(:continue, true)
+            if !should_continue
+              discontinue_message = 'Following testrun_completed_block\'s request to discontinue testing'
+              discontinue_message << " for batch ##{@options[:batch]}" unless @options[:batch].nil?
+              FastlaneCore::UI.verbose(discontinue_message)
+              @testrun_count = options[:try_count]
+            end
+            overridden_only_testing = callback_result.fetch(:only_testing, nil)
+            if overridden_only_testing && should_continue
+              override_only_testing_message = 'Following testrun_completed_block\'s request to change :only_testing to '
+              override_only_testing_message << overridden_only_testing.to_s
+              override_only_testing_message << " for batch ##{@options[:batch]}" unless @options[:batch].nil?
+              FastlaneCore::UI.verbose(override_only_testing_message)
+              @callback_overrides_only_testing = true
+              @options[:only_testing] = overridden_only_testing
+            end
+          end
         end
 
         def failure_details(additional_info)
@@ -242,6 +262,8 @@ module TestCenter
         end
 
         def update_only_testing
+          return if @callback_overrides_only_testing
+
           report_filepath = File.join(output_directory, @reportnamer.junit_last_reportname)
           config = FastlaneCore::Configuration.create(
             Fastlane::Actions::TestsFromJunitAction.available_options,

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

@@ -41,6 +41,7 @@ module TestCenter
         def setup_logcollection
           FastlaneCore::UI.verbose("> setup_logcollection")
           return unless @options[:include_simulator_logs]
+          return unless @options[:platform] == :ios_simulator
           return if Scan::Runner.method_defined?(:prelaunch_simulators)
 
           # We need to prelaunch the simulators so xcodebuild
@@ -65,8 +66,8 @@ module TestCenter
 
           @test_collector = TestCollector.new(@options)
           @options.reject! { |key| %i[testplan].include?(key) }
-          @batch_count = @test_collector.test_batches.size
-          tests = @test_collector.test_batches.flatten
+          @batch_count = @test_collector.batches.size
+          tests = @test_collector.batches.flatten
           if tests.size < @options[:parallel_testrun_count].to_i
             FastlaneCore::UI.important(":parallel_testrun_count greater than the number of tests (#{tests.size}). Reducing to that number.")
             @options[:parallel_testrun_count] = tests.size
@@ -89,16 +90,51 @@ module TestCenter
           remove_preexisting_test_result_bundles
           remote_preexisting_xcresult_bundles
 
-          tests_passed = false
+          test_results = [false]
           if should_run_tests_through_single_try?
-            tests_passed = run_tests_through_single_try
+            test_results.clear
+            setup_run_tests_for_each_device do |device_name|
+              FastlaneCore::UI.message("Single try testing for device '#{device_name}'") if device_name
+              test_results << run_tests_through_single_try
+            end
           end
 
-          unless tests_passed || @options[:try_count] < 1
+          unless test_results.all? || @options[:try_count] < 1
+            test_results.clear 
             setup_testcollector
-            tests_passed = run_test_batches
+            setup_run_tests_for_each_device do |device_name|
+              FastlaneCore::UI.message("Testing batches for device '#{device_name}'") if device_name
+              test_results << run_test_batches
+            end
           end
-          tests_passed
+          test_results.all?
+        end
+
+        def setup_run_tests_for_each_device
+          original_output_directory = @options.fetch(:output_directory, 'test_results') 
+          unless @options[:platform] == :ios_simulator
+            yield
+            return
+          end
+
+          scan_destinations = Scan.config[:destination].clone
+          try_count = @options[:try_count]
+
+          scan_destinations.each_with_index do |destination, device_index|
+            @options[:try_count] = try_count
+            device_udid_match = destination.match(/id=(?<udid>[^,]+)/)
+            device_udid = device_udid_match[:udid] if device_udid_match
+            if scan_destinations.size > 1
+              @options[:output_directory] = File.join(original_output_directory, device_udid)
+              Scan.config[:destination].replace([destination])
+            end
+            command = "xcrun simctl list devices | grep #{device_udid}"
+            device_info = Fastlane::Actions.sh(command, log: false)
+
+            yield device_info.strip.gsub(/ \(#{device_udid}.*/, '')
+          end
+          Scan.config[:destination].replace(scan_destinations)
+          @options[:output_directory] = original_output_directory
         end
 
         def should_run_tests_through_single_try?
@@ -196,7 +232,7 @@ module TestCenter
           pool = TestBatchWorkerPool.new(pool_options)
           pool.setup_workers
 
-          remaining_test_batches = @test_collector.test_batches.clone
+          remaining_test_batches = @test_collector.batches.clone
           remaining_test_batches.each_with_index do |test_batch, current_batch_index|
             worker = pool.wait_for_worker
             FastlaneCore::UI.message("Starting test run #{current_batch_index + 1}")
@@ -209,7 +245,7 @@ module TestCenter
         end
 
         def scan_options_for_worker(test_batch, batch_index)
-          if @test_collector.test_batches.size > 1
+          if @test_collector.batches.size > 1
             # If there are more than 1 batch, then we want each batch result
             # sent to a "batch index" output folder to be collated later
             # into the requested output_folder.

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

@@ -63,7 +63,9 @@ module TestCenter
         def parallel_scan_options(worker_index)
           options = @options.reject { |key| %i[device devices].include?(key) }
           options[:destination] = destination_for_worker(worker_index)
-          options[:scan_devices_override] = simulator_devices_for_worker(worker_index)
+          if @options[:platform] == :ios_simulator
+            options[:scan_devices_override] = simulator_devices_for_worker(worker_index)
+          end
           options[:buildlog_path] = buildlog_path_for_worker(worker_index) if @options[:buildlog_path]
           options[:derived_data_path] = derived_data_path_for_worker(worker_index)
           options[:batch_index] = worker_index
@@ -89,6 +91,12 @@ module TestCenter
           clones.flatten.each(&:delete)
         end
 
+        def shutdown_cloned_simulators(clones)
+          return if clones.nil?
+
+          clones.flatten.each(&:shutdown)
+        end
+
         def setup_serial_workers
           serial_scan_options = @options.reject { |key| %i[device devices].include?(key) }
           serial_scan_options[:destination] ||= Scan&.config&.fetch(:destination)
@@ -125,6 +133,7 @@ module TestCenter
             busy_workers.map(&:pid).each do |pid|
               Process.wait(pid)
             end
+            shutdown_cloned_simulators(@clones)
             busy_workers.each { |w| w.process_results }
           end
         end

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

@@ -3,34 +3,154 @@ module TestCenter
     require 'fastlane_core/ui/ui.rb'
     require 'fastlane/actions/scan'
     require 'plist'
+    require 'set'
 
     class TestCollector
       attr_reader :xctestrun_path
-      attr_reader :only_testing
+      attr_reader :batches
+      attr_reader :testables
 
       def initialize(options)
-        unless options[:xctestrun] || options[:derived_data_path]
-          options[:derived_data_path] = default_derived_data_path(options)
+        @invocation_based_tests = options[:invocation_based_tests]
+        @swift_test_prefix = options[:swift_test_prefix]
+
+        @xctestrun_path = self.class.xctestrun_filepath(options)
+        initialize_batches(options)
+      end
+
+      private
+
+      def initialize_batches(options)
+        if options[:batches]
+          expand_given_batches_to_full_test_identifiers(options)
+        else
+          derive_batches_from_tests(options)
         end
-        @xctestrun_path = options[:xctestrun] || derived_testrun_path(options[:derived_data_path], options[:scheme])
-        unless @xctestrun_path && File.exist?(@xctestrun_path)
-          FastlaneCore::UI.user_error!("Error: cannot find xctestrun file '#{@xctestrun_path}'")
+      end
+
+      def expand_given_batches_to_full_test_identifiers(options)
+        @batches = options[:batches]
+        testables = Set.new
+        @batches.each do |batch|
+          expand_test_identifiers(batch)
+          batch.each { |t| testables << t.split('/')[0] }
         end
-        @only_testing = options[:only_testing] || only_testing_from_testplan(options)
-        if @only_testing.kind_of?(String)
-          @only_testing = @only_testing.split(',')
+        @testables = testables.to_a
+      end
+
+      def derive_batch_count(options)
+        batch_count = options.fetch(:batch_count, 1)
+        if batch_count == 1 && options.fetch(:parallel_testrun_count, 0) > 1
+          # if the batch count is 1, and the users wants parallel runs
+          # we *must* set the batch count to the same number of parallel
+          # runs or else the desired reports will not be written
+          batch_count = options[:parallel_testrun_count]
         end
-        @skip_testing = options[:skip_testing]
-        @invocation_based_tests = options[:invocation_based_tests]
-        @batch_count = options[:batch_count]
-        if @batch_count == 1 && options[:parallel_testrun_count] > 1
-          @batch_count = options[:parallel_testrun_count]
+        batch_count
+      end
+
+      def derive_only_testing(options)
+        only_testing = options[:only_testing] || self.class.only_testing_from_testplan(options)
+        if only_testing && only_testing.kind_of?(String)
+          only_testing = only_testing.split(',').map(&:strip)
         end
+        only_testing
+      end
 
-        @swift_test_prefix = options[:swift_test_prefix]
+      def testable_tests_hash_from_options(options)
+        testable_tests_hash = Hash.new { |h, k| h[k] = [] }
+        only_testing = derive_only_testing(options)
+        if only_testing
+          expand_test_identifiers(only_testing)
+          only_testing.each do |test_identifier|
+            testable = test_identifier.split('/')[0]
+            testable_tests_hash[testable] << test_identifier
+          end
+        else
+          testable_tests_hash = xctestrun_known_tests.clone
+          if options[:skip_testing]
+            expand_test_identifiers(options[:skip_testing])
+            testable_tests_hash.each do |testable, test_identifiers|
+              test_identifiers.replace(test_identifiers - options[:skip_testing])
+              testable_tests_hash.delete(testable) if test_identifiers.empty?
+            end
+          end
+        end
+        testable_tests_hash
+      end
+
+      def derive_batches_from_tests(options)
+        @batches = []
+        testable_tests_hash = testable_tests_hash_from_options(options)
+        @testables = testable_tests_hash.keys
+        batch_count = derive_batch_count(options)
+        testable_tests_hash.each do |testable, test_identifiers|
+          next if test_identifiers.empty?
+
+          if batch_count > 1
+            slice_count = [(test_identifiers.length / batch_count.to_f).ceil, 1].max
+            test_identifiers.each_slice(slice_count).to_a.each do |batch|
+              @batches << batch
+            end
+          else
+            @batches << test_identifiers
+          end
+        end
+      end
+
+      def expand_test_identifiers(test_identifiers)
+        all_known_tests = nil
+        test_identifiers.each_with_index do |test_identifier, index|
+          test_components = test_identifier.split('/')
+          is_full_test_identifier = (test_components.size == 3)
+          next if is_full_test_identifier
+
+          all_known_tests ||= xctestrun_known_tests.clone
+
+          testsuite = ''
+          testable = test_components[0]
+          expanded_test_identifiers = []
+          if test_components.size == 1
+            # this is a testable, also known as a test target. Let's expand it out
+            # to all of its tests. Note: a test target can have many testSuites, each
+            # with their own testCases.
+            if all_known_tests[testable].to_a.empty?
+              FastlaneCore::UI.verbose("Unable to expand #{testable} to constituent tests")
+              expanded_test_identifiers = [testable]
+            else
+              expanded_test_identifiers = all_known_tests[testable]
+            end
+          else
+            # this is a testable and a test suite, let's expand it out to all of
+            # its testCases. Note: if the user put the same test identifier in more than
+            # one place in this array, this could lead to multiple repititions of the same
+            # set of test identifiers
+            testsuite = test_components[1]
+            expanded_test_identifiers = all_known_tests[testable].select do |known_test|
+              known_test.split('/')[1] == testsuite
+            end
+          end
+          test_identifiers.delete_at(index)
+          test_identifiers.insert(index, *expanded_test_identifiers)
+        end
+      end
+
+      def xctestrun_known_tests
+        unless @known_tests
+          config = FastlaneCore::Configuration.create(
+            ::Fastlane::Actions::TestsFromXctestrunAction.available_options,
+            {
+              xctestrun: @xctestrun_path,
+              invocation_based_tests: @invocation_based_tests,
+              swift_test_prefix: @swift_test_prefix
+            }
+          )
+          @known_tests = ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
+        end
+        @known_tests
       end
 
-      def only_testing_from_testplan(options)
+      def self.only_testing_from_testplan(options)
         return unless options[:testplan] && options[:scheme]
 
         config = FastlaneCore::Configuration.create(
@@ -60,153 +180,26 @@ module TestCenter
         return test_options[:only_testing]
       end
 
-      def default_derived_data_path(options)
+      def self.default_derived_data_path
         project_derived_data_path = Scan.project.build_settings(key: "BUILT_PRODUCTS_DIR")
         File.expand_path("../../..", project_derived_data_path)
       end
 
-      def derived_testrun_path(derived_data_path, scheme)
+      def self.derived_testrun_path(derived_data_path)
         xctestrun_files = Dir.glob("#{derived_data_path}/Build/Products/*.xctestrun")
         xctestrun_files.sort { |f1, f2| File.mtime(f1) <=> File.mtime(f2) }.last
       end
 
-      def testables
-        unless @testables
-          if @only_testing
-            @testables ||= only_testing_to_testables_tests.keys
-          else
-            @testables = xctestrun_known_tests.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 xctestrun_known_tests
-        unless @known_tests
-          config = FastlaneCore::Configuration.create(
-            ::Fastlane::Actions::TestsFromXctestrunAction.available_options,
-            {
-              xctestrun: @xctestrun_path,
-              invocation_based_tests: @invocation_based_tests,
-              swift_test_prefix: @swift_test_prefix
-            }
-          )
-          @known_tests = ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
-        end
-        @known_tests
-      end
-
-      def expand_short_testidentifiers_to_tests(testables_tests)
-        # Remember, testable_tests is of the format:
-        # {
-        #   'testable1' => [
-        #     'testsuite1/testcase1',
-        #     'testsuite1/testcase2',
-        #     'testsuite2/testcase1',
-        #     'testsuite2/testcase2',
-        #     ...
-        #     'testsuiteN/testcase1', ... 'testsuiteN/testcaseM'
-        #   ],
-        #   ...
-        #   'testableO' => [
-        #     'testsuite1/testcase1',
-        #     'testsuite1/testcase2',
-        #     'testsuite2/testcase1',
-        #     'testsuite2/testcase2',
-        #     ...
-        #     'testsuiteN/testcase1', ... 'testsuiteN/testcaseM'
-        #   ]
-        # }
-        return if @invocation_based_tests
-
-        # iterate among all the test identifers for each testable
-        # A test identifier is seperated into components by '/'
-        # if a test identifier has only 2 separators, it probably is
-        # 'testable/testsuite' (but it could be 'testsuite/testcase' )
-        all_known_tests = nil
-        known_tests = []
-        testables_tests.each do |testable, tests|
-          tests.each_with_index do |test, index|
-            test_components = test.split('/')
-            is_full_test_identifier = (test_components.size == 3)
-            next if is_full_test_identifier
-
-            all_known_tests ||= xctestrun_known_tests.clone
-
-            testsuite = ''
-            if test_components.size == 1
-              if test_components[0] == testable
-                # The following || [] is just in case the user provided multiple
-                # test targets or there are no actual tests found.
-                testables_tests[testable][index] = all_known_tests[testable] || []
-                all_known_tests.delete(testable)
-                next
-              end
-
-              testsuite = test_components[0]
-            else
-              testsuite = test_components[1]
-            end
-
-            testables_tests[testable][index], all_known_tests[testable] = all_known_tests[testable].partition do |known_test|
-              known_test.split('/')[1] == testsuite
-            end
-          end
-          testables_tests[testable].flatten!
-        end
-      end
-
-      def testables_tests
-        unless @testables_tests
-          if @only_testing
-            @testables_tests = only_testing_to_testables_tests
-            expand_short_testidentifiers_to_tests(@testables_tests)
-          else
-            @testables_tests = xctestrun_known_tests
-            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
+      def self.xctestrun_filepath(options)
+        unless options[:xctestrun] || options[:derived_data_path]
+          options[:derived_data_path] = default_derived_data_path
         end
+        path = (options[:xctestrun] || derived_testrun_path(options[:derived_data_path]))
 
-        @testables_tests
-      end
-
-      def test_batches
-        if @batches.nil?
-          @batches = []
-          testables.each do |testable|
-            testable_tests = testables_tests[testable]
-            next if testable_tests.empty?
-
-            if @batch_count > 1
-              slice_count = [(testable_tests.length / @batch_count.to_f).ceil, 1].max
-              testable_tests.each_slice(slice_count).to_a.each do |tests_batch|
-                @batches << tests_batch
-              end
-            else
-              @batches << testable_tests
-            end
-          end
+        unless path && File.exist?(path)
+          FastlaneCore::UI.user_error!("Error: cannot find xctestrun file '#{path}'")
         end
-
-        @batches
+        path
       end
     end
   end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module TestCenter
-    VERSION = "3.14.3"
+    VERSION = "3.14.8"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-test_center
 version: !ruby/object:Gem::Version
-  version: 3.14.3
+  version: 3.14.8
 platform: ruby
 authors:
 - Lyndsey Ferguson
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-15 00:00:00.000000000 Z
+date: 2020-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -310,7 +310,7 @@ homepage: https://github.com/lyndsey-ferguson/fastlane-plugin-test_center
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -326,7 +326,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Makes testing your iOS app easier
 test_files: []