run_loop 2.1.6 → 2.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff141b60144498a30b21eb09fa12ac5a6c8e95fd
-  data.tar.gz: 8f8f501c79a466e8aefae117ead31fa5fc1b0d38
+  metadata.gz: 8451119a8e88cf2179b1b7a0bfc554a19459e9c5
+  data.tar.gz: 0b75d4af7f258d99780c624750dc3e3f241e5581
 SHA512:
-  metadata.gz: e2654a32fa02ca8e27746102748201934a2d27fc5a995fe58dd10e94b147e4688876fc07c6625b513742410224800e2848e5f394416db6be15385061ff7300a5
-  data.tar.gz: fa60c8ab92dfc6840f45bb242be4b2fec1e4d1394d2f89542e1e159a54c10f8b082d019724c83c26dd3d860ffb9a438faeb0db0d5f65c2defd0b09d73c0c6e99
+  metadata.gz: ad70df268ab1bcd8001f71cb81499653ec67428be5e5fd78a7a6a89d83e527b7fe3e2da982be52bb0c1480eee57de119b40b2a1c3a4b290e6a5d5b5c9565afb2
+  data.tar.gz: d75408caf251d7b4a4ebf532adfe361697dc7cf46e4aab6f15c6447818622604c13205a764202ff5796079e2e28ec0fed871fbe73309d63cdbf1f99e63eaeed5

data/lib/run_loop.rb

@@ -48,6 +48,7 @@ require "run_loop/http/server"
 require "run_loop/http/request"
 require "run_loop/http/retriable_client"
 require "run_loop/physical_device/life_cycle"
+require "run_loop/physical_device/ios_device_manager"
 
 module RunLoop
 

data/lib/run_loop/app.rb

@@ -180,7 +180,7 @@ Bundle must:
     # See #marketing_version
     alias_method :short_bundle_version, :marketing_version
 
-    # Returns the CFBundleVersionString of the app as Version instance.
+    # Returns the CFBundleVersion of the app as Version instance.
     #
     # Apple docs:
     #
@@ -195,14 +195,14 @@ Bundle must:
     # @return [RunLoop::Version, nil] Returns a Version instance if the
     #  CFBundleVersion string is well formed and nil if not.
     def build_version
-      string = plist_buddy.plist_read("CFBundleVersionString", info_plist_path)
+      string = plist_buddy.plist_read("CFBundleVersion", info_plist_path)
       begin
         version = RunLoop::Version.new(string)
       rescue
         if string && string != ""
-          RunLoop.log_debug("CFBundleVersionString: '#{string}' is not a well formed version string")
+          RunLoop.log_debug("CFBundleVersion: '#{string}' is not a well formed version string")
         else
-          RunLoop.log_debug("CFBundleVersionString is not defined in Info.plist")
+          RunLoop.log_debug("CFBundleVersion is not defined in Info.plist")
         end
         version = nil
       end
@@ -218,7 +218,7 @@ Bundle must:
       executables = []
       Dir.glob("#{path}/**/*") do |file|
         next if skip_executable_check?(file)
-        if otool(file).executable?
+        if otool.executable?(file)
           executables << file
         end
       end
@@ -262,9 +262,13 @@ Bundle must:
     end
 
     # @!visibility private
-    # An otool factory.
-    def otool(file)
-      RunLoop::Otool.new(file)
+    def otool
+      @otool ||= RunLoop::Otool.new(xcode)
+    end
+
+    # @!visibility private
+    def xcode
+      @xcode ||= RunLoop::Xcode.new
     end
 
     # @!visibility private

data/lib/run_loop/cli/cli.rb

@@ -30,8 +30,8 @@ module RunLoop
       desc 'instruments', "Interact with Xcode's command-line instruments"
       subcommand 'instruments', RunLoop::CLI::Instruments
 
-      desc 'simctl', "Interact with Xcode's command-line simctl"
-      subcommand 'simctl', RunLoop::CLI::Simctl
+      desc "simctl", "Interact with Xcode's command-line simctl"
+      subcommand "simctl", RunLoop::CLI::Simctl
 
       desc "locale", "Tools for interacting with locales"
       subcommand "locale", RunLoop::CLI::Locale

data/lib/run_loop/cli/simctl.rb

