fastlane 2.54.0.beta.20170822010003 → 2.54.0

data/snapshot/lib/snapshot/setup.rb

@@ -9,15 +9,21 @@ module Snapshot
       end
 
       File.write(snapfile_path, File.read("#{Snapshot::ROOT}/lib/assets/SnapfileTemplate"))
-      File.write(File.join(path, 'SnapshotHelper.swift'), File.read("#{Snapshot::ROOT}/lib/assets/SnapshotHelper.swift"))
+      snapshot_helper_filename = "SnapshotHelperXcode8.swift"
+      if Helper.xcode_at_least?("9.0")
+        snapshot_helper_filename = "SnapshotHelper.swift"
+      end
+
+      # ensure that upgrade is cause when going from 8 to 9
+      File.write(File.join(path, snapshot_helper_filename), File.read("#{Snapshot::ROOT}/lib/assets/#{snapshot_helper_filename}"))
 
-      puts "✅  Successfully created SnapshotHelper.swift '#{File.join(path, 'SnapshotHelper.swift')}'".green
+      puts "✅  Successfully created #{snapshot_helper_filename} '#{File.join(path, snapshot_helper_filename)}'".green
       puts "✅  Successfully created new Snapfile at '#{snapfile_path}'".green
 
       puts "-------------------------------------------------------".yellow
       puts "Open your Xcode project and make sure to do the following:".yellow
       puts "1) Add a new UI Test target to your project".yellow
-      puts "2) Add the ./fastlane/SnapshotHelper.swift to your UI Test target".yellow
+      puts "2) Add the ./fastlane/#{snapshot_helper_filename} to your UI Test target".yellow
       puts "   You can move the file anywhere you want".yellow
       puts "3) Call `setupSnapshot(app)` when launching your app".yellow
       puts ""

data/snapshot/lib/snapshot/simulator_launchers/launcher_configuration.rb

@@ -0,0 +1,53 @@
+
+module Snapshot
+  class SimulatorLauncherConfiguration
+    # both
+    attr_accessor :languages
+    attr_accessor :devices
+    attr_accessor :add_photos
+    attr_accessor :add_videos
+    attr_accessor :clean
+    attr_accessor :erase_simulator
+    attr_accessor :localize_simulator
+    attr_accessor :reinstall_app
+    attr_accessor :app_identifier
+
+    # xcode 8
+    attr_accessor :number_of_retries
+    attr_accessor :stop_after_first_error
+    attr_accessor :output_simulator_logs
+
+    # runner
+    attr_accessor :launch_args_set
+    attr_accessor :output_directory
+
+    # xcode 9
+    attr_accessor :concurrent_simulators
+    alias concurrent_simulators? concurrent_simulators
+
+    def initialize(snapshot_config: nil)
+      @languages = snapshot_config[:languages]
+      @devices = snapshot_config[:devices]
+      @add_photos = snapshot_config[:add_photos]
+      @add_videos = snapshot_config[:add_videos]
+      @clean = snapshot_config[:clean]
+      @erase_simulator = snapshot_config[:erase_simulator]
+      @localize_simulator = snapshot_config[:localize_simulator]
+      @reinstall_app = snapshot_config[:reinstall_app]
+      @app_identifier = snapshot_config[:app_identifier]
+      @number_of_retries = snapshot_config[:number_of_retries]
+      @stop_after_first_error = snapshot_config[:stop_after_first_error]
+      @output_simulator_logs = snapshot_config[:output_simulator_logs]
+      @output_directory = snapshot_config[:output_directory]
+      @concurrent_simulators = snapshot_config[:concurrent_simulators]
+
+      launch_arguments = Array(snapshot_config[:launch_arguments])
+      # if more than 1 set of arguments, use a tuple with an index
+      if launch_arguments.count == 1
+        @launch_args_set = [launch_arguments]
+      else
+        @launch_args_set = launch_arguments.map.with_index { |e, i| [i, e] }
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/simulator_launchers/simulator_launcher.rb

