run_loop 2.1.0.pre1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ea9c17ad6325b7381a689e16ea30c98b34e2765
-  data.tar.gz: a1f044d25c196213e310f2f70f096f35bb558c65
+  metadata.gz: ee9ecaf4f1c6ec33be1a4e7640991c46e14f1938
+  data.tar.gz: 7348a649fd00ef921ccf16d049ca1f7c9c9b5421
 SHA512:
-  metadata.gz: 49f63b7057fb4448850252365b840843b05a4ac39f81db367dd32a52d0b23dc0cdcb67c8de22e4838f02bfb81ef7f2bf3c189da4d4953a008f1812b6bd108326
-  data.tar.gz: 30aed60ffb8069e15260ea81f02fa8a2261a59e473fcd4beaeacfcec940030671c6eb730423d088f73864cfc66daf18972df60a0cfc671013ed61e7f3b8f293f
+  metadata.gz: f2de3db8241ef24056e0d140d569c30082d0436acd251134b0b2908ef063a9dc97e9be2be8431701340c21e80bc3cd2978a41893ffb3b787231aaff191b8637f
+  data.tar.gz: 46c3ca51600d39434fee5a25d47b41c1122846f5e7eb3852e079174c1393acfa18df5e0cb9605899d6341b7cad1e3846212ad8348de1be1aad13af2622555010

data/lib/run_loop.rb

@@ -31,7 +31,7 @@ require 'run_loop/cache/cache'
 require 'run_loop/host_cache'
 require 'run_loop/patches/awesome_print'
 require 'run_loop/core_simulator'
-require 'run_loop/simctl/plists'
+require "run_loop/simctl"
 require 'run_loop/template'
 require "run_loop/locale"
 require "run_loop/language"
@@ -66,64 +66,69 @@ module RunLoop
 
   def self.run(options={})
 
-    if RunLoop::Instruments.new.instruments_app_running?
-      raise %q(The Instruments.app is open.
+    if options[:xcuitest]
+      RunLoop::XCUITest.run(options)
+    else
+
+      if RunLoop::Instruments.new.instruments_app_running?
+        raise %q(The Instruments.app is open.
 
 If the Instruments.app is open, the instruments command line tool cannot take
 control of your application.
 
 Please quit the Instruments.app and try again.)
 
-    end
+      end
 
-    uia_strategy = options[:uia_strategy]
-    if options[:script]
-      script = validate_script(options[:script])
-    else
-      if uia_strategy
-        script = default_script_for_uia_strategy(uia_strategy)
+      uia_strategy = options[:uia_strategy]
+      if options[:script]
+        script = validate_script(options[:script])
       else
-        if options[:calabash_lite]
-          uia_strategy = :host
-          script = Core.script_for_key(:run_loop_host)
-        else
-          uia_strategy = :preferences
+        if uia_strategy
           script = default_script_for_uia_strategy(uia_strategy)
+        else
+          if options[:calabash_lite]
+            uia_strategy = :host
+            script = Core.script_for_key(:run_loop_host)
+          else
+            uia_strategy = :preferences
+            script = default_script_for_uia_strategy(uia_strategy)
+          end
         end
       end
-    end
-    # At this point, 'script' has been chosen, but uia_strategy might not
-    unless uia_strategy
-      desired_script = options[:script]
-      if desired_script.is_a?(String) #custom path to script
-        uia_strategy = :host
-      elsif desired_script == :run_loop_host
-        uia_strategy = :host
-      elsif desired_script == :run_loop_fast_uia
-        uia_strategy = :preferences
-      elsif desired_script == :run_loop_shared_element
-        uia_strategy = :shared_element
-      else
-        raise "Inconsistent state: desired script #{desired_script} has not uia_strategy"
+      # At this point, 'script' has been chosen, but uia_strategy might not
+      unless uia_strategy
+        desired_script = options[:script]
+        if desired_script.is_a?(String) #custom path to script
+          uia_strategy = :host
+        elsif desired_script == :run_loop_host
+          uia_strategy = :host
+        elsif desired_script == :run_loop_fast_uia
+          uia_strategy = :preferences
+        elsif desired_script == :run_loop_shared_element
+          uia_strategy = :shared_element
+        else
+          raise "Inconsistent state: desired script #{desired_script} has not uia_strategy"
+        end
       end
-    end
 
-    # At this point script and uia_strategy selected
-    cloned_options = options.clone
-    cloned_options[:script] = script
-    cloned_options[:uia_strategy] = uia_strategy
+      # At this point script and uia_strategy selected
+      cloned_options = options.clone
+      cloned_options[:script] = script
+      cloned_options[:uia_strategy] = uia_strategy
 
-    # Xcode and SimControl will not be properly cloned and we don't want
-    # them to be; we want to use the exact objects that were passed.
-    if options[:xcode]
-      cloned_options[:xcode] = options[:xcode]
-    end
+      # Xcode and SimControl will not be properly cloned and we don't want
+      # them to be; we want to use the exact objects that were passed.
+      if options[:xcode]
+        cloned_options[:xcode] = options[:xcode]
+      end
 
-    if options[:sim_control]
-      cloned_options[:sim_control] = options[:sim_control]
-    end
+      if options[:sim_control]
+        cloned_options[:sim_control] = options[:sim_control]
+      end
 
-    Core.run_with_options(cloned_options)
+      Core.run_with_options(cloned_options)
+    end
   end
 
   def self.send_command(run_loop, cmd, options={timeout: 60}, num_retries=0, last_error=nil)
@@ -235,5 +240,4 @@ Please quit the Instruments.app and try again.)
   def self.log_info(*args)
     RunLoop::Logging.log_info(*args)
   end
