fastlane-plugin-test_center 3.13.1 → 3.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79e2765eea8d10df4efd2039d298d2e7b3e9481844686eb5dc5c3e5223f96171
-  data.tar.gz: a5856750d9519fe3db99c10aebe9b320a91aa6285a15919ea0547069fdc6627b
+  metadata.gz: 4364b9e3e49e3aa1a3bbd1e26feb07e449de72900bcd1ec3341ff8d1b0ca62ad
+  data.tar.gz: f983745b33c34838839d546aff4c4e407673c8241e72ab14b695d288792bdac4
 SHA512:
-  metadata.gz: 7d40544a3352ddd61af2c9ff77d842d006a0400df54bb9e2492ccd0f01f7ab514a008d6a82c4f1f2fc979e840a599cd1e0e4d514afd9d053e5ad6473347d2f5d
-  data.tar.gz: cbd5f866464960e4a35b3b3f59baceafc6621eb7d0917f72d795cb53973f62f342dd717587431f8f72da958164b9f3b2ed8c709f3661dd759584b0c4574c65ce
+  metadata.gz: 1bb52a9bcc82781df58b2ab2b6dd33c1831da0b345b9b51842959b8a372e5341b773cf639e3cb884bccc426336dad01c8ff1e7fc418fad0baefe201e12c46bab
+  data.tar.gz: 8d6e6a9321e13aada993f1099f45b7317f4d4c30e8bbdfa55a35a49a1a0dd3aa6c7e06c7dd244132e37d4c149ac0a6b9f94d9198d3f0bd8ee912853fa44f773d

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

@@ -171,7 +171,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 +361,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 +383,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 +441,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 +469,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 +498,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/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

@@ -65,10 +65,11 @@ module TestCenter
 
           @test_collector = TestCollector.new(@options)
           @options.reject! { |key| %i[testplan].include?(key) }
-          @batch_count = @test_collector.test_batches.size
-          if @test_collector.test_batches.flatten.size < @options[:parallel_testrun_count].to_i
-            FastlaneCore::UI.important(":parallel_testrun_count greater than the number of tests (#{@test_collector.test_batches.flatten.size}). Reducing to that number.")
-            @options[:parallel_testrun_count] = @test_collector.test_batches.flatten.size
+          @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
           end
         end
 
@@ -195,7 +196,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}")
@@ -208,7 +209,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.
@@ -233,6 +234,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
 
@@ -294,6 +296,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/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")
+              expand_test_identifiers = [testable]
+            else
+              expand_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, *expand_test_identifiers)
+        end
       end
 
-      def only_testing_from_testplan(options)
+      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 self.only_testing_from_testplan(options)
         return unless options[:testplan] && options[:scheme]
 
         config = FastlaneCore::Configuration.create(
@@ -60,107 +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
-        config = FastlaneCore::Configuration.create(
-          ::Fastlane::Actions::TestsFromXctestrunAction.available_options,
-          {
-            xctestrun: @xctestrun_path,
-            invocation_based_tests: @invocation_based_tests,
-            swift_test_prefix: @swift_test_prefix
-          }
-        )
-        ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
-      end
-
-      def expand_testsuites_to_tests
-        return if @invocation_based_tests
-
-        known_tests = []
-        @testables_tests.each do |testable, tests|
-          tests.each_with_index do |test, index|
-            if test.count('/') < 2
-              known_tests += xctestrun_known_tests[testable]
-              test_components = test.split('/')
-              testsuite = test_components.size == 1 ? test_components[0] : test_components[1]
-              @testables_tests[testable][index] = known_tests.select { |known_test| known_test.include?(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_testsuites_to_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.13.1"
+    VERSION = "3.14.4"
   end
 end

metadata

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