@@ -0,0 +1,203 @@
+require 'snapshot/simulator_launchers/simulator_launcher_base'
+
+module Snapshot
+  class SimulatorLauncher < SimulatorLauncherBase
+    # With Xcode 9's ability to run tests on multiple concurrent simulators,
+    # this method sets the maximum number of simulators to run simultaneously
+    # to avoid overloading your machine.
+    def default_number_of_simultaneous_simulators
+      cpu_count = CPUInspector.cpu_count
+      if cpu_count <= 2
+        return cpu_count
+      end
+
+      return cpu_count - 1
+    end
+
+    def take_screenshots_simultaneously
+      languages_finished = {}
+      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
+
+          # Clear logs so subsequent xcodebuild executions dont append to old ones
+          log_path = xcodebuild_log_path(language: language, locale: locale)
+          File.delete(log_path) if File.exist?(log_path)
+
+          # Break up the array of devices into chunks that can
+          # be run simultaneously.
+          if launcher_config.concurrent_simulators?
+            device_batches = launcher_config.devices.each_slice(default_number_of_simultaneous_simulators).to_a
+          else
+            # Put each device in it's own array to run tests one at a time
+            device_batches = launcher_config.devices.map { |d| [d] }
+          end
+
+          device_batches.each do |devices|
+            languages_finished[language] = launch_simultaneously(devices, language, locale, launch_args)
+          end
+        end
+      end
+      launcher_config.devices.each_with_object({}) do |device, results_hash|
+        results_hash[device] = languages_finished
+      end
+    end
+
+    def launch_simultaneously(devices, language, locale, launch_arguments)
+      prepare_for_launch(language, locale, launch_arguments)
+
+      add_media(devices, :photo, launcher_config.add_photos) if launcher_config.add_photos
+      add_media(devices, :video, launcher_config.add_videos) if launcher_config.add_videos
+
+      command = TestCommandGenerator.generate(
+        devices: devices,
+        language: language,
+        locale: locale,
+        log_path: xcodebuild_log_path(language: language, locale: locale)
+      )
+
+      UI.important("Running snapshot on: #{devices.join(', ')}")
+
+      execute(command: command, language: language, locale: locale, launch_args: launch_arguments, devices: devices)
+
+      return copy_screenshots(language: language, locale: locale, launch_args: launch_arguments)
+    end
+
+    def execute(retries = 0, command: nil, language: nil, locale: nil, launch_args: nil, devices: 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|
+                                                self.collected_errors.concat(failed_devices.map do |device, messages|
+                                                  "#{device}: #{messages.join(', ')}"
+                                                end)
+
+                                                cleanup_after_failure(devices, language, locale, launch_args, 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 && return_code != 65
+                                                  # If the return code is not 65, we should assume its a simulator failure and retry
+                                                  launch_simultaneously(devices, language, locale, launch_args)
+                                                elsif retries < launcher_config.number_of_retries
+                                                  # If there are retries remaining, run the tests again
+                                                  retry_tests(retries, command, language, locale, launch_args, devices)
+                                                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...") if launcher_config.stop_after_first_error
+                                                end
+                                              end)
+    end
+
+    def cleanup_after_failure(devices, language, locale, launch_args, return_code)
+      copy_screenshots(language: language, locale: locale, launch_args: launch_args)
+
+      UI.important("Tests failed while running on: #{devices.join(', ')}")
+      UI.important("For more detail about the test failures, check the logs here:")
+      UI.important(xcodebuild_log_path(language: language, locale: locale))
+      UI.important(" ")
+      UI.important("You can also find the test result data here:")
+      UI.important(test_results_path)
+      UI.important(" ")
+      UI.important("You can find the incomplete screenshots here:")
+      UI.important(SCREENSHOTS_DIR)
+      UI.important(launcher_config.output_directory)
+    end
+
+    def retry_tests(retries, command, language, locale, launch_args, devices)
+      UI.important("Retrying on devices: #{devices.join(', ')}")
+      UI.important("Number of retries remaining: #{launcher_config.number_of_retries - retries - 1}")
+      execute(retries + 1, command: command, language: language, locale: locale, launch_args: launch_args, devices: devices)
+    end
+
+    def copy_screenshots(language: nil, locale: nil, launch_args: nil)
+      raw_output = File.read(xcodebuild_log_path(language: language, locale: locale))
+      dir_name = locale || language
+      return Collector.fetch_screenshots(raw_output, dir_name, '', launch_args.first)
+    end
+
+    def test_results_path
+      derived_data_path = TestCommandGenerator.derived_data_path
+      return File.join(derived_data_path, 'Logs/Test')
+    end
+
+    # This method returns a hash of { device name => [failure messages] }
+    # {
+    #   'iPhone 7': [], # this empty array indicates success
+    #   'iPhone 7 Plus': ["No tests were executed"],
+    #   'iPad Air': ["Launch session expired", "Array out of bounds"]
+    # }
+    def failed_devices
+      test_summaries = Dir["#{test_results_path}/*_TestSummaries.plist"]
+      test_summaries.each_with_object({}) do |plist, hash|
+        summary = FastlaneCore::TestParser.new(plist)
+        name = summary.data.first[:run_destination_name]
+        if summary.data.first[:number_of_tests] == 0
+          hash[name] = ["No tests were executed"]
+        else
+          tests = Array(summary.data.first[:tests])
+          hash[name] = tests.map { |test| test[:failures].map { |failure| failure[:failure_message] } }.flatten
+        end
+      end
+    end
+
+    def xcodebuild_log_path(language: nil, locale: nil)
+      name_components = [Snapshot.project.app_name, Snapshot.config[:scheme]]
+
+      if Snapshot.config[:namespace_log_files]
+        name_components << launcher_config.devices.join('-') if launcher_config.devices.count >= 1
+        name_components << language if language
+        name_components << locale if locale
+      end
+
+      file_name = "#{name_components.join('-')}.log"
+
+      containing = File.expand_path(Snapshot.config[:buildlog_path])
+      FileUtils.mkdir_p(containing)
+
+      return File.join(containing, file_name)
+    end
+  end
+
+  class CPUInspector
+    def self.hwprefs_available?
+      `which hwprefs` != ''
+    end
+
+    def self.cpu_count
+      @cpu_count ||=
+        case RUBY_PLATFORM
+        when /darwin9/
+          `hwprefs cpu_count`.to_i
+        when /darwin10/
+          (hwprefs_available? ? `hwprefs thread_count` : `sysctl -n hw.physicalcpu_max`).to_i
+        when /linux/
+          UI.user_error!("We detected that you are running snapshot on Linux, but snapshot is only supported on macOS")
+        when /freebsd/
+          UI.user_error!("We detected that you are running snapshot on FreeBSD, but snapshot is only supported on macOS")
+        else
+          if RbConfig::CONFIG['host_os'] =~ /darwin/
+            (hwprefs_available? ? `hwprefs thread_count` : `sysctl -n hw.physicalcpu_max`).to_i
+          else
+            UI.crash!("Cannot find the machine's processor count.")
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+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
+    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(language, locale, launch_arguments)
+      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)
+
+      prepare_simulators_for_launch(language: language, locale: locale)
+    end
+
+    def prepare_simulators_for_launch(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/snapshot/issues/337
+      `xcrun simctl shutdown booted &> /dev/null`
+
+      Fixes::SimulatorZoomFix.patch
+      Fixes::HardwareKeyboardFix.patch
+
+      devices = launcher_config.devices || []
+      devices.each do |type|
+        if launcher_config.erase_simulator || launcher_config.localize_simulator
+          erase_simulator(type)
+          if launcher_config.localize_simulator
+            localize_simulator(type, language, locale)
+          end
+        elsif launcher_config.reinstall_app
+          # no need to reinstall if device has been erased
+          uninstall_app(type)
+        end
+      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}'"
+          Helper.backticks("xcrun simctl add#{media_type} #{device_udid} #{path.shellescape} &> /dev/null")
+        end
+      end
+    end
+
+    def uninstall_app(device_type)
+      UI.verbose "Uninstalling app '#{launcher_config.app_identifier}' from #{device_type}..."
+      launcher_config.app_identifier ||= UI.input("App Identifier: ")
+      device_udid = TestCommandGenerator.device_udid(device_type)
+
+      UI.message "Launch Simulator #{device_type}"
+      Helper.backticks("xcrun instruments -w #{device_udid} &> /dev/null")
+
+      UI.message "Uninstall application #{launcher_config.app_identifier}"
+      Helper.backticks("xcrun simctl uninstall #{device_udid} #{launcher_config.app_identifier} &> /dev/null")
+    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 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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'snapshot/simulator_launchers/simulator_launcher_base'
+
+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(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