run_loop_tcc 2.1.3

data/lib/run_loop/device_agent/cbxrunner.rb

@@ -0,0 +1,156 @@
+
+module RunLoop
+  # @!visibility private
+  module DeviceAgent
+    # @!visibility private
+    class CBXRunner
+
+
+      # @!visibility private
+      @@cbxdevice = nil
+
+      # @!visibility private
+      @@cbxsim = nil
+
+      # @!visibility private
+      def self.device_agent_dir
+        @@device_agent_dir ||= File.expand_path(File.dirname(__FILE__))
+      end
+
+      # @!visibility private
+      def self.detect_cbxsim
+        @@cbxsim ||= lambda do
+          from_env = RunLoop::Environment.cbxsim
+
+          if from_env
+            if File.exist?(from_env)
+              from_env
+            else
+              raise RuntimeError, %Q[
+CBXSIM environment variable defined:
+
+  #{from_env}
+
+but runner does not exist at that path.
+]
+            end
+          else
+            self.default_cbxsim
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def self.detect_cbxdevice
+        @@cbxdevice ||= lambda do
+          from_env = RunLoop::Environment.cbxdevice
+
+          if from_env
+            if File.exist?(from_env)
+              from_env
+            else
+              raise RuntimeError, %Q[
+CBXDEVICE environment variable defined:
+
+  #{from_env}
+
+but runner does not exist at that path.
+]
+            end
+          else
+            self.default_cbxdevice
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def self.default_cbxdevice
+        cbx = File.join(self.device_agent_dir, "ipa", "CBX-Runner.app")
+
+        if !File.exist?(cbx)
+          self.expand_runner_archive("#{cbx}.zip")
+        else
+          cbx
+        end
+      end
+
+      # @!visibility private
+      def self.default_cbxsim
+        cbx = File.join(self.device_agent_dir, "app", "CBX-Runner.app")
+
+        if !File.exist?(cbx)
+          self.expand_runner_archive("#{cbx}.zip")
+        else
+          cbx
+        end
+      end
+
+      # @!visibility private
+      # TODO move this behavior to shell.rb - should be able to call Shell.run_unix_command
+      def self.expand_runner_archive(archive)
+        shell = Class.new do
+          require "run_loop/shell"
+          include RunLoop::Shell
+          def to_s; "#<CBXRunner Shell>"; end
+          def inspect; to_s; end
+        end.new
+
+        dir = File.dirname(archive)
+        options = { :log_cmd => true }
+        Dir.chdir(dir) do
+          RunLoop.log_unix_cmd("cd #{dir}")
+          shell.run_unix_command(["unzip", File.basename(archive)], options)
+        end
+        File.join(dir, "CBX-Runner.app")
+      end
+
+      # @!visibility private
+      attr_reader :device
+
+      # @!visibility private
+      # @param [RunLoop::Device] device the target device
+      def initialize(device)
+        @device = device
+      end
+
+      # @!visibility private
+      def runner
+        @runner ||= lambda do
+          if device.physical_device?
+            RunLoop::DeviceAgent::CBXRunner.detect_cbxdevice
+          else
+            RunLoop::DeviceAgent::CBXRunner.detect_cbxsim
+          end
+        end.call
+      end
+
+      # @!visibility private
+      def tester
+        @tester ||= File.join(runner, "PlugIns", "CBX.xctest")
+      end
+
+      # @!visibility private
+      def version
+        @version ||= lambda do
+          short = pbuddy.plist_read("CFBundleShortVersionString", info_plist)
+          build = pbuddy.plist_read("CFBundleVersion", info_plist)
+          str = "#{short}.pre#{build}"
+          RunLoop::Version.new(str)
+        end.call
+      end
+
+      private
+
+      # @!visibility private
+      def info_plist
+        @info_plist ||= File.join(runner, "PlugIns", "CBX.xctest", "Info.plist")
+      end
+
+      # @!visibility private
+      def pbuddy
+        @pbuddy ||= RunLoop::PlistBuddy.new
+      end
+    end
+  end
+end
+

data/lib/run_loop/device_agent/frameworks.rb

