fastlane-plugin-test_center 3.14.1 → 3.14.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 391e38d9af23a2337bcb32634971de2b7fc3813de2c2e8cddf1e20059ca588df
-  data.tar.gz: e438f5cef4c5c2864da937ea488b19e254277d0bcffe05721d2292271124c892
+  metadata.gz: 8d4ae676597a3e9b639c6f31c26e8b1237c821b5923a404a106637bea39c998c
+  data.tar.gz: 916b0ec2290cd0f572f48938c1c0860dac107fdee6be21a94d1325ec445f0825
 SHA512:
-  metadata.gz: 44fc75715573240e6acb1146146075d5ba5f58f18e19b7fd568933d7749ed24fc513cff9f0806a46a2013c8575cc537592906901708efb7df13d79b86cdc1ce5
-  data.tar.gz: 568537fbb709f14c3f91fc0880cda63c88ce22470696f8f1cf17281176f635b4a31af4707e081251dfab06ed5ee6631fe78b63b96ebfe68e71d3538a875a1ca8
+  metadata.gz: 7cc2b3a851e7e1a50b2d6fd18fa8565cd1f831e98d74589d7d99c42b1b3242c697e48dbe25fadf7e403de51e665db85d6a9aa29781736e0c274afb2f59b01078
+  data.tar.gz: 202223ce81f2649ded6613a8d9f831838aaf72653667b68c6edb98c8ca28d9ace86c7f5d88729533a144d82d8efd814caf5dc6a99aa87735eae49c62a7f972af

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/collate_test_result_bundles.rb

@@ -221,10 +221,12 @@ module Fastlane
             'collate the test_result bundles to a temporary bundle \"result.test_result\"'
           )
           bundles = Dir['../spec/fixtures/*.test_result'].map { |relpath| File.absolute_path(relpath) }
-          collate_test_result_bundles(
-            bundles: bundles,
-            collated_bundle: File.join('test_output', 'result.test_result')
-          )
+          Dir.mktmpdir('test_output') do |dir|
+            collate_test_result_bundles(
+              bundles: bundles,
+              collated_bundle: File.join(dir, 'result.test_result')
+            )
+          end
           "
         ]
       end

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

