run_loop 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a05a75fc51c334a7120e7d0930c4cb673302138
-  data.tar.gz: 17cd820907c0d174cc81ad7ff02f9a3b172198d9
+  metadata.gz: 37ad2fc838d709c0132334cf1a24b88822664e9b
+  data.tar.gz: 818e85d9a7480820bdc7737cf99ed1d42b3aef1a
 SHA512:
-  metadata.gz: 198b2bd5e060074724dca694de25d4121ca42d7fca592118713798dff2374703c087f74c196b48a7d179babccabbc47e6cf6720452e19cbff85571227012cd90
-  data.tar.gz: 87e39e777923cb401a38a165654180ca5d9e5809e86f3fa3f17c591fc16246b4b3c501855f8f444074e625ec6b5beae23a3e9223c8e557442f6ce66d1411f8ed
+  metadata.gz: 12670d8f9a3490d292280e03adaf8d74343ed5af14568e257d8333a2314cb4602c4f566dd0ea55318daaaf1d26e7f207a3db10c0e8d8486bf701eefbab8ac8aa
+  data.tar.gz: 7fff1abf53e185e59ef0b92c8b851b59c0581300ce5d1f1a851b3e0bfeaad2a26df3dbc476141b1deff84ff4a4974e14102f7f44c869e82ba1c2de695cad05be

data/lib/run_loop/core.rb

@@ -48,23 +48,6 @@ module RunLoop
       RunLoop::Logging.log_debug(logger, "\n" + message)
     end
 
-    # @deprecated since 1.0.0
-    # still used extensively in calabash-ios launcher
-    def self.above_or_eql_version?(target_version, xcode_version)
-      if target_version.is_a?(RunLoop::Version)
-        target = target_version
-      else
-        target = RunLoop::Version.new(target_version)
-      end
-
-      if xcode_version.is_a?(RunLoop::Version)
-        xcode = xcode_version
-      else
-        xcode = RunLoop::Version.new(xcode_version)
-      end
-      target >= xcode
-    end
-
     def self.script_for_key(key)
       if SCRIPTS[key].nil?
         return nil
@@ -122,6 +105,68 @@ module RunLoop
       end
     end
 
+    # Prepares the simulator for running.
+    #
+    # 1. enabling accessibility and software keyboard
+    # 2. installing / uninstalling apps
+    # 3. @todo resetting the app sandbox
+    #
+    # `Bridge#launch_simulator` launches the targeted iOS Simulator.  The
+    # simulator itself has several async tasks that must be completed before
+    # we start interacting with it.  If your simulator ends up in a bad state,
+    # you can increase the post-launch wait time by setting the
+    # `CAL_SIM_POST_LAUNCH_WAIT` environment variable.  The default wait time
+    # is 1.0.  This was arrived at through testing.
+    def self.prepare_simulator(launch_options, sim_control)
+
+      # Respect option passed from Calabash
+      if launch_options[:relaunch_simulator]
+        sim_control.quit_sim
+      end
+
+      if !sim_control.xctools.xcode_version_gte_6?
+        # Xcode 5.1.1
+
+        # Will quit the simulator!
+        sim_control.enable_accessibility_on_sims({:verbose => false})
+      else
+
+        # CoreSimulator
+
+        udid = launch_options[:udid]
+        device = sim_control.simulators.detect do |sim|
+          sim.udid == udid || sim.instruments_identifier == udid
+        end
+
+        if device.nil?
+          raise "Could not find simulator with name or UDID that matches: '#{udid}'"
+        end
+
+        # Will quit the simulator if it is running.
+        # @todo fix accessibility_enabled? so we don't have to quit the sim
+        # SimControl#accessibility_enabled? is always false during Core#prepare_simulator
+        # https://github.com/calabash/run_loop/issues/167
+        sim_control.ensure_accessibility(device)
+
+        # 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
+        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 sim_control.xctools.xcode_version_gte_63?
+          app_bundle_path = launch_options[:bundle_dir_or_bundle_id]
+          bridge = RunLoop::Simctl::Bridge.new(device, app_bundle_path)
+
+          if bridge.app_is_installed? && !sim_control.sim_is_running?
+            bridge.launch_simulator
+          end
+        end
+      end
+    end
+
     def self.run_with_options(options)
       before = Time.now
 
