run_loop 2.1.6 → 2.1.7

data/lib/run_loop/device_agent/ios_device_manager.rb

@@ -95,21 +95,30 @@ but binary does not exist at that path.
                 "-t", runner.tester,
                 "-d", device.udid]
 
+        code_sign_identity = RunLoop::Environment.code_sign_identity
+        if !code_sign_identity
+          code_sign_identity = "iPhone Developer"
+        end
+
         if device.physical_device?
           args << "-c"
-          args << RunLoop::Environment.codesign_identity
+          args << code_sign_identity
         end
 
         log_file = IOSDeviceManager.log_file
         FileUtils.rm_rf(log_file)
         FileUtils.touch(log_file)
 
+        env = {
+          "CLOBBER" => "1"
+        }
+
         options = {:out => log_file, :err => log_file}
         RunLoop.log_unix_cmd("#{cmd} #{args.join(" ")} >& #{log_file}")
 
         # Gotta keep the ios_device_manager process alive or the connection
         # to testmanagerd will fail.
-        pid = Process.spawn(cmd, *args, options)
+        pid = Process.spawn(env, cmd, *args, options)
         Process.detach(pid)
 
         if device.simulator?

data/lib/run_loop/device_agent/xcodebuild.rb

@@ -61,7 +61,8 @@ module RunLoop
       # @!visibility private
       def xcodebuild
         env = {
-          "COMMAND_LINE_BUILD" => "1"
+          "COMMAND_LINE_BUILD" => "1",
+          "CLOBBER" => "1"
         }
 
         args = [
@@ -72,7 +73,11 @@ module RunLoop
           "-config", "Debug",
           "-destination",
           "id=#{device.udid}",
-          "clean",
+          "CLANG_ENABLE_CODE_COVERAGE=YES",
+          "GCC_GENERATE_TEST_COVERAGE_FILES=NO",
+          "GCC_INSTRUMENT_PROGRAM_FLOW_ARCS=NO",
+          # Scheme setting.
+          "-enableCodeCoverage", "YES",
           "test"
         ]
 

data/lib/run_loop/environment.rb

@@ -163,8 +163,8 @@ module RunLoop
     end
 
     # Returns the value of CODESIGN_IDENTITY
-    def self.codesign_identity
-      value = ENV["CODESIGN_IDENTITY"]
+    def self.code_sign_identity
+      value = ENV["CODE_SIGN_IDENTITY"]
       if !value || value == ""
         nil
       else

data/lib/run_loop/instruments.rb

@@ -158,10 +158,13 @@ module RunLoop
     # @todo Should this raise errors?
     # @todo Is this jruby compatible?
     def spawn(automation_template, options, log_file)
+      env = {
+        "CLOBBER" => "1"
+      }
       splat_args = spawn_arguments(automation_template, options)
       logger = options[:logger]
       RunLoop::Logging.log_debug(logger, "xcrun #{splat_args.join(' ')} >& #{log_file}")
-      pid = Process.spawn('xcrun', *splat_args, {:out => log_file, :err => log_file})
+      pid = Process.spawn(env, 'xcrun', *splat_args, {:out => log_file, :err => log_file})
       Process.detach(pid)
       pid.to_i
     end

data/lib/run_loop/otool.rb

@@ -5,26 +5,14 @@ module RunLoop
   class Otool
 
     # @!visibility private
-    attr_reader :path
-
-    # @!visibility private
-    def initialize(path)
-      @path = path
-
-      if !Otool.valid_path?(path)
-        raise ArgumentError,
-%Q{File:
-
-#{path}
-
-must exist and not be a directory.
-}
-      end
+    # @param [RunLoop::Xcode] xcode An instance of Xcode
+    def initialize(xcode)
+      @xcode = xcode
     end
 
     # @!visibility private
     def to_s
-      "#<OTOOL: #{path}>"
+      "#<OTOOL: Xcode #{xcode.version.to_s}>"
     end
 
     # @!visibility private
@@ -33,15 +21,19 @@ must exist and not be a directory.
     end
 
     # @!visibility private