@@ -86,15 +86,19 @@ module Fastlane
       def self.example_code
         [
           "
+          require 'tmpdir'
+
           UI.important(
             'example: ' \\
             'collate the xcresult bundles to a temporary xcresult bundle \"result.xcresult\"'
           )
-          xcresults = Dir['../spec/fixtures/*.xcresult'].map { |relpath| File.absolute_path(relpath) }
-          collate_xcresults(
-            xcresults: xcresults,
-            collated_xcresult: File.join('test_output', 'result.xcresult')
-          )
+          xcresults = Dir['../spec/fixtures/AtomicBoyUITests-batch-{3,4}/result.xcresult'].map { |relpath| File.absolute_path(relpath) }
+          Dir.mktmpdir('test_output') do |dir|
+            collate_xcresults(
+              xcresults: xcresults,
+              collated_xcresult: File.join(dir, 'result.xcresult')
+            )
+          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
 
@@ -171,7 +188,10 @@ module Fastlane
         use_scanfile_to_override_settings(scan_options)
         turn_off_concurrent_workers(scan_options)
         UI.important("Turning off :skip_build as it doesn't do anything with multi_scan") if scan_options[:skip_build]
-        scan_options.reject! { |k,v| k == :skip_build }
+        if scan_options[:disable_xcpretty]
+          UI.important("Turning off :disable_xcpretty as xcpretty is needed to generate junit reports for retrying failed tests")
+        end
+        scan_options.reject! { |k,v| %i[skip_build disable_xcpretty].include?(k) }
         ScanHelper.remove_preexisting_simulator_logs(scan_options)
         if scan_options[:test_without_building]
           UI.verbose("Preparing Scan config options for multi_scan testing")
@@ -358,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'",
@@ -372,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, "\
@@ -430,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,
@@ -458,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(
@@ -483,6 +515,199 @@ 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
+
+      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 batches')
+          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 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/actions/tests_from_xcresult.rb

@@ -0,0 +1,103 @@
+require 'trainer'
+require 'shellwords'
+
+module Fastlane
+  module Actions
+    class TestsFromXcresultAction < Action
+      def self.run(params)
+        unless FastlaneCore::Helper.xcode_at_least?('11.0.0')
+          UI.error("Error: tests_from_xcresult requires at least Xcode 11.0")
+          return {}
+        end
+
+        xcresult_path = File.absolute_path(params[:xcresult])
+
+        # taken from the rubygem trainer, in the test_parser.rb module
+        result_bundle_object_raw = sh("xcrun xcresulttool get --path #{xcresult_path.shellescape} --format json", print_command: false, print_command_output: false)
+        result_bundle_object = JSON.parse(result_bundle_object_raw)
+
+        # Parses JSON into ActionsInvocationRecord to find a list of all ids for ActionTestPlanRunSummaries
+        actions_invocation_record = Trainer::XCResult::ActionsInvocationRecord.new(result_bundle_object)
+        test_refs = actions_invocation_record.actions.map do |action|
+          action.action_result.tests_ref
+        end.compact
+
+        ids = test_refs.map(&:id)
+        summaries = ids.map do |id|
+          raw = sh("xcrun xcresulttool get --format json --path #{xcresult_path.shellescape} --id #{id}", print_command: false, print_command_output: false)
+          json = JSON.parse(raw)
+          Trainer::XCResult::ActionTestPlanRunSummaries.new(json)
+        end
+        failures = actions_invocation_record.issues.test_failure_summaries || []
+        all_summaries = summaries.map(&:summaries).flatten
+        testable_summaries = all_summaries.map(&:testable_summaries).flatten
+        failed = []
+        passing = []
+        failure_details = {}
+        rows = testable_summaries.map do |testable_summary|
+          all_tests = testable_summary.all_tests.flatten
+          all_tests.each do |t|
+            if t.test_status == 'Success'
+              passing << "#{t.parent.name}/#{t.identifier}"
+            else
+              test_identifier = "#{t.parent.name}/#{t.identifier}"
+              failed << test_identifier
+              failure = t.find_failure(failures)
+              if failure
+                failure_details[test_identifier] = {
+                  message: failure.failure_message
+                }
+              end
+            end
+          end
+        end
+        {
+          failed: failed.uniq,
+          passing: passing.uniq,
+          failure_details: failure_details
+        }
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "☑️ Retrieves the failing and passing tests as reportedn an xcresult bundle"
+      end
+
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :xcresult,
+            env_name: "FL_TESTS_FROM_XCRESULT_XCRESULT_PATH",
+            description: "The path to the xcresult bundle to retrieve the tests from",
+            verify_block: proc do |path|
+              UI.user_error!("Error: cannot find the xcresult bundle at '#{path}'") unless Dir.exist?(path)
+              UI.user_error!("Error: cannot parse files that are not in the xcresult format") unless File.extname(path) == ".xcresult"
+            end
+          )
+        ]
+      end
+
+      def self.return_value
+        "A Hash with information about the test results:\r\n" \
+        "failed: an Array of the failed test identifiers\r\n" \
+        "passing: an Array of the passing test identifiers\r\n"
+      end
+
+      def self.authors
+        ["lyndsey-ferguson/lyndseydf"]
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.is_supported?(platform)
+        %i[ios mac].include?(platform)
+      end
+    end
+  end
+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_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.1"
+    VERSION = "3.14.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-test_center
 version: !ruby/object:Gem::Version
-  version: 3.14.1
+  version: 3.14.6
 platform: ruby
 authors:
 - Lyndsey Ferguson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-17 00:00:00.000000000 Z
+date: 2020-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: trainer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: xcodeproj
   requirement: !ruby/object:Gem::Requirement
@@ -270,6 +284,7 @@ files:
 - lib/fastlane/plugin/test_center/actions/test_options_from_testplan.rb
 - lib/fastlane/plugin/test_center/actions/testplans_from_scheme.rb
 - lib/fastlane/plugin/test_center/actions/tests_from_junit.rb
+- lib/fastlane/plugin/test_center/actions/tests_from_xcresult.rb
 - lib/fastlane/plugin/test_center/actions/tests_from_xctestrun.rb
 - lib/fastlane/plugin/test_center/helper/fastlane_core/device_manager/simulator_extensions.rb
 - lib/fastlane/plugin/test_center/helper/html_test_report.rb
@@ -295,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
@@ -310,8 +325,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Makes testing your iOS app easier
 test_files: []