run_loop_tcc 2.1.3

data/lib/run_loop/simctl.rb

@@ -0,0 +1,275 @@
+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_reader :device
+
+    # @!visibility private
+    def initialize
+      @ios_devices = []
+      @tvos_devices = []
+      @watchos_devices = []
+    end
+
+    # @!visibility private
+    def to_s
+      "#<Simctl: #{xcode.version}>"
+    end
+
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
+    # @!visibility private
+    def simulators
+      simulators = ios_devices
+      if simulators.empty?
+       simulators = fetch_devices![:ios]
+      end
+      simulators
+    end
+
+    # @!visibility private
+    #
+    # This method is not supported on Xcode < 7 - returns nil.
+    #
+    # Simulator must be booted in El Cap, which makes this method useless for us
+    # because we have to do a bunch of pre-launch checks for sandbox resetting.
+    #
+    # Testing has shown that moving the device in and out of the booted state
+    # takes a long time (seconds) and is unpredictable.
+    #
+    # TODO ensure a booted state.
+    #
+    # @param [String] bundle_id The CFBundleIdentifier of the app.
+    # @param [RunLoop::Device] device The device under test.
+    # @return [String] The path to the .app bundle if it exists; nil otherwise.
+    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)
+
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        nil
+      else
+        hash[:out].strip
+      end
+    end
+
+    # @!visibility private
+    #
+    # SimControl compatibility
+    def ensure_accessibility(device)
+      sim_control.ensure_accessibility(device)
+    end
+
+    # @!visibility private
+    #
+    # SimControl compatibility
+    def ensure_software_keyboard(device)
+      sim_control.ensure_software_keyboard(device)
+    end
+
+    # @!visibility private
+    #
+    # TODO Make this private again; exposed for SimControl compatibility.
+    def xcode
+      @xcode ||= RunLoop::Xcode.new
+    end
+
+    private
+
+    # @!visibility private
+    attr_reader :ios_devices, :tvos_devices, :watchos_devices
+
+    # @!visibility private
+    def execute(array, options)
+      merged = DEFAULTS.merge(options)
+      xcrun.run_command_in_context(array, merged)
+    end
+
+    # @!visibility private
+    #
+    # Starting in Xcode 7, simctl allows a --json option for listing devices.
+    #
+    # On Xcode 6, we will fall back to SimControl which does a line-by-line
+    # processing of `simctl list devices`. tvOS and watchOS devices are not
+    # available on Xcode < 7.
+    #
+    # This is a destructive operation on `@ios_devices`, `@tvos_devices`, and
+    # `@watchos_devices`.  Callers should check for existing devices to avoid
+    # the overhead of calling `simctl list devices --json`.
+    def fetch_devices!
+      if !xcode.version_gte_7?
+        return {
+          :ios => sim_control.simulators,
+          :tvos => [],
+          :watchos => []
+        }
+      end
+
+      @ios_devices = []
+      @tvos_devices = []
+      @watchos_devices = []
+
+      cmd = ["simctl", "list", "devices", "--json"]
+      hash = execute(cmd, DEFAULTS)
+
+      out = hash[:out]
+      exit_status = hash[:exit_status]
+      if exit_status != 0
+        raise RuntimeError, %Q[simctl exited #{exit_status}:
+
+#{out}
+
+while trying to list devices.
+]
+      end
+
+      devices = json_to_hash(out)["devices"]
+
+      devices.each do |key, device_list|
+        version = device_key_to_version(key)
+        bucket = bucket_for_key(key)
+
+        device_list.each do |record|
+          if device_available?(record)
+            bucket << device_from_record(record, version)
+          end
+        end
+      end
+      {
+        :ios => ios_devices,
+        :tvos => tvos_devices,
+        :watchos => watchos_devices
+      }
+    end
+
+    # @!visibility private
+    #
+    # command_runner_ng combines stderr and stdout and starting in Xcode 7.3,
+    # simctl has started generating stderr output.  This must be filtered out
+    # so that we can parse the JSON response.
+    def filter_stderr(out)
+      out.split($-0).map do |line|
+        if stderr_line?(line)
+          nil
+        else
+          line
+        end
+      end.compact.join($-0)
+    end
+
+    # @!visibility private
+    def stderr_line?(line)
+      line[/CoreSimulatorService/, 0] || line[/simctl\[.+\]/, 0]
+    end
+
+    # @!visibility private
+    def json_to_hash(json)
+      filtered = filter_stderr(json)
+      begin
+        JSON.parse(filtered)
+      rescue TypeError, JSON::ParserError => e
+        raise RuntimeError, %Q[Could not parse simctl JSON response:
+
+#{e}
+]
+      end
+    end
+
+    # @!visibility private
+    def device_key_is_ios?(key)
+      key[/iOS/, 0]
+    end
+
+    # @!visibility private
+    def device_key_is_tvos?(key)
+      key[/tvOS/, 0]
+    end
+
+    # @!visibility private
+    def device_key_is_watchos?(key)
+      key[/watchOS/, 0]
+    end
+
+    # @!visibility private
+    def device_key_to_version(key)
+      str = key.split(" ").last
+      RunLoop::Version.new(str)
+    end
+
+    # @!visibility private
+    def device_available?(record)
+      record["availability"] == "(available)"
+    end
+
+    # @!visibility private
+    def device_from_record(record, version)
+      RunLoop::Device.new(record["name"],
+                          version,
+                          record["udid"],
+                          record["state"])
+    end
+
+    # @!visibility private
+    def bucket_for_key(key)
+      if device_key_is_ios?(key)
+        bin = @ios_devices
+      elsif device_key_is_tvos?(key)
+        bin = @tvos_devices
+      elsif device_key_is_watchos?(key)
+        bin = @watchos_devices
+      else
+        raise RuntimeError, "Unexpected key while processing simctl output:
+
+key = #{key}
+
+is not an iOS, tvOS, or watchOS device"
+      end
+      bin
+    end
+
+    # @!visibility private
+    def xcrun
+      @xcrun ||= RunLoop::Xcrun.new
+    end
+
+    # @!visibility private
+    # Support for Xcode < 7 when trying to collect simulators.  Xcode 7 allows
+    # a --json option which is much easier to parse.
+    def sim_control
+      @sim_control ||= RunLoop::SimControl.new
+    end
+  end
+end

