cukunity 0.1.0

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

@@ -0,0 +1,152 @@
+require 'singleton'
+require 'socket'
+require 'json'
+require 'thread'
+
+module Cukunity
+  module IOS
+    class UIAutomationMaster
+      include Singleton
+      include Cukunity::Utils
+
+      DEFAULT_HOSTNAME = '127.0.0.1'
+      DEFAULT_PORT = 9927
+      UIAUTOMATION_SLAVE_DEFAULT_TIMEOUT = 30
+
+      def initialize
+        @server = nil
+        @client = nil
+        @client_mutex = Mutex.new
+        @client_acquired = ConditionVariable.new
+        @client_finished = ConditionVariable.new
+      end
+
+      def command(name, options = {})
+        options = merge_options(options, { :max_time => UIAUTOMATION_SLAVE_DEFAULT_TIMEOUT })
+        max_time = options.delete(:max_time)
+        listen
+        begin
+          client = sync_with_client(max_time)
+          # write command to client
+          req = options.merge({'command' => name})
+          client.puts req.to_json
+          close_client(client)
+          client = nil
+          client = wait_client(max_time)
+          # wait response from client
+          res = JSON.parse(client.readline.chomp)
+          if res.nil? or res.has_key?('error')
+            raise Exception::UIAutomationSlaveInvalidResponse.new(res['error']) 
+          end
+          res
+        rescue Errno::ECONNRESET
+          close_client(client)
+          sleep 0.1
+          retry
+        rescue Errno::EPIPE
+          close_client(client)
+          sleep 0.1
+          retry
+        ensure
+          close_client(client)
+        end
+      end
+
+      def address
+        listen
+        @server.local_address.ip_address
+      end
+
+      def port
+        listen
+        @server.local_address.ip_port
+      end
+
+      def close
+        unless @server.nil?
+          @server.close rescue ::Exception
+          @server = nil
+        end
+        unless @client_mutex.nil?
+          @client_mutex.synchronize do
+            @client_finished.signal
+          end
+        end
+        unless @thread.nil?
+          @thread.join
+          @thread = nil
+        end
+      end
+
+      private
+      def listen
+        return unless @server.nil?
+        # create server
+        @server = TCPServer.new(DEFAULT_HOSTNAME, DEFAULT_PORT)
+        # create a thread for dealing with clients
+        @thread = Thread.start do
+          begin
+            # keep accepting clients
+            loop do
+              break if @server.nil?
+              # new client
+              client = @server.accept
+              @client_mutex.synchronize do
+                @client = client
+                # inform others we got a client.
+                @client_acquired.signal
+                # wait for reply saying we don't need the client anymore
+                @client_finished.wait(@client_mutex)
+              end
+            end
+          rescue Errno::EBADF
+          end
+        end
+      end
+
+      def wait_client(max_time)
+        client = nil
+        @client_mutex.synchronize do
+          if @client.nil?
+            @client_acquired.wait(@client_mutex, max_time)
+          end
+          client = @client
+        end
+        raise Exception::UIAutomationSlaveTimeout.new if client.nil?
+        client
+      end
+
+      def close_client(client)
+        @client_mutex.synchronize do
+          if !client.nil? and client == @client
+            @client = nil
+            client.close rescue ::Exception
+            @client_finished.signal
+          end
+        end
+      end
+
+      def sync_with_client(max_time)
+        # wait for client
+        client = wait_client(max_time)
+        begin
+          # expect client ack
+          JSON.parse(client.readline.chomp).tap do |ack|
+            break unless ack != {}
+            # try to synchronize once again
+            close_client(client)
+            client = nil
+            client = wait_client(max_time)
+            JSON.parse(client.readline.chomp).tap do |ack|
+              raise Exception::UIAutomationSlaveInvalidAck.new if ack != {}
+            end
+          end
+        rescue ::Exception => err
+          client_close(client)
+          raise err
+        end
+        client
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS/uiautomation_slave.js