@@ -202,9 +247,8 @@ module RunLoop
       merged_options = options.merge(discovered_options)
 
       if self.simulator_target?(merged_options, sim_control)
-        # @todo only enable accessibility on the targeted simulator
-        sim_control.enable_accessibility_on_sims({:verbose => false})
         self.expect_compatible_simulator_architecture(merged_options, sim_control)
+        self.prepare_simulator(merged_options, sim_control)
       end
 
       self.log_run_loop_options(merged_options, xctools)
@@ -409,11 +453,6 @@ module RunLoop
       return udid, bundle_dir_or_bundle_id
     end
 
-    # @deprecated 1.0.0 replaced with Xctools#version
-    def self.xcode_version(xctools=RunLoop::XCTools.new)
-      xctools.xcode_version.to_s
-    end
-
     def self.create_uia_pipe(repl_path)
       begin
         Timeout::timeout(5, RunLoop::TimeoutError) do
@@ -480,6 +519,11 @@ module RunLoop
       cmd.gsub(backquote,backquote*4)
     end
 
+    def self.log_instruments_error(msg)
+      $stderr.puts "\033[31m\n\n*** #{msg} ***\n\n\033[0m"
+      $stderr.flush
+    end
+
     def self.read_response(run_loop, expected_index, empty_file_timeout=10, search_for_property='index')
       debug_read = RunLoop::Environment.debug_read?
 
@@ -499,14 +543,31 @@ module RunLoop
 
         if /AXError: Could not auto-register for pid status change/.match(output)
           if /kAXErrorServerNotFound/.match(output)
-            $stderr.puts "\n\n****** Accessibility is not enabled on device/simulator, please enable it *** \n\n"
-            $stderr.flush
+            self.log_instruments_error('Accessibility is not enabled on device/simulator, please enable it.')
           end
           raise RunLoop::TimeoutError.new('AXError: Could not auto-register for pid status change')
         end
+
         if /Automation Instrument ran into an exception/.match(output)
           raise RunLoop::TimeoutError.new('Exception while running script')
         end
+
+        if /FBSOpenApplicationErrorDomain error/.match(output)
+          msg = "Instruments failed to launch app: 'FBSOpenApplicationErrorDomain error 8"
+          if RunLoop::Environment.debug?
+            self.log_instruments_error(msg)
+          end
+          raise RunLoop::TimeoutError.new(msg)
+        end
+
+        if /Error: Script threw an uncaught JavaScript error: unknown JavaScript exception/.match(output)
+          msg = "Instruments failed to launch: because of an unknown JavaScript exception"
+          if RunLoop::Environment.debug?
+            self.log_instruments_error(msg)
+          end
+          raise RunLoop::TimeoutError.new(msg)
+        end
+
         index_if_found = output.index(START_DELIMITER)
         if debug_read
           puts output.gsub('*', '')
@@ -556,11 +617,6 @@ module RunLoop
       result
     end
 
-    # @deprecated 1.0.5
-    def self.pids_for_run_loop(run_loop, &block)
-      RunLoop::Instruments.new.instruments_pids(&block)
-    end
-
     def self.automation_template(xctools, candidate = RunLoop::Environment.trace_template)
       unless candidate && File.exist?(candidate)
         candidate = default_tracetemplate xctools
@@ -608,6 +664,32 @@ module RunLoop
     def self.instruments_pids
       RunLoop::Instruments.new.instruments_pids
     end
-  end
 
+    # @deprecated 1.0.0 replaced with Xctools#version
+    def self.xcode_version(xctools=RunLoop::XCTools.new)
+      xctools.xcode_version.to_s
+    end
+
+    # @deprecated since 1.0.0
+    # still used extensively in calabash-ios launcher
+    def self.above_or_eql_version?(target_version, xcode_version)
+      if target_version.is_a?(RunLoop::Version)
+        target = target_version
+      else
+        target = RunLoop::Version.new(target_version)
+      end
+
+      if xcode_version.is_a?(RunLoop::Version)
+        xcode = xcode_version
+      else
+        xcode = RunLoop::Version.new(xcode_version)
+      end
+      target >= xcode
+    end
+
+    # @deprecated 1.0.5
+    def self.pids_for_run_loop(run_loop, &block)
+      RunLoop::Instruments.new.instruments_pids(&block)
+    end
+  end
 end