-    def executable?
-      !arch_info[/is not an object file/, 0]
+    def executable?(path)
+      expect_valid_path!(path)
+      !arch_info(path)[/is not an object file/, 0]
     end
 
     private
 
     # @!visibility private
-    def arch_info
-      args = ["otool", "-hv", "-arch", "all", path]
+    attr_reader :xcode, :command_name
+
+    # @!visibility private
+    def arch_info(path)
+      args = [command_name, "-hv", "-arch", "all", path]
       opts = { :log_cmd => false }
 
       hash = xcrun.run_command_in_context(args, opts)
@@ -60,17 +52,41 @@ exited #{hash[:exit_status]} with the following output:
 }
       end
 
-      @arch_info = hash[:out]
+      hash[:out]
     end
 
     # @!visibility private
-    def self.valid_path?(path)
-      File.exist?(path) && !File.directory?(path)
+    def expect_valid_path!(path)
+      return true if File.exist?(path) && !File.directory?(path)
+      raise ArgumentError, %Q[
+File:
+
+#{path}
+
+must exist and not be a directory.
+
+]
     end
 
     # @!visibility private
     def xcrun
-      RunLoop::Xcrun.new
+      @xcrun ||= RunLoop::Xcrun.new
+    end
+
+    # @!visibility private
+    def xcode
+      @xcode
+    end
+
+    # @!visibility private
+    def command_name
+      @command_name ||= begin
+        if xcode.version_gte_8?
+          "otool-classic"
+        else
+          "otool"
+        end
+      end
     end
   end
 end

data/lib/run_loop/physical_device/ios_device_manager.rb

@@ -0,0 +1,89 @@
+
+module RunLoop
+  module PhysicalDevice
+
+    require "run_loop/physical_device/life_cycle"
+    class IOSDeviceManager < RunLoop::PhysicalDevice::LifeCycle
+
+      # Is the tool installed?
+      def self.tool_is_installed?
+        File.exist?(IOSDeviceManager.executable_path)
+      end
+
+      # Path to tool.
+      def self.executable_path
+        RunLoop::DeviceAgent::IOSDeviceManager.ios_device_manager
+      end
+
+      def initialize(device)
+        super(device)
+
+        # Expands the Frameworks.zip if necessary.
+        RunLoop::DeviceAgent::Frameworks.instance.install
+      end
+
+      def app_installed?(bundle_id)
+        args = [
+          IOSDeviceManager.executable_path,
+          "is_installed",
+          "-d", device.udid,
+          "-b", bundle_id
+        ]
+
+        options = { :log_cmd => true }
+        hash = run_shell_command(args, options)
+
+        # TODO: error reporting
+        hash[:exit_status] == 0
+      end
+
+      def install_app(app_or_ipa)
+        app = app_or_ipa
+        if is_ipa?(app)
+          app = app_or_ipa.app
+        end
+
+        code_sign_identity = RunLoop::Environment.code_sign_identity
+        if !code_sign_identity
+          code_sign_identity = "iPhone Developer"
+        end
+
+        args = [
+          IOSDeviceManager.executable_path,
+          "install",
+          "-d", device.udid,
+          "-a", app.path,
+          "-c", code_sign_identity
+        ]
+
+        options = { :log_cmd => true }
+        hash = run_shell_command(args, options)
+
+        # TODO: error reporting
+        if hash[:exit_status] == 0
+          true
+        else
+          puts hash[:out]
+          false
+        end
+      end
+
+      def uninstall_app(bundle_id)
+        return true if !app_installed?(bundle_id)
+
+        args = [
+          IOSDeviceManager.executable_path,
+          "uninstall",
+          "-d", device.udid,
+          "-b", bundle_id
+        ]
+
+        options = { :log_cmd => true }
+        hash = run_shell_command(args, options)
+
+        # TODO: error reporting
+        hash[:exit_status] == 0
+      end
+    end
+  end
+end

data/lib/run_loop/regex.rb

@@ -13,7 +13,7 @@ module RunLoop
     DEVICE_UDID_REGEX = /[a-f0-9]{40}/.freeze
 
     # @!visibility private