@@ -0,0 +1,238 @@
+UIAutomationSlave = function(address, port) {
+  this.address = address;
+  this.port = port; 
+
+  this.target = UIATarget.localTarget();
+  this.target.setTimeout(0);
+  this.app = this.target.frontMostApp();
+  this.host = this.target.host();
+
+  this.result = {};
+  this.running = true;
+};
+
+UIAutomationSlave.prototype.exchange = function(timeout) {
+  var ruby, args = [], request;
+
+  // prepare arguments to inform master of the result
+  ruby = "{{ruby}}";
+  args.push("{{slave}}");
+
+  args.push(this.address);
+  args.push(this.port.toString());
+  args.push(JSON.stringify(this.result));
+
+  timeout = timeout || 10;
+
+  // inform master of result and get a new request
+  try {
+    request = this.host.performTaskWithPathArgumentsTimeout(ruby, args, timeout);
+  }
+  catch (e) {
+    // timeout
+    return this.running;
+  };
+
+  switch (request.exitCode) {
+    case 0:
+      try {
+        this.result = this.execute(JSON.parse(request.stdout));
+      }
+      catch (e) {
+        this.result = { "error" : e.message };
+      }
+      break;
+
+    // connection refused
+    case 2:
+      break;
+
+    case 1:
+    default:
+      UIALogger.logError("Could not connect to master: " + request.exitCode);
+      this.result = {};
+      break;
+  }
+  return this.running;
+};
+
+UIAutomationSlave.prototype.keyboard = function() {
+  var keyboard = this.app.keyboard();
+  if ((keyboard) && (keyboard.isValid()) && (keyboard.isVisible())) {
+    return keyboard;
+  }
+  return null;
+};
+
+UIAutomationSlave.prototype.handleKeyboard = function(result, success, error) {
+  var keyboard = this.keyboard();
+  if (keyboard) {
+    return success(keyboard);
+  }
+  result["error"] = "Keyboard currently unavailable";
+  if (error) {
+    return error();
+  }
+};
+
+UIAutomationSlave.prototype.keyboardToolbar = function() {
+  var keyboardToolbar;
+  if (this.keyboard()) {
+    keyboardToolbar = this.app.mainWindow().toolbar();
+    if ((keyboardToolbar) && (keyboardToolbar.isValid()) &&
+        (keyboardToolbar.isVisible())) {
+      return keyboardToolbar;
+    }
+  }
+  return null;
+};
+
+UIAutomationSlave.prototype.handleKeyboardToolbar = function(result, success, error) {
+  var keyboardToolbar = this.keyboardToolbar();
+  if (keyboardToolbar) {
+    return success(keyboardToolbar);
+  }
+  result["error"] = "Toolbar currently unavailable";
+  if (error) {
+    return error();
+  }
+};
+
+UIAutomationSlave.prototype.execute = function(request) {
+  var command = request['command'], result = { 'command': command };
+
+  // delete command from hash, so we can use the hash for passing into functions
+  delete request['command'];
+
+  // execute respective command
+  switch (command) {
+    case 'isKeyboardAvailable':
+      if (this.keyboard()) {
+        result["available"] = true;
+      }
+      else {
+        result["available"] = false;
+      }
+      break;
+
+    case 'typedText':
+      this.handleKeyboardToolbar(result, function(keyboardToolbar) {
+        var textField = keyboardToolbar.textFields().toArray()[0];
+        if ((textField) && (textField.isValid())) {
+          result["text"] = textField.value();
+        }
+        else {
+          result["error"] = "Text field not currently unavailable";
+        }
+      });
+      break;
+
+    case 'clearText':
+      this.handleKeyboardToolbar(result, function(keyboardToolbar) {
+        var textField = keyboardToolbar.textFields().toArray()[0];
+        if ((textField) && (textField.isValid())) {
+          textField.setValue('');
+        }
+        else {
+          result["error"] = "Text field not currently unavailable";
+        }
+      });
+      break;
+
+    case 'typeText':
+      this.handleKeyboard(result, function(keyboard) {
+        keyboard.typeString(request["text"]);
+      });
+      break;
+
+    case 'keyboardButtons':
+      this.handleKeyboard(result, function(keyboard) {
+        var buttons = [], button, _buttons = keyboard.buttons().toArray();
+        for (button in _buttons) {
+          buttons[button] = _buttons[button].name();
+        }
+        result["keyboardButtons"] = buttons;
+      });
+      break;
+
+    case 'tapKeyboardButton':
+      this.handleKeyboard(result, function(keyboard) {
+        var button = keyboard.buttons()[request["button"].toString()];
+        if ((button) && (button.isValid())) {
+          button.tap();
+        }
+        else {
+          result["error"] = "Button currently unavailable";
+        }
+      });
+      break;
+
+    case 'keyboardKeys':
+      this.handleKeyboard(result, function(keyboard) {
+        var key, keys = [], _keys = keyboard.keys().toArray();
+        for (key in _keys) {
+          keys[key] = _keys[key].name();
+        }
+        result["keyboardKeys"] = keys;
+      });
+      break;
+
+    case 'tapKeyboardKey':
+      this.handleKeyboard(result, function(keyboard) {
+        var key = keyboard.keys()[request["key"].toString()];
+        if ((key) && (key.isValid())) {
+          key.tap();
+        }
+        else {
+          result["error"] = "Key currently unavailable";
+        }
+      });
+      break;
+
+    case 'keyboardToolbarButtons':
+      this.handleKeyboardToolbar(result, function(keyboardToolbar) {
+        var buttons = [], button, _buttons = keyboardToolbar.buttons().toArray();
+        for (button in _buttons) {
+          buttons[button] = _buttons[button].name();
+        }
+        result["keyboardToolbarButtons"] = buttons;
+      });
+      break;
+
+    case 'tapKeyboardToolbarButton':
+      this.handleKeyboardToolbar(result, function(keyboardToolbar) {
+        var button = keyboardToolbar.buttons()[request["button"].toString()];
+        if ((button) && (button.isValid())) {
+          button.tap();
+        }
+        else {
+          result["error"] = "Button currently unavailable";
+        }
+      });
+      break;
+
+    case 'bundleIdentifier':
+      result['bundleIdentifier'] = "{{bundle_id}}";
+      break;
+
+    case 'terminate':
+      this.running = false;
+      break;
+
+    default:
+      result["error"] = "Unknown command";
+      break;
+  };
+
+  return result;
+};
+
+(function() {
+  // create automation slave
+  var slave = new UIAutomationSlave("{{address}}", {{port}});
+
+  // execute happily
+  while (slave.exchange()) {
+    // don't need to wait, it's already slow enough...
+  }
+})();

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

