run_loop 2.1.2 → 2.1.3

data/lib/run_loop/device_agent/xcodebuild.rb

@@ -0,0 +1,91 @@
+
+module RunLoop
+
+  # @!visibility private
+  module DeviceAgent
+
+    # @!visibility private
+    class Xcodebuild < RunLoop::DeviceAgent::Launcher
+
+      # @!visibility private
+      def self.log_file
+        path = File.join(Xcodebuild.dot_dir, "xcodebuild.log")
+        FileUtils.touch(path) if !File.exist?(path)
+        path
+      end
+
+      # @!visibility private
+      def to_s
+        "#<Xcodebuild #{workspace}>"
+      end
+
+      # @!visibility private
+      def inspect
+        to_s
+      end
+
+      # @!visibility private
+      def launch
+        workspace
+
+        if device.simulator?
+          # quits the simulator
+          sim = CoreSimulator.new(device, "")
+          sim.launch_simulator
+        end
+
+        start = Time.now
+        RunLoop.log_debug("Waiting for CBX-Runner to build...")
+        pid = xcodebuild
+        RunLoop.log_debug("Took #{Time.now - start} seconds to build and launch CBX-Runner")
+        pid
+      end
+
+      # @!visibility private
+      def workspace
+        @workspace ||= lambda do
+          path = RunLoop::Environment.send(:cbxws)
+          if path
+            path
+          else
+            raise "The CBXWS env var is undefined. Are you a maintainer?"
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def xcodebuild
+        env = {
+          "COMMAND_LINE_BUILD" => "1"
+        }
+
+        args = [
+          "xcrun",
+          "xcodebuild",
+          "-scheme", "CBXAppStub",
+          "-workspace", workspace,
+          "-config", "Debug",
+          "-destination",
+          "id=#{device.udid}",
+          "clean",
+          "test"
+        ]
+
+        log_file = Xcodebuild.log_file
+
+        options = {
+          :out => log_file,
+          :err => log_file
+        }
+
+        command = "#{env.map.each { |k, v| "#{k}=#{v}" }.join(" ")} #{args.join(" ")}"
+        RunLoop.log_unix_cmd("#{command} >& #{log_file}")
+
+        pid = Process.spawn(env, *args, options)
+        Process.detach(pid)
+        pid.to_i
+      end
+    end
+  end
+end
+

data/lib/run_loop/device_agent/xctestctl.rb

@@ -0,0 +1,109 @@
+
+module RunLoop
+  # @!visibility private
+  module DeviceAgent
+    # @!visibility private
+    #
+    # A wrapper around the test-control binary.
+    class XCTestctl < RunLoop::DeviceAgent::Launcher
+
+      # @!visibility private
+      @@xctestctl = nil
+
+      # @!visibility private
+      def self.device_agent_dir
+        @@device_agent_dir ||= File.expand_path(File.dirname(__FILE__))
+      end
+
+      # @!visibility private
+      def self.xctestctl
+        @@xctestctl ||= lambda do
+          from_env = RunLoop::Environment.xctestctl
+          if from_env
+            if File.exist?(from_env)
+              RunLoop.log_debug("Using XCTESTCTL=#{from_env}")
+              from_env
+            else
+              raise RuntimeError, %Q[
+XCTESTCTL environment variable defined:
+
+#{from_env}
+
+but binary does not exist at that path.
+            ]
+            end
+
+          else
+            File.join(self.device_agent_dir, "bin", "xctestctl")
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def to_s
+        "#<Testctl: #{XCTestctl.xctestctl}>"
+      end
+
+      # @!visibility private
+      def inspect
+        to_s
+      end
+
+      # @!visibility private
+      def runner
+        @runner ||= RunLoop::DeviceAgent::CBXRunner.new(device)
+      end
+
+      # @!visibility private
+      def self.log_file
+        path = File.join(Launcher.dot_dir, "xctestctl.log")
+        FileUtils.touch(path) if !File.exist?(path)
+        path
+      end
+
+      # @!visibility private
+      def launch
+        RunLoop::DeviceAgent::Frameworks.instance.install
+
+        if device.simulator?
+          cbxapp = RunLoop::App.new(runner.runner)
+
+          # quits the simulator
+          sim = CoreSimulator.new(device, cbxapp)
+          sim.install
+        end
+
+        cmd = RunLoop::DeviceAgent::XCTestctl.xctestctl
+
+        args = ["-r", runner.runner,
+                "-t", runner.tester,
+                "-d", device.udid]
+
+        if device.physical_device?
+          args << "-c"
+          args << RunLoop::Environment.codesign_identity
+        end
+
+        log_file = XCTestctl.log_file
+        FileUtils.rm_rf(log_file)
+        FileUtils.touch(log_file)
+
+        options = {:out => log_file, :err => log_file}
+        RunLoop.log_unix_cmd("#{cmd} #{args.join(" ")} >& #{log_file}")
+
+        # Gotta keep the xctestctl process alive or the connection
+        # to testmanagerd will fail.
+        pid = Process.spawn(cmd, *args, options)
+        Process.detach(pid)
+
+        if device.simulator?
+          device.simulator_wait_for_stable_state
+        end
+
+        pid.to_i
+      end
+    end
+  end
+end
+
+