data/lib/run_loop/device.rb

@@ -5,6 +5,9 @@ module RunLoop
     attr_reader :version
     attr_reader :udid
     attr_reader :state
+    attr_reader :simulator_root_dir
+    attr_reader :simulator_accessibility_plist_path
+    attr_reader :simulator_preferences_plist_path
 
     # Create a new device.
     #
@@ -86,5 +89,30 @@ module RunLoop
         raise 'Finding the instruction set of a device requires a third-party tool like ideviceinfo'
       end
     end
+
+    def simulator_root_dir
+      @simulator_root_dir ||= lambda {
+        return nil if physical_device?
+        File.join(CORE_SIMULATOR_DEVICE_DIR, udid)
+      }.call
+    end
+
+    def simulator_accessibility_plist_path
+      @simulator_accessibility_plist_path ||= lambda {
+        return nil if physical_device?
+        File.join(simulator_root_dir, 'data/Library/Preferences/com.apple.Accessibility.plist')
+      }.call
+    end
+
+    def simulator_preferences_plist_path
+      @simulator_preferences_plist_path ||= lambda {
+        return nil if physical_device?
+        File.join(simulator_root_dir, 'data/Library/Preferences/com.apple.Preferences.plist')
+      }.call
+    end
+
+    private
+
+    CORE_SIMULATOR_DEVICE_DIR = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
   end
 end

data/lib/run_loop/environment.rb

@@ -73,5 +73,33 @@ module RunLoop
         value
       end
     end
+
+    # Returns the value of CAL_SIM_POST_LAUNCH_WAIT
+    #
+    # Controls how long to wait _after_ the simulator is opened.
+    #
+    # The default wait time is 1.0.  This was arrived at through testing.
+    #
+    # In CoreSimulator environments, the iOS Simulator starts many async
+    # processes that must be allowed to finish before we start operating on the
+    # simulator.  Until we find the right combination of processes to wait for,
+    # this variable will give us the opportunity to control how long we wait.
+    #
+    # Essential for managed envs like Travis + Jenkins and on slower machines.
+    def self.sim_post_launch_wait
+      value = ENV['CAL_SIM_POST_LAUNCH_WAIT']
+      float = nil
+      begin
+        float = value.to_f
+      rescue NoMethodError => _
+
+      end
+
+      if float.nil? || float == 0.0
+        nil
+      else
+        float
+      end
+    end
   end
 end

data/lib/run_loop/process_waiter.rb

@@ -13,7 +13,7 @@ module RunLoop
     # Collect a list of Integer pids.
     # @return [Array<Integer>] An array of integer pids for the `process_name`
     def pids
-      process_info = `ps x -o pid,comm | grep -v grep | grep #{process_name}`
+      process_info = `ps x -o pid,comm | grep -v grep | grep '#{process_name}'`
       process_array = process_info.split("\n")
       process_array.map { |process| process.split(' ').first.strip.to_i }
     end

data/lib/run_loop/sim_control.rb

@@ -82,7 +82,7 @@ module RunLoop
     # @todo Consider migrating apple script call to xctools.
     def launch_sim(opts={})
       unless sim_is_running?
