cukunity 0.1.0

data/lib/cukunity/drivers/android/process.rb

@@ -0,0 +1,103 @@
+module Cukunity
+  module Android
+    module Process
+      extend Android::Utils
+      extend Cukunity::Utils
+
+      def self.launch(path, extras = {}, max_time = 30)
+        unless App::installed?(path)
+          App::install(path)
+        end
+        package = package_name(path)
+        activity = launchable_activity_name(path)
+        extras_args = extras.inject([]) do |extras, kvp|
+          key, value = kvp
+          type = 
+            if value.kind_of? String
+              '--es'
+            elsif value.kind_of? Fixnum
+              '--ei'
+            elsif value === true or value === false
+              '--ez'
+            else
+              raise ArgumentError.new("Unsupported type #{value.class} as extra parameter to activity")
+            end
+          extras.push %Q[#{type} "#{key}" "#{value}"]
+        end.join(" ")
+        shell %Q[am start #{extras_args} -n "#{package}/#{activity}" -W]
+        raise Exception::LaunchTimeout.new if max_time > 0 and check_timeout(max_time) do
+          foreground?(path)
+        end
+      end
+
+      def self.running
+        headers = /^\S+\s+(\d+)\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+(\S.*)/
+        shell('ps').scan(headers).inject({}) do |packages, m|
+          packages[m[0].to_i] = m[1].chomp
+          packages
+        end
+      end
+
+      def self.foreground
+        shell('dumpsys activity').match(/TaskRecord\{[^\n\}]+\s+([^\s\}]+)}/) do |m|
+          return m[1]
+        end
+      end
+
+      def self.foreground?(path)
+        fg = foreground
+        if fg
+          fg.downcase  == package_name(path).downcase
+        else
+          false
+        end
+      end
+
+      def self.running?(path)
+        package = package_name(path).downcase
+        running.any? do |pid, p|
+          p.downcase == package 
+        end
+      end
+
+      def self.pids(path)
+        package = package_name(path).downcase
+        running.select do |pid, p|
+          p.downcase == package 
+        end.keys
+      end
+
+      def self.relaunch(path, max_time = 30)
+        unless App::installed?(path)
+          App::install(path)
+        end
+        before_pids = pids(path)
+        unless before_pids.empty?
+          # launch restarter
+          _relaunch(path)
+          raise Exception::LaunchTimeout.new if check_timeout(max_time) do
+            now_pids = pids(path)
+            before_pids.all? do |pid|
+              # old process does not exist?
+              not now_pids.include?(pid)
+            end
+          end
+        end
+        # wait for a new app
+        start = Time.now
+        raise Exception::LaunchTimeout.new if check_timeout(max_time) do
+          foreground?(path)
+        end
+      end
+
+      private
+      def self._relaunch(path)
+        app_killer = File.join(File.expand_path(File.dirname(__FILE__)), 'appkiller', 'bin', 'AppKiller.apk')
+        unless App::installed?(app_killer)
+          App::install(app_killer)
+        end
+        launch(app_killer, {'package' => package_name(path)}, 0)
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/android/touch_input.rb