-
 end

data/lib/run_loop/app.rb

@@ -33,7 +33,20 @@ Bundle must:
 
     # @!visibility private
     def to_s
-      "#<APP: #{path}>"
+      cf_bundle_version = bundle_version
+      cf_bundle_short_version = short_bundle_version
+
+      if cf_bundle_version && cf_bundle_short_version
+        version = "#{cf_bundle_version.to_s} / #{cf_bundle_short_version}"
+      elsif cf_bundle_version
+        version = cf_bundle_version.to_s
+      elsif cf_bundle_short_version
+        version = cf_bundle_short_version
+      else
+        version = ""
+      end
+
+      "#<APP #{bundle_identifier} #{version} #{path}>"
     end
 
     # @!visibility private
@@ -130,6 +143,75 @@ Bundle must:
       RunLoop::Codesign.distribution?(path)
     end
 
+    # Returns the CFBundleShortVersionString of the app as Version instance.
+    #
+    # Apple docs:
+    #
+    # CFBundleShortVersionString specifies the release version number of the
+    # bundle, which identifies a released iteration of the app. The release
+    # version number is a string comprised of three period-separated integers.
+    #
+    # The first integer represents major revisions to the app, such as revisions
+    # that implement new features or major changes. The second integer denotes
+    # revisions that implement less prominent features. The third integer
+    # represents maintenance releases.
+    #
+    # The value for this key differs from the value for CFBundleVersion, which
+    # identifies an iteration (released or unreleased) of the app. This key can
+    # be localized by including it in your InfoPlist.strings files.
+    #
+    # @return [RunLoop::Version, nil] Returns a Version instance if the
+    #  CFBundleShortVersion string is well formed and nil if not.
+    def marketing_version
+      string = plist_buddy.plist_read("CFBundleShortVersionString", info_plist_path)
+      begin
+        version = RunLoop::Version.new(string)
+      rescue
+        if string && string != ""
+          RunLoop.log_debug("CFBundleShortVersionString: '#{string}' is not a well formed version string")
+        else
+          RunLoop.log_debug("CFBundleShortVersionString is not defined in Info.plist")
+        end
+        version = nil
+      end
+      version
+    end
+
+    # See #marketing_version
+    alias_method :short_bundle_version, :marketing_version
+
+    # Returns the CFBundleVersionString of the app as Version instance.
+    #
+    # Apple docs:
+    #
+    # CFBundleVersion specifies the build version number of the bundle, which
+    # identifies an iteration (released or unreleased) of the bundle. The build
+    # version number should be a string comprised of three non-negative,
+    # period-separated integers with the first integer being greater than zero.
+    # The string should only contain numeric (0-9) and period (.) characters.
+    # Leading zeros are truncated from each integer and will be ignored (that
+    # is, 1.02.3 is equivalent to 1.2.3).
+    #
+    # @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)
+      begin
+        version = RunLoop::Version.new(string)
+      rescue
+        if string && string != ""
+          RunLoop.log_debug("CFBundleVersionString: '#{string}' is not a well formed version string")
+        else
+          RunLoop.log_debug("CFBundleVersionString is not defined in Info.plist")
+        end
+        version = nil
+      end
+      version
+    end
+
+    # See #build_version
+    alias_method :bundle_version, :build_version
+
     # @!visibility private
     # Collects the paths to executables in the bundle.
     def executables

data/lib/run_loop/cli/simctl.rb

@@ -56,20 +56,25 @@ module RunLoop
         debug = options[:debug]
         device = options[:device]
 
+        manage_processes
+
         if device
           RunLoop::Environment.with_debugging(debug) do
+            RunLoop::CoreSimulator.erase(device)
             launch_simulator(device, xcode)
           end
         else