data/lib/run_loop/sqlite.rb

@@ -0,0 +1,61 @@
+module RunLoop
+  # @!visibility private
+  class Sqlite
+
+    # @!visibility private
+    # MacOS ships with sqlite3
+    SQLITE3 = "/usr/bin/sqlite3"
+
+    # @!visibility private
+    def self.exec(file, sql)
+      if !File.exist?(file)
+        raise ArgumentError,
+%Q{sqlite database must exist at path:
+
+#{file}
+}
+      end
+
+      if sql.nil? || sql == ""
+        raise ArgumentError, "Sql argument must not be nil or the empty string"
+      end
+
+      args = [SQLITE3, file, sql]
+      hash = self.xcrun.exec(args, {:log_cmd => true})
+
+      out = hash[:out]
+      exit_status = hash[:exit_status]
+
+			if exit_status.nil? || exit_status != 0
+				raise RuntimeError,
+%Q{
+Could not complete sqlite operation:
+
+file: #{file}
+ sql: #{sql}
+ out: #{out}
+
+Exited with status: '#{exit_status}'
+}
+			end
+
+      out
+    end
+
+    # @!visibilty private
+    def self.parse(string, delimiter="|")
+       if string == nil
+         []
+       else
+         string.split(delimiter)
+       end
+    end
+
+    private
+
+    def self.xcrun
+      RunLoop::Xcrun.new
+    end
+  end
+end
+

data/lib/run_loop/strings.rb

@@ -0,0 +1,88 @@
+module RunLoop
+  # @!visibility private
+  #
+  # A class for interacting with the strings tool
+  class Strings
+
+    # @!visibility private
+    attr_reader :path
+
+    # @!visibility private
+    def initialize(path)
+      @path = path
+
+      if !Strings.valid_path?(path)
+        raise ArgumentError,
+%Q{File:
+
+#{path}
+
+must exist and not be a directory.
+}
+      end
+    end
+
+    # @!visibility private
+    def to_s
+      "#<STRINGS: #{path}>"
+    end
+
+    # @!visibility private
+    def inspect
+      to_s
+    end
+
+    # @!visibility private
+    #
+    # @return [RunLoop::Version] A version instance or nil if the file
+    #   at path does not contain server version information.
+    def server_version
+      regex = /CALABASH VERSION: (\d+\.\d+\.\d+(\.pre\d+)?)/
+      match = dump[regex, 0]
+
+      if match
+        str = match.split(":")[1]
+        RunLoop::Version.new(str)
+      else
+        nil
+      end
+    end
+
+    private
+
+    # @!visibility private
+    def dump
+      args = ["strings", path]
+      opts = { :log_cmd => true }
+
+      hash = xcrun.run_command_in_context(args, opts)
+
+      if hash[:exit_status] != 0
+        raise RuntimeError,
+%Q{Could not get strings info from file:
+
+#{path}
+
+#{args.join(" ")}
+
+exited #{hash[:exit_status]} with the following output:
+
+#{hash[:out]}
+}
+      end
+
+      @dump = hash[:out]
+    end
+
+    # @!visibility private
+    def self.valid_path?(path)
+      File.exist?(path) && !File.directory?(path)
+    end
+
+    # @!visibility private
+    def xcrun
+      RunLoop::Xcrun.new
+    end
+  end
+end
+

