fastlane-plugin-test_center 3.6.2 → 3.6.3.parallelizing

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

@@ -0,0 +1,59 @@
+module TestCenter
+  module Helper
+    module MultiScanManager
+      class SimulatorHelper
+        def initialize(options)
+          @options = options
+        end
+
+        def setup
+          if @options[:parallelize]
+            setup_scan_config
+            delete_multi_scan_cloned_simulators
+          end
+        end
+
+        def setup_scan_config
+          unless ::Scan.config&._values.has_key?(:destination)
+            scan_option_keys = Scan.config.all_keys
+            ::Scan.config = FastlaneCore::Configuration.create(
+              Fastlane::Actions::ScanAction.available_options,
+              @options.select{ |k| scan_option_keys.include?(k) }
+            )
+          end
+        end
+
+        def clone_destination_simulators
+          cloned_simulators = []
+
+          batch_count = @options[:batch_count] || 0
+          destination_simulator_ids = Scan.config[:destination].map do |destination|
+            destination.split(',id=').last
+          end
+          original_simulators = FastlaneCore::DeviceManager.simulators('iOS').find_all do |simulator|
+            destination_simulator_ids.include?(simulator.udid)
+          end
+          (0...batch_count).each do |batch_index|
+            cloned_simulators << []
+            original_simulators.each do |simulator|
+              FastlaneCore::UI.verbose("Cloning simulator")
+              cloned_simulator = simulator.clone
+              new_first_name = simulator.name.sub(/( ?\(.*| ?$)/, " Clone #{batch_index}")
+              new_last_name = "#{self.class.name}<#{self.object_id}>"
+              cloned_simulator.rename("#{new_first_name} #{new_last_name}")
+
+              cloned_simulators.last << cloned_simulator
+            end
+          end
+          cloned_simulators
+        end
+
+        def delete_multi_scan_cloned_simulators
+          FastlaneCore::DeviceManager.simulators('iOS').each do |simulator|
+            simulator.delete if /#{self.class.name}<\d+>/ =~ simulator.name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,317 @@
+module TestCenter
+  module Helper
+    module MultiScanManager
+      require 'scan'
+      require 'colorize'
+      require_relative './device_manager'
+
+      class Parallelization
+        def initialize(batch_count, output_directory, testrun_completed_block)
+          @batch_count = batch_count
+          @output_directory = output_directory
+          @testrun_completed_block = testrun_completed_block
+          
+          @simulators ||= []
+
+          if ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
+            @simhelper = SimulatorHelper.new(
+              parallelize: true,
+              batch_count: batch_count
+            )
+            @simhelper.setup
+          end
+          if @batch_count < 1
+            raise FastlaneCore::FastlaneCrash.new({}), "batch_count (#{@batch_count}) < 1, this should never happen"
+          end
+          ObjectSpace.define_finalizer(self, self.class.finalize)
+        end
+
+        def self.finalize
+          proc { cleanup_simulators }
+        end
+
+        def setup_simulators(devices, batch_deploymentversions)
+          if ENV['USE_REFACTORED_PARALLELIZED_MULTI_SCAN']
+            @simulators = @simhelper.clone_destination_simulators
+          else
+            FastlaneCore::DeviceManager.simulators('iOS').each do |simulator|
+              simulator.delete if /-batchclone-/ =~ simulator.name
+            end
+
+            (0...@batch_count).each do |batch_index|
+              found_simulator_devices = []
+              if devices.count > 0
+                found_simulator_devices = detect_simulator(devices, batch_deploymentversions[batch_index])
+              else
+                found_simulator_devices = Scan::DetectValues.detect_simulator(devices, 'iOS', 'IPHONEOS_DEPLOYMENT_TARGET', 'iPhone 5s', nil)
+              end
+              @simulators[batch_index] ||= []
+              found_simulator_devices.each do |found_simulator_device|
+                device_for_batch = found_simulator_device.clone
+                new_name = "#{found_simulator_device.name.gsub(/[^a-zA-Z\d]/,'')}-batchclone-#{batch_index + 1}"
+                device_for_batch.rename(new_name)
+                device_for_batch.boot
+                @simulators[batch_index] << device_for_batch
+              end
+            end
+          end
+        end
+
+        def detect_simulator(devices, deployment_target_version)
+          require 'set'
+
+          simulators = Scan::DetectValues.filter_simulators(
+            FastlaneCore::DeviceManager.simulators('iOS').tap do |array|
+              if array.empty?
+                FastlaneCore::UI.user_error!(['No', simulator_type_descriptor, 'simulators found on local machine'].reject(&:nil?).join(' '))
+              end
+            end,
+            :greater_than_or_equal,
+            deployment_target_version
+          ).tap do |sims|
+            if sims.empty?
+              FastlaneCore::UI.error("No simulators found that are greater than or equal to the version of deployment target (#{deployment_target_version})")
+            end
+          end
+
+          # At this point we have all simulators for the given deployment target (or higher)
+
+          # We create 2 lambdas, which we iterate over later on
+          # If the first lambda `matches` found a simulator to use
+          # we'll never call the second one
+
+          matches = lambda do
+            set_of_simulators = devices.inject(
+              Set.new # of simulators
+            ) do |set, device_string|
+              pieces = device_string.split(/\s(?=\([\d\.]+\)$)/)
+
+              selector = ->(sim) { pieces.count > 0 && sim.name == pieces.first }
+
+              set + (
+                if pieces.count == 0
+                  [] # empty array
+                elsif pieces.count == 1
+                  simulators
+                    .select(&selector)
+                    .reverse # more efficient, because `simctl` prints higher versions first
+                    .sort_by! { |sim| Gem::Version.new(sim.os_version) }
+                    .pop(1)
+                else # pieces.count == 2 -- mathematically, because of the 'end of line' part of our regular expression
+                  version = pieces[1].tr('()', '')
+                  potential_emptiness_error = lambda do |sims|
+                    if sims.empty?
+                      FastlaneCore::UI.error("No simulators found that are equal to the version " \
+                      "of specifier (#{version}) and greater than or equal to the version " \
+                      "of deployment target (#{deployment_target_version})")
+                    end
+                  end
+                  Scan::DetectValues.filter_simulators(simulators, :equal, version).tap(&potential_emptiness_error).select(&selector)
+                end
+              ).tap do |array|
+                FastlaneCore::UI.error("Ignoring '#{device_string}', couldn't find matching simulator") if array.empty?
+              end
+            end
+
+            set_of_simulators.to_a
+          end
+
+          default = lambda do
+            FastlaneCore::UI.error("Couldn't find any matching simulators for '#{devices}' - falling back to default simulator") if (devices || []).count > 0
+
+            result = Array(
+              simulators
+                .select { |sim| sim.name == default_device_name }
+                .reverse # more efficient, because `simctl` prints higher versions first
+                .sort_by! { |sim| Gem::Version.new(sim.os_version) }
+                .last || simulators.first
+            )
+
+            FastlaneCore::UI.message("Found simulator \"#{result.first.name} (#{result.first.os_version})\"") if result.first
+
+            result
+          end
+
+          [matches, default].lazy.map { |x|
+            arr = x.call
+            arr unless arr.empty?
+          }.reject(&:nil?).first
+        end
+
+        def cleanup_simulators
+          @simulators.flatten.each(&:delete)
+          @simulators = []
+        end
+
+        def destination_for_batch(batch_index)
+          @simulators[batch_index]
+        end
+
+        def devices(batch_index)
+          if batch_index > @batch_count
+            simulator_count = [@batch_count, @simulators.count].max
+            raise "Error: impossible to request devices for batch #{batch_index}, there are only #{simulator_count} set(s) of simulators"
+          end
+
+          if @simulators.count > 0
+            @simulators[batch_index - 1].map do |simulator|
+              "#{simulator.name} (#{simulator.os_version})"
+            end
+          else
+            @scan_options[:devices] || Array(@scan_options[:device])
+          end
+        end
+
+        def ensure_conflict_free_scanlogging(scan_options, batch_index)
+          scan_options[:buildlog_path] = scan_options[:buildlog_path] + "-#{batch_index}"
+        end
+
+        def ensure_devices_cloned_for_testrun_are_used(scan_options, batch_index)
+          scan_options.delete(:device)
+          scan_options[:devices] = devices(batch_index)
+        end
+
+        def setup_scan_options_for_testrun(scan_options, batch_index)
+          ensure_conflict_free_scanlogging(scan_options, batch_index)
+          ensure_devices_cloned_for_testrun_are_used(scan_options, batch_index)
+        end
+
+        def setup_pipes_for_fork
+          @pipe_endpoints = []
+          (0...@batch_count).each do
+            @pipe_endpoints << IO.pipe
+          end
+        end
+
+        def connect_subprocess_endpoint(batch_index)
+          mainprocess_reader, = @pipe_endpoints[batch_index]
+          mainprocess_reader.close # we are now in the subprocess
+          FileUtils.mkdir_p(@output_directory)
+          subprocess_output_dir = Dir.mktmpdir
+          subprocess_logfilepath = File.join(subprocess_output_dir, "batchscan_#{batch_index}.log")
+          $subprocess_logfile = File.open(subprocess_logfilepath, 'w')
+          $subprocess_logfile.sync = true
+          $old_stdout = $stdout.dup
+          $old_stderr = $stderr.dup
+          $stdout.reopen($subprocess_logfile)
+          $stderr.reopen($subprocess_logfile)
+        end
+
+        def disconnect_subprocess_endpoints
+          # This is done from the parent process to close the pipe from its end so
+          # that its reading of the pipe doesn't block waiting for more IO on the
+          # writer.
+          # This has to be done after the fork, because we don't want the subprocess
+          # to receive its endpoint already closed.
+          @pipe_endpoints.each { |_, subprocess_writer| subprocess_writer.close }
+        end
+
+        def send_subprocess_tryinfo(info)
+          puts "in send_subprocess_tryinfo"
+          _, subprocess_writer = @pipe_endpoints[batch_index]
+          subprocess_output = {
+            'message_type' => 'tryinfo',
+            'batch_index' => batch_index,
+            'tryinfo' => info
+          }
+          subprocess_writer.puts subprocess_output.to_json
+        end
+
+        def send_subprocess_result(batch_index, result)
+          $stdout = $old_stdout.dup
+          $stderr = $old_stderr.dup
+          _, subprocess_writer = @pipe_endpoints[batch_index]
+
+          subprocess_output = {
+            'message_type' => 'completed',
+            'batch_index' => batch_index,
+            'subprocess_logfilepath' => $subprocess_logfile.path,
+            'tests_passed' => result
+          }
+          subprocess_writer.puts subprocess_output.to_json
+          subprocess_writer.close
+          $subprocess_logfile.close
+        end
+
+        def parse_subprocess_results(subprocess_index, subprocess_output)
+          subprocess_result = {
+            'tests_passed' => false
+          }
+          if subprocess_output.empty?
+            FastlaneCore::UI.error("Something went terribly wrong: no output from parallelized batch #{subprocess_index}!")
+          else
+            subprocess_result = JSON.parse(subprocess_output)
+          end
+          subprocess_result
+        end
+
+        def stream_subprocess_result_to_console(index, subprocess_logfilepath)
+          puts '-' * 80
+          if File.exist?(subprocess_logfilepath)
+            simulator_prefix = "[Sim-#{index}]"
+            unless ENV['FASTLANE_DISABLE_COLORS']
+            colors = String.colors - [:default, :black, :white]
+            color = colors.sample
+              simulator_prefix = simulator_prefix.colorize(color)
+            end
+            File.foreach(subprocess_logfilepath) do |line|
+              print simulator_prefix, line
+            end
+          end
+        end
+
+        def handle_subprocesses
+          # disconnect_subprocess_endpoints # to ensure no blocking on pipe
+          FastlaneCore::Helper.show_loading_indicator("Scanning in #{@batch_count} batches")
+          loop do
+            break if @pipe_endpoints.size.zero?
+
+            remaining_pipe_endpoints = @pipe_endpoints.map(&:first).reject { |pe| pe.closed? }
+            puts "there are #{remaining_pipe_endpoints.size} endpoints remaining".yellow
+            read_array, _, error_array = IO.select(remaining_pipe_endpoints)
+            read_array.each do |pipe_reader|
+              endpoint_index = @pipe_endpoints.find_index { |pe| pe.first == pipe_reader }
+              child_message_size = pipe_reader.stat.size
+              child_message = pipe_reader.read_nonblock(child_message_size)
+              subprocess_result = parse_subprocess_results(0, child_message)
+              if subprocess_result['message_type'] == 'completed'
+                stream_subprocess_result_to_console(subprocess_result['batch_index'], subprocess_result['subprocess_logfilepath'])
+                pipe_reader.close
+                @pipe_endpoints.delete_at(endpoint_index)
+              elsif subprocess_result['message_type'] == 'tryinfo'
+                puts "in simulator_manager, about to call @testrun_completed_block witth #{subprocess_result['tryinfo']}"
+                @testrun_completed_block && @testrun_completed_block.call(subprocess_result['tryinfo'])
+              end
+            end
+            error_array.each { |e| puts e }
+            break if error_array.size > 0
+            break if read_array.size.zero?
+          end
+          FastlaneCore::Helper.hide_loading_indicator
+        end
+
+        def wait_for_subprocesses
+          disconnect_subprocess_endpoints # to ensure no blocking on the pipe
+          FastlaneCore::Helper.show_loading_indicator("Scanning in #{@batch_count} batches")
+          Process.waitall
+          FastlaneCore::Helper.hide_loading_indicator
+        end
+
+        def handle_subprocesses_results
+          tests_passed = false
+          FastlaneCore::UI.header("Output from parallelized batch run")
+          @pipe_endpoints.each_with_index do |endpoints, index|
+            mainprocess_reader, = endpoints
+            subprocess_result = parse_subprocess_results(index, mainprocess_reader.read)
+            mainprocess_reader.close
+            stream_subprocess_result_to_console(index, subprocess_result['subprocess_logfilepath'])
+            tests_passed = subprocess_result['tests_passed']
+          end
+          puts '=' * 80
+          tests_passed
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -64,9 +64,12 @@ module TestCenter
         numbered_filename(@output_files.to_s.split(',')[junit_index])
       end
 
-      def junit_reportname
+      def junit_reportname(suffix = '')
         junit_index = @output_types.split(',').find_index('junit')
-        @output_files.to_s.split(',')[junit_index]
+        report_name = @output_files.to_s.split(',')[junit_index]
+        return report_name if suffix.empty?
+
+        "#{File.basename(report_name, '.*')}-#{suffix}#{junit_filextension}"
       end
 
       def junit_filextension
@@ -90,9 +93,12 @@ module TestCenter
         numbered_filename(@output_files.to_s.split(',')[html_index])
       end
 
-      def html_reportname
+      def html_reportname(suffix = '')
         html_index = @output_types.split(',').find_index('html')
-        @output_files.to_s.split(',')[html_index]
+        report_name = @output_files.to_s.split(',')[html_index]
+        return report_name if suffix.empty?
+
+        "#{File.basename(report_name, '.*')}-#{suffix}#{html_filextension}"
       end
 
       def html_filextension
@@ -116,9 +122,12 @@ module TestCenter
         numbered_filename(@output_files.to_s.split(',')[json_index])
       end
 
-      def json_reportname
+      def json_reportname(suffix = '')
         json_index = @output_types.split(',').find_index('json')
-        @output_files.to_s.split(',')[json_index]
+        report_name = @output_files.to_s.split(',')[json_index]
+        return report_name if suffix.empty?
+
+        "#{File.basename(report_name, '.*')}-#{suffix}#{json_filextension}"
       end
 
       def json_filextension

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

@@ -5,6 +5,8 @@ module TestCenter
     require 'plist'
 
     class TestCollector
+      attr_reader :xctestrun_path
+
       def initialize(options)
         unless options[:xctestrun] || options[:derived_data_path]
           options[:derived_data_path] = default_derived_data_path(options)
@@ -15,6 +17,7 @@ module TestCenter
         end
         @only_testing = options[:only_testing]
         @skip_testing = options[:skip_testing]
+        @batch_count = options[:batch_count]
       end
 
       def default_derived_data_path(options)
@@ -34,7 +37,9 @@ module TestCenter
           if @only_testing
             @testables ||= only_testing_to_testables_tests.keys
           else
-            @testables ||= Plist.parse_xml(@xctestrun_path).keys
+            @testables ||= Plist.parse_xml(@xctestrun_path).keys.reject do |key|
+              key == '__xctestrun_metadata__'
+            end
           end
         end
         @testables
@@ -49,13 +54,30 @@ module TestCenter
         tests
       end
 
+      def xctestrun_known_tests
+        config = FastlaneCore::Configuration.create(::Fastlane::Actions::TestsFromXctestrunAction.available_options, xctestrun: @xctestrun_path)
+        ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
+      end
+
       def testables_tests
         unless @testables_tests
           if @only_testing
+            known_tests = nil
             @testables_tests = only_testing_to_testables_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
           else
-            config = FastlaneCore::Configuration.create(::Fastlane::Actions::TestsFromXctestrunAction.available_options, xctestrun: @xctestrun_path)
-            @testables_tests = ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
+            @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|
@@ -68,8 +90,30 @@ module TestCenter
             end
           end
         end
+        
         @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
+        end
+
+        @batches
+      end
     end
   end
 end