data/lib/run_loop/dylib_injector.rb

@@ -11,10 +11,19 @@ module RunLoop
     #
     # Try 3 times for 10 seconds each try with a sleep of 2 seconds
     # between tries.
+    #
+    # You can override these values if they do not work in your environment.
+    #
+    # For cucumber users, the best place to override would be in your
+    # features/support/env.rb.
+    #
+    # For example:
+    #
+    # RunLoop::DylibInjector::RETRY_OPTIONS[:timeout] = 60
     RETRY_OPTIONS = {
       :tries => 3,
       :interval => 2,
-      :timeout => 10
+      :timeout => RunLoop::Environment.ci? ? 40 : 20
     }
 
     # @!attribute [r] process_name

data/lib/run_loop/environment.rb

@@ -162,6 +162,72 @@ module RunLoop
       end
     end
 
+    # Returns the value of CODESIGN_IDENTITY
+    def self.codesign_identity
+      value = ENV["CODESIGN_IDENTITY"]
+      if !value || value == ""
+        nil
+      else
+        value
+      end
+    end
+
+    # Returns the value of KEYCHAIN
+    #
+    # Use this to specify a non-default KEYCHAIN for code signing.
+    #
+    # The default KEYCHAIN is login.keychain.
+    def self.keychain
+      value = ENV["KEYCHAIN"]
+      if !value || value == ""
+        nil
+      else
+        value
+      end
+    end
+
+    # Returns the value of XCTESTCTL
+    #
+    # Use this to specify a non-default xctestctl binary.
+    #
+    # The default xctestctl binary is bundled with this gem.
+    def self.xctestctl
+      value = ENV["XCTESTCTL"]
+      if !value || value == ""
+        nil
+      else
+        value
+      end
+    end
+
+    # Returns the value of CBXDEVICE
+    #
+    # Use this to specify a non-default CBX-Runner for physical devices.
+    #
+    # The default CBX-Runner is bundled with this gem.
+    def self.cbxdevice
+      value = ENV["CBXDEVICE"]
+      if !value || value == ""
+        nil
+      else
+        value
+      end
+    end
+
+    # Returns the value of CBXSIM
+    #
+    # Use this to specify a non-default CBX-Runner for simulators.
+    #
+    # The default CBX-Runner is bundled with this gem.
+    def self.cbxsim
+      value = ENV["CBXSIM"]
+      if !value || value == ""
+        nil
+      else
+        value
+      end
+    end
+
     # Returns true if running in Jenkins CI
     #
     # Checks the value of JENKINS_HOME

data/lib/run_loop/host_cache.rb

