run_loop 1.5.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbbee55fbd11dd5c1cd13fa461ae1be917adc6d3
-  data.tar.gz: 22f0456c4949e71f6c8d2d951d7f0aa559448674
+  metadata.gz: 8d3ac00b7d27f57b3b75a5c968119b85e42106c5
+  data.tar.gz: 991d05cd919e9a9beab809a162a654c917404c64
 SHA512:
-  metadata.gz: 434db36ae98ba6a3530cb164d9ac0379fbe59cfad22a2851901530abbe20393668ff3c8be03e046a180b3a168f4842376825bb13920fb0f3c9b9417e5b125902
-  data.tar.gz: 351adc46d8f2849bb6c1b5f8b0772073f3608776fabe3ee324e16daed86e8d6b07fa58fc22f59881d86c60b979a27a2f050e2af6bc5759be833dc3c1e88f36e3
+  metadata.gz: b228aeeafd1f6a418deef62898a4001f8902c6566497b6d906da927356982bfc1b3b05f136ead14026135c0223d9ae32cfa9fc8c0f0c32598326d7a74657b466
+  data.tar.gz: c0786de6bf90282b0c9e9106a2893ceb8984b2df909aaa6d581b1a7fa7d58864a49066776caa780cefdabb21de960276d1d11ecc64acacbfabde40d2217e1aaf

data/lib/run_loop.rb

@@ -13,7 +13,6 @@ require 'run_loop/dylib_injector'
 require 'run_loop/fifo'
 require 'run_loop/core'
 require 'run_loop/version'
-require 'run_loop/xctools'
 require 'run_loop/plist_buddy'
 require 'run_loop/app'
 require 'run_loop/ipa'
@@ -24,7 +23,6 @@ require 'run_loop/lipo'
 require 'run_loop/cache/cache'
 require 'run_loop/host_cache'
 require 'run_loop/patches/awesome_print'
-require 'run_loop/patches/retriable'
 require 'run_loop/core_simulator'
 require 'run_loop/simctl/plists'
 
@@ -37,11 +35,7 @@ module RunLoop
   # @return [void]
   def self.deprecated(version, msg)
 
-    if RUBY_VERSION < '2.0'
-      stack = Kernel.caller[1..6].join("\n")
-    else
-      stack = Kernel.caller(0, 6)[1..-1].join("\n")
-    end
+    stack = Kernel.caller(0, 6)[1..-1].join("\n")
 
     msg = "deprecated '#{version}' - #{msg}\n#{stack}"
 

data/lib/run_loop/cli/simctl.rb

@@ -97,8 +97,12 @@ module RunLoop
         ENV['DEBUG'] = '1' if debug
 
         begin
-          RunLoop::SimControl.terminate_all_sims
-          RunLoop::LifeCycle::Simulator.new.terminate_core_simulator_processes
+          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

@@ -185,7 +185,10 @@ module RunLoop
         # Quits the simulator.
         core_sim = RunLoop::CoreSimulator.new(device, app)
 
-        core_sim.install
+        # :reset is a legacy variable; has been replaced with :reset_app_sandbox
+        if launch_options[:reset] || launch_options[:reset_app_sandbox]
+          core_sim.reset_app_sandbox
+        end
 
         # Will quit the simulator if it is running.
         # @todo fix accessibility_enabled? so we don't have to quit the sim
@@ -196,17 +199,15 @@ module RunLoop
         # Will quit the simulator if it is running.
         # @todo fix software_keyboard_enabled? so we don't have to quit the sim
         # SimControl#software_keyboard_enabled? is always false during Core#prepare_simulator
-        # https://github.com/calabash/run_loop/issues/167
+        # https://github.com/calabash/run_loop/issues/168
         sim_control.ensure_software_keyboard(device)
 
-        # Xcode 6.3 instruments cannot launch an app that is already installed on
-        # iOS 8.3 Simulators. See: https://github.com/calabash/calabash-ios/issues/744
-        if xcode.version_gte_63?
+        # Launches the simulator if the app is not installed.
+        core_sim.install
 
-          if core_sim.app_is_installed? && !sim_control.sim_is_running?
-            core_sim.launch_simulator
-          end
-        end
+        # If CoreSimulator has already launched the simulator, it will not
+        # launching it again.
+        core_sim.launch_simulator
       end
     end
 
@@ -218,15 +219,6 @@ module RunLoop
       logger = options[:logger]
       sim_control ||= options[:sim_control] || RunLoop::SimControl.new
 