@@ -0,0 +1,24 @@
+module Cukunity
+  module Android
+    module TouchInput
+      extend Android::Utils
+      extend Cukunity::TouchInputMethods
+
+      def self.touch_screen(options)
+        options = merge_options(options, { :x => 0, :y => 0, :type => :tap })
+        wait = (options.delete(:wait) || 0.1).to_f
+        options[:x] = options[:x].to_i
+        options[:y] = options[:y].to_i
+        prefix = 
+          if options[:type] == :tap
+            "tap"
+          else
+            "touch #{type}"
+          end
+        req = %Q[#{prefix} #{options[:x]} #{options[:y]}]
+        monkey.command(req)
+        sleep(wait) unless wait.nil? or wait <= 0
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/android/tunnel_client_methods.rb

@@ -0,0 +1,22 @@
+module Cukunity
+  module Android
+    module TunnelClientMethods
+      include Cukunity::Android::Utils
+
+      def open_tunnel(lport, rport)
+        return @tunnel if @tunnel == [lport, rport]
+        # create tunnel to device
+        output, status = adb ['forward', "tcp:#{lport.to_i}", "tcp:#{rport.to_i}"]
+        unless status.exited? and status.exitstatus == 0
+          raise Exception::TunnelError.new
+        end
+        @tunnel = [lport, rport]
+      end
+
+      def close_tunnel
+        # FIXME: remove tunnel
+        @tunnel = nil
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/android/unity_client.rb

@@ -0,0 +1,27 @@
+module Cukunity
+  module Android
+    module Unity
+      class Client
+        include Cukunity::Android::TunnelClientMethods
+        include Cukunity::Unity::ClientMethods
+        alias_method :client_connect_original, :connect
+        alias_method :client_close_original, :close
+
+        def platform
+          Cukunity::Android
+        end
+
+        def close
+          client_close_original
+          close_tunnel
+        end
+
+        private
+        def connect(host = DEFAULT_HOSTNAME, port = DEFAULT_PORT)
+          open_tunnel(port + 1, port)
+          client_connect_original(host, port + 1)
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/android/utils.rb

@@ -0,0 +1,50 @@
+module Cukunity
+  module Android
+    module Utils
+      include Cukunity::Utils
+
+      def monkey
+        Android::MonkeyClient.instance
+      end
+
+      def shell(cmd_line)
+        `adb -d shell #{cmd_line}`
+      end
+
+      def adb(cmd, options = {})
+        options = merge_options(options, { :wait => true })
+        cmd_line = ['adb', '-d'] + cmd + [:err => [:child, :out]]
+        return IO.popen(cmd_line) if !options[:wait]
+        output = IO.popen(cmd_line) do |io|
+          if block_given?
+            yield io
+          else
+            io.readlines
+          end
+        end
+        [output, $?]
+      end
+
+      def launchable_activity_name(path)
+        return path unless File.exists?(path)
+        dump_badging(path).match(/launchable-activity:.*name='(.[^']+)'/) do |m|
+          return m[1]
+        end
+        raise Exception::InvalidApp.new(path)
+      end
+
+      def package_name(path)
+        return path unless File.exists?(path)
+        dump_badging(path).match(/package:.*name='(.[^']+)'/) do |m|
+          return m[1]
+        end
+        throw InvalidApp.new(path)
+      end
+
+      private
+      def dump_badging(path)
+        `aapt dump badging "#{path}"`
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/android.rb

@@ -0,0 +1,9 @@
+require 'cukunity/drivers/android/utils'
+require 'cukunity/drivers/android/tunnel_client_methods'
+require 'cukunity/drivers/android/monkey_client'
+require 'cukunity/drivers/android/app'
+require 'cukunity/drivers/android/process'
+require 'cukunity/drivers/android/touch_input'
+require 'cukunity/drivers/android/keycodes'
+require 'cukunity/drivers/android/keyboard_input'
+require 'cukunity/drivers/android/unity_client'

data/lib/cukunity/drivers/iOS/app.rb

@@ -0,0 +1,32 @@
+module Cukunity
+  module IOS 
+    module App
+      extend IOS::Utils
+      extend Cukunity::Utils
+
+      def self.install(path, options = {})
+        options = merge_options(options, { :max_time => 30 })
+        output = mobile_device_cmd(['install_app', path], options).first.chomp
+        raise Exception::InstallFailed.new unless output == 'OK'
+      end
+
+      def self.uninstall(path, options = {})
+        options = merge_options(options, { :max_time => 30 })
+        bundle_id = bundle_identifier(path)
+        output = mobile_device_cmd(['uninstall_app', bundle_id], options).first.chomp
+        raise Exception::UninstallFailed.new unless output == 'OK'
+      end
+
+      def self.installed
+        mobile_device_cmd(['list_installed_apps']).map do |bundle_id|
+          bundle_id.chomp
+        end
+      end
+
+      def self.installed?(path)
+        bundle_id = bundle_identifier(path)
+        installed.include?(bundle_id)
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS/keyboard_input.rb