@@ -0,0 +1,41 @@
+require 'singleton'
+require 'socket'
+require 'json'
+
+module Cukunity
+  module IOS
+    class UIAutomationSlave
+      def exchange(host, port, result = {})
+        sock = TCPSocket.new(host, port)
+        begin
+          sock.puts result.to_json
+          JSON.parse(sock.gets.chomp)
+        ensure
+          sock.close unless sock.nil?
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  begin
+    # read commands (no error handling)
+    host = ARGV.shift
+    port = ARGV.shift.to_i
+    result = JSON.parse(ARGV.shift)
+    # create client
+    slave = Cukunity::IOS::UIAutomationSlave.new
+    # send result of previous command and wait for new
+    command = slave.exchange(host, port, result).to_json
+    # print out new command
+    puts command
+    exit(0)
+  rescue Errno::ECONNREFUSED => err
+    $stderr.puts "Error: #{err}"
+    exit(2)
+  rescue => err
+    $stderr.puts "Error: #{err}"
+    exit(1)
+  end
+end

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

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

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

@@ -0,0 +1,46 @@
+module Cukunity
+  module IOS
+    module Utils
+      include Cukunity::Utils
+
+      MOBILE_DEVICE_DEFAULT_TIMEOUT = 60
+
+      def unity_command(name, opts = {})
+        Cukunity::IOS::Unity::Client.instance.command(name, opts)
+      end
+
+      def mobile_device_cmd(cmd, options = {})
+        options = merge_options(options, { :wait => true, :max_time => MOBILE_DEVICE_DEFAULT_TIMEOUT })
+        pipe = IO.popen(['mobiledevice'] + cmd)
+        return pipe unless options[:wait]
+        status = nil
+        raise Exception::MobileDeviceTimeout.new(cmd) if check_timeout(options[:max_time]) do
+          if ::Process.waitpid(pipe.pid, ::Process::WNOHANG)
+            status = $?
+            true
+          else
+            false
+          end
+        end
+        output = pipe.readlines
+        pipe.close
+        raise Exception::MobileDeviceError.new(cmd) unless status.exitstatus == 0
+        output
+      end
+
+      def device_udid
+        udid = mobile_device_cmd(['get_udid']).first.chomp
+        raise Exception::MobileDeviceError.new(udid) unless udid.length == 40
+        udid
+      end
+
+      def bundle_identifier(app_folder)
+        mobile_device_cmd(['get_bundle_id', app_folder]).first.chomp
+      end
+
+      def uiautomation_cmd(name, options = {})
+        Cukunity::IOS::UIAutomationMaster.instance.command(name, options)
+      end
+    end
+  end
+end