@@ -24,11 +24,16 @@ module RunLoop
     # @return [String] Expanded path to the default cache directory.
     # @raise [RuntimeError] When the ~/.run_loop exists, but is not a directory.
     def self.default_directory
-      run_loop_dir = File.expand_path('~/.run-loop')
+      run_loop_dir = File.join(RunLoop::Environment.user_home_directory, ".run-loop")
       if !File.exist?(run_loop_dir)
         FileUtils.mkdir(run_loop_dir)
       elsif !File.directory?(run_loop_dir)
-        raise "Expected '#{run_loop_dir}' to be a directory.\nRunLoop requires this directory to cache files."
+        raise %Q[
+Expected ~/.run_loop to be a directory.
+
+RunLoop requires this directory to cache files
+]
+
       end
       run_loop_dir
     end

data/lib/run_loop/physical_device/{ideviceinstaller.rb → life_cycle.rb}

@@ -2,8 +2,54 @@ module RunLoop
   # @!visibility private
   module PhysicalDevice
 
+    # Raised when installation fails.
+    class InstallError < RuntimeError; end
+
+    # Raised when uninstall fails.
+    class UninstallError < RuntimeError; end
+
+    # Raised when tool cannot perform task.
+    class NotImplementedError < StandardError; end
+
+    # Controls the behavior of various life cycle commands.
+    #
+    # You can override these values if they do not work in your environment.
+    #
+    # For cucumber users, the best place to override would be in your
+    # features/support/env.rb.
+    #
+    # For example:
+    #
+    # RunLoop::PhysicalDevice::LifeCycle::DEFAULT_OPTIONS[:timeout] = 60
+    DEFAULT_OPTIONS = {
+      :install_timeout => RunLoop::Environment.ci? ? 120 : 30
+    }
+
     # @!visibility private
-    class IDeviceInstaller < LifeCycle
+    class LifeCycle
+
+      require "run_loop/abstract"
+      include RunLoop::Abstract
+
+      require "run_loop/shell"
+      include RunLoop::Shell
+
+      attr_reader :device
+
+      # Create a new instance.
+      #
+      # @param [RunLoop::Device] device A physical device.
+      # @raise [ArgumentError] If device is a simulator.
+      def initialize(device)
+        if !device.physical_device?
+          raise ArgumentError, %Q[Device:
+
+#{device}
+
+must be a physical device.]
+        end
+        @device = device
+      end
 
       # Is the tool installed?
       def self.tool_is_installed?
@@ -19,6 +65,7 @@ module RunLoop
 
       # Is the app installed?
       #
+      # @param [String] bundle_id The CFBundleIdentifier of an app.
       # @return [Boolean] true or false
       def app_installed?(bundle_id)
         abstract_method!
@@ -30,14 +77,19 @@ module RunLoop
       # no version check is performed.
       #
       # App data is never preserved.  If you want to preserve the app data,
-      # call `ensure_app_installed`.
+      # call `ensure_newest_installed`.
       #
       # Possible return values:
       #
       # * :reinstalled => app was installed, but app data was not preserved.
       # * :installed => app was not installed.
       #
+      # @param [RunLoop::Ipa, RunLoop::App] app_or_ipa The ipa to install.
+      #   The caller is responsible for validating the ipa for the device by
+      #   checking that the codesign and instruction set is correct.
+      #
       # @raise [InstallError] If app was not installed.
+      #
       # @return [Symbol] A keyword describing the action that was performed.
       def install_app(app_or_ipa)
         abstract_method!
@@ -47,15 +99,18 @@ module RunLoop
       #
       # App data is never preserved.  If you want to install a new version of
       # an app and preserve app data (upgrade testing), call
-      # `ensure_app_installed`.
+      # `ensure_newest_installed`.
       #
       # Possible return values:
       #
       # * :nothing => app was not installed
       # * :uninstall => app was uninstalled
       #