-          launch_each_simulator
+          RunLoop::Environment.with_debugging(debug) do
+            erase_and_launch_each_simulator
+          end
         end
 
-        manage_processes
       end
 
       no_commands do
-        def launch_each_simulator
+        def erase_and_launch_each_simulator
           sim_control.simulators.each do |simulator|
+            RunLoop::CoreSimulator.erase(simulator)
             launch_simulator(simulator, xcode)
           end
         end

data/lib/run_loop/core.rb

@@ -676,6 +676,8 @@ Logfile: #{log_file}
     #
     # 1. enabling accessibility and software keyboard
     # 2. installing / uninstalling apps
+    #
+    # TODO: move to CoreSimulator?
     def self.prepare_simulator(app, device, xcode, simctl, reset_options)
 
       # Validate the architecture.

data/lib/run_loop/core_simulator.rb

@@ -57,7 +57,7 @@ class RunLoop::CoreSimulator
               # This process is a daemon, and requires 'KILL' to terminate.
               # Killing the process is fast, but it takes a long time to
               # restart.
-              # ['com.apple.CoreSimulator.CoreSimulatorService', false],
+              ['com.apple.CoreSimulator.CoreSimulatorService', false],
 
               # Probably do not need to quit this, but it is tempting to do so.
               #['com.apple.CoreSimulator.SimVerificationService', false],
@@ -94,6 +94,12 @@ class RunLoop::CoreSimulator
               # launchd_sim process.
               ['launchd_sim', false],
 
+              # Required for XCUITest termination; the simulator hangs otherwise.
+              ["xpcproxy", false],
+
+              # Causes crash reports on Xcode < 7.0
+              ["apsd", true],
+
               # assetsd instances clobber each other and are not properly
               # killed when quiting the simulator.
               ['assetsd', false],
@@ -167,7 +173,7 @@ class RunLoop::CoreSimulator
   #
   # @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
+  # @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.
   #
@@ -393,25 +399,46 @@ $ bundle exec run-loop simctl manage-processes
     # relaunch it.
     launch_simulator
 
-    args = ['simctl', 'launch', device.udid, app.bundle_identifier]
-    timeout = DEFAULT_OPTIONS[:launch_app_timeout]
-    hash = xcrun.exec(args, log_cmd: true, timeout: timeout)
+    tries = RunLoop::Environment.ci? ? 5 : 3
+    last_error = nil
 
-    exit_status = hash[:exit_status]
+    RunLoop.log_debug("Trying #{tries} times to launch #{app.bundle_identifier} on #{device}")
 
-    if exit_status != 0
-      RunLoop.log_error(hash[:out])
-      raise RuntimeError, "Could not launch #{app.bundle_identifier} on #{device}"
+    tries.times do
+      hash = launch_app_with_simctl
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        RunLoop.log_debug("Failed to launch app.")
+        out.split($-0).each do |line|
+          RunLoop.log_debug("    #{line}")
+        end
+        # Simulator is probably in a bad state, but this will be super disruptive.
+        # Let's try a softer approach first - sleep.
+        # self.terminate_core_simulator_processes
+        sleep(0.5)
+        last_error = out
+      else
+        last_error = nil
+        break
+      end
+    end
+
+    if last_error
+      raise RuntimeError, %Q[Could not launch #{app.bundle_identifier} on #{device}
+
+#{last_error}
+
+]
     end
 
     options = {
-          :timeout => 10,
-          :raise_on_timeout => true
+      :timeout => 10,
+      :raise_on_timeout => true
     }
 
     RunLoop::ProcessWaiter.new(app.executable_name, options).wait_for_any
-
     device.simulator_wait_for_stable_state
+
     true
   end
 
@@ -588,6 +615,13 @@ Command had no output
     installed_app_bundle_dir
   end
 
+  # @!visibility private
+  def launch_app_with_simctl
+    args = ['simctl', 'launch', device.udid, app.bundle_identifier]
+    timeout = DEFAULT_OPTIONS[:launch_app_timeout]
+    xcrun.exec(args, log_cmd: true, timeout: timeout)
+  end
+
   # Required for support of iOS 7 CoreSimulators.  Can be removed when
   # Xcode support is dropped.
   def sdk_gte_8?
@@ -716,15 +750,20 @@ Command had no output
   def installed_app_bundle_dir
     sim_app_dir = device_applications_dir
     return nil if !File.exist?(sim_app_dir)
