fastlane_hotfix 2.165.0

data/snapshot/lib/snapshot/simulator_launchers/simulator_launcher_base.rb

@@ -0,0 +1,200 @@
+require 'plist'
+require 'time'
+
+require_relative '../module'
+require_relative '../test_command_generator'
+require_relative '../collector'
+require_relative '../fixes/hardware_keyboard_fix'
+require_relative '../fixes/simulator_zoom_fix'
+require_relative '../fixes/simulator_shared_pasteboard'
+
+module Snapshot
+  class SimulatorLauncherBase
+    attr_accessor :collected_errors
+
+    # The number of times we failed on launching the simulator... sigh
+    attr_accessor :current_number_of_retries_due_to_failing_simulator
+    attr_accessor :launcher_config
+
+    def initialize(launcher_configuration: nil)
+      @launcher_config = launcher_configuration
+      @device_boot_datetime = DateTime.now
+    end
+
+    def collected_errors
+      @collected_errors ||= []
+    end
+
+    def current_number_of_retries_due_to_failing_simulator
+      @current_number_of_retries_due_to_failing_simulator || 0
+    end
+
+    def prepare_for_launch(device_types, language, locale, launch_arguments)
+      prepare_directories_for_launch(language: language, locale: locale, launch_arguments: launch_arguments)
+      prepare_simulators_for_launch(device_types, language: language, locale: locale)
+    end
+
+    def prepare_directories_for_launch(language: nil, locale: nil, launch_arguments: nil)
+      screenshots_path = TestCommandGenerator.derived_data_path
+      FileUtils.rm_rf(File.join(screenshots_path, "Logs"))
+      FileUtils.rm_rf(screenshots_path) if launcher_config.clean
+      FileUtils.mkdir_p(screenshots_path)
+
+      FileUtils.mkdir_p(CACHE_DIR)
+      FileUtils.mkdir_p(SCREENSHOTS_DIR)
+
+      File.write(File.join(CACHE_DIR, "language.txt"), language)
+      File.write(File.join(CACHE_DIR, "locale.txt"), locale || "")
+      File.write(File.join(CACHE_DIR, "snapshot-launch_arguments.txt"), launch_arguments.last)
+    end
+
+    def prepare_simulators_for_launch(device_types, language: nil, locale: nil)
+      # Kill and shutdown all currently running simulators so that the following settings
+      # changes will be picked up when they are started again.
+      Snapshot.kill_simulator # because of https://github.com/fastlane/fastlane/issues/2533
+      `xcrun simctl shutdown booted &> /dev/null`
+
+      Fixes::SimulatorZoomFix.patch
+      Fixes::HardwareKeyboardFix.patch
+      Fixes::SharedPasteboardFix.patch
+
+      device_types.each do |type|
+        if launcher_config.erase_simulator || launcher_config.localize_simulator || !launcher_config.dark_mode.nil?
+          if launcher_config.erase_simulator
+            erase_simulator(type)
+          end
+          if launcher_config.localize_simulator
+            localize_simulator(type, language, locale)
+          end
+          unless launcher_config.dark_mode.nil?
+            interface_style(type, launcher_config.dark_mode)
+          end
+        elsif launcher_config.reinstall_app
+          # no need to reinstall if device has been erased
+          uninstall_app(type)
+        end
+        if launcher_config.disable_slide_to_type
+          disable_slide_to_type(type)
+        end
+      end
+
+      unless launcher_config.headless
+        simulator_path = File.join(Helper.xcode_path, 'Applications', 'Simulator.app')
+        Helper.backticks("open -a #{simulator_path} -g", print: FastlaneCore::Globals.verbose?)
+      end
+    end
+
+    # pass an array of device types
+    def add_media(device_types, media_type, paths)
+      media_type = media_type.to_s
+
+      device_types.each do |device_type|
+        UI.verbose("Adding #{media_type}s to #{device_type}...")
+        device_udid = TestCommandGenerator.device_udid(device_type)
+
+        UI.message("Launch Simulator #{device_type}")
+        Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
+
+        paths.each do |path|
+          UI.message("Adding '#{path}'")
+
+          # Attempting addmedia since addphoto and addvideo are deprecated
+          output = Helper.backticks("xcrun simctl addmedia #{device_udid} #{path.shellescape} &> /dev/null")
+
+          # Run legacy addphoto and addvideo if addmedia isn't found
+          # Output will be empty strin gif it was a success
+          # Output will contain "usage: simctl" if command not found
+          if output.include?('usage: simctl')
+            Helper.backticks("xcrun simctl add#{media_type} #{device_udid} #{path.shellescape} &> /dev/null")
+          end
+        end
+      end
+    end
+
+    def override_status_bar(device_type)
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.message("Launch Simulator #{device_type}")
+      Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
+
+      UI.message("Overriding Status Bar")
+
+      # The time needs to be passed as ISO8601 so the simulator formats it correctly
+      time = Time.new(2007, 1, 9, 9, 41, 0)
+      Helper.backticks("xcrun simctl status_bar #{device_udid} override --time #{time.iso8601} --dataNetwork wifi --wifiMode active --wifiBars 3 --cellularMode active --cellularBars 4 --batteryState charged --batteryLevel 100 &> /dev/null")
+    end
+
+    def clear_status_bar(device_type)
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.message("Clearing Status Bar Override")
+      Helper.backticks("xcrun simctl status_bar #{device_udid} clear &> /dev/null")
+    end
+
+    def uninstall_app(device_type)
+      launcher_config.app_identifier ||= UI.input("App Identifier: ")
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      FastlaneCore::Simulator.uninstall_app(launcher_config.app_identifier, device_type, device_udid)
+    end
+
+    def erase_simulator(device_type)
+      UI.verbose("Erasing #{device_type}...")
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.important("Erasing #{device_type}...")
+
+      `xcrun simctl erase #{device_udid} &> /dev/null`
+    end
+
+    def localize_simulator(device_type, language, locale)
+      device_udid = TestCommandGenerator.device_udid(device_type)
+      if device_udid
+        locale ||= language.sub("-", "_")
+        plist = {
+          AppleLocale: locale,
+          AppleLanguages: [language]
+        }
+        UI.message("Localizing #{device_type} (AppleLocale=#{locale} AppleLanguages=[#{language}])")
+        plist_path = "#{ENV['HOME']}/Library/Developer/CoreSimulator/Devices/#{device_udid}/data/Library/Preferences/.GlobalPreferences.plist"
+        File.write(plist_path, Plist::Emit.dump(plist))
+      end
+    end
+
+    def interface_style(device_type, dark_mode)
+      device_udid = TestCommandGenerator.device_udid(device_type)
+      if device_udid
+        plist = {
+          UserInterfaceStyleMode: (dark_mode ? 2 : 1)
+        }
+        UI.message("Setting interface style #{device_type} (UserInterfaceStyleMode=#{dark_mode})")
+        plist_path = "#{ENV['HOME']}/Library/Developer/CoreSimulator/Devices/#{device_udid}/data/Library/Preferences/com.apple.uikitservices.userInterfaceStyleMode.plist"
+        File.write(plist_path, Plist::Emit.dump(plist))
+      end
+    end
+
+    def disable_slide_to_type(device_type)
+      device_udid = TestCommandGenerator.device_udid(device_type)
+      if device_udid
+        UI.message("Disabling slide to type on #{device_type}")
+        FastlaneCore::Simulator.disable_slide_to_type(udid: device_udid)
+      end
+    end
+
+    def copy_simulator_logs(device_names, language, locale, launch_arguments)
+      return unless launcher_config.output_simulator_logs
+
+      detected_language = locale || language
+      language_folder = File.join(launcher_config.output_directory, detected_language)
+
+      device_names.each do |device_name|
+        device = TestCommandGeneratorBase.find_device(device_name)
+        components = [launch_arguments].delete_if { |a| a.to_s.length == 0 }
+
+        UI.header("Collecting system logs #{device_name} - #{language}")
+        log_identity = Digest::MD5.hexdigest(components.join("-"))
+        FastlaneCore::Simulator.copy_logs(device, log_identity, language_folder, @device_boot_datetime)
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/simulator_launchers/simulator_launcher_xcode_8.rb

