fastlane-plugin-test_center 2.5.1 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a225615997474cf16464c3fd57d09d783e18cef
-  data.tar.gz: 4204b66e3a8c23b16e823b03c38b84b72c559293
+  metadata.gz: e52d3f37f8075a9050200d5d5cf19b8fa0b02fb8
+  data.tar.gz: b2c7b4dd8c192c105dbb71a8aa390425c856aa24
 SHA512:
-  metadata.gz: a146b8bb62a9fd8a0a28ed0c5edd5e61a820004ca96fbdc8afc494bc6c2906dd865644265f9170e034c5b4606abf0adcf737d3a8d1f175ed6d2db80860b1b758
-  data.tar.gz: 50ffa07ac1b8ca36e3c8362ee399ab75d5722763169b91f65d9612c1c903b3445b7d9286bf54bfe66fadbd7df209f50c828ffb29e199a34af82d7217055d3138
+  metadata.gz: 4dc6d5e02ea3c35c4504a493b4c0e3197576acaf203b5f92fffb3487a28f5e3309943df72b852df10d012374066f63949a570b319b768046eec2c67113cc342c
+  data.tar.gz: 9b6c0b59e057fe140964369185e2c9373939441f031d5ce19570d521fd961b64ef4d8539f30ccab2a8772fcc7084c13e1436cd2bfeceec739d23f9ecd2660565

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

@@ -1,5 +1,6 @@
 module Fastlane
   module Actions
+    require 'fastlane_core/ui/errors/fastlane_common_error'
     require 'fastlane/actions/scan'
     require 'shellwords'
     require 'xctest_list'
@@ -7,218 +8,70 @@ module Fastlane
 
     class MultiScanAction < Action
       def self.run(params)
-        scan_options = params.values.reject { |k| %i[try_count batch_count].include?(k) }
-
         unless Helper.test?
           FastlaneCore::PrintTable.print_values(
-            config: params._values.reject { |k, v| scan_options.key?(k) },
+            config: params._values.select { |k, _| %i[try_count batch_count fail_build].include?(k) },
             title: "Summary for multi_scan (test_center v#{Fastlane::TestCenter::VERSION})"
           )
         end