data/lib/run_loop/tcc/tcc.rb

@@ -0,0 +1,240 @@
+module RunLoop
+  # @!visibility private
+  class TCC
+
+    # @!visibility private
+    PRIVACY_SERVICES = {
+      :calendar => "kTCCServiceCalendar",
+      :camera => "kTCCServiceCamera",
+      :contacts => "kTCCServiceAddressBook",
+      :microphone => "kTCCServiceMicrophone",
+      :motion => "kTCCServiceMotion",
+      :photos => "kTCCServicePhotos",
+      :reminders => "kTCCServiceReminders",
+      :twitter => "kTCCServiceTwitter"
+    }
+
+    # Returns a list of known services as keys that can be passed
+    # to RunLoop::TCC.allow or RunLoop::TCC.deny.
+    def self.services
+      PRIVACY_SERVICES.map do |key, _|
+        key
+      end
+    end
+
+    # Prohibits the `device` from popping a Privacy Alert for `service`.
+    #
+    # Only works on iOS Simulator.
+    #
+    # There is a set of known services like :camera, :microphone, and :twitter,
+    # but you can pass arbritary services - this may or may not have an effect
+    # on your application.
+    #
+    # @param [String, RunLoop::Device] device
+    # @param [String] bundle_id
+    # @param [Array] services An array of services.  The default is to allow
+    #   all services.
+    #
+    # @raise [ArgumentError] If device is a physical device.
+    # @raise [ArgumentError] If not device with identifier can be found.
+    def self.allow(device, bundle_id, services = [])
+      _device = self.ensure_device(device)
+
+      if services.empty?
+        _services = self.services
+      else
+        _services = services
+      end
+
+      tcc = self.tcc(device, bundle_id)
+
+      _services.each do |service|
+        tcc.allow_service(service)
+      end
+      _services
+    end
+
+    # Force the `device` to pop a Privacy Alert for `service`.
+    #
+    # Only works on iOS Simulator.
+    #
+    # @param [String, RunLoop::Device] device
+    # @param [String] bundle_id
+    # @param [Array] services An array of services.  The default is to deny
+    #   all services.
+    #
+    # @raise [ArgumentError] If device is a physical device.
+    # @raise [ArgumentError] If not device with identifier can be found.
+    def self.deny(device, bundle_id, services = [])
+      _device = self.ensure_device(device)
+
+      if services.empty?
+        _services = self.services
+      else
+        _services = services
+      end
+
+      tcc = self.tcc(device, bundle_id)
+
+      _services.each do |service|
+        tcc.deny_service(service)
+      end
+      _services
+    end
+
+    # @!visibility private
+    def initialize(device, bundle_id)
+      @device = device
+      @bundle_id = bundle_id
+
+      if device.physical_device?
+        raise(ArgumentError, "Managing the TCC.db only works on simulators")
+      end
+
+      if !bundle_id.is_a?(String)
+        raise(ArgumentError, "Managing the TCC.db requires a valid bundle_id")
+      end
+    end
+
+    # @!visibility private
+    def allow_service(service)
+      service_name = service_name(service)
+      state = service_is_allowed(service_name)
+
+      return true if state == true
+
+      if state == nil
+        insert_allowed(service_name, 1)
+      else
+        update_allowed(service_name, 1)
+      end
+      true
+    end
+
+    # @!visibility private
+    def deny_service(service)
+      service_name = service_name(service)
+      state = service_is_allowed(service_name)
+
+      # state == false; need to update prompt_count
+      if state == nil
+        insert_allowed(service_name, 0)
+      else
+        update_allowed(service_name, 0)
+      end
+      true
+    end
+
+    # @!visibility private
+    def delete_service(service)
+      service_name = service_name(service)
+      state = service_is_allowed(service_name)
+
+      return true if state.nil?
+      delete_allowed(service_name)
+      true
+    end
+
+    private
+
+    # @!visibility private
+    attr_reader :device, :bundle_id
+
+    # @!visibility private
+    ACCESS_COLUMNS = [
+      "service",
+      "client",
+      "client_type",
+      "allowed",
+      "prompt_count"
+    ]
+
+    # @!visibility private
+    def where(service)
+      %Q{WHERE client="#{client}" AND service="#{service}"}
+    end
+
+    # @!visibility private
+    def service_is_allowed(service)
+      service_name = service_name(service)
+      sql = %Q{SELECT allowed FROM access #{where(service_name)}}
+      out = RunLoop::Sqlite.exec(db, sql)
+
+      case out
+      when ""
+        return nil
+      when "1"
+        return true
+      when "0"
+        return false
+      else
+        raise RuntimeError, %Q{Expected '', '1', or '0' found: '#{out}'"}
+      end
+    end
+
+    # @!visibility private
+    def access_columns
+      "service, client, client_type, allowed, prompt_count"
+    end
+
+    # @!visibility private
+    def access_values(service, state)
+      %Q{"#{service}", "#{client}", 0, #{state}, #{state}}
+    end
+
+    # @!visibility private
+    def insert_allowed(service, state)
+      sql = %Q{INSERT INTO access (#{access_columns}) VALUES (#{access_values(service, state)})}
+      RunLoop::Sqlite.exec(db, sql)
+    end
+
+    # @!visibility private
+    def update_allowed(service, state)
+      sql = %Q{UPDATE access SET allowed=#{state}, prompt_count=#{state} #{where(service)}}
+      RunLoop::Sqlite.exec(db, sql)
+    end
+
+    # @!visibility private
+    def delete_allowed(service)
+     sql = %Q{DELETE FROM access #{where(service)}}
+     RunLoop::Sqlite.exec(db, sql)
+    end
+
+    # @!visibility private
+    def service_name(key)
+      PRIVACY_SERVICES[key] || key
+    end
+
+    # @!visibility private
+    def client
+      bundle_id
+    end
+
+    # @!visibility private
+    def db
+      device.simulator_tcc_db
+    end
+
+    # @!visibility private
+    def self.tcc(device, bundle_id)
+      RunLoop::TCC.new(device, bundle_id)
+    end
+
+    # @!visibility private
+    def self.ensure_device(device)
+      if device.is_a?(RunLoop::Device)
+        simulator = device
+      else
+        simulator = RunLoop::Device.device_with_identifier(device)
+      end
+
+      if simulator.physical_device?
+        raise ArgumentError,
+          "Cannot manage Privacy Settings on physical devices"
+      end
+
+      simulator
+    end
+  end
+end
+

data/lib/run_loop/template.rb

@@ -0,0 +1,61 @@
+require 'erb'
+
+module RunLoop
+
+  # @!visibility private
+  # Class to break up javascript templates in to reusable chunks
+  class UIAScriptTemplate < ERB
+
+    # @!visibility private
+    def initialize(template_root, template_relative_path)
+      @template_root = template_root
+      template_path = File.join(@template_root, template_relative_path)
+      @template = File.read(template_path).force_encoding("utf-8")
+      super(@template)
+    end
+
+    # @!visibility private
+    def render_template(template_relative_path)
+      UIAScriptTemplate.new(@template_root, template_relative_path).result
+    end
+
+    # @!visibility private
+    def result
+      super(binding)
+    end
+
+    # @!visibility private
+    def self.sub_path_var!(javascript, results_dir)
+      self.substitute_variable!(javascript, "PATH", results_dir)
+    end
+
+    # @!visibility private
+    def self.sub_read_script_path_var!(javascript, read_cmd_sh)
+      self.substitute_variable!(javascript, "READ_SCRIPT_PATH", read_cmd_sh)
+    end
+
+    # @!visibility private
+    def self.sub_timeout_script_path_var!(javascript, timeout_sh)
+      self.substitute_variable!(javascript, "TIMEOUT_SCRIPT_PATH", timeout_sh)
+    end
+
+    # @!visibility private
+    def self.sub_flush_uia_logs_var!(javascript, value)
+      self.substitute_variable!(javascript, "FLUSH_LOGS", value)
+    end
+
+    # @!visibility private
+    #
+    # Legacy and XTC - related to :no_flush which is a deprecated option.
+    #
+    # Replaced with :flush_uia_logs
+    def self.sub_mode_var!(javascript, value)
+      self.substitute_variable!(javascript, "MODE", value)
+    end
+
+    # @!visibility private
+    def self.substitute_variable!(javascript, variable, value)
+      javascript.gsub!(/\$#{variable}/, value)
+    end
+  end
+end