@@ -0,0 +1,113 @@
+require_relative 'simulator_launcher_base'
+require_relative '../error_handler'
+require_relative '../collector'
+require_relative '../test_command_generator_xcode_8'
+
+module Snapshot
+  class SimulatorLauncherXcode8 < SimulatorLauncherBase
+    def take_screenshots_one_simulator_at_a_time
+      results = {} # collect all the results for a nice table
+      launcher_config.devices.each_with_index do |device, device_index|
+        # launch_args_set always has at at least 1 item (could be "")
+        launcher_config.launch_args_set.each do |launch_args|
+          launcher_config.languages.each_with_index do |language, language_index|
+            locale = nil
+            if language.kind_of?(Array)
+              locale = language[1]
+              language = language[0]
+            end
+            results[device] ||= {}
+
+            current_run = device_index * launcher_config.languages.count + language_index + 1
+            number_of_runs = launcher_config.languages.count * launcher_config.devices.count
+            UI.message("snapshot run #{current_run} of #{number_of_runs}")
+            results[device][language] = run_for_device_and_language(language, locale, device, launch_args)
+            copy_simulator_logs([device], language, locale, launch_args)
+          end
+        end
+      end
+      results
+    end
+
+    # This is its own method so that it can re-try if the tests fail randomly
+    # @return true/false depending on if the tests succeeded
+    def run_for_device_and_language(language, locale, device, launch_arguments, retries = 0)
+      return launch_one_at_a_time(language, locale, device, launch_arguments)
+    rescue => ex
+      UI.error(ex.to_s) # show the reason for failure to the user, but still maybe retry
+
+      if retries < launcher_config.number_of_retries
+        UI.important("Tests failed, re-trying #{retries + 1} out of #{launcher_config.number_of_retries + 1} times")
+        run_for_device_and_language(language, locale, device, launch_arguments, retries + 1)
+      else
+        UI.error("Backtrace:\n\t#{ex.backtrace.join("\n\t")}") if FastlaneCore::Globals.verbose?
+        self.collected_errors << ex
+        raise ex if launcher_config.stop_after_first_error
+        return false # for the results
+      end
+    end
+
+    # Returns true if it succeeded
+    def launch_one_at_a_time(language, locale, device_type, launch_arguments)
+      prepare_for_launch([device_type], language, locale, launch_arguments)
+
+      add_media([device_type], :photo, launcher_config.add_photos) if launcher_config.add_photos
+      add_media([device_type], :video, launcher_config.add_videos) if launcher_config.add_videos
+
+      open_simulator_for_device(device_type)
+
+      command = TestCommandGeneratorXcode8.generate(device_type: device_type, language: language, locale: locale)
+
+      if locale
+        UI.header("#{device_type} - #{language} (#{locale})")
+      else
+        UI.header("#{device_type} - #{language}")
+      end
+
+      execute(command: command, language: language, locale: locale, device_type: device_type, launch_args: launch_arguments)
+
+      raw_output = File.read(TestCommandGeneratorXcode8.xcodebuild_log_path(device_type: device_type, language: language, locale: locale))
+
+      dir_name = locale || language
+
+      return Collector.fetch_screenshots(raw_output, dir_name, device_type, launch_arguments.first)
+    end
+
+    def execute(command: nil, language: nil, locale: nil, device_type: nil, launch_args: nil)
+      prefix_hash = [
+        {
+          prefix: "Running Tests: ",
+          block: proc do |value|
+            value.include?("Touching")
+          end
+        }
+      ]
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: true,
+                                      print_command: true,
+                                             prefix: prefix_hash,
+                                            loading: "Loading...",
+                                              error: proc do |output, return_code|
+                                                ErrorHandler.handle_test_error(output, return_code)
+
+                                                # no exception raised... that means we need to retry
+                                                UI.error("Caught error... #{return_code}")
+
+                                                self.current_number_of_retries_due_to_failing_simulator += 1
+                                                if self.current_number_of_retries_due_to_failing_simulator < 20
+                                                  launch_one_at_a_time(language, locale, device_type, launch_arguments)
+                                                else
+                                                  # It's important to raise an error, as we don't want to collect the screenshots
+                                                  UI.crash!("Too many errors... no more retries...")
+                                                end
+                                              end)
+    end
+
+    def open_simulator_for_device(device_name)
+      return unless FastlaneCore::Env.truthy?('FASTLANE_EXPLICIT_OPEN_SIMULATOR')
+
+      device = TestCommandGeneratorBase.find_device(device_name)
+      FastlaneCore::Simulator.launch(device) if device
+    end
+  end
+end