-    Dir.glob("#{sim_app_dir}/**/*.app").find do |path|
-      RunLoop::App.new(path).bundle_identifier == app.bundle_identifier
+
+    if xcode.version_gte_7?
+      simctl = RunLoop::Simctl.new(device)
+      simctl.app_container(app.bundle_identifier)
+    else
+      Dir.glob("#{sim_app_dir}/**/*.app").find do |path|
+        RunLoop::App.new(path).bundle_identifier == app.bundle_identifier
+      end
     end
   end
 
   # 1. Does nothing if the app is not installed.
   # 2. Does nothing if the app the same as the app that is installed
   # 3. Installs app if it is different from the installed app
-  #
   def ensure_app_same
     installed_app_bundle = installed_app_bundle_dir
 

data/lib/run_loop/environment.rb

@@ -229,6 +229,27 @@ module RunLoop
       value = ENV["CI"]
       !!value && value != ''
     end
+
+    # !@visibility private
+    # Returns the value of CBXWS.  This can be used to override the default
+    # CBXDriver.xcworkspace.  You should only set this if you are actively
+    # developing the CBXDriver.
+    def self.cbxws
+      value = ENV["CBXWS"]
+      if value.nil? || value == ""
+        nil
+      else
+        path = File.expand_path(value)
+        if !File.directory?(path)
+          raise RuntimeError, %Q[CBXWS is set, but there is no workspace at
+#{path}
+
+Only set CBXWS if you are developing new features in the CBXRunner.
+
+Check your environment.]
+        end
+        path
+      end
+    end
   end
 end
-

data/lib/run_loop/http/retriable_client.rb

@@ -101,6 +101,10 @@ module RunLoop
         request(request, :post, options)
       end
 
+      def delete(request, options={})
+        request(request, :delete, options)
+      end
+
       private
 
       def request(request, request_method, options={})
@@ -134,7 +138,7 @@ module RunLoop
             return client.send(request_method, @server.endpoint + request.route,
                                request.params, header)
           rescue *RETRY_ON => e
-            RunLoop.log_debug("Rescued http error: #{e}")
+            #RunLoop.log_debug("Rescued http error: #{e}")
 
             if first_try
               if @on_error[e.class]

data/lib/run_loop/instruments.rb

@@ -124,15 +124,11 @@ module RunLoop
     # Send a kill signal to any running `instruments` processes.
     #
     # Only one instruments process can be running at any one time.
-    #
-    # @param [RunLoop::Xcode] xcode Used to make check the
-    #  active Xcode version.
-    def kill_instruments(xcode = RunLoop::Xcode.new)
-      kill_signal = kill_signal(xcode)
+    def kill_instruments(_=nil)
       instruments_pids.each do |pid|
-        terminator = RunLoop::ProcessTerminator.new(pid, kill_signal, 'instruments')
+        terminator = RunLoop::ProcessTerminator.new(pid, "QUIT", "instruments")
         unless terminator.kill_process
-          terminator = RunLoop::ProcessTerminator.new(pid, 'KILL', 'instruments')
+          terminator = RunLoop::ProcessTerminator.new(pid, "KILL", "instruments")
           terminator.kill_process
         end
       end
@@ -369,29 +365,6 @@ module RunLoop
       end.compact.sort
     end
 
-    # @!visibility private
-    # The kill signal should be sent to instruments.
-    #
-    # When testing against iOS 8, sending -9 or 'TERM' causes the ScriptAgent
-    # process on the device to emit the following error until the device is
-    # rebooted.
-    #
-    # ```
-    # MobileGestaltHelper[909] <Error>: libMobileGestalt MobileGestalt.c:273: server_access_check denied access to question UniqueDeviceID for pid 796

-    # ScriptAgent[796] <Error>: libMobileGestalt MobileGestaltSupport.m:170: pid 796 (ScriptAgent) does not have sandbox access for re6Zb+zwFKJNlkQTUeT+/w and IS NOT appropriately entitled
-    # ScriptAgent[703] <Error>: libMobileGestalt MobileGestalt.c:534: no access to UniqueDeviceID (see <rdar://problem/11744455>)
-    # ```
-    #
-    # @see https://github.com/calabash/run_loop/issues/34
-    #
-    # @param [RunLoop::Xcode] xcode The Xcode tools to use to determine
-    #  what version of Xcode is active.
-    # @return [String] Either 'QUIT' or 'TERM', depending on the Xcode
-    #  version.
-    def kill_signal(xcode = RunLoop::Xcode.new)
-      xcode.version_gte_6? ? 'QUIT' : 'TERM'
-    end
-
     # @!visibility private
     #
     # Execute an instruments command.

data/lib/run_loop/ipa.rb

@@ -25,7 +25,20 @@ module RunLoop
 
     # @!visibility private
     def to_s