-
-        scan_options = config_with_junit_report(scan_options)
-
-        unless scan_options[:test_without_building]
-          build_for_testing(scan_options)
-          scan_options.delete(:build_for_testing)
-          scan_options[:test_without_building] = true
-        end
-
-        batch_count = params[:batch_count]
-        if batch_count == 1
-          try_scan_with_retry(scan_options, params[:try_count])
-        else
-          tests = tests_to_batch(scan_options)
-          tests.each_slice((tests.length / batch_count.to_f).round).to_a.each do |tests_batch|
-            scan_options.reject! { |key| key == :skip_testing }
-            scan_options[:only_testing] = tests_batch
-            try_scan_with_retry(scan_options, params[:try_count])
-          end
-        end
-        collate_reports(scan_options)
-      end
-
-      def self.try_scan_with_retry(scan_options, maximum_try_count)
-        try_count = 0
-        begin
-          try_count += 1
-          config = FastlaneCore::Configuration.create(Fastlane::Actions::ScanAction.available_options, scan_options)
-          Fastlane::Actions::ScanAction.run(config)
-        rescue FastlaneCore::Interface::FastlaneTestFailure => e
-          UI.verbose("Scan failed with #{e}")
-          if try_count < maximum_try_count
-            report_filepath = junit_report_filepath(scan_options)
-            failed_tests = other_action.tests_from_junit(junit: report_filepath)[:failed]
-            scan_options[:only_testing] = failed_tests.map(&:shellescape)
-            increment_report_filenames(scan_options)
-            retry
-          end
-        else
-          increment_report_filenames(scan_options)
-        end
-      end
-
-      def self.collate_reports(scan_options)
-        extension = junit_report_fileextension(scan_options)
-        report_files = Dir.glob("#{scan_options[:output_directory]}/*#{extension}").map do |relative_filepath|
-          File.absolute_path(relative_filepath)
-        end
-        if report_files.size > 1
-          r = Regexp.new("^(?<filename>.*)-(\\d+)\\.(junit|xml|html)")
-          final_report_name = junit_report_filename(scan_options)
-          match = r.match(final_report_name)
-          if match
-            final_report_name = "#{match[:filename]}#{extension}"
-          end
-          other_action.collate_junit_reports(
-            reports: report_files.sort { |f1, f2| File.mtime(f1) <=> File.mtime(f2) },
-            collated_report: File.absolute_path(File.join(scan_options[:output_directory], final_report_name))
+        unless params[:test_without_building]
+          build_for_testing(
+            params._values
           )
         end
-        FileUtils.rm_f(Dir.glob("#{scan_options[:output_directory]}/*-[1-9]*#{extension}"))
-      end
-
-      def self.kill(program)
-        Actions.sh("killall -9 '#{program}' &> /dev/null || true", log: false)
-      end
-
-      def self.quit_simulators
-        kill('iPhone Simulator')
-        kill('Simulator')
-        kill('SimulatorBridge')
-
-        launchctl_list_count = 0
-        while Actions.sh('launchctl list | grep com.apple.CoreSimulator.CoreSimulatorService || true', log: false) != ''
-          break if (launchctl_list_count += 1) > 10
-          Actions.sh('launchctl remove com.apple.CoreSimulator.CoreSimulatorService &> /dev/null || true', log: false)
-          sleep(1)
-        end
-      end
-
-      def self.tests_to_batch(scan_options)
-        unless scan_options[:only_testing].nil?
-          return scan_options[:only_testing]
+        smart_scanner = ::TestCenter::Helper::CorrectingScanHelper.new(params.values)
+        tests_passed = smart_scanner.scan
+        if params[:fail_build] && !tests_passed
+          raise UI.test_failure!('Tests have failed')
         end
-
-        xctestrun_path = scan_options[:xctestrun] || testrun_path(scan_options)
-        if xctestrun_path.nil? || !File.exist?(xctestrun_path)
-          UI.user_error!("Error: cannot find expected xctestrun file '#{xctestrun_path}'")
+        summary = run_summary(params, tests_passed, smart_scanner.retry_total_count)
+        unless Helper.test?
+          FastlaneCore::PrintTable.print_values(
+            config: summary,
+            title: "multi_scan results"
+          )
         end
-        tests = xctestrun_tests(xctestrun_path)
-        remove_skipped_tests(tests, scan_options[:skip_testing])
-      end
-
-      def self.remove_skipped_tests(tests_to_batch, tests_to_skip)
-        if tests_to_skip.nil?
-          return tests_to_batch
+        summary
+      end
+
+      def self.run_summary(scan_options, tests_passed, retry_total_count)
+        reportnamer = ::TestCenter::Helper::ReportNameHelper.new(
+          scan_options[:output_types],
+          scan_options[:output_files],
+          scan_options[:custom_report_file_name]
+        )
+        passing_testcount = 0
+        failed_tests = []
+        report_files = Dir.glob("#{scan_options[:output_directory]}/**/*#{reportnamer.junit_filextension}").map do |relative_filepath|
+          File.absolute_path(relative_filepath)
         end
-
-        if tests_to_skip
-          tests_to_skip = tests_to_skip
-          testsuites_to_skip = tests_to_skip.select do |testsuite|
-            testsuite.count('/') == 1 # just the testable/testsuite
-          end
-          tests_to_skip -= testsuites_to_skip
-          tests_to_batch.reject! do |test_identifier|
-            test_suite = test_identifier.split('/').first(2).join('/')
-            testsuites_to_skip.include?(test_suite)
-          end
-          tests_to_batch -= tests_to_skip
+        report_files.each do |report_file|
+          junit_results = other_action.tests_from_junit(junit: report_file)
+          failed_tests.concat(junit_results[:failed])
+          passing_testcount += junit_results[:passing].size
         end
-        tests_to_batch
-      end
-
-      def self.xctestrun_tests(xctestrun_path)
-        tests_across_testables = other_action.tests_from_xctestrun(xctestrun: xctestrun_path)
-        tests_across_testables.values.flatten
-      end
-
-      def self.xctest_bundle_path(xctestrun_rootpath, xctestrun_config)
-        xctest_host_path = xctestrun_config['TestHostPath'].sub('__TESTROOT__', xctestrun_rootpath)
-        xctestrun_config['TestBundlePath'].sub!('__TESTHOST__', xctest_host_path)
-        xctestrun_config['TestBundlePath'].sub('__TESTROOT__', xctestrun_rootpath)
-      end
-
-      def self.testrun_path(scan_options)
-        Dir.glob("#{scan_options[:derived_data_path]}/Build/Products/*.xctestrun").first
-      end
-
-      def self.test_products_path(derived_data_path)
-        File.join(derived_data_path, "Build", "Products")
+        {
+          result: tests_passed,
+          total_tests: passing_testcount + failed_tests.size,
+          passing_testcount: passing_testcount,
+          failed_testcount: failed_tests.size,
+          failed_tests: failed_tests,
+          total_retry_count: retry_total_count,
+          report_files: report_files
+        }
       end
 
       def self.build_for_testing(scan_options)
-        scan_options.delete(:test_without_building)
-        scan_options[:build_for_testing] = true
-        config = FastlaneCore::Configuration.create(Fastlane::Actions::ScanAction.available_options, scan_options)
+        config = FastlaneCore::Configuration.create(
+          Fastlane::Actions::ScanAction.available_options,
+          scan_options.merge(build_for_testing: true).reject { |k, _| %i[try_count batch_count test_without_building].include?(k) }
+        )
         Fastlane::Actions::ScanAction.run(config)
-        scan_options[:derived_data_path] = Scan.config[:derived_data_path]
-      end
-
-      def self.config_has_junit_report(config)
-        output_types = config.fetch(:output_types, '').to_s.split(',')
-        output_filenames = config.fetch(:output_files, '').to_s.split(',')
-
-        output_type_file_count_match = output_types.size == output_filenames.size
-        output_types.include?('junit') && (output_type_file_count_match || config[:custom_report_file_name].to_s.strip.length > 0)
-      end
-
-      def self.config_with_junit_report(config)
-        return config if config_has_junit_report(config)
-
-        if config[:output_types].to_s.strip.empty? || config[:custom_report_file_name]
-          config[:custom_report_file_name] ||= 'report.xml'
-          config[:output_types] = 'junit'
-        elsif config[:output_types].strip == 'junit' && config[:output_files].to_s.strip.empty?
-          config[:custom_report_file_name] ||= 'report.xml'
-        elsif !config[:output_types].split(',').include?('junit')
-          config[:output_types] << ',junit'
-          config[:output_files] << ',report.xml'
-        elsif config[:output_files].nil?
-          config[:output_files] = config[:output_types].split(',').map { |type| "report.#{type}" }.join(',')
-        end
-        config
-      end
-
-      def self.junit_report_filename(config)
-        report_filename = config[:custom_report_file_name]
-        if report_filename.nil?
-          junit_index = config[:output_types].split(',').find_index('junit')
-          report_filename = config[:output_files].to_s.split(',')[junit_index]
-        end
-        report_filename
-      end
 
-      def self.junit_report_fileextension(config)
-        File.extname(junit_report_filename(config))
-      end
-
-      def self.junit_report_filepath(config)
-        File.absolute_path(File.join(config[:output_directory], junit_report_filename(config)))
-      end
-
-      def self.increment_report_filename(filename)
-        new_report_number = 2
-        basename = File.basename(filename, '.*')
-        r = Regexp.new("^(?<filename>.*)-(?<report_number>\\d+)\\.(junit|xml|html)")
-        match = r.match(filename)
-        if match
-          new_report_number = match[:report_number].to_i + 1
-          basename = match[:filename]
-        end
-        "#{basename}-#{new_report_number}#{File.extname(filename)}"
-      end
-
-      def self.increment_report_filenames(config)
-        if config[:output_files]
-          output_files = config[:output_files].to_s.split(',')
-          output_files = output_files.map do |output_file|
-            increment_report_filename(output_file)
-          end
-          config[:output_files] = output_files.join(',')
-        elsif config[:custom_report_file_name]
-          config[:custom_report_file_name] = increment_report_filename(config[:custom_report_file_name])
-        end
+        scan_options.merge!(
+          test_without_building: true,
+          derived_data_path: Scan.config[:derived_data_path]
+        ).delete(:build_for_testing)
       end
 
       #####################################################
@@ -226,11 +79,14 @@ module Fastlane
       #####################################################
 
       def self.description
-        "Uses scan to run Xcode tests a given number of times: only re-testing failing tests."
+        "Uses scan to run Xcode tests a given number of times, with the option " \
+        "of batching them, only re-testing failing tests."
       end
 
       def self.details
-        "Use this action to run your tests if you have fragile tests that fail sporadically."
+        "Use this action to run your tests if you have fragile tests that fail" \
+        "sporadically, if you have a huge number of tests that should be " \
+        "batched, or have multiple test targets and need meaningful junit reports."
       end
 
       def self.scan_options
@@ -258,10 +114,54 @@ module Fastlane
             verify_block: proc do |count|
               UI.user_error!("Error: Batch counts must be greater than zero") unless count > 0
             end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :testrun_completed_block,
+            description: 'A block invoked each time a test run completes',
+            optional: true,
+            is_string: false,
+            default_value: nil
           )
         ]
       end
 