data/snapshot/lib/snapshot/test_command_generator.rb

@@ -0,0 +1,108 @@
+require_relative 'test_command_generator_base'
+require_relative 'latest_os_version'
+
+module Snapshot
+  # Responsible for building the fully working xcodebuild command
+  # Xcode 9 introduced the ability to run tests in parallel on multiple simulators
+  # This TestCommandGenerator constructs the appropriate `xcodebuild` command
+  # to be used for executing simultaneous tests
+  class TestCommandGenerator < TestCommandGeneratorBase
+    class << self
+      def generate(devices: nil, language: nil, locale: nil, log_path: nil)
+        parts = prefix
+        parts << "xcodebuild"
+        parts += options(language, locale)
+        parts += destination(devices)
+        parts += build_settings
+        parts += actions
+        parts += suffix
+        parts += pipe(log_path: log_path)
+
+        return parts
+      end
+
+      def pipe(log_path: nil)
+        tee_command = ['tee']
+        tee_command << '-a' if log_path && File.exist?(log_path)
+        tee_command << log_path.shellescape if log_path
+
+        pipe = ["| #{tee_command.join(' ')}"]
+        if Snapshot.config[:disable_xcpretty]
+          return pipe
+        end
+
+        xcpretty = "xcpretty #{Snapshot.config[:xcpretty_args]}"
+        xcpretty << "--no-color" if Helper.colors_disabled?
+        pipe << "| #{xcpretty}"
+        pipe << "> /dev/null" if Snapshot.config[:suppress_xcode_output]
+        return pipe
+      end
+
+      def destination(devices)
+        unless verify_devices_share_os(devices)
+          UI.user_error!('All devices provided to snapshot should run the same operating system')
+        end
+        # on Mac we will always run on host machine, so should specify only platform
+        return ["-destination 'platform=macOS'"] if devices.first.to_s =~ /^Mac/
+
+        os = devices.first.to_s =~ /^Apple TV/ ? "tvOS" : "iOS"
+
+        os_version = Snapshot.config[:ios_version] || Snapshot::LatestOsVersion.version(os)
+
+        destinations = devices.map do |d|
+          device = find_device(d, os_version)
+          if device.nil?
+            UI.user_error!("No device found named '#{d}' for version '#{os_version}'") if device.nil?
+          elsif device.os_version != os_version
+            UI.important("Using device named '#{device.name}' with version '#{device.os_version}' because no match was found for version '#{os_version}'")
+          end
+          "-destination 'platform=#{os} Simulator,name=#{device.name},OS=#{device.os_version}'"
+        end
+
+        return [destinations.join(' ')]
+      end
+
+      def verify_devices_share_os(device_names)
+        # Get device types based off of device name
+        devices = get_device_type_with_simctl(device_names)
+
+        # Check each device to see if it is an iOS device
+        all_ios = devices.map do |device|
+          device = device.downcase
+          device.include?('iphone') || device.include?('ipad')
+        end
+        # Return true if all devices are iOS devices
+        return true unless all_ios.include?(false)
+
+        all_tvos = devices.map do |device|
+          device = device.downcase
+          device.include?('apple tv')
+        end
+        # Return true if all devices are iOS devices
+        return true unless all_tvos.include?(false)
+
+        # There should only be more than 1 device type if
+        # it is iOS or tvOS, therefore, if there is more than 1
+        # device in the array, and they are not all iOS or tvOS
+        # as checked above, that would imply that this is a mixed bag
+        return devices.count == 1
+      end
+
+      private
+
+      def get_device_type_with_simctl(device_names)
+        return device_names if Helper.test?
+
+        require("simctl")
+
+        # Gets actual simctl device type from device name
+        return device_names.map do |device_name|
+          device = SimCtl.device(name: device_name)
+          if device
+            device.devicetype.name
+          end
+        end.compact
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/test_command_generator_base.rb