-      "#<IPA: #{bundle_identifier}: '#{path}'>"
+      cf_bundle_version = bundle_version
+      cf_bundle_short_version = short_bundle_version
+
+      if cf_bundle_version && cf_bundle_short_version
+        version = "#{cf_bundle_version.to_s}/#{cf_bundle_short_version}"
+      elsif cf_bundle_version
+        version = cf_bundle_version.to_s
+      elsif cf_bundle_short_version
+        version = cf_bundle_short_version
+      else
+        version = ""
+      end
+
+      "#<IPA #{bundle_identifier} #{version} #{path}>"
     end
 
     # @!visibility private
@@ -71,6 +84,22 @@ module RunLoop
       app.distribution_signed?
     end
 
+    # @!visibility private
+    def marketing_version
+      app.marketing_version
+    end
+
+    # See #marketing_version
+    alias_method :short_bundle_version, :marketing_version
+
+    # @!visibility private
+    def build_version
+      app.build_version
+    end
+
+    # See #build_version
+    alias_method :bundle_version, :build_version
+
     private
 
     # @!visibility private

data/lib/run_loop/simctl.rb

@@ -0,0 +1,89 @@
+module RunLoop
+
+  # @!visibility private
+  # An interface to the `simctl` command line tool for CoreSimulator.
+  #
+  # Replacement for SimControl.
+  class Simctl
+
+    # @!visibility private
+    DEFAULTS = {
+      :timeout => RunLoop::Environment.ci? ? 90 : 30,
+      :log_cmd => true
+    }
+
+    # @!visibility private
+    SIMCTL_PLIST_DIR = lambda {
+      dirname  = File.dirname(__FILE__)
+      joined = File.join(dirname, '..', '..', 'plists', 'simctl')
+      File.expand_path(joined)
+    }.call
+
+    # @!visibility private
+    def self.uia_automation_plist
+      File.join(SIMCTL_PLIST_DIR, 'com.apple.UIAutomation.plist')
+    end
+
+    # @!visibility private
+    def self.uia_automation_plugin_plist
+      File.join(SIMCTL_PLIST_DIR, 'com.apple.UIAutomationPlugIn.plist')
+    end
+
+    # @!visibility private
+    attr_accessor :device
+
+    # @!visibility private
+    #
+    # @param [RunLoop::Device] device Cannot be nil.
+    def initialize(device)
+      @device = device
+    end
+
+    # @!visibility private
+    def to_s
+      "#<Simctl: #{device.name} #{device.udid}>"
+    end
+
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
+    # @!visibility private
+    #
+    # This method is not supported on Xcode < 7 - returns nil.
+    #
+    # @param [String] bundle_id The CFBundleIdentifier of the app.
+    # @return [String] The path to the .app bundle if it exists; nil otherwise.
+    def app_container(bundle_id)
+      return nil if !xcode.version_gte_7?
+      cmd = ["simctl", "get_app_container", device.udid, bundle_id]
+      hash = execute(cmd, DEFAULTS)
+
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        nil
+      else
+        hash[:out].strip
+      end
+    end
+
+    private
+
+    # @!visibility private
+    def execute(array, options)
+      merged = DEFAULTS.merge(options)
+      xcrun.exec(array, merged)
+    end
+
+    # @!visibility private
+    def xcrun
+      @xcrun ||= RunLoop::Xcrun.new
+    end
+
+    # @!visibility private
+    def xcode
+      @xcode ||= RunLoop::Xcode.new
+    end
+  end
+end

data/lib/run_loop/version.rb

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

data/lib/run_loop/xcuitest.rb

@@ -3,20 +3,44 @@ module RunLoop
   # @!visibility private
   class XCUITest
 
+    class HTTPError < RuntimeError; end
+
     # @!visibility private
     DEFAULTS = {
       :port => 27753,
-      :simulator_ip => "127.0.0.1"
+      :simulator_ip => "127.0.0.1",
+      :http_timeout => RunLoop::Environment.ci? ? 120 : 60,
+      :version => "1.0"
     }
 
     # @!visibility private
-    def self.workspace
-      value = ENV["XCUITEST_WORKSPACE"]
-      if value.nil? || value == ""
-        return nil
-      else
-        value
+    def self.run(options={})
+      # logger = options[:logger]
+      simctl = options[:sim_control] || options[:simctl] || RunLoop::SimControl.new
+      xcode = options[:xcode] || RunLoop::Xcode.new
+      instruments = options[:instruments] || RunLoop::Instruments.new
+
+      # Find the Device under test, the App under test, UIA strategy, and reset options
+      device = RunLoop::Device.detect_device(options, xcode, simctl, instruments)
+      app_details = RunLoop::DetectAUT.detect_app_under_test(options)
+      reset_options = RunLoop::Core.send(:detect_reset_options, options)
+
+      app = app_details[:app]
+      bundle_id = app_details[:bundle_id]
+
+      if device.simulator? && app
+        core_sim = RunLoop::CoreSimulator.new(device, app, :xcode => xcode)
+        if reset_options
+          core_sim.reset_app_sandbox
+        end
+
+        simctl.ensure_software_keyboard(device)
+        core_sim.install
       end