-        default_opts = {:post_launch_wait => 2.0,
+        default_opts = {:post_launch_wait => RunLoop::Environment.sim_post_launch_wait || 2.0,
                         :hide_after => false}
         merged_opts = default_opts.merge(opts)
         `xcrun open -a "#{sim_app_path}"`
@@ -107,7 +107,7 @@ module RunLoop
     #  tired of your editor losing focus. :)
     def relaunch_sim(opts={})
       default_opts = {:post_quit_wait => 1.0,
-                      :post_launch_wait => 2.0,
+                      :post_launch_wait => RunLoop::Environment.sim_post_launch_wait || 2.0,
                       :hide_after => false}
       merged_opts = default_opts.merge(opts)
       quit_sim(merged_opts)
@@ -199,7 +199,7 @@ module RunLoop
     #  **NOTE:** This option is ignored in Xcode < 6.
     def reset_sim_content_and_settings(opts={})
       default_opts = {:post_quit_wait => 1.0,
-                      :post_launch_wait => 3.0,
+                      :post_launch_wait => RunLoop::Environment.sim_post_launch_wait || 3.0,
                       :hide_after => false,
                       :sim_udid => nil}
       merged_opts = default_opts.merge(opts)
@@ -333,8 +333,149 @@ module RunLoop
       end
     end
 
-    private
+    def accessibility_enabled?(device)
+      plist = device.simulator_accessibility_plist_path
+      return false unless File.exist?(plist)
+
+      if device.version >= RunLoop::Version.new('8.0')
+        plist_hash = SDK_80_ACCESSIBILITY_PROPERTIES_HASH
+      else
+        plist_hash = SDK_LT_80_ACCESSIBILITY_PROPERTIES_HASH
+      end
+
+      plist_hash.each do |_, details|
+        key = details[:key]
+        value = details[:value]
+
+        unless pbuddy.plist_read(key, plist) == "#{value}"
+          return false
+        end
+      end
+      true
+    end
+
+    def ensure_accessibility(device)
+      if accessibility_enabled?(device)
+        true
+      else
+        enable_accessibility(device)
+      end
+    end
+
+    def enable_accessibility(device)
+      debug_logging = RunLoop::Environment.debug?
+
+      quit_sim
+
+      plist_path = device.simulator_accessibility_plist_path
+
+      if device.version >= RunLoop::Version.new('8.0')
+        plist_hash = SDK_80_ACCESSIBILITY_PROPERTIES_HASH
+      else
+        plist_hash = SDK_LT_80_ACCESSIBILITY_PROPERTIES_HASH
+      end
+
+      unless File.exist? plist_path
+        preferences_dir = File.join(device.simulator_root_dir, 'data/Library/Preferences')
+        FileUtils.mkdir_p(preferences_dir)
+        plist = CFPropertyList::List.new
+        data = {}
+        plist.value = CFPropertyList.guess(data)
+        plist.save(plist_path, CFPropertyList::List::FORMAT_BINARY)
+      end
+
+      msgs = []
+
+      successes = plist_hash.map do |hash_key, settings|
+        success = pbuddy.plist_set(settings[:key], settings[:type], settings[:value], plist_path)
+        unless success
+          if debug_logging
+            if settings[:type] == 'bool'
+              value = settings[:value] ? 'YES' : 'NO'
+            else
+              value = settings[:value]
+            end
+            msgs << "could not set #{hash_key} => '#{settings[:key]}' to #{value}"
+          end
+        end
+        success
+      end
+
+      if successes.all?
+        true
+      else
+        return false, msgs
+      end
+    end
 
+    def software_keyboard_enabled?(device)
+      unless xcode_version_gte_51?
+        raise RuntimeError, 'Keyboard enabling is only available on Xcode >= 6'
+      end
+
+      plist = device.simulator_preferences_plist_path
+      return false unless File.exist?(plist)
+
+      CORE_SIMULATOR_KEYBOARD_PROPERTIES_HASH.each do |_, details|
+        key = details[:key]
+        value = details[:value]
+
+        unless pbuddy.plist_read(key, plist) == "#{value}"
+          return false
+        end
+      end
+      true
+    end
+
+    def ensure_software_keyboard(device)
+      if software_keyboard_enabled?(device)
+        true
+      else
+        enable_software_keyboard(device)
+      end
+    end
+
+    def enable_software_keyboard(device)
+      debug_logging = RunLoop::Environment.debug?
+
+      quit_sim
+
+      plist_path = device.simulator_preferences_plist_path
+
+      unless File.exist? plist_path
+        preferences_dir = File.join(device.simulator_root_dir, 'data/Library/Preferences')
+        FileUtils.mkdir_p(preferences_dir)
+        plist = CFPropertyList::List.new
+        data = {}
+        plist.value = CFPropertyList.guess(data)
+        plist.save(plist_path, CFPropertyList::List::FORMAT_BINARY)
+      end
+
+      msgs = []
+
+      successes = CORE_SIMULATOR_KEYBOARD_PROPERTIES_HASH.map do |hash_key, settings|
+        success = pbuddy.plist_set(settings[:key], settings[:type], settings[:value], plist_path)
+        unless success
+          if debug_logging
+            if settings[:type] == 'bool'
+              value = settings[:value] ? 'YES' : 'NO'
+            else
+              value = settings[:value]
+            end
+            msgs << "could not set #{hash_key} => '#{settings[:key]}' to #{value}"
+          end
+        end
+        success
+      end
+
+      if successes.all?
+        true
+      else
+        return false, msgs
+      end
+    end
+
+    private
 
     # @!visibility private
     # The list of possible SDKs for 5.0 <= Xcode < 6.0
@@ -449,6 +590,15 @@ module RunLoop
     # and parsing the output of `simctl list sessions`.
     XCODE_6_SIM_UDID_REGEX = /[A-F0-9]{8}-([A-F0-9]{4}-){3}[A-F0-9]{12}/.freeze
 
+    CORE_SIMULATOR_KEYBOARD_PROPERTIES_HASH =
+          {
+                :automatic_minimization => {
+                      :key => 'AutomaticMinimizationEnabled',
+                      :value => 0,
+                      :type => 'integer'
+                }
+          }
+
     # @!visibility private
     # Returns the current Simulator pid.
     #

data/lib/run_loop/simctl/bridge.rb

@@ -1,73 +1,96 @@
 module RunLoop::Simctl
 
+  class SimctlError < StandardError
+
+  end
+
   # @!visibility private
   # This is not a public API.  You have been warned.
   #
-  # Proof of concept for using simctl to install and launch an app on a device.
-  #
-  # Do not use this in production code.
-  #
-  # TODO Rename this class.
   # TODO Some code is duplicated from sim_control.rb
-  # TODO Uninstall
   # TODO Reinstall if checksum does not match.
   # TODO Analyze terminate_core_simulator_processes
   class Bridge
 
     attr_reader :device
-    attr_reader :app_bundle_path
     attr_reader :app
+    attr_reader :sim_control
 
     def initialize(device, app_bundle_path)
-      @device = device
+
       @sim_control = RunLoop::SimControl.new
-      @simulator_app_path ||= lambda {
+      @path_to_ios_sim_app_bundle = lambda {
         dev_dir = @sim_control.xctools.xcode_developer_dir
         "#{dev_dir}/Applications/iOS Simulator.app"
       }.call
 
-      @app_bundle_path = app_bundle_path
       @app = RunLoop::App.new(app_bundle_path)
-      RunLoop::SimControl.terminate_all_sims
-      shutdown
-      terminate_core_simulator_processes
-    end
-
-    def udid
-      @udid ||= device.udid
-    end
 
-    def fullname
-      @fullname ||= device.instruments_identifier
-    end
+      unless @app.valid?
+        raise "Could not recreate a valid app from '#{app_bundle_path}'"
+      end
 
-    def bundle_identifier
-      app.bundle_identifier
-    end
+      @device = device
 
-    def executable_name
-      app.executable_name
+      # It may seem weird to do this in the initialize, but you cannot make
+      # simctl calls successfully unless the simulator is:
+      # 1. closed
+      # 2. the device you are trying to operate on is Shutdown
+      # 3. the CoreSimulator processes are terminated
+      RunLoop::SimControl.terminate_all_sims
+      shutdown
+      terminate_core_simulator_processes
     end
 
     def simulator_app_dir
       @simulator_app_dir ||= lambda {
         device_dir = File.expand_path('~/Library/Developer/CoreSimulator/Devices')
         if device.version < RunLoop::Version.new('8.0')
-          File.join(device_dir, udid, 'data', 'Applications')
+          File.join(device_dir, device.udid, 'data', 'Applications')
         else
-          File.join(device_dir, udid, 'data', 'Containers', 'Bundle', 'Application')
+          File.join(device_dir, device.udid, 'data', 'Containers', 'Bundle', 'Application')
         end
       }.call
     end
 
-    def update_device_state
-      current = @sim_control.simulators.detect do |sim|
-        sim.udid == udid
+    def update_device_state(options={})
+      merged_options = UPDATE_DEVICE_STATE_OPTS.merge(options)
+      debug_logging = RunLoop::Environment.debug?
+
+      interval = merged_options[:interval]
+      tries = merged_options[:tries]
+
+      on_retry = Proc.new do |_, try, elapsed_time, next_interval|
+        if debug_logging
+          # Retriable 2.0
+          if elapsed_time && next_interval
+            puts "Updating device state attempt #{try} failed in '#{elapsed_time}'; will retry in '#{next_interval}'"
+          else
+            puts "Updating device state attempt #{try} failed; will retry in #{interval}"
+          end
+        end
       end
-      unless current
-        raise "simctl could not find device with '#{udid}'"
+
+      retry_opts = RunLoop::RetryOpts.tries_and_interval(tries, interval,
+                                                         {:on_retry => on_retry,
+                                                          :on => [SimctlError]
+                                                         })
+      matching_device = nil
+
+      Retriable.retriable(retry_opts) do
+        matching_device = fetch_matching_device
+
+        unless matching_device
+          raise "simctl could not find device with '#{device.udid}'"
+        end
+
+        if matching_device.state == nil || matching_device.state == ''
+          raise SimctlError, "Could not find the state of the device with #{device.udid}"
+        end
       end
-      @device = current
+
+      # Device#state is immutable
+      @device = matching_device
       @device.state
     end
 
@@ -86,7 +109,6 @@ module RunLoop::Simctl
       end
     end
 
-
     def wait_for_device_state(target_state)
       return true if update_device_state == target_state
 
@@ -112,7 +134,7 @@ module RunLoop::Simctl
       sim_app_dir = simulator_app_dir
       return false if !File.exist?(sim_app_dir)
       app_path = Dir.glob("#{sim_app_dir}/**/*.app").detect do |path|
-        RunLoop::App.new(path).bundle_identifier == bundle_identifier
+        RunLoop::App.new(path).bundle_identifier == app.bundle_identifier
       end
 
       !app_path.nil?
@@ -132,10 +154,33 @@ module RunLoop::Simctl
         sleep delay
       end
 
-      puts "Waited for #{timeout} seconds for '#{bundle_identifier}' to install."
+      puts "Waited for #{timeout} seconds for '#{app.bundle_identifier}' to install."
 
       unless is_installed
-        raise "Expected app to be installed on #{fullname}"
+        raise "Expected app to be installed on #{device.instruments_identifier}"
+      end
+
+      true
+    end
+
+    def wait_for_app_uninstall
+      return true unless app_is_installed?
+
+      now = Time.now
+      timeout = WAIT_FOR_APP_INSTALL_OPTS[:timeout]
+      poll_until = now + timeout
+      delay = WAIT_FOR_APP_INSTALL_OPTS[:interval]
+      not_installed = false
+      while Time.now < poll_until
+        not_installed = !app_is_installed?
+        break if not_installed
+        sleep delay
+      end
+
+      puts "Waited for #{timeout} seconds for '#{app.bundle_identifier}' to uninstall."
+
+      unless not_installed
+        raise "Expected app to be installed on #{device.instruments_identifier}"
       end
 
       true
@@ -145,15 +190,15 @@ module RunLoop::Simctl
       return true if update_device_state == 'Shutdown'
 
       if device.state != 'Booted'
-        raise "Cannot handle state '#{device.state}' for #{fullname}"
+        raise "Cannot handle state '#{device.state}' for #{device.instruments_identifier}"
       end
 
-      args = "simctl shutdown #{udid}".split(' ')
+      args = "simctl shutdown #{device.udid}".split(' ')
       Open3.popen3('xcrun', *args) do |_, _, stderr, status|
         err = stderr.read.strip
         exit_status = status.value.exitstatus
         if exit_status != 0
-          raise "Could not shutdown #{fullname}: #{exit_status} => '#{err}'"
+          raise "Could not shutdown #{device.instruments_identifier}: #{exit_status} => '#{err}'"
         end
       end
       wait_for_device_state('Shutdown')
@@ -163,15 +208,15 @@ module RunLoop::Simctl
       return true if update_device_state == 'Booted'
 
       if device.state != 'Shutdown'
-        raise "Cannot handle state '#{device.state}' for #{fullname}"
+        raise "Cannot handle state '#{device.state}' for #{device.instruments_identifier}"
       end
 
-      args = "simctl boot #{udid}".split(' ')
+      args = "simctl boot #{device.udid}".split(' ')
       Open3.popen3('xcrun', *args) do |_, _, stderr, status|
         err = stderr.read.strip
         exit_status = status.value.exitstatus
         if exit_status != 0
-          raise "Could not boot #{fullname}: #{exit_status} => '#{err}'"
+          raise "Could not boot #{device.instruments_identifier}: #{exit_status} => '#{err}'"
         end
       end
       wait_for_device_state('Booted')
@@ -182,12 +227,12 @@ module RunLoop::Simctl
 
       boot
 
-      args = "simctl install #{udid} #{app.path}".split(' ')
+      args = "simctl install #{device.udid} #{app.path}".split(' ')
       Open3.popen3('xcrun', *args) do |_, _, stderr, process_status|
         err = stderr.read.strip
         exit_status = process_status.value.exitstatus
         if exit_status != 0
-          raise "Could not install '#{bundle_identifier}': #{exit_status} => '#{err}'."
+          raise "Could not install '#{app.bundle_identifier}': #{exit_status} => '#{err}'."
         end
       end
 
@@ -195,9 +240,33 @@ module RunLoop::Simctl
       shutdown
     end
 
+    def uninstall
+      return true unless app_is_installed?
+
+      boot
+
+      args = "simctl uninstall #{device.udid} #{app.bundle_identifier}".split(' ')
+      Open3.popen3('xcrun', *args) do |_, _, stderr, process_status|
+        err = stderr.read.strip
+        exit_status = process_status.value.exitstatus
+        if exit_status != 0
+          raise "Could not uninstall '#{app.bundle_identifier}': #{exit_status} => '#{err}'."
+        end
+      end
+
+      wait_for_app_uninstall
+      shutdown
+    end
+
     def launch_simulator
-      `xcrun open -a "#{@simulator_app_path}" --args -CurrentDeviceUDID #{udid}`
-      sleep(5)
+      args = ['open', '-a', @path_to_ios_sim_app_bundle, '--args', '-CurrentDeviceUDID', device.udid]
+      pid = spawn('xcrun', *args)
+      Process.detach(pid)
+      RunLoop::ProcessWaiter.new('CoreSimulatorBridge', WAIT_FOR_APP_LAUNCH_OPTS).wait_for_any
+      RunLoop::ProcessWaiter.new('iOS Simulator', WAIT_FOR_APP_LAUNCH_OPTS).wait_for_any
+      RunLoop::ProcessWaiter.new('SimulatorBridge', WAIT_FOR_APP_LAUNCH_OPTS).wait_for_any
+      wait_for_device_state 'Booted'
+      sleep(SIM_POST_LAUNCH_WAIT)
     end
 
     def launch
@@ -205,16 +274,16 @@ module RunLoop::Simctl
       install
       launch_simulator
 
-      args = "simctl launch #{udid} #{bundle_identifier}".split(' ')
+      args = "simctl launch #{device.udid} #{app.bundle_identifier}".split(' ')
       Open3.popen3('xcrun', *args) do |_, _, stderr, process_status|
         err = stderr.read.strip
         exit_status = process_status.value.exitstatus
         unless exit_status == 0
-          raise "Could not simctl launch '#{bundle_identifier}' on '#{fullname}': #{exit_status} => '#{err}'"
+          raise "Could not simctl launch '#{app.bundle_identifier}' on '#{device.instruments_identifier}': #{exit_status} => '#{err}'"
         end
       end
 
-      RunLoop::ProcessWaiter.new(executable_name, WAIT_FOR_APP_LAUNCH_OPTS).wait_for_any
+      RunLoop::ProcessWaiter.new(app.executable_name, WAIT_FOR_APP_LAUNCH_OPTS).wait_for_any
       true
     end
 
@@ -238,5 +307,19 @@ module RunLoop::Simctl
                 raise_on_timeout: true
           }
 
+    UPDATE_DEVICE_STATE_OPTS =
+          {
+                :tries => 100,
+                :interval => 0.1
+          }
+
+    SIM_POST_LAUNCH_WAIT = RunLoop::Environment.sim_post_launch_wait || 1.0
+
+    # @!visibility private
+    def fetch_matching_device
+      sim_control.simulators.detect do |sim|
+        sim.udid == device.udid
+      end
+    end
   end
 end

data/lib/run_loop/version.rb

@@ -1,5 +1,5 @@
 module RunLoop
-  VERSION = '1.3.0'
+  VERSION = '1.3.1'
 
   # A model of a software release version that can be used to compare two versions.
   #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_loop
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Karl Krukow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-09 00:00:00.000000000 Z
+date: 2015-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json