-      if options[:xctools]
-        if RunLoop::Environment.debug?
-          RunLoop.deprecated('1.5.0', %q(
-RunLoop::XCTools has been replaced with RunLoop::Xcode.
-The :xctools key will be ignored.  It has been replaced by the :xcode key.
-Please update your sources to pass an instance of RunLoop::Xcode))
-        end
-      end
-
       xcode ||= options[:xcode] || sim_control.xcode
 
       instruments = RunLoop::Instruments.new
@@ -476,34 +468,23 @@ Logfile: #{log_file}
   #
   # For historical reasons, the most recent non-64b SDK should be used.
   #
-  # @param [RunLoop::XCTools, RunLoop::Xcode] xcode Used to detect the current xcode
+  # @param [RunLoop::Xcode] xcode Used to detect the current xcode
   #  version.
   def self.default_simulator(xcode=RunLoop::Xcode.new)
-    if xcode.is_a?(RunLoop::XCTools)
-      if RunLoop::Environment.debug?
-        RunLoop.deprecated('1.5.0',
-                           %q(
-RunLoop::XCTools has been replaced with RunLoop::Xcode.
-Please update your sources to pass an instance of RunLoop::Xcode))
-      end
-      ensured_xcode = RunLoop::Xcode.new
-    else
-      ensured_xcode = xcode
-    end
 
-    if ensured_xcode.version_gte_71?
+    if xcode.version_gte_71?
       'iPhone 6s (9.1)'
-    elsif ensured_xcode.version_gte_7?
+    elsif xcode.version_gte_7?
       'iPhone 5s (9.0)'
-    elsif ensured_xcode.version_gte_64?
+    elsif xcode.version_gte_64?
       'iPhone 5s (8.4 Simulator)'
-    elsif ensured_xcode.version_gte_63?
+    elsif xcode.version_gte_63?
       'iPhone 5s (8.3 Simulator)'
-    elsif ensured_xcode.version_gte_62?
+    elsif xcode.version_gte_62?
       'iPhone 5s (8.2 Simulator)'
-    elsif ensured_xcode.version_gte_61?
+    elsif xcode.version_gte_61?
       'iPhone 5s (8.1 Simulator)'
-    elsif ensured_xcode.version_gte_6?
+    elsif xcode.version_gte_6?
       'iPhone 5s (8.0 Simulator)'
     else
       'iPhone Retina (4-inch) - Simulator - iOS 7.1'
@@ -731,18 +712,7 @@ Please update your sources to pass an instance of RunLoop::Xcode))
       candidate
     end
 
-    def self.default_tracetemplate(instruments_arg=RunLoop::Instruments.new)
-      if instruments_arg.is_a?(RunLoop::XCTools)
-        if RunLoop::Environment.debug?
-          RunLoop.deprecated('1.5.0',
-                             %q(
-RunLoop::XCTools has been replaced with RunLoop::Xcode.
-Please update your sources to pass an instance of RunLoop::Instruments))
-        end
-        instruments = RunLoop::Instruments.new
-      else
-        instruments = instruments_arg
-      end
+    def self.default_tracetemplate(instruments=RunLoop::Instruments.new)
 
       templates = instruments.templates
 

data/lib/run_loop/core_simulator.rb

@@ -1,6 +1,34 @@
 # A class to manage interactions with CoreSimulators.
 class RunLoop::CoreSimulator
 
+  # These options control various aspects of an app's life cycle on the iOS
+  # Simulator.
+  #
+  # You can override these values if they do not work in your environment.
+  #
+  # For cucumber users, the best place to override would be in your
+  # features/support/env.rb.
+  #
+  # For example:
+  #
+  # RunLoop::CoreSimulator::DEFAULT_OPTIONS[:install_app_timeout] = 60
+  DEFAULT_OPTIONS = {
+    # In most cases 30 seconds is a reasonable amount of time to wait for an
+    # install.  When testing larger apps, on slow machines, or in CI, this
+    # value may need to be higher.  120 is the default for CI.
+    :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
+  }
+
+  # @!visibility private
+  # This should not be overridden
+  WAIT_FOR_SIMULATOR_STATE_INTERVAL = 0.1
+
+  # @!visibility private
+  @@simulator_pid = nil
+
   # @!visibility private
   attr_reader :app
 
@@ -16,20 +44,12 @@ class RunLoop::CoreSimulator
   # @!visibility private
   attr_reader :xcrun
 
