fastlane-plugin-test_center 3.14.2 → 3.14.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5110e6b44d55945155e5769bf07fa9a1883521d125349f0d06211eea98014d14
-  data.tar.gz: ae0ffaa0f14c026a2ffdf2413f9b119142a130ba530742746715f2338cd058d2
+  metadata.gz: 83032c7ae1a7fd821330d9729adcc3a6adc82a3767f7e1aa04327227bf1dfcb0
+  data.tar.gz: 44fe3edc2e95fdcf129b6031e4e01e586c7acecba69b99e47a9d4034fff57878
 SHA512:
-  metadata.gz: 00eeb25839214b31b2cdf248f0daa5978fba3a3e1e03c31b994bf24b618e6fd56588a2e2c41c4b6610346892c5a4460db0df854c78014b2aafdf3ee1651b37cb
-  data.tar.gz: 4928830dfca2a60011d1435ee38532bebfb4d9e7b3887cd3088f1a7dcc26fe503028229b4d73d64e04d166ac21ee25d8bd8641a0a8b30e4eb96400e160d932e5
+  metadata.gz: 2a50e19f593fb782828cd14ca45468f5841b1b20781701c0982c644a4cb88d9261f83ccf75eb900c562c4611baca19691e7f5d9094bb909fba11512eb0e813b1
+  data.tar.gz: 56bb12fd6b0ed79041d98d97977b5946fd83d6a05b7f623dbb1ac6145ebf4f8da852f2f69a0766aeb11b617ad7b01c62f404d63b378e7656f5589db8d59813c0

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_html_reports.rb

@@ -44,9 +44,10 @@ module Fastlane
         html_file_contents = File.read(html_report_filepath)
         File.open(html_report_filepath, 'w') do |file|
           html_file_contents.each_line do |line|
-            m = %r{(<section class="test-detail[^"]*">)(.*(<|>).*)(</section>)}.match(line)
+            m = %r{(<section class="test-detail[^"]*">)(.*(<|>|&(?!amp;)).*)(</section>)}.match(line)
             if m
               test_details = m[2]
+              test_details.gsub!(/&(?!amp;)/, '&amp;')
               test_details.gsub!('<', '&lt;')
               test_details.gsub!('>', '&gt;')
               line = m[1] + test_details + m[4]

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

@@ -1,6 +1,7 @@
 module Fastlane
   module Actions
     class CollateJunitReportsAction < Action
+      require 'set'
 
       def self.run(params)
         report_filepaths = params[:reports]
@@ -9,17 +10,27 @@ module Fastlane
         else
           UI.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 
+
           # copy any missing testsuites
           target_report = reports.shift
-          preprocess_testsuites(target_report)
+
+          package = target_report.root.attribute('name').value
+          preprocess_testsuites(target_report, package, combine_multiple_targets)
 
           reports.each do |report|
             increment_testable_tries(target_report.root, report.root)
-            preprocess_testsuites(report)
+            package = report.root.attribute('name').value
+            preprocess_testsuites(report, package, combine_multiple_targets)
             UI.verbose("> collating last report file #{report_filepaths.last}")
             report.elements.each('//testsuite') do |testsuite|
               testsuite_name = testsuite.attribute('name').value
-              target_testsuite = REXML::XPath.first(target_report, "//testsuite[@name='#{testsuite_name}']")
+              package_attribute = ''
+              if combine_multiple_targets
+                package_attribute = "@package='#{package}'"
+              end
+              target_testsuite = REXML::XPath.first(target_report, "//testsuite[@name='#{testsuite_name}' #{package_attribute}]")
               if target_testsuite
                 UI.verbose("  > collating testsuite #{testsuite_name}")
                 collate_testsuite(target_testsuite, testsuite)
@@ -36,6 +47,7 @@ module Fastlane
           end
           testable = REXML::XPath.first(target_report, 'testsuites')
           update_testable_counts(testable)
+          testable.add_attribute('name', packages.to_a.join(', '))
 
           FileUtils.mkdir_p(File.dirname(params[:collated_report]))
           File.open(params[:collated_report], 'w') do |f|
@@ -81,10 +93,11 @@ module Fastlane
         update_testsuite_counts(testsuite)
       end
 
-      def self.preprocess_testsuites(report)
+      def self.preprocess_testsuites(report, package, combine_multiple_targets)
         report.elements.each('//testsuite') do |testsuite|
           flatten_duplicate_testsuites(report, testsuite)
           collapse_testcase_multiple_failures_in_testsuite(testsuite)
+          testsuite.add_attribute('package', package) if combine_multiple_targets
         end
       end
 

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/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.
@@ -234,6 +270,7 @@ module TestCenter
           @test_collector.testables.each do |testable|
             collate_batched_reports_for_testable(testable)
           end
+          collate_multitarget_junits
           move_single_testable_reports_to_final_location
         end
 
@@ -295,6 +332,31 @@ module TestCenter
           File.symlink(xcresult_bundlename_path, test_result_bundlename_path)
         end
 
+        def collate_multitarget_junits
+          return if @test_collector.testables.size < 2
+
+          Fastlane::UI.verbose("Collating test targets's junit results")
+
+          given_custom_report_file_name = @options[:custom_report_file_name]
+          given_output_types = @options[:output_types]
+          given_output_files = @options[:output_files]
+
+          report_name_helper = ReportNameHelper.new(
+            given_output_types,
+            given_output_files,
+            given_custom_report_file_name
+          )
+
+          absolute_output_directory = File.absolute_path(output_directory)
+          source_reports_directory_glob = "#{absolute_output_directory}/*"
+
+          TestCenter::Helper::MultiScanManager::ReportCollator.new(
+            source_reports_directory_glob: source_reports_directory_glob,
+            output_directory: absolute_output_directory,
+            reportnamer: report_name_helper
+          ).collate_junit_reports 
+        end
+
         def collate_batched_reports_for_testable(testable)
           FastlaneCore::UI.verbose("Collating results for all batches")
 

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.2"
+    VERSION = "3.14.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-test_center
 version: !ruby/object:Gem::Version
-  version: 3.14.2
+  version: 3.14.7
 platform: ruby
 authors:
 - Lyndsey Ferguson
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-01 00:00:00.000000000 Z
+date: 2020-10-23 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: []