+
+      xcuitest = RunLoop::XCUITest.new(bundle_id, device)
+      xcuitest.launch
+      xcuitest
     end
 
     # @!visibility private
@@ -30,78 +54,262 @@ module RunLoop
     end
 
     # @!visibility private
-    def initialize(bundle_id)
+    #
+    # The app with `bundle_id` needs to be installed.
+    #
+    # @param [String] bundle_id The identifier of the app under test.
+    # @param [RunLoop::Device] device The device device.
+    def initialize(bundle_id, device)
       @bundle_id = bundle_id
+      @device = device
+    end
+
+    def to_s
+      "#<XCUITest #{url} : #{bundle_id} : #{device}>"
+    end
+
+    def inspect
+      to_s
     end
 
     # @!visibility private
-    # TODO: move to Device ?
-    # TODO: needs tests for device case
-    def url
-      if target.simulator?
-        "http://#{DEFAULTS[:simulator_ip]}:#{DEFAULTS[:port]}"
-      else
-        calabash_endpoint = RunLoop::Environment.device_endpoint
-        if calabash_endpoint
-          base = calabash_endpoint.split(":")[0..1].join(":")
-          "http://#{base}:#{DEFAULTS[:port]}"
+    def bundle_id
+      @bundle_id
+    end
+
+    # @!visibility private
+    def device
+      @device
+    end
+
+    # @!visibility private
+    def workspace
+      @workspace ||= lambda do
+        path = RunLoop::Environment.send(:cbxws)
+        if path
+          path
         else