-  # @!visibility private
-  attr_reader :simulator_pid
-
   # @!visibility private
   METADATA_PLIST = '.com.apple.mobile_container_manager.metadata.plist'
 
   # @!visibility private
   CORE_SIMULATOR_DEVICE_DIR = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
 
-  # @!visibility private
-  WAIT_FOR_DEVICE_STATE_OPTS = {
-        interval: 0.1,
-        timeout: 5
-  }
 
   # @!visibility private
   MANAGED_PROCESSES =
@@ -109,6 +129,122 @@ class RunLoop::CoreSimulator
       send_term_first = process_details[1]
       self.term_or_kill(process_name, send_term_first)
     end
+
+    self.simulator_pid = nil
+  end
+
+  # @!visibility private
+  #
+  # Some operations, like erase, require that the simulator be
+  # 'Shutdown'.
+  #
+  # @param [RunLoop::Device] simulator the sim to wait for
+  # @param [String] target_state the state to wait for
+  def self.wait_for_simulator_state(simulator, target_state)
+    now = Time.now
+    timeout = DEFAULT_OPTIONS[:wait_for_state_timeout]
+    poll_until = now + timeout
+    delay = WAIT_FOR_SIMULATOR_STATE_INTERVAL
+    in_state = false
+    while Time.now < poll_until
+      in_state = simulator.update_simulator_state == target_state
+      break if in_state
+      sleep delay if delay != 0
+    end
+
+    elapsed = Time.now - now
+    RunLoop.log_debug("Waited for #{elapsed} seconds for device to have state: '#{target_state}'.")
+
+    unless in_state
+      raise "Expected '#{target_state} but found '#{simulator.state}' after waiting."
+    end
+    in_state
+  end
+
+  # @!visibility private
+  # Erase a simulator.  This is the same as touching the Simulator
+  # "Reset Content & Settings" menu item.
+  #
+  # @param [RunLoop::Device] simulator The simulator to erase
+  # @param [Hash] options Control the behavior of the method.
+  # @option options [Numeric] :timout (180) How long tow wait for simctl to
+  #   shutdown and erase the simulator.  The timeout is apply separately to
+  #   each command.
+  #
+  # @raise RuntimeError If the simulator cannot be shutdown
+  # @raise RuntimeError If the simulator cannot be erased
+  # @raise ArgumentError If the simulator is a physical device
+  def self.erase(simulator, options={})
+    if simulator.physical_device?
+      raise ArgumentError,
+        "#{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.exec(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.
+
+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.exec(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
+  end
+
+  # @!visibility private
+  def self.simulator_pid
+    @@simulator_pid
+  end
+
+  # @!visibility private
+  def self.simulator_pid=(pid)
+    @@simulator_pid = pid
   end
 
   # @param [RunLoop::Device] device The device.
@@ -130,7 +266,7 @@ class RunLoop::CoreSimulator
       RunLoop::CoreSimulator.quit_simulator
     end
 
-    # stdio.pipe - can cause problems finding the SHA or size data dir
+    # stdio.pipe - can cause problems finding the SHA of a simulator
     rm_instruments_pipe
   end
 
@@ -149,19 +285,14 @@ class RunLoop::CoreSimulator
     @xcrun ||= RunLoop::Xcrun.new
   end
 
-  # @!visibility private
-  def simulator_pid
-    @simulator_pid
-  end
-
   # Launch the simulator indicated by device.
   def launch_simulator
 
-    if sim_pid != nil
+    if running_simulator_pid != nil
       # There is a running simulator.
 
       # Did we launch it?
-      if sim_pid == simulator_pid
+      if running_simulator_pid == RunLoop::CoreSimulator.simulator_pid
         # Nothing to do, we already launched the simulator.
         return
       else
@@ -177,12 +308,9 @@ class RunLoop::CoreSimulator
 
     start_time = Time.now
 
-    pid = spawn('xcrun', *args)
+    pid = Process.spawn('xcrun', *args)
     Process.detach(pid)
 
-    # Keep track of the pid so we can know if we have already launched this sim.
-    @simulator_pid = pid
-
     options = { :timeout => 5, :raise_on_timeout => true }
     RunLoop::ProcessWaiter.new(sim_name, options).wait_for_any
 
@@ -191,6 +319,9 @@ class RunLoop::CoreSimulator
     elapsed = Time.now - start_time
     RunLoop.log_debug("Took #{elapsed} seconds to launch the simulator")
 
+    # Keep track of the pid so we can know if we have already launched this sim.
+    RunLoop::CoreSimulator.simulator_pid = running_simulator_pid
+
     true
   end
 
@@ -201,14 +332,20 @@ class RunLoop::CoreSimulator
   def launch
     install
 
+    # If the app is the same, install will not launch the simulator.
+    # In order to launch the app, the simulator needs to be running.
+    # launch_simulator ensures that the sim is launched and will not
+    # relaunch it.
+    launch_simulator
+
     args = ['simctl', 'launch', device.udid, app.bundle_identifier]
-    hash = xcrun.exec(args, log_cmd: true, timeout: 20)
+    timeout = DEFAULT_OPTIONS[:launch_app_timeout]
+    hash = xcrun.exec(args, log_cmd: true, timeout: timeout)
 
     exit_status = hash[:exit_status]
 
     if exit_status != 0
-      err = hash[:err]
-      RunLoop.log_error(err)
+      RunLoop.log_error(hash[:out])
       raise RuntimeError, "Could not launch #{app.bundle_identifier} on #{device}"
     end
 
@@ -254,7 +391,7 @@ class RunLoop::CoreSimulator
   def reset_app_sandbox
     return true if !app_is_installed?
 
-    wait_for_device_state('Shutdown')
+    RunLoop::CoreSimulator.wait_for_simulator_state(device, "Shutdown")
 
     reset_app_sandbox_internal
   end
@@ -266,7 +403,9 @@ class RunLoop::CoreSimulator
     launch_simulator
 
     args = ['simctl', 'uninstall', device.udid, app.bundle_identifier]
-    xcrun.exec(args, log_cmd: true, timeout: 20)
+
+    timeout = DEFAULT_OPTIONS[:uninstall_app_timeout]
+    xcrun.exec(args, log_cmd: true, timeout: timeout)
 
     device.simulator_wait_for_stable_state
     true
@@ -345,12 +484,46 @@ class RunLoop::CoreSimulator
   #
   # @note Will only search for the current Xcode simulator.
   #
-  # @return [String, nil] The pid as a String or nil if no process is found.
+  # @return [Integer, nil] The pid as a String or nil if no process is found.
   #
   # @todo Convert this to force UTF8
-  def sim_pid
+  def running_simulator_pid
     process_name = "MacOS/#{sim_name}"
-    `xcrun ps x -o pid,command | grep "#{process_name}" | grep -v grep`.strip.split(' ').first
+
+    args = ["xcrun", "ps", "x", "-o", "pid,command"]
+    hash = xcrun.exec(args)
+
+    exit_status = hash[:exit_status]
+    if exit_status != 0
+      raise RuntimeError,
+%Q{Could not find the pid of #{sim_name} with:
+
+#{args.join(" ")}
+
+Command exited with status #{exit_status}
+Message: '#{hash[:out]}'
+}
+    end
+
+    if hash[:out].nil? || hash[:out] == ""
+       raise RuntimeError,
+%Q{Could not find the pid of #{sim_name} with:
+
+#{args.join(" ")}
+
+Command had no output
+}
+    end
+
+    lines = hash[:out].split("\n")
+
+    match = lines.detect do |line|
+      line[/#{process_name}/, 0]
+    end
+
+    return nil if match.nil?
+
+    match.split(" ").first.to_i
   end
 
   # @!visibility private
@@ -358,34 +531,13 @@ class RunLoop::CoreSimulator
     launch_simulator
 
     args = ['simctl', 'install', device.udid, app.path]
-    xcrun.exec(args, log_cmd: true, timeout: 20)
+    timeout = DEFAULT_OPTIONS[:install_app_timeout]
+    xcrun.exec(args, log_cmd: true, timeout: timeout)
 
     device.simulator_wait_for_stable_state
     installed_app_bundle_dir
   end
 
-  # @!visibility private
-  def wait_for_device_state(target_state)
-    now = Time.now
-    timeout = WAIT_FOR_DEVICE_STATE_OPTS[:timeout]
-    poll_until = now + timeout
-    delay = WAIT_FOR_DEVICE_STATE_OPTS[:interval]
-    in_state = false
-    while Time.now < poll_until
-      in_state = device.update_simulator_state == target_state
-      break if in_state
-      sleep delay
-    end
-
-    elapsed = Time.now - now
-    RunLoop.log_debug("Waited for #{elapsed} seconds for device to have state: '#{target_state}'.")
-
-    unless in_state
-      raise "Expected '#{target_state} but found '#{device.state}' after waiting."
-    end
-    in_state
-  end
-
   # Required for support of iOS 7 CoreSimulators.  Can be removed when
   # Xcode support is dropped.
   def sdk_gte_8?