@@ -0,0 +1,104 @@
+module Cukunity
+  module IOS
+    module KeyboardInput
+      extend IOS::Utils
+      extend Cukunity::KeyboardInputMethods
+
+      def self.typed_text(options = {})
+        res = keyboard_command(options) do
+          'typedText'
+        end
+        res['text']
+      end
+
+      def self.type_text(text, options = {})
+        keyboard_command(options) do
+          ['typeText', { 'text' => text.to_s }]
+        end
+      end
+
+      def self.clear_text(options = {})
+        keyboard_command(options) do
+          'clearText'
+        end
+      end
+
+      def self.press_key(code, options = {})
+        keyboard_command(options) do
+          ['tapKeyboardKey', { 'key' => code }]
+        end
+      end
+
+      def self.press_button(code, options = {})
+        keyboard_command(options) do
+          ['tapKeyboardButton', { 'button' => code }]
+        end
+      end
+
+      def self.press_toolbar_button(code, options = {})
+        keyboard_command(options) do
+          ['tapKeyboardToolbarButton', { 'button' => code }]
+        end
+      end
+
+      def self.keyboard_buttons(options = {})
+        keyboard_command(options) do
+          'keyboardButtons'
+        end
+      end
+
+      def self.keyboard_keys(options = {})
+        keyboard_command(options) do
+          'keyboardKeys'
+        end
+      end
+
+      def self.press_done(options = {})
+        press_toolbar_button('Done', options)
+      end
+
+      def self.press_back(options = {})
+        press_done(options)
+      end
+
+      def self.press_enter(options = {})
+        press_button('return', options)
+      end
+
+      def self.press_space(options = {})
+        press_key('space', options)
+      end
+
+      def self.press_delete(options = {})
+        press_button('Delete', options)
+      end
+
+      private
+      def self.closed?(options = {})
+        res = keyboard_command(options) do
+          'isKeyboardAvailable'
+        end
+        res['available'] != true
+      end
+
+      def self.platform_open_keyboard(options = {})
+        raise Exception::KeyboardWaitTimeout.new if check_timeout(10) do
+          !closed?(options)
+        end
+        if options[:clear]
+          clear_text
+        end
+      end
+
+      def self.platform_keyboard_command(options, *cmd)
+        uiautomation_cmd(*cmd)
+      end
+
+      def self.toolbar_buttons(options = {})
+        keyboard_command(options) do
+          'keyboardToolbarButtons'
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS/process.rb

@@ -0,0 +1,42 @@
+require 'tmpdir'
+
+module Cukunity
+  module IOS
+    module Process
+      extend IOS::Utils
+      extend Cukunity::Utils
+
+      def self.launch(path, max_time = 30)
+        unless App::installed?(path)
+          App::install(path)
+        end
+        pipe = Cukunity::IOS::UIAutomation.instance.popen(bundle_identifier(path))
+        raise Exception::LaunchTimeout.new if max_time > 0 and check_timeout(max_time) do
+          foreground?(path)
+        end
+      end
+
+      def self.foreground?(path)
+        running?(path)
+      end
+
+      def self.running?(path)
+        path_bundle_id = bundle_identifier(path)
+        begin
+          # it should be already running and polling
+          res = uiautomation_cmd('bundleIdentifier', :max_time => 3)
+          res['bundleIdentifier'] == path_bundle_id
+        rescue Exception::UIAutomationSlaveTimeout
+          false
+        end
+      end
+
+      def self.relaunch(path, max_time = 30)
+        Cukunity::IOS::Unity::Client.instance.close
+        Cukunity::IOS::UIAutomationMaster.instance.close
+        Cukunity::IOS::UIAutomation.instance.close
+        launch(path, max_time)
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS/touch_input.rb

@@ -0,0 +1,18 @@
+module Cukunity
+  module IOS
+    module TouchInput
+      extend IOS::Utils
+      extend Cukunity::TouchInputMethods
+
+      def self.touch_screen(options)
+        options = merge_options(options, { :x => 0, :y => 0, :method => 'tap', :tapCount => 1 })
+        wait = (options.delete(:wait) || self.default_tap_delay).to_f
+        # FIXME: screen dimensions
+        options[:x] = options[:x].to_i / 2
+        options[:y] = options[:y].to_i / 2
+        unity_command('touch_screen', restrict_options(options, :x, :y, :method, :tapCount))
+        sleep(wait) unless wait.nil? or wait <= 0
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS/tunnel_client_methods.rb