data/lib/cukunity/drivers/iOS.rb

@@ -0,0 +1,9 @@
+require 'cukunity/drivers/iOS/utils'
+require 'cukunity/drivers/iOS/uiautomation'
+require 'cukunity/drivers/iOS/uiautomation_master'
+require 'cukunity/drivers/iOS/tunnel_client_methods'
+require 'cukunity/drivers/iOS/app'
+require 'cukunity/drivers/iOS/process'
+require 'cukunity/drivers/iOS/touch_input'
+require 'cukunity/drivers/iOS/keyboard_input'
+require 'cukunity/drivers/iOS/unity_client'

data/lib/cukunity/exceptions.rb

@@ -0,0 +1,24 @@
+module Cukunity 
+  module Exception
+    class UnspecifiedPlatform < ::Exception; end
+    class InvalidApp < ::Exception; end
+    class LaunchTimeout < ::Exception; end
+    class InstallFailed < ::Exception; end
+    class UninstallFailed < ::Exception; end
+    class InstallTimeout < ::Exception; end
+    class UninstallTimeout < ::Exception; end
+    class TunnelError < ::Exception; end
+    class ConnectionTimeout < ::Exception; end
+    class MonkeyInvalidAck < ::Exception; end
+    class MonkeyCommandError < ::Exception; end
+    class MonkeyConnectTimeout < ::Exception; end
+    class MobileDeviceError < ::Exception; end
+    class MobileDeviceTimeout < ::Exception; end
+    class UIAutomationSlaveTimeout < ::Exception; end
+    class UIAutomationSlaveInvalidAck < ::Exception; end
+    class UIAutomationSlaveInvalidResponse < ::Exception; end
+    class KeyboardWaitTimeout < ::Exception; end
+    class UnityInvalidAck < ::Exception; end
+    class UnityCommandError < ::Exception; end
+  end
+end

data/lib/cukunity/keyboard_input_methods.rb

@@ -0,0 +1,35 @@
+module Cukunity
+  module KeyboardInputMethods
+    include Cukunity::Utils
+
+    def open(options = {})
+      options = merge_options(options, { :clear => false, :close => true })
+      platform_open_keyboard(restrict_options(options, :clear))
+      yield self
+      if options[:close]
+        close_keyboard
+      end
+    end
+
+    private
+    def keyboard_command(options)
+      options = to_options(options)
+      wait = (options.delete(:wait) || 0.5).to_f
+      cmd = yield
+      res = platform_keyboard_command(options, *cmd)
+      sleep(wait) unless wait.nil? or wait <= 0
+      res
+    end
+
+    def close_keyboard(options = {})
+      raise Exception::KeyboardWaitTimeout.new if check_timeout(10) do
+        if closed?
+          true
+        else
+          press_back
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cukunity/request_line_response_client_methods.rb