+      # @param [String] bundle_id The CFBundleIdentifier of an app.
+      #
       # @raise [UninstallError] If the app cannot be uninstalled, usually
       #   because it is a system app.
+      #
       # @return [Symbol] A keyword that describes what action was performed.
       def uninstall_app(bundle_id)
         abstract_method!
@@ -80,11 +135,15 @@ module RunLoop
       #                   but app data was not preserved.
       # * :installed => app was not installed.
       #
+      # @param [RunLoop::Ipa, RunLoop::App] app_or_ipa The ipa to install.
+      #   The caller is responsible for validating the ipa for the device by
+      #   checking that the codesign and instruction set is correct.
+      #
       # @raise [InstallError] If the app could not be installed.
       # @raise [UninstallError] If the app could not be uninstalled.
       #
       # @return [Symbol] A keyword that describes the action that was taken.
-      def ensure_app_installed(app_or_ipa)
+      def ensure_newest_installed(app_or_ipa)
         abstract_method!
       end
 
@@ -94,18 +153,33 @@ module RunLoop
       # the CFBundleShortVersionString. If either are different, then this
       # method returns false.
       #
+      # @param [RunLoop::Ipa, RunLoop::App] app_or_ipa The ipa to install.
+      #   The caller is responsible for validating the ipa for the device by
+      #   checking that the codesign and instruction set is correct.
+      #
       # @raise [RuntimeError] If app is not already installed.
       def installed_app_same_as?(app_or_ipa)
         abstract_method!
       end
 
+      # Returns true if this tool can reset an app's sandbox without
+      # uninstalling the app.
+      def can_reset_app_sandbox?
+        abstract_method!
+      end
+
       # Clear the app sandbox.
       #
       # This method will never uninstall the app.  If the concrete
       # implementation cannot reset the app data, this method should raise
-      # an exception.
+      # a RunLoop::PhysicalDevice::NotImplementedError
       #
       # Does not clear Keychain.  Use the Calabash iOS Keychain API.
+      #
+      # @param [String] bundle_id The CFBundleIdentifier of an app.
+      #
+      # @raise [RunLoop::PhysicalDevice::NotImplementedError] If this tool
+      #   cannot reset the app sandbox without unintalling the app.
       def reset_app_sandbox(bundle_id)
         abstract_method!
       end
@@ -141,48 +215,21 @@ module RunLoop
       #
       # * sandbox/Documents
       # * sandbox/Library
-      # * sandbox/Preferences
+      # * sandbox/Library/Preferences
       # * sandbox/tmp
       #
-      # The data is a hash of arrays that define source/target file
-      # path pairs.
-      #
-      #  {
-      #    :documents => [
-      #      {
-      #        :source => "path/to/file/on/disk",
-      #        :target => "sub/dir/under/Documents"
-      #      },
-      #      {
-      #        :source => "path/to/other/file",
-      #        :target => "./"
-      #      }
-      #    ],
-      #
-      #    :library => [ < ditto >],
-      #    :preferences => [ < ditto > ],
-      #    :tmp => [ < ditto >]
-      #  }
-      #
-      # * If a file exists at a target path, it will be replaced.
-      # * Subdirectories will be created as necessary.
-      # * :source files must exist.
+      # Behavior TBD.
       def sideload(data)
-        abstract_method!
+        raise NotImplementedError,
+          "The behavior of the sideload method has not been determined"
       end
 
       # Removes a file or directory from the app sandbox.
       #
-      # If the path does not exist, no error will be raised.
-      #
-      # Documents, Library, Preferences, and tmp directories will be
-      # deleted, but then recreated.  For example:
-      #
-      #  remove_file_from_sandbox("Preferences")
-      #
-      # The Preferences directory will be deleted and then recreated.
+      # Behavior TBD.
       def remove_from_sandbox(path)
-        abstract_method!
+        raise NotImplementedError,
+          "The behavior of the remove_from_sandbox method has not been determined"
       end
 
       # @!visibility private