+      def self.example_code
+        [
+          'multi_scan(
+            project: File.absolute_path("../AtomicBoy/AtomicBoy.xcodeproj"),
+            scheme: "Professor",
+            try_count: 3,
+            custom_report_file_name: "atomic_report.xml",
+            output_types: "junit"
+          )',
+          'multi_scan(
+            project: File.absolute_path("../GalaxyFamily/GalaxyFamily.xcodeproj"),
+            scheme: "Everything",
+            try_count: 3,
+            batch_count: 2, # splits the tests into two chunks to not overload the iOS Simulator
+            custom_report_file_name: "atomic_report.xml",
+            output_types: "junit"
+          )',
+          'multi_scan(
+            project: File.absolute_path("../GalaxyFamily/GalaxyFamily.xcodeproj"),
+            scheme: "Everything",
+            try_count: 3,
+            batch_count: 8, # splits the tests into 8 chunks to not overload the iOS Simulator
+            testrun_completed_block: lambda { |testrun_info|
+              passed_test_count = testrun_info[:failed].size
+              failed_test_count = testrun_info[:passing].size
+              try_attempt = testrun_info[:try_count]
+              batch = testrun_info[:batch]
+
+              if failed_test_count > passed_test_count / 2
+                UI.abort_with_message!("Too many tests are failing")
+              end
+              UI.message("😊 everything is fine, let\'s continue try #{try_attempt} for batch #{batch}")
+            }
+          )'
+        ]
+      end
+
       def self.authors
         ["lyndsey-ferguson/@lyndseydf"]
       end

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