@@ -0,0 +1,27 @@
+module Cukunity
+  module IOS
+    module TunnelClientMethods
+      include Cukunity::IOS::Utils
+
+      def open_tunnel(lport, rport)
+        return @tunnel if lport == 0 and !@tunnel.nil?
+        # create tunnel to device
+        @mobiledevice_pipe = mobile_device_cmd(['tunnel', lport.to_s, rport.to_s, :err => [:child, :out]], :wait => false)
+        output = @mobiledevice_pipe.readline
+        match = output.match(/^Tunneling from local port (\d+) to device port/)
+        raise Exception::TunnelError.new(output) if match.nil?
+        lport = match[1].to_i
+        @tunnel = [lport, rport]
+      end
+
+      def close_tunnel
+        @tunnel = nil
+        unless @mobiledevice_pipe.nil?
+          ::Process.kill('KILL', @mobiledevice_pipe.pid) rescue ::Exception
+          @mobiledevice_pipe.close rescue ::Exception
+          @mobiledevice_pipe = nil
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS/uiautomation.rb

@@ -0,0 +1,97 @@
+require 'singleton'
+
+module Cukunity
+  module IOS
+    class UIAutomation
+      include Singleton
+      include IOS::Utils
+      include Cukunity::Utils
+
+      def initialize
+        @pipe = nil
+        @tmpdir = []
+        @pipes = []
+      end
+
+      def popen(bundle_id)
+        udid = device_udid
+
+        # create a temp directory for instrument logs and js file
+        tmpdir = File.expand_path(Dir.mktmpdir(['cukunity_', '_uiautomation']))
+        cmd = nil
+        begin
+          # export javascript to folder too
+          slave_js = File.join(tmpdir, 'uiautomation_slave.js')
+          slave_rb = File.join(File.dirname(__FILE__), 'uiautomation_slave.rb')
+          slave_js_opts = {
+            :ruby => File.expand_path(RbConfig.ruby),
+            :slave => slave_rb,
+            :address => UIAutomationMaster.instance.address,
+            :port => UIAutomationMaster.instance.port,
+            :bundle_id => bundle_id
+          }
+
+          generate_slave_js(slave_js, slave_js_opts) 
+
+          # as of Xcode 4.3.2, the Developer folder is now in a different place.
+          templates = ['/Developer/Platforms/iPhoneOS.platform/Developer/Library/Instruments/PlugIns/AutomationInstrument.bundle/Contents/Resources/Automation.tracetemplate', '/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/Library/Instruments/PlugIns/AutomationInstrument.bundle/Contents/Resources/Automation.tracetemplate']
+          template = templates.find do |template|
+            File.file?(template)
+          end
+
+          # build path to command
+          cmd = ['instruments', '-w', udid,
+            '-t', template,
+            bundle_id,
+            '-e', 'UIASCRIPT',
+            slave_js,
+            '-e', 'UIARESULTSPATH', tmpdir,
+            :err => [:child, :out]]
+        rescue => err
+          FileUtils.remove_entry_secure(tmpdir)
+          raise err
+        end
+
+        # remove later
+        @tmpdir << tmpdir
+        # execute UIAutomation instruments
+        Dir.chdir tmpdir do
+          @pipes << IO.popen(cmd)
+        end
+      end
+
+      def close
+        # close all created pipes
+        @pipes.each do |pipe|
+          ::Process.kill('KILL', pipe.pid) rescue ::Exception
+          pipe.close rescue ::Exception
+        end
+        @pipes = []
+        # remove all created temporary dirs
+        @tmpdir.each do |tmpdir|
+          FileUtils.remove_entry_secure(tmpdir, true)
+        end
+        @tmpdir = []
+      end
+
+      private
+      def generate_slave_js(path, interpolations)
+        slave_js = File.join(File.dirname(__FILE__), 'uiautomation_slave.js')
+        # read original js file contents
+        contents = File.open(slave_js) do |f|
+          f.read
+        end
+        # perform necessary interpolations
+        interpolations.each_pair do |key, value|
+          if contents.gsub!("{{#{key}}}", value.to_s).nil?
+            raise "Could not perform replacement"
+          end
+        end
+        # output
+        File.open(path, 'w') do |f|
+          f.write(contents)
+        end
+      end
+    end
+  end
+end