@@ -0,0 +1,65 @@
+
+module RunLoop
+  # @!visibility private
+  module DeviceAgent
+    # @!visibility private
+    class Frameworks
+      require "singleton"
+      include Singleton
+
+      # @!visibility private
+      def install
+        if File.exist?(frameworks)
+          RunLoop.log_debug("#{frameworks} already exists; skipping install")
+          return true
+        end
+
+        RunLoop.log_debug("Installing Frameworks to #{target}")
+
+        options = { :log_cmd => true }
+
+        Dir.chdir(rootdir) do
+          RunLoop.log_unix_cmd("cd #{rootdir}")
+          shell.run_shell_command(["unzip", File.basename(zip)], options)
+        end
+
+        shell.run_shell_command(["cp", "-r", "#{frameworks}/*.framework", target], options)
+        shell.run_shell_command(["cp", "#{frameworks}/*LICENSE", target], options)
+        RunLoop.log_debug("Installed frameworks to #{target}")
+      end
+
+      private
+
+      # @!visibility private
+      # TODO replace with include Shell
+      def shell
+        require "run_loop/shell"
+        Class.new do
+          include RunLoop::Shell
+          def to_s; "#<Frameworks Shell>"; end
+          def inspect; to_s; end
+        end.new
+      end
+
+      # @!visibility private
+      def target
+        @target ||= File.join(RunLoop::DotDir.directory, "Frameworks")
+      end
+
+      # @!visibility private
+      def frameworks
+        @frameworks ||= File.join(rootdir, "Frameworks")
+      end
+
+      # @!visibility private
+      def zip
+        @zip ||= File.join(rootdir, "Frameworks.zip")
+      end
+
+      # @!visibility private
+      def rootdir
+        @rootdir ||= File.expand_path(File.join(File.dirname(__FILE__), "frameworks"))
+      end
+    end
+  end
+end

data/lib/run_loop/device_agent/launcher.rb

@@ -0,0 +1,51 @@
+
+module RunLoop
+  # @!visibility private
+  module DeviceAgent
+    # @!visibility private
+    #
+    # An abstract base class for something that can launch the CBXRunner on a
+    # device.  The CBXRunner is AKA the DeviceAgent.
+    class Launcher
+      require "run_loop/abstract"
+      include RunLoop::Abstract
+
+      # @!visibility private
+      attr_reader :device
+
+      # @!visibility private
+      # @param [RunLoop::Device] device where to launch the CBX-Runner
+      def initialize(device)
+        @device = device
+
+        if device.version < RunLoop::Version.new("9.0")
+          raise ArgumentError, %Q[
+Invalid device:
+
+#{device}
+
+XCUITest is only available for iOS >= 9.0
+]
+        end
+      end
+
+      # @!visibility private
+      #
+      # Does whatever it takes to launch the CBX-Runner on the device.
+      def launch
+        abstract_method!
+      end
+
+      # @!visibility private
+      def self.dot_dir
+        path = File.join(RunLoop::DotDir.directory, "xcuitest")
+
+        if !File.exist?(path)
+          FileUtils.mkdir_p(path)
+        end
+
+        path
+      end
+    end
+  end
+end

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/directory.rb