@@ -1,3 +1,5 @@
+require 'plist'
+
 module Fastlane
   module Actions
     class TestsFromXctestrunAction < Action
@@ -23,8 +25,7 @@ module Fastlane
 
       def self.xctest_bundle_path(xctestrun_rootpath, xctestrun_config)
         xctest_host_path = xctestrun_config['TestHostPath'].sub('__TESTROOT__', xctestrun_rootpath)
-        xctestrun_config['TestBundlePath'].sub!('__TESTHOST__', xctest_host_path)
-        xctestrun_config['TestBundlePath'].sub('__TESTROOT__', xctestrun_rootpath)
+        xctestrun_config['TestBundlePath'].sub('__TESTHOST__', xctest_host_path).sub('__TESTROOT__', xctestrun_rootpath)
       end
 
       #####################################################

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

@@ -0,0 +1,163 @@
+module TestCenter
+  module Helper
+    require 'fastlane_core/ui/ui.rb'
+    require 'plist'
+
+    class CorrectingScanHelper
+      attr_reader :retry_total_count
+
+      def initialize(multi_scan_options)
+        @batch_count = multi_scan_options[:batch_count] || 1
+        @output_directory = multi_scan_options[:output_directory] || 'test_results'
+        @try_count = multi_scan_options[:try_count]
+        @retry_total_count = 0
+        @testrun_completed_block = multi_scan_options[:testrun_completed_block]
+        @given_custom_report_file_name = multi_scan_options[:custom_report_file_name]
+        @given_output_types = multi_scan_options[:output_types]
+        @given_output_files = multi_scan_options[:output_files]
+        @scan_options = multi_scan_options.reject do |option, _|
+          %i[
+            output_directory
+            only_testing
+            skip_testing
+            try_count
+            batch_count
+            custom_report_file_name
+            fail_build
+            testrun_completed_block
+          ].include?(option)
+        end
+        @test_collector = TestCollector.new(multi_scan_options)
+      end
+
+      def scan
+        tests_passed = true
+        @testables_count = @test_collector.testables.size
+        @test_collector.testables.each do |testable|
+          tests_passed = scan_testable(testable) && tests_passed
+        end
+        tests_passed
+      end
+
+      def scan_testable(testable)
+        tests_passed = true
+        reportnamer = ReportNameHelper.new(
+          @given_output_types,
+          @given_output_files,
+          @given_custom_report_file_name
+        )
+        output_directory = @output_directory
+        if @batch_count > 1 || @testables_count > 1
+          testable_tests = @test_collector.testables_tests[testable]
+          current_batch = 1
+          testable_tests.each_slice((testable_tests.length / @batch_count.to_f).round).to_a.each do |tests_batch|
+            if @testables_count > 1
+              output_directory = File.join(@output_directory, "results-#{testable}")
+            end
+            FastlaneCore::UI.header("Starting test run on testable '#{testable}'")
+            tests_passed = correcting_scan(
+              {
+                only_testing: tests_batch,
+                output_directory: output_directory
+              },
+              current_batch,
+              reportnamer
+            ) && tests_passed
+            current_batch += 1
+            reportnamer.increment
+          end
+        else
+          options = {
+            output_directory: output_directory
+          }
+          options[:skip_testing] = @skip_testing if @skip_testing
+          tests_passed = correcting_scan(options, 1, reportnamer) && tests_passed
+        end
+        collate_reports(output_directory, reportnamer)
+        tests_passed
+      end
+
+      def collate_reports(output_directory, reportnamer)
+        report_files = Dir.glob("#{output_directory}/*#{reportnamer.junit_filextension}").map do |relative_filepath|
+          File.absolute_path(relative_filepath)
+        end
+        if report_files.size > 1
+          config = FastlaneCore::Configuration.create(
+            Fastlane::Actions::CollateJunitReportsAction.available_options,
+            {
+              reports: report_files.sort { |f1, f2| File.mtime(f1) <=> File.mtime(f2) },
+              collated_report: File.absolute_path(File.join(output_directory, reportnamer.junit_reportname))
+            }
+          )
+          Fastlane::Actions::CollateJunitReportsAction.run(config)
+        end
+        retried_junit_reportfiles = Dir.glob("#{output_directory}/**/*-[1-9]*#{reportnamer.junit_filextension}")
+        FileUtils.rm_f(retried_junit_reportfiles)
+      end
+
+      def correcting_scan(scan_run_options, batch, reportnamer)
+        scan_options = @scan_options.merge(scan_run_options)
+        try_count = 0
+        tests_passed = true
+        begin
+          try_count += 1
+          config = FastlaneCore::Configuration.create(
+            Fastlane::Actions::ScanAction.available_options,
+            scan_options.merge(reportnamer.scan_options)
+          )
+          quit_simulators
+          Fastlane::Actions::ScanAction.run(config)
+          @testrun_completed_block && @testrun_completed_block.call(
+            testrun_info(batch, try_count, reportnamer, scan_options[:output_directory])
+          )
+          tests_passed = true
+        rescue FastlaneCore::Interface::FastlaneTestFailure => e
+          FastlaneCore::UI.verbose("Scan failed with #{e}")
+          if try_count < @try_count
+            @retry_total_count += 1
+
+            info = testrun_info(batch, try_count, reportnamer, scan_options[:output_directory])
+            @testrun_completed_block && @testrun_completed_block.call(
+              info
+            )
+            scan_options[:only_testing] = info[:failed].map(&:shellescape)
+            FastlaneCore::UI.message('Re-running scan on only failed tests')
+            reportnamer.increment
+            retry
+          end
+          tests_passed = false
+        end
+        tests_passed
+      end
+
+      def testrun_info(batch, try_count, reportnamer, output_directory)
+        report_filepath = File.join(output_directory, reportnamer.junit_last_reportname)
+        config = FastlaneCore::Configuration.create(
+          Fastlane::Actions::TestsFromJunitAction.available_options,
+          {
+            junit: File.absolute_path(report_filepath)
+          }
+        )
+        junit_results = Fastlane::Actions::TestsFromJunitAction.run(config)
+
+        {
+          failed: junit_results[:failed],
+          passing: junit_results[:passing],
+          batch: batch,
+          try_count: try_count,
+          report_filepath: report_filepath
+        }
+      end
+
+      def quit_simulators
+        Fastlane::Actions.sh("killall -9 'iPhone Simulator' 'Simulator' 'SimulatorBridge' &> /dev/null || true", log: false)
+        launchctl_list_count = 0
+        while Fastlane::Actions.sh('launchctl list | grep com.apple.CoreSimulator.CoreSimulatorService || true', log: false) != ''
+          break if (launchctl_list_count += 1) > 10
+          Fastlane::Actions.sh('launchctl remove com.apple.CoreSimulator.CoreSimulatorService &> /dev/null || true', log: false)
+          sleep(1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module TestCenter
+  module Helper
+    require 'fastlane_core/ui/ui.rb'
+
+    class ReportNameHelper
+      def initialize(output_types = nil, output_files = nil, custom_report_file_name = nil)
+        @output_types = output_types || 'junit'
+        @output_files = output_files || custom_report_file_name
+        @report_count = 0
+
+        if @output_types && @output_files.nil?
+          @output_files = @output_types.split(',').map { |type| "report.#{type}" }.join(',')
+        end
+        unless @output_types.include?('junit')
+          FastlaneCore::UI.important('Scan output types missing \'junit\', adding it')
+          @output_types = @output_types.split(',').push('junit').join(',')
+          if @output_types.split(',').size == @output_files.split(',').size + 1
+            @output_files = @output_files.split(',').push('report.xml').join(',')
+            FastlaneCore::UI.message('As output files has one less than the new number of output types, assumming the filename for the junit was missing and added it')
+          end
+        end
+
+        types = @output_types.split(',').each(&:chomp)
+        files = @output_files.split(',').each(&:chomp)
+        unless files.size == types.size
+          raise ArgumentError, "Error: count of :output_types, #{types}, does not match the output filename(s) #{files}"
+        end
+      end
+
+      def numbered_filename(filename)
+        if @report_count > 0
+          basename = File.basename(filename, '.*')
+          extension = File.extname(filename)
+          filename = "#{basename}-#{@report_count + 1}#{extension}"
+        end
+        filename
+      end
+
+      def scan_options
+        files = @output_files.split(',').each(&:chomp)
+        files.map! do |filename|
+          filename.chomp
+          numbered_filename(filename)
+        end
+        {
+          output_types: @output_types,
+          output_files: files.join(',')
+        }
+      end
+
+      def junit_last_reportname
+        junit_index = @output_types.split(',').find_index('junit')
+        numbered_filename(@output_files.to_s.split(',')[junit_index])
+      end
+
+      def junit_reportname
+        junit_index = @output_types.split(',').find_index('junit')
+        @output_files.to_s.split(',')[junit_index]
+      end
+
+      def junit_filextension
+        File.extname(junit_reportname)
+      end
+
+      def increment
+        @report_count += 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module TestCenter
+  module Helper
+    require 'fastlane_core/ui/ui.rb'
+    require 'plist'
+
+    class TestCollector
+      def initialize(options)
+        @xctestrun_path = options[:xctestrun] || derived_testrun_path(options[:derived_data_path], options[:scheme])
+        @only_testing = options[:only_testing]
+        @skip_testing = options[:skip_testing]
+      end
+
+      def derived_testrun_path(derived_data_path, scheme)
+        Dir.glob("#{derived_data_path}/Build/Products/#{scheme}*.xctestrun").first
+      end
+
+      def testables
+        unless @testables
+          if @only_testing
+            @testables ||= only_testing_to_testables_tests.keys
+          else
+            @testables ||= Plist.parse_xml(@xctestrun_path).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 testables_tests
+        unless @testables_tests
+          if @only_testing
+            @testables_tests = only_testing_to_testables_tests
+          else
+            config = FastlaneCore::Configuration.create(::Fastlane::Actions::TestsFromXctestrunAction.available_options, xctestrun: @xctestrun_path)
+            @testables_tests = ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
+            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
+        end
+        @testables_tests
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module TestCenter
-    VERSION = "2.5.1"
+    VERSION = "3.0.1"
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-test_center
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 3.0.1
 platform: ruby
 authors:
 - Lyndsey Ferguson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-04 00:00:00.000000000 Z
+date: 2018-02-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: plist
+  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
@@ -39,13 +53,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.1.2
 - !ruby/object:Gem::Dependency
-  name: plist
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -53,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: colorize
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -188,8 +202,10 @@ files:
 - lib/fastlane/plugin/test_center/actions/suppressed_tests.rb
 - lib/fastlane/plugin/test_center/actions/tests_from_junit.rb
 - lib/fastlane/plugin/test_center/actions/tests_from_xctestrun.rb
+- lib/fastlane/plugin/test_center/helper/correcting_scan_helper.rb
 - lib/fastlane/plugin/test_center/helper/junit_helper.rb
-- lib/fastlane/plugin/test_center/helper/test_center_helper.rb
+- lib/fastlane/plugin/test_center/helper/reportname_helper.rb
+- lib/fastlane/plugin/test_center/helper/test_collector.rb
 - lib/fastlane/plugin/test_center/helper/xcodebuild_string.rb
 - lib/fastlane/plugin/test_center/version.rb
 homepage: https://github.com/lyndsey-ferguson/fastlane-plugin-test_center
@@ -217,3 +233,4 @@ signing_key:
 specification_version: 4
 summary: Makes testing your iOS app easier
 test_files: []
+has_rdoc: 

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

@@ -1,12 +0,0 @@
-module Fastlane
-  module Helper
-    class TestCenterHelper
-      # class methods that you define here become available in your action
-      # as `Helper::TestCenterHelper.your_method`
-      #
-      def self.show_message
-        UI.message("Hello from the test_center plugin helper!")
-      end
-    end
-  end
-end