-    VERSION_REGEX = /(\d\.\d(\.\d)?)/.freeze
+    VERSION_REGEX = /(\d+\.\d+(\.\d+)?)/.freeze
 
   end
 end

data/lib/run_loop/shell.rb

@@ -26,6 +26,16 @@ module RunLoop
     # Raised when shell command times out.
     class TimeoutError < RuntimeError; end
 
+    def self.run_shell_command(args, options={})
+      shell = Class.new do
+        include RunLoop::Shell
+        def to_s; "#<Anonymous Shell>"; end
+        def inspect; to_s; end
+      end.new
+
+      shell.run_shell_command(args, options)
+    end
+
     def run_shell_command(args, options={})
 
       merged_options = DEFAULT_OPTIONS.merge(options)
@@ -85,19 +95,43 @@ executing this command:
 }
       end
 
+      now = Time.now
+
       if hash[:exit_status].nil?
-        elapsed = "%0.2f" % (Time.now - start_time)
-        raise TimeoutError,
-%Q{Timed out after #{elapsed} seconds executing
+        elapsed = "%0.2f" % (now - start_time)
+
+        if timeout_exceeded?(start_time, timeout)
+          raise TimeoutError,
+%Q[
+Timed out after #{elapsed} seconds executing
 
 #{cmd}
 
 with a timeout of #{timeout}
-}
+]
+        else
+          raise Error,
+                %Q[
+There was an error executing:
+
+#{cmd}
+
+The command generated this output:
+
+#{hash[:out]}
+]
+
+        end
       end
 
       hash
     end
+
+    private
+
+    def timeout_exceeded?(start_time, timeout)
+      Time.now > start_time + timeout
+    end
   end
 end
 

data/lib/run_loop/sim_control.rb

@@ -1136,7 +1136,9 @@ module RunLoop
     #  base sdk version.
     # @see #simctl_list
     def simctl_list_devices
-      args = ['simctl', 'list', 'devices']
+      # Ensure correct CoreSimulator service is installed.
+      RunLoop::Simctl.new
+      args = ["simctl", 'list', 'devices']
       hash = xcrun.run_command_in_context(args)
 
       current_sdk = nil
@@ -1219,7 +1221,9 @@ module RunLoop
     #
     # @see #simctl_list
     def simctl_list_runtimes
-      args = ['simctl', 'list', 'runtimes']
+      # Ensure correct CoreSimulator service is installed.
+      RunLoop::Simctl.new
+      args = ["simctl", 'list', 'runtimes']
       hash = xcrun.run_command_in_context(args)
 
       # Ex.

data/lib/run_loop/simctl.rb

@@ -15,10 +15,17 @@ module RunLoop
     # @!visibility private
     SIMCTL_PLIST_DIR = lambda {
       dirname  = File.dirname(__FILE__)
-      joined = File.join(dirname, '..', '..', 'plists', 'simctl')
+      joined = File.join(dirname, "..", "..", "plists", "simctl")
       File.expand_path(joined)
     }.call
 
+    # @!visibility private
+    SIM_STATES = {
+      "Shutdown" => 1,
+      "Shutting Down" => 2,
+      "Booted" => 3,
+    }.freeze
+
     # @!visibility private
     def self.uia_automation_plist
       File.join(SIMCTL_PLIST_DIR, 'com.apple.UIAutomation.plist')
@@ -29,6 +36,28 @@ module RunLoop
       File.join(SIMCTL_PLIST_DIR, 'com.apple.UIAutomationPlugIn.plist')
     end
 
+    # @!visibility private
+    def self.ensure_valid_core_simulator_service
+      require "run_loop/shell"
+      args = ["xcrun", "simctl", "help"]
+
+      max_tries = 3
+      3.times do |try|
+        hash = {}
+        begin
+          hash = Shell.run_shell_command(args)
+          if hash[:exit_status] != 0
+            RunLoop.log_debug("Invalid CoreSimulator service for active Xcode: try #{try + 1} of #{max_tries}")
+          else
+            return true
+          end
+        rescue RunLoop::Shell::Error => _
+          RunLoop.log_debug("Invalid CoreSimulator service for active Xcode, retrying #{try + 1} of #{max_tries}")
+        end
+      end
+      false
+    end
+
     # @!visibility private
     attr_reader :device
 