@@ -103,11 +103,6 @@ module RunLoop
 
         begin
           RunLoop::CoreSimulator.terminate_core_simulator_processes
-          process_name = "com.apple.CoreSimulator.CoreSimulatorService"
-          RunLoop::ProcessWaiter.new(process_name).pids.each do |pid|
-            kill_options = { :timeout => 0.5 }
-            RunLoop::ProcessTerminator.new(pid, 'KILL', process_name, kill_options)
-          end
         ensure
           ENV['DEBUG'] = original_value if debug
         end

data/lib/run_loop/core.rb

@@ -65,7 +65,8 @@ module RunLoop
       xcode = options[:xcode] || RunLoop::Xcode.new
       instruments = options[:instruments] || RunLoop::Instruments.new
 
-      if xcode.version_gte_8?
+      # Guard against Xcode version check on the XTC.
+      if !RunLoop::Environment.xtc? && xcode.version_gte_8?
         raise %Q[
 UIAutomation is not available on Xcode >= 8.*.
 

data/lib/run_loop/core_simulator.rb

@@ -22,7 +22,8 @@ class RunLoop::CoreSimulator
     :install_app_timeout => RunLoop::Environment.ci? ? 120 : 30,
     :uninstall_app_timeout => RunLoop::Environment.ci? ? 120 : 30,
     :launch_app_timeout => RunLoop::Environment.ci? ? 120 : 30,
-    :wait_for_state_timeout => RunLoop::Environment.ci? ? 120 : 30
+    :wait_for_state_timeout => RunLoop::Environment.ci? ? 120 : 30,
+    :app_launch_retries => RunLoop::Environment.ci? ? 5 : 3
   }
 
   # @!visibility private
@@ -178,9 +179,8 @@ class RunLoop::CoreSimulator
   #
   # @param [RunLoop::Device] simulator The simulator to erase
   # @param [Hash] options Control the behavior of the method.
-  # @option options [Numeric] :timeout (180) How long tow wait for simctl to
-  #   shutdown and erase the simulator.  The timeout is apply separately to
-  #   each command.
+  # @option options [Numeric] :timeout How long to wait for simctl to
+  #   shutdown the simulator. This is necessary for the erase to succeed.
   #
   # @raise RuntimeError If the simulator cannot be shutdown
   # @raise RuntimeError If the simulator cannot be erased
@@ -191,61 +191,13 @@ class RunLoop::CoreSimulator
         "#{simulator} is a physical device.  This method is only for Simulators"
     end
 
-    default_options = {
-      :timeout => 60*3
-    }
-
-    merged_options = default_options.merge(options)
-
-    self.quit_simulator
-
-    xcrun = merged_options[:xcrun] || RunLoop::Xcrun.new
-    timeout = merged_options[:timeout]
-    xcrun_opts = {
-      :log_cmd => true,
-      :timeout => timeout
-    }
-
-    if simulator.update_simulator_state != "Shutdown"
-      args = ["simctl", "shutdown", simulator.udid]
-      xcrun.run_command_in_context(args, xcrun_opts)
-      begin
-        self.wait_for_simulator_state(simulator, "Shutdown")
-      rescue RuntimeError => _
-        raise RuntimeError, %Q{
-Could not erase simulator because it could not be Shutdown.
+    merged_options = DEFAULT_OPTIONS.merge(options)
+    simctl = merged_options[:simctl] || RunLoop::Simctl.new
+    timeout = merged_options[:timeout] || merged_options[:wait_for_state_timeout]
 
-This usually means your CoreSimulator processes need to be restarted.
-
-You can restart the CoreSimulator processes with this command:
-
-$ bundle exec run-loop simctl manage-processes
-
-}
-
-      end
-    end
-
-    args = ["simctl", "erase", simulator.udid]
-    hash = xcrun.run_command_in_context(args, xcrun_opts)
-
-    if hash[:exit_status] != 0
-      raise RuntimeError, %Q{
-Could not erase simulator because simctl returned this error:
-
-#{hash[:out]}
-
-This usually means your CoreSimulator processes need to be restarted.
-
-You can restart the CoreSimulator processes with this command:
-
-$ bundle exec run-loop simctl manage-processes
-
-}
-
-    end
-
-    hash
+    simctl.erase(simulator,
+                 timeout,
+                 WAIT_FOR_SIMULATOR_STATE_INTERVAL)
   end
 
   # @!visibility private