@@ -0,0 +1,128 @@
+require 'fastlane_core/device_manager'
+require_relative 'module'
+
+module Snapshot
+  class TestCommandGeneratorBase
+    class << self
+      def prefix
+        ["set -o pipefail &&"]
+      end
+
+      # Path to the project or workspace as parameter
+      # This will also include the scheme (if given)
+      # @return [Array] The array with all the components to join
+      def project_path_array
+        proj = Snapshot.project.xcodebuild_parameters
+        return proj if proj.count > 0
+        UI.user_error!("No project/workspace found")
+      end
+
+      def options(language, locale)
+        config = Snapshot.config
+        result_bundle_path = resolve_result_bundle_path(language, locale) if config[:result_bundle]
+
+        options = []
+        options += project_path_array
+        options << "-sdk '#{config[:sdk]}'" if config[:sdk]
+        if derived_data_path && !options.include?("-derivedDataPath #{derived_data_path.shellescape}")
+          options << "-derivedDataPath #{derived_data_path.shellescape}"
+        end
+        options << "-resultBundlePath '#{result_bundle_path}'" if result_bundle_path
+        if FastlaneCore::Helper.xcode_at_least?(11)
+          options << "-testPlan '#{config[:testplan]}'" if config[:testplan]
+        end
+        options << config[:xcargs] if config[:xcargs]
+
+        # detect_values will ensure that these values are present as Arrays if
+        # they are present at all
+        options += config[:only_testing].map { |test_id| "-only-testing:#{test_id.shellescape}" } if config[:only_testing]
+        options += config[:skip_testing].map { |test_id| "-skip-testing:#{test_id.shellescape}" } if config[:skip_testing]
+        return options
+      end
+
+      def build_settings
+        config = Snapshot.config
+
+        build_settings = []
+        build_settings << "FASTLANE_SNAPSHOT=YES"
+        build_settings << "TEST_TARGET_NAME=#{config[:test_target_name].shellescape}" if config[:test_target_name]
+
+        return build_settings
+      end
+
+      def actions
+        actions = []
+        if Snapshot.config[:test_without_building]
+          actions << "test-without-building"
+        else
+          actions << :clean if Snapshot.config[:clean]
+          actions << :build # https://github.com/fastlane/fastlane/issues/2581
+          actions << :test
+        end
+        return actions
+      end
+
+      def suffix
+        return []
+      end
+
+      def find_device(device_name, os_version = Snapshot.config[:ios_version])
+        # We might get this error message
+        # > The requested device could not be found because multiple devices matched the request.
+        #
+        # This happens when you have multiple simulators for a given device type / iOS combination
+        #   { platform:iOS Simulator, id:1685B071-AFB2-4DC1-BE29-8370BA4A6EBD, OS:9.0, name:iPhone 5 }
+        #   { platform:iOS Simulator, id:A141F23B-96B3-491A-8949-813B376C28A7, OS:9.0, name:iPhone 5 }
+        #
+        simulators = FastlaneCore::DeviceManager.simulators
+        # Sort devices with matching names by OS version, largest first, so that we can
+        # pick the device with the newest OS in case an exact OS match is not available
+        name_matches = simulators.find_all { |sim| sim.name.strip == device_name.strip }
+                                 .sort_by { |sim| Gem::Version.new(sim.os_version) }
+                                 .reverse
+        return name_matches.find { |sim| sim.os_version == os_version } || name_matches.first
+      end
+
+      def device_udid(device_name, os_version = Snapshot.config[:ios_version])
+        device = find_device(device_name, os_version)
+
+        return device ? device.udid : nil
+      end
+
+      def derived_data_path
+        Snapshot.cache[:derived_data_path] ||= (Snapshot.config[:derived_data_path] || Dir.mktmpdir("snapshot_derived"))
+      end
+
+      def resolve_result_bundle_path(language, locale)
+        Snapshot.cache[:result_bundle_path] = {}
+        language_key = locale || language
+
+        unless Snapshot.cache[:result_bundle_path][language_key]
+          ext = FastlaneCore::Helper.xcode_at_least?(11) ? '.xcresult' : '.test_result'
+          path = File.join(Snapshot.config[:output_directory], "test_output", language_key, Snapshot.config[:scheme]) + ext
+          if File.directory?(path)
+            FileUtils.remove_dir(path)
+          end
+          Snapshot.cache[:result_bundle_path][language_key] = path
+        end
+        return Snapshot.cache[:result_bundle_path][language_key]
+      end
+
+      def initialize
+        not_implemented(__method__)
+      end
+
+      def pipe(device_type, language, locale)
+        not_implemented(__method__)
+      end
+
+      def destination(device_name)
+        not_implemented(__method__)
+      end
+
+      def xcodebuild_log_path(device_type: nil, language: nil, locale: nil)
+        not_implemented(__method__)
+      end
+    end
+  end
+end