@@ -0,0 +1,80 @@
+require 'socket'
+
+module Cukunity
+  module RequestLineResponseClientMethods
+    include Cukunity::Utils
+
+    DEFAULT_TIMEOUT = 30
+
+    def request(line, options = {})
+      options = merge_options(options, { :max_time => DEFAULT_TIMEOUT,
+                                         :quit => false, :retry => true })
+      connect
+      response = nil
+      begin
+        raise Exception::MobileDeviceTimeout.new(cmd) if check_timeout(options[:max_time]) do
+          @socket.puts(line)
+          @socket.flush
+          return if options[:quit]
+          response = @socket.gets
+          break unless response.nil? and options[:retry]
+          close
+          sleep 0.1
+          connect
+          false
+        end
+      rescue Errno::ECONNRESET
+        return if options[:quit]
+        close
+        if options[:retry]
+          connect
+          retry
+        end
+      rescue Errno::EPIPE
+        return if options[:quit]
+        close
+        if options[:retry]
+          connect
+          retry
+        end
+      end
+      if block_given?
+        yield response
+      else
+        response
+      end
+    end
+
+    private
+    def connect(host, port, max_time = DEFAULT_TIMEOUT)
+      return unless @socket.nil? or @socket.closed?
+      raise Exception::ConnectionTimeout.new if check_timeout(max_time) do
+        # new connection to server
+        @socket = TCPSocket.new(host, port)
+        # get ACK from server
+        if block_given?
+          begin
+            yield @socket
+          rescue
+            # close and retry
+            @socket.close rescue ::Exception
+            @socket = nil
+          end
+        else
+          true
+        end
+      end
+    end
+
+    def connected?
+      !@socket.nil?
+    end
+
+    def close
+      unless @socket.nil?
+        @socket.close rescue ::Exception
+        @socket = nil
+      end
+    end
+  end
+end

data/lib/cukunity/tasks/cucumber.rake

@@ -0,0 +1,22 @@
+Cucumber::Rake::Task.new(:android) do |features|
+  features.cucumber_opts = "features --format progress -t ~@ios,@android"
+end
+namespace :android do
+  Cucumber::Rake::Task.new(:pretty) do |features|
+    features.cucumber_opts = "features --format pretty -t ~@ios,@android"
+  end
+  Cucumber::Rake::Task.new(:wip) do |features|
+    features.cucumber_opts = "features --format pretty -t ~@ios,@android -t @wip --wip"
+  end
+end
+Cucumber::Rake::Task.new(:ios) do |features|
+  features.cucumber_opts = "features --format progress -t ~@android,@ios"
+end
+namespace :ios do
+  Cucumber::Rake::Task.new(:pretty) do |features|
+    features.cucumber_opts = "features --format pretty -t ~@android,@ios"
+  end
+  Cucumber::Rake::Task.new(:wip) do |features|
+    features.cucumber_opts = "features --format pretty -t ~@android,@ios -t @wip --wip"
+  end
+end

data/lib/cukunity/touch_input_methods.rb

@@ -0,0 +1,19 @@
+module Cukunity
+  module TouchInputMethods
+    include Cukunity::Utils
+
+    DEFAULT_TAP_DELAY = 0.5
+
+    def default_tap_delay=(delay)
+      @default_tap_delay = delay.to_f
+    end
+
+    def set_default_tap_delay(delay)
+      default_tap_delay = delay
+    end
+
+    def default_tap_delay
+      @default_tap_delay || DEFAULT_TAP_DELAY
+    end
+  end
+end