-          device_name = target.name.gsub(/[\'\s]/, "")
-          encoding_options = {
-            :invalid           => :replace,  # Replace invalid byte sequences
-            :undef             => :replace,  # Replace anything not defined in ASCII
-            :replace           => ''        # Use a blank for those replacements
-          }
-          encoded = device_name.encode(Encoding.find("ASCII"), encoding_options)
-          "http://#{encoded}.local:27753"
+          raise "TODO: figure out how to distribute the CBX-Runner"
         end
+      end.call
+    end
+
+    def launch
+      start = Time.now
+      launch_cbx_runner
+      launch_aut
+      elapsed = Time.now - start
+      RunLoop.log_debug("Took #{elapsed} seconds to launch #{bundle_id} on #{device}")
+      true
+    end
+
+    # @!visibility private
+    def running?
+      begin
+        health(ping_options)
+      rescue => _
+        nil
+      end
+    end
+
+    # @!visibility private
+    def stop
+      begin
+        shutdown
+      rescue => _
+        nil
       end
     end
 
     # @!visibility private
-    def launch_calabus_driver
+    def launch_other_app(bundle_id)
+      launch_aut(bundle_id)
+    end
 
-      driver_url = url
-      server = RunLoop::HTTP::Server.new(driver_url)
-      request = RunLoop::HTTP::Request.new("/shutdown", {})
-      options = {
-         :timeout => 0.5,
-         :retries => 1
+    # @!visibility private
+    def query(mark)
+      options = http_options
+      parameters = { :text => mark }
+      request = request("query", parameters)
+      client = client(options)
+      response = client.post(request)
+      expect_200_response(response)
+    end
+
+    # @!visibility private
+    def tap_mark(mark)
+      options = http_options
+      parameters = {
+        :gesture => "tap",
+        :text => mark
       }
-      client = RunLoop::HTTP::RetriableClient.new(server, options)
+      request = request("gesture", parameters)
+      client(options)
+      response = client.post(request)
+      expect_200_response(response)
+    end
 
-      begin
-        response = client.post(request)
-        RunLoop.log_debug("Calabus driver says, \"#{response.body}\"")
-        sleep(2.0)
-      rescue => e
-        RunLoop.log_debug("Driver shutdown raised #{e}")
-      end
+    # @!visibility private
+    def tap_coordinate(x, y)
+      options = http_options
+      parameters = {
+        :gesture => "tap_coordinate",
+        :coordinate => {x: x, y: y}
+      }
+      request = request("gesture", parameters)
+      client(options)
+      response = client.post(request)
+      expect_200_response(response)
+    end
 
-      workspace = XCUITest.workspace
+    # @!visibility private
+    def tap_query_result(hash)
+      rect = hash["rect"]
+      h = rect["height"]
+      w = rect["width"]
+      x = rect["x"]
+      y = rect["y"]
+
+      touchx = x + (h/2)
+      touchy = y + (w/2)
+      tap_coordinate(touchx, touchy)
+    end
 
-      if !workspace || !File.directory?(workspace)
-        raise RuntimeError, "No workspace found"
-      end
+    private
 
-      destination = target.udid
+    # @!visibility private
+    def xcrun
+      RunLoop::Xcrun.new
+    end
 
-      # might be nil
-      if target.simulator?
-        # quits the simulator
-        sim = CoreSimulator.new(target, "")
-        sim.launch_simulator
+    # @!visibility private
+    def url
+      @url ||= lambda do
+        if device.simulator?
+          "http://#{DEFAULTS[:simulator_ip]}:#{DEFAULTS[:port]}/"
+        else
+          # This block is untested.
+          calabash_endpoint = RunLoop::Environment.device_endpoint
+          if calabash_endpoint
+            base = calabash_endpoint.split(":")[0..1].join(":")
+            "http://#{base}:#{DEFAULTS[:port]}/"
+          else
+            device_name = device.name.gsub(/['\s]/, "")
+            encoding_options = {
+              :invalid           => :replace,  # Replace invalid byte sequences
+              :undef             => :replace,  # Replace anything not defined in ASCII
+              :replace           => ""         # Use a blank for those replacements
+            }
+            encoded = device_name.encode(Encoding.find("ASCII"), encoding_options)
+            "http://#{encoded}.local:27753/"
+          end
+        end
+      end.call
+    end
+
+    # @!visibility private
+    def server
+      @server ||= RunLoop::HTTP::Server.new(url)
+    end
+
+    # @!visibility private
+    def client(options={})
+      RunLoop::HTTP::RetriableClient.new(server, options)
+    end
+
+    # @!visibility private
+    def versioned_route(route)
+      if ["health", "ping", "sessionIdentifier"].include?(route)
+        route
       else
+        "#{DEFAULTS[:version]}/#{route}"
+      end
+    end
+
+    # @!visibility private
+    def request(route, parameters={})
+      versioned = versioned_route(route)
+      RunLoop::HTTP::Request.request(versioned, parameters)
+    end
+
+    # @!visibility private
+    def ping_options
+      @ping_options ||= { :timeout => 0.5, :retries => 1 }
+    end
 
+    # @!visibility private
+    def http_options
+      {
+        :timeout => DEFAULTS[:http_timeout],
+        :interval => 0.1,
+        :retries => (DEFAULTS[:http_timeout]/0.1).to_i
+      }
+    end
+
+    # @!visibility private
+    def session_delete
+      options = ping_options
+      request = request("delete")
+      client = client(options)
+      begin
+        response = client.delete(request)
+        body = expect_200_response(response)
+        RunLoop.log_debug("CBX-Runner says, #{body}")
+        body
+      rescue => e
+        RunLoop.log_debug("CBX-Runner session delete error: #{e}")
+        nil
       end
+    end
 
+    # @!visibility private
+    # TODO expect 200 response and parse body (atm the body in not valid JSON)
+    def shutdown
+      session_delete
+      options = ping_options
+      request = request("shutdown")
+      client = client(options)
+      begin
+        response = client.post(request)
+        body = response.body
+        RunLoop.log_debug("CBX-Runner says, \"#{body}\"")
+        5.times do
+          begin
+            health
+            sleep(0.2)
+          rescue => _
+            break
+          end
+        end
+        body
+      rescue => e
+        RunLoop.log_debug("CBX-Runner shutdown error: #{e}")
+        nil
+      end
+    end
+
+    # @!visibility private
+    # TODO expect 200 response and parse body (atm the body is not valid JSON)
+    def health(options={})
+      merged_options = http_options.merge(options)
+      request = request("health")
+      client = client(merged_options)
+      response = client.get(request)
+      body = response.body
+      RunLoop.log_debug("CBX-Runner driver says, \"#{body}\"")
+      body
+    end
+
+    # @!visibility private
+    def xcodebuild
       args = [
         "xcrun",
         "xcodebuild",
         "-scheme", "CBXAppStub",
         "-workspace", workspace,
         "-config", "Debug",
-        "-destination", "id=#{destination}",
+        "-destination",
+        "id=#{device.udid}",
         "clean",
         "test"
       ]
@@ -118,82 +326,80 @@ module RunLoop
 
       pid = Process.spawn(*args, options)
       Process.detach(pid)
+      pid
+    end
 
-      if target.simulator?
-        target.simulator_wait_for_stable_state
-      end
-
-      RunLoop.log_debug("Waiting for CBX-Runner to build...")
+    # @!visibility private
+    def launch_cbx_runner
+      # Fail fast if CBXWS is not defined.
+      # WIP - we will distribute the workspace somehow.
+      workspace
 
-      server = RunLoop::HTTP::Server.new(driver_url)
-      request = RunLoop::HTTP::Request.new("/health", {})
+      shutdown
 
-      options = {
-        :timeout => 60,
-        :interval => 0.1,
-        :retries => 600
-      }
+      if device.simulator?
+        # quits the simulator
+        sim = CoreSimulator.new(device, "")
+        sim.launch_simulator
+      else
+        # anything special about physical devices?
+      end
 
-      client = RunLoop::HTTP::RetriableClient.new(server, options)
-      response = client.get(request)
+      start = Time.now
+      pid = xcodebuild
+      RunLoop.log_debug("Waiting for CBX-Runner to build...")
+      health
 
-      RunLoop.log_debug("Calabus driver says, \"#{response.body}\"")
+      RunLoop.log_debug("Took #{Time.now - start} seconds to build and launch")
       pid.to_i
     end
 
-    def launch_app
-      server = RunLoop::HTTP::Server.new(url)
-      request = RunLoop::HTTP::Request.request("/session", {:bundleID => bundle_id})
-      client = RunLoop::HTTP::RetriableClient.new(server)
-      response = client.post(request)
-
-      RunLoop.log_debug("Calabus driver says, \"#{response.body}\"")
-    end
-
     # @!visibility private
-    def target
-      @device ||= lambda do
-        target = RunLoop::Environment.device_target
+    def launch_aut(bundle_id = @bundle_id)
+      client = client(http_options)
+      request = request("session", {:bundleID => bundle_id})
 
-        if !target
-          target = RunLoop::Core.default_simulator
+      begin
+        response = client.post(request)
+        RunLoop.log_debug("Launched #{bundle_id} on #{device}")
+        RunLoop.log_debug("#{response.body}")
+        if device.simulator?
+          device.simulator_wait_for_stable_state
         end
+        expect_200_response(response)
+      rescue => e
+        raise e.class, %Q[Could not launch #{bundle_id} on #{device}:
 
-        options = {
-          :sim_control => simctl,
-          :instruments => instruments
-        }
-
-        device = RunLoop::Device.device_with_identifier(target, options)
-
-        if !device
-          raise RuntimeError, "Could not find a device"
-        end
+#{e.message}
 
-        device
-      end.call
+Something went wrong.
+]
+      end
     end
 
     # @!visibility private
-    def bundle_id
-      @bundle_id
+    def response_body_to_hash(response)
+      body = response.body
+      begin
+        JSON.parse(body)
+      rescue TypeError, JSON::ParserError => _
+        raise RunLoop::XCUITest::HTTPError,
+              "Could not parse response '#{body}'; the app has probably crashed"
+      end
     end
 
-    private
-
     # @!visibility private
-    def simctl
-      @simctl ||= RunLoop::SimControl.new
-    end
+    def expect_200_response(response)
+      body = response_body_to_hash(response)
+      return body if response.status_code < 300
 
-    # @!visibility private
-    def instruments
-      @instruments ||= RunLoop::Instruments.new
-    end
+      raise RunLoop::XCUITest::HTTPError,
+        %Q[Expected status code < 200, found #{response.status_code}.
 
-    # @!visibility private
-    def xcrun
-      RunLoop::Xcrun.new
+Server replied with:
+
+#{body}
+]
     end
 
     # @!visibility private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: run_loop
 version: !ruby/object:Gem::Version
-  version: 2.1.0.pre1
+  version: 2.1.0
 platform: ruby
 authors:
 - Karl Krukow
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-22 00:00:00.000000000 Z
+date: 2016-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -326,7 +326,7 @@ files:
 - lib/run_loop/process_waiter.rb
 - lib/run_loop/regex.rb
 - lib/run_loop/sim_control.rb
-- lib/run_loop/simctl/plists.rb
+- lib/run_loop/simctl.rb
 - lib/run_loop/strings.rb
 - lib/run_loop/template.rb
 - lib/run_loop/version.rb
@@ -362,9 +362,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.2

data/lib/run_loop/simctl/plists.rb

@@ -1,20 +0,0 @@
-module RunLoop
-  module Simctl
-    class Plists
-
-      SIMCTL_PLIST_DIR = lambda {
-        dirname  = File.dirname(__FILE__)
-        joined = File.join(dirname, '..', '..', '..', 'plists', 'simctl')
-        File.expand_path(joined)
-      }.call
-
-      def self.uia_automation_plist
-        File.join(SIMCTL_PLIST_DIR, 'com.apple.UIAutomation.plist')
-      end
-
-      def self.uia_automation_plugin_plist
-        File.join(SIMCTL_PLIST_DIR, 'com.apple.UIAutomationPlugIn.plist')
-      end
-    end
-  end
-end