@@ -37,6 +66,7 @@ module RunLoop
       @ios_devices = []
       @tvos_devices = []
       @watchos_devices = []
+      Simctl.ensure_valid_core_simulator_service
     end
 
     # @!visibility private
@@ -76,7 +106,7 @@ module RunLoop
     def app_container(device, bundle_id)
       return nil if !xcode.version_gte_7?
       cmd = ["simctl", "get_app_container", device.udid, bundle_id]
-      hash = execute(cmd, DEFAULTS)
+      hash = shell_out_with_xcrun(cmd, DEFAULTS)
 
       exit_status = hash[:exit_status]
       if exit_status != 0
@@ -86,6 +116,253 @@ module RunLoop
       end
     end
 
+    # @!visibility private
+    def simulator_state_as_int(device)
+      plist = device.simulator_device_plist
+      pbuddy.plist_read("state", plist).to_i
+    end
+
+    # @!visibility private
+    def simulator_state_as_string(device)
+      string_for_sim_state(simulator_state_as_int(device))
+    end
+
+    # @!visibility private
+    def shutdown(device)
+      if simulator_state_as_int(device) == SIM_STATES["Shutdown"]
+        RunLoop.log_debug("Simulator is already shutdown")
+        true
+      else
+        cmd = ["simctl", "shutdown", device.udid]
+        hash = shell_out_with_xcrun(cmd, DEFAULTS)
+
+        exit_status = hash[:exit_status]
+        if exit_status != 0
+
+          if simulator_state_as_int(device) == SIM_STATES["Shutdown"]
+            RunLoop.log_debug("simctl shutdown called when state is 'Shutdown'; ignoring error")
+          else
+            raise RuntimeError,
+                  %Q[Could not shutdown the simulator:
+
+  command: xcrun #{cmd.join(" ")}
+simulator: #{device}
+
+                  #{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
+        end
+        true
+      end
+    end
+
+    # @!visibility private
+    #
+    # Waiting for anything but 'Shutdown' is not advised.  The simulator reports
+    # that it is "Booted" long before it is ready to receive commands.
+    #
+    # Waiting for 'Shutdown' is required for erasing the simulator and launching
+    # launching the simulator with iOSDeviceManager.
+    def wait_for_shutdown(device, timeout, delay)
+      now = Time.now
+      poll_until = now + timeout
+      in_state = false
+
+      state = nil
+
+      while Time.now < poll_until
+        state = simulator_state_as_int(device)
+        in_state = state == SIM_STATES["Shutdown"]
+        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: 'Shutdown'.")
+
+      unless in_state
+        string = string_for_sim_state(state)
+        raise "Expected 'Shutdown' state but found '#{string}' after waiting for #{elapsed} seconds."
+      end
+      in_state
+    end
+
+    # @!visibility private
+    # Erases the simulator.
+    #
+    # @param [RunLoop::Device] device The simulator to erase.
+    # @param [Numeric] wait_timeout How long to wait for the simulator to have
+    #  state "Shutdown"; passed to #wait_for_shutdown.
+    # @param [Numeric] wait_delay How long to wait between calls to
+    #  #simulator_state_as_int while waiting for the simulator have to state "Shutdown";
+    #  passed to #wait_for_shutdown
+    def erase(device, wait_timeout, wait_delay)
+      require "run_loop/core_simulator"
+      CoreSimulator.quit_simulator
+
+      shutdown(device)
+      wait_for_shutdown(device, wait_timeout, wait_delay)
+
+      cmd = ["simctl", "erase", device.udid]
+      hash = shell_out_with_xcrun(cmd, DEFAULTS)
+
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        raise RuntimeError,
+%Q[Could not erase the simulator:
+
+  command: xcrun #{cmd.join(" ")}
+simulator: #{device}
+
+              #{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
+      true
+    end
+
+    # @!visibility private
+    #
+    # Launches the app on on the device.
+    #
+    # Caller is responsible for the following:
+    #
+    # 1. Launching the simulator.
+    # 2. Installing the application.
+    #
+    # No checks are made.
+    #
+    # @param [RunLoop::Device] device The simulator to launch on.
+    # @param [RunLoop::App] app The app to launch.
+    # @param [Numeric] timeout How long to wait for simctl to complete.
+    def launch(device, app, timeout)
+      cmd = ["simctl", "launch", device.udid, app.bundle_identifier]
+      options = DEFAULTS.dup
+      options[:timeout] = timeout
+
+      hash = shell_out_with_xcrun(cmd, options)
+
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        raise RuntimeError,
+%Q[Could not launch app on simulator:
+
+  command: xcrun #{cmd.join(" ")}
+simulator: #{device}
+      app: #{app}
+
+#{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
+      true
+    end
+
+    # @!visibility private
+    #
+    # Launches the app on on the device.
+    #
+    # Caller is responsible for the following:
+    #
+    # 1. Launching the simulator.
+    # 2. That the application is installed; simctl uninstall will fail if app
+    #    is installed.
+    #
+    # No checks are made.
+    #
+    # @param [RunLoop::Device] device The simulator to launch on.
+    # @param [RunLoop::App] app The app to launch.
+    # @param [Numeric] timeout How long to wait for simctl to complete.
+    def uninstall(device, app, timeout)
+      cmd = ["simctl", "uninstall", device.udid, app.bundle_identifier]
+      options = DEFAULTS.dup
+      options[:timeout] = timeout
+
+      hash = shell_out_with_xcrun(cmd, options)
+
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        raise RuntimeError,
+%Q[Could not uninstall app from simulator:
+
+  command: xcrun #{cmd.join(" ")}
+simulator: #{device}
+      app: #{app}
+
+#{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
+      true
+    end
+
+    # @!visibility private
+    #
+    # Launches the app on on the device.
+    #
+    # Caller is responsible for the following:
+    #
+    # 1. Launching the simulator.
+    #
+    # No checks are made.
+    #
+    # @param [RunLoop::Device] device The simulator to launch on.
+    # @param [RunLoop::App] app The app to launch.
+    # @param [Numeric] timeout How long to wait for simctl to complete.
+    def install(device, app, timeout)
+      cmd = ["simctl", "install", device.udid, app.path]
+      options = DEFAULTS.dup
+      options[:timeout] = timeout
+
+      hash = shell_out_with_xcrun(cmd, options)
+
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        raise RuntimeError,
+%Q[Could not install app on simulator:
+
+  command: xcrun #{cmd.join(" ")}
+simulator: #{device}
+      app: #{app}
+
+#{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
+      true
+    end
+
     # @!visibility private
     #
     # SimControl compatibility
@@ -110,10 +387,26 @@ module RunLoop
     private
 
     # @!visibility private
-    attr_reader :ios_devices, :tvos_devices, :watchos_devices
+    attr_reader :ios_devices, :tvos_devices, :watchos_devices, :pbuddy
+
+    # @!visibility private
+    def pbuddy
+      @pbuddy ||= RunLoop::PlistBuddy.new
+    end
+
+    # @!visibility private
+    def string_for_sim_state(integer)
+      SIM_STATES.each do |key, value|
+        if value == integer
+          return key
+        end
+      end
+
+      raise ArgumentError, "Could not find state for #{integer}"
+    end
 
     # @!visibility private
-    def execute(array, options)
+    def shell_out_with_xcrun(array, options)
       merged = DEFAULTS.merge(options)
       xcrun.run_command_in_context(array, merged)
     end
@@ -143,7 +436,7 @@ module RunLoop
       @watchos_devices = []
 
       cmd = ["simctl", "list", "devices", "--json"]
-      hash = execute(cmd, DEFAULTS)
+      hash = shell_out_with_xcrun(cmd, DEFAULTS)
 
       out = hash[:out]
       exit_status = hash[:exit_status]