@@ -0,0 +1,179 @@
+module RunLoop
+
+  # Class for performing operations on directories.
+  class Directory
+    require 'digest'
+    require 'openssl'
+    require 'pathname'
+
+    # Dir.glob ignores files that start with '.', but we often need to find
+    # dotted files and directories.
+    #
+    # Ruby 2.* does the right thing by ignoring '..' and '.'.
+    #
+    # Ruby < 2.0 includes '..' and '.' in results which causes problems for some
+    # of run-loop's internal methods.  In particular `reset_app_sandbox`.
+    def self.recursive_glob_for_entries(base_dir)
+      Dir.glob("#{base_dir}/{**/.*,**/*}").select do |entry|
+        !(entry.end_with?('..') || entry.end_with?('.'))
+      end
+    end
+
+    # Computes the digest of directory.
+    #
+    # @param path A path to a directory.
+    # @param options Control the behavior of the method.
+    # @option options :handle_errors_by (:raising) Controls what to do when
+    #   File.read causes an error.  The default behavior is to raise.  Other
+    #   options are: :logging and :ignoring.  Logging will only happen if
+    #   running in debug mode.
+    #
+    # @raise ArgumentError When `path` is not a directory or path does not exist.
+    # @raise ArgumentError When options[:handle_errors_by] has n unsupported value.
+    def self.directory_digest(path, options={})
+      default_options = {
+        :handle_errors_by => :raising
+      }
+
+      merged_options = default_options.merge(options)
+      handle_errors_by = merged_options[:handle_errors_by]
+      unless [:raising, :logging, :ignoring].include?(handle_errors_by)
+        raise ArgumentError,
+%Q{Expected :handle_errors_by to be :raising, :logging, or :ignoring;
+found '#{handle_errors_by}'
+}
+      end
+
+      unless File.exist?(path)
+        raise ArgumentError, "Expected '#{path}' to exist"
+      end
+
+      unless File.directory?(path)
+        raise ArgumentError, "Expected '#{path}' to be a directory"
+      end
+
+      entries = self.recursive_glob_for_entries(path)
+
+      if entries.empty?
+        raise ArgumentError, "Expected a non-empty dir at '#{path}' found '#{entries}'"
+      end
+
+      debug = RunLoop::Environment.debug?
+
+      sha = OpenSSL::Digest::SHA256.new
+      entries.each do |file|
+        unless self.skip_file?(file, 'SHA1', debug)
+          begin
+            sha << File.read(file)
+          rescue => e
+            case handle_errors_by
+            when :logging
+              message =
+%Q{RunLoop::Directory.directory_digest raised an error:
+
+         #{e}
+
+       while trying to find the SHA of this file:
+
+         #{file}
+
+       This is not a fatal error; it can be ignored.
+}
+              RunLoop.log_debug(message)
+            when :raising
+              raise e.class, e.message
+            when :ignoring
+               # nop
+            else
+               # nop
+            end
+          end
+        end
+      end
+      sha.hexdigest
+    end
+
+    def self.size(path, format)
+
+      allowed_formats = [:bytes, :kb, :mb, :gb]
+      unless allowed_formats.include?(format)
+        raise ArgumentError, "Expected '#{format}' to be one of #{allowed_formats.join(', ')}"
+      end
+
+      unless File.exist?(path)
+        raise ArgumentError, "Expected '#{path}' to exist"
+      end
+
+      unless File.directory?(path)
+        raise ArgumentError, "Expected '#{path}' to be a directory"
+      end
+
+      entries = self.recursive_glob_for_entries(path)
+
+      if entries.empty?
+        raise ArgumentError, "Expected a non-empty dir at '#{path}' found '#{entries}'"
+      end
+
+      size = self.iterate_for_size(entries)
+
+      case format
+        when :bytes
+          size
+        when :kb
+          size/1000.0
+        when :mb
+          size/1000.0/1000.0
+        when :gb
+          size/1000.0/1000.0/1000.0
+        else
+          # Not expected to reach this.
+          size
+      end
+    end
+
+    private
+
+    def self.skip_file?(file, task, debug)
+      skip = false
+      if File.directory?(file)
+        # Skip directories
+        skip = true
+      elsif !Pathname.new(file).exist?
+        # Skip broken symlinks
+        skip = true
+      elsif !File.exist?(file)
+        # Skip files that don't exist
+        skip = true
+      else
+        case File.ftype(file)
+          when 'fifo'
+            RunLoop.log_warn("#{task} IS SKIPPING FIFO #{file}") if debug
+            skip = true
+          when 'socket'
+            RunLoop.log_warn("#{task} IS SKIPPING SOCKET #{file}") if debug
+            skip = true
+          when 'characterSpecial'
+            RunLoop.log_warn("#{task} IS SKIPPING CHAR SPECIAL #{file}") if debug
+            skip = true
+          when 'blockSpecial'
+            skip = true
+            RunLoop.log_warn("#{task} SKIPPING BLOCK SPECIAL #{file}") if debug
+          else
+
+        end
+      end
+      skip
+    end
+
+    def self.iterate_for_size(entries)
+      debug = RunLoop::Environment.debug?
+      size = 0
+      entries.each do |file|
+        unless self.skip_file?(file, "SIZE", debug)
+          size = size + File.size(file)
+        end
+      end
+      size
+    end
+  end
+end