@@ -351,6 +303,11 @@ $ bundle exec run-loop simctl manage-processes
     @xcrun ||= RunLoop::Xcrun.new
   end
 
+  # @!visibility private
+  def simctl
+    @simctl ||= RunLoop::Simctl.new
+  end
+
   # Launch the simulator indicated by device.
   def launch_simulator
 
@@ -404,29 +361,19 @@ $ bundle exec run-loop simctl manage-processes
     # relaunch it.
     launch_simulator
 
-    tries = RunLoop::Environment.ci? ? 5 : 3
-    last_error = nil
+    tries = app_launch_retries
 
     RunLoop.log_debug("Trying #{tries} times to launch #{app.bundle_identifier} on #{device}")
 
-    tries.times do |try|
-      # Terminates CoreSimulatorService on failures.
-      hash = attempt_to_launch_app_with_simctl
-
-      exit_status = hash[:exit_status]
-      if exit_status != 0
-        # Last argument is how long to sleep after an error.
-        last_error = handle_failed_app_launch(hash, try, tries, 0.5)
-      else
-        last_error = nil
-        break
-      end
-    end
+    last_error = try_to_launch_app_n_times(tries)
 
     if last_error
-      raise RuntimeError, %Q[Could not launch #{app.bundle_identifier} on #{device}
+      raise RuntimeError, %Q[
+Could not launch #{app.bundle_identifier} on #{device} after trying #{tries} times:
 
-#{last_error}
+#{last_error}:
+
+#{last_error.message}
 
 ]
     end
@@ -487,10 +434,8 @@ $ bundle exec run-loop simctl manage-processes
 
     launch_simulator
 
-    args = ['simctl', 'uninstall', device.udid, app.bundle_identifier]
-
     timeout = DEFAULT_OPTIONS[:uninstall_app_timeout]
-    xcrun.run_command_in_context(args, log_cmd: true, timeout: timeout)
+    simctl.uninstall(device, app, timeout)
 
     device.simulator_wait_for_stable_state
     true
@@ -610,9 +555,8 @@ Command had no output
   def install_app_with_simctl
     launch_simulator
 
-    args = ['simctl', 'install', device.udid, app.path]
     timeout = DEFAULT_OPTIONS[:install_app_timeout]
-    xcrun.run_command_in_context(args, log_cmd: true, timeout: timeout)
+    simctl.install(device, app, timeout)
 
     device.simulator_wait_for_stable_state
     installed_app_bundle_dir
@@ -620,42 +564,48 @@ Command had no output
 
   # @!visibility private
   def launch_app_with_simctl
-    args = ['simctl', 'launch', device.udid, app.bundle_identifier]
     timeout = DEFAULT_OPTIONS[:launch_app_timeout]
-    xcrun.run_command_in_context(args, log_cmd: true, timeout: timeout)
+    simctl.launch(device, app, timeout)
   end
 
   # @!visibility private
-  def handle_failed_app_launch(hash, try, tries, wait_time)
-    out = hash[:out]
-    RunLoop.log_debug("Failed to launch app on try #{try + 1} of #{tries}.")
-    out.split($-0).each do |line|
-      RunLoop.log_debug("    #{line}")
+  #
+  # Returns nil if launch_app_with_simctl succeeds and the error if it fails.
+  def try_to_launch_app
+    begin
+      launch_app_with_simctl
+      nil
+    rescue RuntimeError, RunLoop::Xcrun::TimeoutError  => error
+      # Simulator is probably in a bad state.  Restart the service.
+      RunLoop::CoreSimulator.terminate_core_simulator_processes
+      Kernel.sleep(0.5)
+      launch_simulator
+      error
     end
-    # If we timed out on the launch, the CoreSimulator processes are quit
-    # (see above).  If at all possible, we want to avoid terminating
-    # CoreSimulatorService, because it takes a long time to launch.
-    sleep(wait_time) if wait_time > 0
+  end
 
-    out
+  # @!visibility private
+  def app_launch_retries
+    DEFAULT_OPTIONS[:app_launch_retries]
   end
 
   # @!visibility private
-  def attempt_to_launch_app_with_simctl
-    begin
-      hash = launch_app_with_simctl
-    rescue RunLoop::Xcrun::TimeoutError => e
-      hash = {
-        :exit_status => 1,
-        :out => e.message
-      }
-      # Simulator is probably in a bad state.  Terminates the
-      # CoreSimulatorService.  Restarting this service is expensive!
-      RunLoop::CoreSimulator.terminate_core_simulator_processes
-      Kernel.sleep(0.5)
-      launch_simulator
+  #
+  # Returns nil if launch_app_with_simctl succeeds and the error if it fails.
+  def try_to_launch_app_n_times(tries)
+    last_error = nil
+
+    tries.times do |try|
+      # Terminates CoreSimulatorService on failures and launches the simulator again.
+      # Returns nil if app launched.
+      # Returns rescued Runtime or Timeout errors.
+      last_error = try_to_launch_app
+
+      break if last_error.nil?
+      RunLoop.log_debug("Failed to launch app on try #{try + 1} of #{tries}.")
     end
-    hash
+
+    last_error
   end
 
   # Required for support of iOS 7 CoreSimulators.  Can be removed when

data/lib/run_loop/device.rb

@@ -4,6 +4,9 @@ module RunLoop
     require 'securerandom'
     include RunLoop::Regex
 
+    require "run_loop/shell"
+    include RunLoop::Shell
+
     # Starting in Xcode 7, iOS 9 simulators have a new "booting" state.
     #
     # The simulator must completely boot before run-loop tries to do things
@@ -39,7 +42,6 @@ module RunLoop
     attr_reader :simulator_accessibility_plist_path
     attr_reader :simulator_preferences_plist_path
     attr_reader :simulator_log_file_path
-    attr_reader :pbuddy
 
     # Create a new device.
     #
@@ -268,7 +270,7 @@ version: #{version}
         raise RuntimeError, 'This method is available only for simulators'
       end
 
-      @state = fetch_simulator_state
+      @state = simctl.simulator_state_as_string(self)
     end
 
     # @!visibility private
@@ -498,20 +500,35 @@ version: #{version}
       global_plist = simulator_global_preferences_path
 
       cmd = [
-        "PlistBuddy",
+        "/usr/libexec/PlistBuddy",
         "-c",
         "Add :AppleLanguages:0 string '#{lang_code}'",
         global_plist
       ]
 
       # RunLoop::PlistBuddy cannot add items to arrays.
-      xcrun.run_command_in_context(cmd, {:log_cmd => true})
+      hash = run_shell_command(cmd, {:log_cmd => true})
+
+      if hash[:exit_status] != 0
+        raise RuntimeError, %Q[
+Could not update the Simulator languages because this command:
+
+#{cmd.join(" ")}
+
+failed with this output:
+
+#{hash[:out]}
+
+]
+      end
 
       simulator_languages
     end
 
     private
 
+    attr_reader :pbuddy, :simctl, :xcrun
+
     # @!visibility private
     def xcrun
       RunLoop::Xcrun.new
@@ -523,43 +540,8 @@ version: #{version}
     end
 
     # @!visibility private
-    def detect_state_from_line(line)
-
-      if line[/unavailable/, 0]
-        RunLoop.log_debug("Simulator state is unavailable: #{line}")
-        return 'Unavailable'
-      end
-
-      state = line[/(Booted|Shutdown|Shutting Down)/,0]
-
-      if state.nil?
-        RunLoop.log_debug("Simulator state is unknown: #{line}")
-        'Unknown'
-      else
-        state
-      end
-    end
-
-    # @!visibility private
-    def fetch_simulator_state
-      if physical_device?
-        raise RuntimeError, 'This method is available only for simulators'
-      end
-
-      args = ['simctl', 'list', 'devices']
-      hash = xcrun.run_command_in_context(args)
-      out = hash[:out]
-
-      matched_line = out.split("\n").find do |line|
-        line.include?(udid)
-      end
-
-      if matched_line.nil?
-        raise RuntimeError,
-              "Expected a simulator with udid '#{udid}', but found none"
-      end
-
-      detect_state_from_line(matched_line)
+    def simctl
+      @simctl ||= RunLoop::Simctl.new
     end
 
     # @!visibility private