Merge lp:~veebers/ubuntu-keyboard/adding_autopilot_tests_and_emulators into lp:ubuntu-keyboard

[Christopher Lee]

Adding autopilot emulators and tests to ubuntu-keyboard.

Adding autopilot emulators and tests to ubuntu-keyboard.

The tests cover expectations in the design docs as well as other general tests.

The Emulators will allow us to add a backend to autopilot so that we can use the OSK during tests to enter input.

[Michael Terry (mterry)]

Looking at the debian/* changes, the only change I would make is a small pet peeve of mine, but can you keep the the Depends lines sorted? python* should be after pkg-config, and the lines for the new package too.

As an aside, I'm bummed that autopilot is python2, instead of python3. :-/

[Thomi Richards (thomir-deactivatedaccount)]

> As an aside, I'm bummed that autopilot is python2, instead of python3. :-/

man, me too!

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:31
http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-ci/16/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-amd64-ci/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/16
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/16/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-i386-ci/16

Click here to trigger a rebuild:
http://s-jenkins:8080/job/ubuntu-keyboard-ci/16/rebuild

review: Approve (continuous-integration)

[Thomi Richards (thomir-deactivatedaccount)]

Python side LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:32
http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-ci/17/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-amd64-ci/18/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/17/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-i386-ci/17/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/ubuntu-keyboard-ci/17/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:33
http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-ci/20/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-amd64-ci/21
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/20
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/20/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-i386-ci/20

Click here to trigger a rebuild:
http://s-jenkins:8080/job/ubuntu-keyboard-ci/20/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:34
http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-ci/21/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-amd64-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/21
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-ci/21/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-i386-ci/21

Click here to trigger a rebuild:
http://s-jenkins:8080/job/ubuntu-keyboard-ci/21/rebuild

review: Approve (continuous-integration)

[Bill Filler (bfiller)]

approve, there are known failures of the majority of tests due to reported bugs, but those bugs will get fixed as soon as possible. daily image testing of ubuntu-keyboard should not be enabled until that point.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
Unapproved changes made after approval.
http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-autolanding/9/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-amd64-autolanding/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-autolanding/9
        deb: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-armhf-autolanding/9/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/ubuntu-keyboard-saucy-i386-autolanding/9

review: Needs Fixing (continuous-integration)

Unmerged revisions

=== modified file 'debian/control'
--- debian/control	2013-08-22 02:03:04 +0000
+++ debian/control	2013-08-23 04:29:04 +0000
@@ -14,6 +14,8 @@
                libubuntu-platform-api1-dev,
                maliit-framework-dev (>= 0.99.0+git20130615+97e8335-0ubuntu3),
                pkg-config,
+               python:any (>= 2.7),
+               python-setuptools,
                qt5-default,
                qtbase5-dev,
                qtdeclarative5-dev,
@@ -55,3 +57,12 @@
          ${shlibs:Depends},
 Description: Ubuntu on-screen keyboard tests
  Tests for the Ubuntu virtual keyboard
+
+Package: ubuntu-keyboard-autopilot
+Architecture: all
+Depends: libautopilot-qt,
+         ${misc:Depends},
+         ${python:Depends},
+         ubuntu-keyboard (>= ${source:Version}),
+Description: Tests and emulators package for ubuntu-keyboard
+ Autopilot tests for the ubuntu-keyboard package
 \ No newline at end of file
 
=== modified file 'debian/rules'
--- debian/rules	2013-08-15 21:07:50 +0000
+++ debian/rules	2013-08-23 04:29:04 +0000
@@ -4,7 +4,7 @@
 export DPKG_GENSYMBOLS_CHECK_LEVEL=4
 
 %:
-	dh $@ --fail-missing
+	dh $@ --fail-missing --with python2
 
 override_dh_auto_configure:
 	dh_auto_configure -- -recursive \
@@ -19,10 +19,16 @@
 	                     CONFIG+=enable-qt-mobility
 
 override_dh_install:
-	# Don't install the tests
+	# install autopilot tests
+	cd tests/autopilot; \
+	set -ex; for python in $(shell pyversions -r); do \
+	    $$python setup.py install --root=$(CURDIR)/debian/tmp --install-layout=deb; \
+	done; \
+	cd $(CURDIR)
+	# Don't install the other tests
 	rm debian/tmp/usr/bin/language-layout-loading
 	rm debian/tmp/usr/bin/language-layout-switching
 	rm debian/tmp/usr/bin/repeat-backspace
 	rm debian/tmp/usr/bin/ut_editor
 	rm debian/tmp/usr/bin/word-candidates
-	dh_install
+	dh_install -X'*.pyc' --fail-missing
 
=== added file 'debian/ubuntu-keyboard-autopilot.install'
--- debian/ubuntu-keyboard-autopilot.install	1970-01-01 00:00:00 +0000
+++ debian/ubuntu-keyboard-autopilot.install	2013-08-23 04:29:04 +0000
@@ -0,0 +1,1 @@
+usr/lib/python*/*/ubuntu_keyboard*
 
=== modified file 'qml/Keyboard.qml'
--- qml/Keyboard.qml	2013-08-20 21:43:23 +0000
+++ qml/Keyboard.qml	2013-08-23 04:29:04 +0000
@@ -33,6 +33,7 @@
 
 Item {
     id: canvas
+    objectName: "ubuntuKeyboard" // Allow us to specify a specific keyboard within autopilot.
     property alias layout: keyRepeater.model
     property variant event_handler
     property bool area_enabled // MouseArea has no id property so we cannot alias its enabled property.
@@ -40,6 +41,10 @@
 
     visible: layout.visible
 
+    // Expose details for use with Autopilot.
+    readonly property var layoutState: layout.keyboard_state
+    readonly property string activeView: layout.activeView
+
     property int contentOrientation: Qt.PrimaryOrientation
 
     property bool shown: false;
@@ -77,6 +82,7 @@
 
     WordRibbon {
         id: wordRibbon
+        objectName: "wordRibbon"
 
         anchors.bottom: keypadMouseArea.top
         width: parent.width;
@@ -125,6 +131,7 @@
             }
 
             Item {
+                objectName: "keyboardKeypad"
                 id: keyPad
 
                 anchors.top: borderTop.bottom
@@ -160,6 +167,9 @@
                         Text {
                             id: key_text_item
 
+                            // Expose detail for use within Autopilot
+                            property var action_type: key_action_type
+
                             anchors.fill: parent
                             text: key_text
                             font.family: key_font
 
=== modified file 'qml/WordRibbon.qml'
--- qml/WordRibbon.qml	2013-07-19 12:05:07 +0000
+++ qml/WordRibbon.qml	2013-08-23 04:29:04 +0000
@@ -20,6 +20,7 @@
 Rectangle {
 
     id: wordRibbonCanvas
+    objectName: "wordRibbenCanvas"
     state: "NORMAL"
 
     Rectangle {
@@ -29,6 +30,7 @@
 
     ListView {
         id: listView
+        objectName: "wordListView"
         anchors.fill: parent;
 
         model: maliit_wordribbon
@@ -44,6 +46,7 @@
             id: wordCandidateItem
             width: wordItem.width + units.gu(2);
             height: wordRibbonCanvas.height
+            property alias word_text: wordItem // For testing in Autopilot
 
             Item {
                 anchors.fill: parent
 
=== modified file 'src/lib/logic/layouthelper.h'
--- src/lib/logic/layouthelper.h	2013-07-19 12:05:07 +0000
+++ src/lib/logic/layouthelper.h	2013-08-23 04:29:04 +0000
@@ -35,6 +35,7 @@
 #include "models/key.h"
 #include "models/keyarea.h"
 #include "models/wordribbon.h"
+#include "models/layout.h"
 
 #include <QtCore>
 
@@ -143,6 +144,7 @@
     Q_SLOT void onKeysOverriden(const Logic::KeyOverrides &overriden_keys,
                                 bool update);
 
+    Q_SIGNAL void stateChanged(Model::Layout::State state);
 private:
     const QScopedPointer<LayoutHelperPrivate> d_ptr;
 };
 
=== modified file 'src/lib/logic/layoutupdater.cpp'
--- src/lib/logic/layoutupdater.cpp	2013-08-09 15:22:29 +0000
+++ src/lib/logic/layoutupdater.cpp	2013-08-23 04:29:04 +0000
@@ -733,6 +733,13 @@
     converter.setLayoutOrientation(orientation);
     d->layout->setCenterPanel(d->inShiftedState() ? converter.shiftedKeyArea()
                                                   : converter.keyArea());
+
+    if (d->inShiftedState())
+        Q_EMIT d->layout->stateChanged(Model::Layout::ShiftedState);
+    else if (d->inDeadkeyState())
+        Q_EMIT d->layout->stateChanged(Model::Layout::DeadkeyState);
+    else
+        Q_EMIT d->layout->stateChanged(Model::Layout::DefaultState);
 }
 
 void LayoutUpdater::switchToPrimarySymView()
@@ -750,6 +757,8 @@
 
     // Reset shift state machine, also see switchToMainView.
     d->shift_machine.restart();
+
+    Q_EMIT d->layout->stateChanged(Model::Layout::PrimarySymbolState);
 }
 
 void LayoutUpdater::switchToSecondarySymView()
@@ -764,6 +773,8 @@
     KeyAreaConverter converter(d->style->attributes(), &d->loader);
     converter.setLayoutOrientation(orientation);
     d->layout->setCenterPanel(converter.symbolsKeyArea(1));
+
+    Q_EMIT d->layout->stateChanged(Model::Layout::SecondarySymbolState);
 }
 
 void LayoutUpdater::switchToAccentedView()
 
=== modified file 'src/lib/models/layout.cpp'
--- src/lib/models/layout.cpp	2013-08-09 15:22:29 +0000
+++ src/lib/models/layout.cpp	2013-08-23 04:29:04 +0000
@@ -63,6 +63,7 @@
     KeyArea key_area;
     QString image_directory;
     QHash<int, QByteArray> roles;
+    Layout::State state;
     QString activeViewId;
 
     explicit LayoutPrivate();
@@ -74,6 +75,7 @@
     , key_area()
     , image_directory()
     , roles()
+    , state(Layout::DefaultState)
 {
     // Model roles are used as variables in QML, hence the under_score naming
     // convention:
@@ -88,6 +90,7 @@
     roles[Layout::RoleKeyFontStretch] = "key_font_stretch";
     roles[Layout::RoleKeyIcon] = "key_icon";
     roles[Layout::RoleKeyActionInsert] = "key_action_insert";
+    roles[Layout::RoleKeyAction] = "key_action_type";
 }
 
 
@@ -230,6 +233,18 @@
                     qGuiApp->primaryScreen()->orientation()) );
 }
 
+Layout::State Layout::state() const
+{
+    Q_D(const Layout);
+    return d->state;
+}
+
+void Layout::setState(Model::Layout::State state)
+{
+    Q_D(Layout);
+    d->state = state;
+    Q_EMIT stateChanged(state);
+}
 
 QString Layout::activeView() const
 {
@@ -321,6 +336,9 @@
 
     case RoleKeyActionInsert:
         return QVariant(key.action() == Key::ActionInsert);
+
+    case RoleKeyAction:
+        return QVariant(key.action());
     }
 
     qWarning() << __PRETTY_FUNCTION__
 
=== modified file 'src/lib/models/layout.h'
--- src/lib/models/layout.h	2013-08-09 15:22:29 +0000
+++ src/lib/models/layout.h	2013-08-23 04:29:04 +0000
@@ -78,11 +78,22 @@
     Q_PROPERTY(int invisible_toucharea_height READ invisibleTouchAreaHeight
                                          NOTIFY invisibleTouchAreaHeightChanged)
 
+    Q_PROPERTY(State keyboard_state READ state WRITE setState
+                            NOTIFY stateChanged)
     Q_PROPERTY(QString activeView READ activeView WRITE setActiveView
                                          NOTIFY activeViewChanged)
 
+    Q_ENUMS(State)
 
 public:
+    enum State {
+        DefaultState,
+        ShiftedState,
+        PrimarySymbolState,
+        SecondarySymbolState,
+        DeadkeyState
+    };
+
     enum Roles {
         RoleKeyRectangle = Qt::UserRole + 1,
         RoleKeyReactiveArea,
@@ -94,7 +105,8 @@
         RoleKeyFontSize,
         RoleKeyFontStretch,
         RoleKeyIcon,
-        RoleKeyActionInsert
+        RoleKeyActionInsert,
+        RoleKeyAction   // Extra introspection detail for testing.
     };
 
     explicit Layout(QObject *parent = 0);
@@ -137,6 +149,10 @@
     Q_SLOT int invisibleTouchAreaHeight() const;
     Q_SIGNAL void invisibleTouchAreaHeightChanged(int &changed);
 
+    Q_SLOT State state() const;
+    Q_SLOT void setState(Model::Layout::State state);
+    Q_SIGNAL void stateChanged(Model::Layout::State state);
+
     Q_SLOT QString activeView() const;
     Q_SLOT void setActiveView(const QString& activeViewId);
     Q_SIGNAL void activeViewChanged(const QString &activeViewId);
 
=== modified file 'src/plugin/inputmethod.cpp'
--- src/plugin/inputmethod.cpp	2013-08-22 17:05:44 +0000
+++ src/plugin/inputmethod.cpp	2013-08-23 04:29:04 +0000
@@ -244,6 +244,9 @@
     QObject::connect(&layout.updater, SIGNAL(languageChanged(QString)),
                      &editor,  SLOT(onLanguageChanged(const QString&)));
 
+    QObject::connect(&layout.helper, SIGNAL(stateChanged(Model::Layout::State)),
+                     &layout.model,  SLOT(setState(Model::Layout::State)));
+
 #ifdef EXTENDED_SURFACE_TEMP_DISABLED
     QObject::connect(&layout.event_handler,          SIGNAL(extendedKeysShown(Key)),
                      &extended_layout.event_handler, SLOT(onExtendedKeysShown(Key)));
 
=== added directory 'tests/autopilot'
=== added file 'tests/autopilot/setup.py'
--- tests/autopilot/setup.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/setup.py	2013-08-23 04:29:04 +0000
@@ -0,0 +1,32 @@
+#!/usr/bin/python
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Autopilot Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from distutils.core import setup
+from setuptools import find_packages
+
+setup(
+    name='ubuntu_keyboard',
+    version='1.0',
+    description='Ubuntu Keyboard autopilot tests and emulators.',
+    url='https://launchpad.net/ubuntu-keyboard',
+    license='GPLv3',
+    packages=find_packages(),
+)
 
=== added directory 'tests/autopilot/ubuntu_keyboard'
=== added file 'tests/autopilot/ubuntu_keyboard/__init__.py'
--- tests/autopilot/ubuntu_keyboard/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/__init__.py	2013-08-23 04:29:04 +0000
@@ -0,0 +1,18 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 
=== added directory 'tests/autopilot/ubuntu_keyboard/emulators'
=== added file 'tests/autopilot/ubuntu_keyboard/emulators/__init__.py'
--- tests/autopilot/ubuntu_keyboard/emulators/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/emulators/__init__.py	2013-08-23 04:29:04 +0000
@@ -0,0 +1,18 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 
=== added file 'tests/autopilot/ubuntu_keyboard/emulators/keyboard.py'
--- tests/autopilot/ubuntu_keyboard/emulators/keyboard.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/emulators/keyboard.py	2013-08-23 04:29:04 +0000
@@ -0,0 +1,346 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from collections import defaultdict, namedtuple
+from time import sleep
+import logging
+
+from autopilot.input import Pointer, Touch
+from autopilot.introspection import (
+    get_proxy_object_for_existing_process,
+    ProcessSearchError
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+# Definitions of enums used within the cpp source code.
+class KeyboardState:
+    DEFAULT = 0
+    SHIFTED = 1
+    SYMBOL_1 = 2
+    SYMBOL_2 = 3
+
+
+class KeyAction:
+    INSERT = 0
+    SHIFT = 1
+    BACKSPACE = 2
+    SPACE = 3
+    SYM = 6
+    RETURN = 7
+    SWITCH = 11
+
+
+class UnsupportedKey(RuntimeError):
+    pass
+
+
+class Keyboard(object):
+
+    KeyPos = namedtuple("KeyPos", ['x', 'y', 'h', 'w'])
+
+    # Note (veebers 19-aug-13): this hardcoded right now, but will be reading
+    # data from the keyboard itself in the very near future. Moved '/' to
+    # primary symbol, default layout can have a .com instead.
+    default_keys = "qwertyuiopasdfghjklzxcvbnm."
+    shifted_keys = "QWERTYUIOPASDFGHJKLZXCVBNM."
+    primary_symbol = "1234567890*#+-=()!?@~/\\';:,."
+    secondary_symbol = u"$%<>[]`^|_{}\"&,.\u20ac\xa3\xa5\u20b9\xa7\xa1\xbf" \
+        u"\xab\xbb\u201c\u201d\u201e"
+
+    # The ability to name the non-text keys.
+    _action_id_to_text = {
+        KeyAction.SHIFT: 'SHIFT',
+        KeyAction.BACKSPACE: '\b',
+        KeyAction.SPACE: ' ',
+        KeyAction.RETURN: '\n'
+    }
+
+    def __init__(self, pointer=None):
+        try:
+            maliit = get_proxy_object_for_existing_process(
+                connection_name='org.maliit.server'
+            )
+        except ProcessSearchError as e:
+            e.args += (
+                "Unable to find maliit-server dbus object. Has it been "
+                "started with introspection enabled?",
+            )
+            raise
+
+        try:
+            self.keyboard = maliit.select_single(
+                "Keyboard",
+                objectName="ubuntuKeyboard"
+            )
+            if self.keyboard is None:
+                raise RuntimeError(
+                    "Unable to find the Ubuntu Keyboard object within the "
+                    "maliit server"
+                )
+        except ValueError as e:
+            e.args += (
+                "There was more than one Keyboard object found, aborting.",
+            )
+            raise
+
+        try:
+            self.keypad = self.keyboard.select_single(
+                "QQuickItem",
+                objectName="keyboardKeypad"
+            )
+
+            if self.keypad is None:
+                raise RuntimeError(
+                    "Unable to find the keypad object within the "
+                    "maliit server"
+                )
+        except ValueError as e:
+            e.args += (
+                "There was more than one keyboard keypad object found, "
+                "aborting.",
+            )
+            raise
+
+        # Contains instructions on how to move the keyboard into a specific
+        # state/layout so that we can successfully press the required key.
+        self._state_lookup_table = self._generate_state_lookup_table()
+        # Cache the position of the keys
+        self._key_pos_table = defaultdict(dict)
+
+        if pointer is None:
+            self.pointer = Pointer(Touch.create())
+        else:
+            self.pointer = pointer
+
+    def dismiss(self):
+        """Swipe the keyboard down to hide it.
+
+        :raises: *AssertionError* if the state.wait_for fails meaning that the
+         keyboard failed to hide.
+
+        """
+        if self.is_available():
+            x, y, h, w = self.keyboard.globalRect
+            x_pos = int(w / 2)
+            # start_y: just inside the keyboard, must be a better way than +1px
+            start_y = y + 1
+            end_y = y + int(h / 2)
+            self.pointer.drag(x_pos, start_y, x_pos, end_y)
+
+            self.keyboard.state.wait_for("HIDDEN")
+
+    def is_available(self):
+        """Returns true if the keyboard is shown and ready to use."""
+        return (
+            self.keyboard.state == "SHOWN"
+            and not self.keyboard.hideAnimationFinished
+        )
+
+    @property
+    def current_state(self):
+        return self.keyboard.layoutState
+
+    # Much like is_available, but attempts to wait for the keyboard to be
+    # ready.
+    def wait_for_keyboard_ready(self, timeout=10):
+        """Waits for *timeout* for the keyboard to be ready and returns
+        true. Returns False if the keyboard fails to be considered ready within
+        the alloted time.
+
+        """
+        try:
+            self.keyboard.state.wait_for("SHOWN", timeout=timeout)
+            self.keyboard.hideAnimationFinished.wait_for(
+                False,
+                timeout=timeout
+            )
+            return True
+        except RuntimeError:
+            return False
+
+    def get_key_position(self, key):
+        """Returns the global rect of the given key.
+
+        It may need to do a lookup to update the table of positions.
+
+        """
+        current_state = self.keyboard.layoutState
+        if self._key_pos_table.get(current_state) is None:
+            self._update_pos_table_for_current_state()
+
+        return self._key_pos_table[current_state][key]
+
+    def _update_pos_table_for_current_state(self):
+        all_keys = self.keypad.select_many('QQuickText')
+        current_state = self.keyboard.layoutState
+        labeled_keys = (KeyAction.INSERT, KeyAction.SWITCH, KeyAction.SYM)
+        for key in all_keys:
+            with key.no_automatic_refreshing():
+                key_pos = Keyboard.KeyPos(*key.globalRect)
+                if key.action_type in labeled_keys:
+                    self._key_pos_table[current_state][key.text] = key_pos
+                else:
+                    key_text = Keyboard._action_id_to_text[key.action_type]
+                    self._key_pos_table[current_state][key_text] = key_pos
+
+    def press_key(self, key):
+        """Tap on the key with the internal pointer
+
+        :params key: String containing the text of the key to tap.
+
+        :raises: *RuntimeError* if the keyboard is not available and thus not
+          ready to be used.
+        :raises: *UnsupportedKey* if the supplied key cannot be found on any of
+          the the current keyboards layouts.
+        """
+        if not self.is_available():
+            raise RuntimeError("Keyboard is not on screen")
+
+        if not self._is_special_key(key):
+            required_state_for_key = self._get_keys_required_state(key)
+            self._switch_keyboard_to_state(required_state_for_key)
+
+        key_rect = self.get_key_position(key)
+        self.pointer.click_object(key_rect)
+
+    def type(self, string, delay=0.1):
+        """Type the string *string* with a delay of *delay* between each key
+        press
+
+        .. note:: The delay provides a minimum delay, it may take longer
+        between each press as the keyboard shifts between states etc.
+
+        Only 'normal' or single characters can be typed this way.
+
+        :raises: *UnsupportedKey* if one of the the supplied keys cannot be
+          found on any of the the current keyboards layouts.
+
+        """
+        for char in string:
+            self.press_key(char)
+            sleep(delay)
+
+    def _get_keys_required_state(self, char):
+        """Given a character determine which state the keyboard needs to be in
+        so that it is visible and can be clicked.
+
+        """
+
+        if char in Keyboard.default_keys:
+            return KeyboardState.DEFAULT
+        elif char in Keyboard.shifted_keys:
+            return KeyboardState.SHIFTED
+        elif char in Keyboard.primary_symbol:
+            return KeyboardState.SYMBOL_1
+        elif char in Keyboard.secondary_symbol:
+            return KeyboardState.SYMBOL_2
+        else:
+            raise UnsupportedKey(
+                "Don't know which state key '%s' requires" % char
+            )
+
+    def _switch_keyboard_to_state(self, target_state):
+        """Given a target_state, presses the required keys to bring the
+        keyboard into the correct state.
+
+        :raises: *RuntimeError* if unable to change the keyboard into the
+          expected state.
+
+        """
+        current_state = self.keyboard.layoutState
+
+        if target_state == current_state:
+            return
+
+        instructions = self._state_lookup_table[target_state].get(
+            current_state,
+            None
+        )
+        if instructions is None:
+            raise RuntimeError(
+                "Don't know how to get to state %d from current state (%d)"
+                % (target_state, current_state)
+            )
+
+        for step in instructions:
+            key, expected_state = step
+            self.press_key(key)
+            self.keyboard.layoutState.wait_for(expected_state)
+
+    def _is_special_key(self, key):
+        return key in ["\n", "\b", " ", "SHIFT", "?123", "ABC", "1/2", "2/2"]
+
+    # Give the state that you want and the current state, get instructions on
+    # how to move to that state.
+    # lookup_table[REQUESTED_STATE][CURRENT_STATE] -> Instructions(Key to
+    # press, Expected state after key press.)
+    def _generate_state_lookup_table(self):
+        return {
+            KeyboardState.DEFAULT: {
+                KeyboardState.SHIFTED: [
+                    ("SHIFT", KeyboardState.DEFAULT)
+                ],
+                KeyboardState.SYMBOL_1: [
+                    ("ABC", KeyboardState.DEFAULT)
+                ],
+                KeyboardState.SYMBOL_2: [
+                    ("ABC", KeyboardState.DEFAULT)
+                ],
+            },
+            KeyboardState.SHIFTED: {
+                KeyboardState.DEFAULT: [
+                    ("SHIFT", KeyboardState.SHIFTED)
+                ],
+                KeyboardState.SYMBOL_1: [
+                    ("ABC", KeyboardState.DEFAULT),
+                    ("SHIFT", KeyboardState.SHIFTED)
+                ],
+                KeyboardState.SYMBOL_2: [
+                    ("ABC", KeyboardState.DEFAULT),
+                    ("SHIFT", KeyboardState.SHIFTED)
+                ],
+            },
+            KeyboardState.SYMBOL_1: {
+                KeyboardState.DEFAULT: [
+                    ("?123", KeyboardState.SYMBOL_1)
+                ],
+                KeyboardState.SHIFTED: [
+                    ("?123", KeyboardState.SYMBOL_1)
+                ],
+                KeyboardState.SYMBOL_2: [
+                    ("2/2", KeyboardState.SYMBOL_1)
+                ],
+            },
+            KeyboardState.SYMBOL_2: {
+                KeyboardState.DEFAULT: [
+                    ("?123", KeyboardState.SYMBOL_1),
+                    ("1/2", KeyboardState.SYMBOL_2)
+                ],
+                KeyboardState.SHIFTED: [
+                    ("?123", KeyboardState.SYMBOL_1),
+                    ("1/2", KeyboardState.SYMBOL_2)
+                ],
+                KeyboardState.SYMBOL_1: [
+                    ("1/2", KeyboardState.SYMBOL_2)
+                ],
+            },
+        }
 
=== added directory 'tests/autopilot/ubuntu_keyboard/tests'
=== added file 'tests/autopilot/ubuntu_keyboard/tests/__init__.py'
--- tests/autopilot/ubuntu_keyboard/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/tests/__init__.py	2013-08-23 04:29:04 +0000
@@ -0,0 +1,18 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
 
=== added file 'tests/autopilot/ubuntu_keyboard/tests/test_keyboard.py'
--- tests/autopilot/ubuntu_keyboard/tests/test_keyboard.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntu_keyboard/tests/test_keyboard.py	2013-08-23 04:29:04 +0000
@@ -0,0 +1,342 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Ubuntu Keyboard Test Suite
+# Copyright (C) 2013 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import os
+
+from testtools.matchers import Equals
+from tempfile import mktemp
+from textwrap import dedent
+
+from autopilot.testcase import AutopilotTestCase
+from autopilot.input import Pointer, Touch
+from autopilot.matchers import Eventually
+
+from ubuntu_keyboard.emulators.keyboard import Keyboard, KeyboardState
+
+
+class UbuntuKeyboardTests(AutopilotTestCase):
+    def setUp(self):
+        super(UbuntuKeyboardTests, self).setUp()
+        self.pointer = Pointer(Touch.create())
+
+    def launch_test_input_area(self, label="", input_hints=None):
+        self.app = self._launch_simple_input(label, input_hints)
+        text_area = self.app.select_single("QQuickTextInput")
+
+        return text_area
+
+    def ensure_focus_on_input(self, input_area):
+        self.pointer.click_object(input_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+        self.assertThat(keyboard.is_available, Eventually(Equals(True)))
+
+    def _start_qml_script(self, script_contents):
+        """Launch a qml script."""
+        qml_path = mktemp(suffix='.qml')
+        open(qml_path, 'w').write(script_contents)
+        self.addCleanup(os.remove, qml_path)
+
+        return self.launch_test_application(
+            "qmlscene",
+            qml_path,
+            app_type='qt',
+        )
+
+    def _launch_simple_input(self, label="", input_hints=None):
+        if input_hints is None:
+            extra_script = "Qt.ImhNoPredictiveText"
+        else:
+            extra_script = "|".join(input_hints)
+
+        simple_script = dedent("""
+        import QtQuick 2.0
+        import Ubuntu.Components 0.1
+
+        Rectangle {
+            id: window
+            objectName: "windowRectangle"
+            color: "lightgrey"
+
+            Text {
+                id: inputLabel
+                text: "%(label)s"
+                font.pixelSize: units.gu(3)
+                anchors {
+                    left: input.left
+                    top: parent.top
+                    topMargin: 25
+                    bottomMargin: 25
+                }
+            }
+
+            TextField {
+                id: input;
+                objectName: "input"
+                anchors {
+                    top: inputLabel.bottom
+                    horizontalCenter: parent.horizontalCenter
+                    topMargin: 10
+                }
+                inputMethodHints: %(input_method)s
+            }
+        }
+
+        """ % {'label': label, 'input_method': extra_script})
+
+        return self._start_qml_script(simple_script)
+
+
+class UbuntuKeyboardTestsAccess(UbuntuKeyboardTests):
+
+    def test_keyboard_is_available(self):
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+        app = self._launch_simple_input()
+        text_rectangle = app.select_single("QQuickTextInput")
+
+        self.pointer.click_object(text_rectangle)
+
+        self.assertThat(keyboard.is_available, Eventually(Equals(True)))
+
+
+class UbuntuKeyboardTypingTests(UbuntuKeyboardTests):
+
+    scenarios = [
+        (
+            'lower_alpha',
+            dict(
+                label="Lowercase",
+                input='abcdefghijklmnopqrstuvwxyz'
+            )
+        ),
+        (
+            'upper_alpha',
+            dict(
+                label="Uppercase",
+                input='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+            )
+        ),
+        (
+            'numeric',
+            dict(
+                label="Numeric",
+                input='0123456789'
+            )
+        ),
+        (
+            'punctuation',
+            dict(
+                label="Puncuation",
+                input='`~!@#$%^&*()_-+={}[]|\\:;"\'<>,.?/'
+            )
+        )
+    ]
+
+    def test_can_type_string(self):
+        text_area = self.launch_test_input_area(label=self.label)
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        keyboard.type(self.input)
+
+        self.assertThat(text_area.text, Eventually(Equals(self.input)))
+
+
+class UbuntuKeyboardStateChanges(UbuntuKeyboardTests):
+
+    # Note: this is a failing test due to bug lp:1214695
+    # Note: based on UX design doc
+    def test_keyboard_layout_starts_shifted(self):
+        """When first launched the keyboard state must be
+        shifted/capitalised.
+
+        """
+        text_area = self.launch_test_input_area()
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        self.assertThat(
+            keyboard.keyboard.layoutState,
+            Eventually(Equals(KeyboardState.SHIFTED))
+        )
+
+    def test_shift_latch(self):
+        """Double tap of the shift key must lock it 'On' until the shift key
+        tapped again.
+
+        Normally hitting shift then a letter reverts from the shifted state
+        back to the default. If double clicked it should stay in the shifted
+        until the shift key is clicked again.
+
+        """
+        text_area = self.launch_test_input_area()
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        keyboard.type('abc')
+        keyboard.press_key('SHIFT')
+        keyboard.press_key('SHIFT')
+        keyboard.type('S')
+
+        self.assertThat(
+            keyboard.keyboard.layoutState,
+            Eventually(Equals(KeyboardState.SHIFTED))
+        )
+        self.assertThat(text_area.text, Eventually(Equals('abcS')))
+
+    # Note: based on UX design doc
+    def test_shift_state_returns_to_default_after_letter_typed(self):
+        """Pushing shift and then typing an uppercase letter must automatically
+        shift the keyboard back into the default state.
+
+        """
+        text_area = self.launch_test_input_area()
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        # Normally, type and (press_key) take care of shifting into the correct
+        # state, we do it manually here as that's what we're testing.
+        keyboard.type('abc')
+        keyboard.press_key('SHIFT')
+        keyboard.type('A')
+
+        # Once the capital letter has been typed, we must be able to access the
+        # lowercase letters, otherwise it's not in the correct state.
+        self.assertThat(
+            keyboard.keyboard.layoutState,
+            Eventually(Equals(KeyboardState.DEFAULT))
+        )
+
+        self.assertThat(text_area.text, Eventually(Equals('abcA')))
+
+    # Note: this is a failing test due to bug lp:1214695
+    # Note: Based on UX design doc.
+    def test_shift_state_entered_after_fullstop(self):
+        """After typing a fullstop the keyboard state must automatically
+        enter the shifted state.
+
+        """
+        text_area = self.launch_test_input_area()
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        keyboard.type("abc.")
+
+        self.assertThat(
+            text_area.text,
+            Eventually(Equals("abc."))
+        )
+
+        self.assertThat(
+            keyboard.keyboard.layoutState,
+            Eventually(Equals(KeyboardState.SHIFTED))
+        )
+
+    def test_switching_between_states(self):
+        """The user must be able to type many different characters including
+        spaces and backspaces.
+
+        """
+        text_area = self.launch_test_input_area()
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        keyboard.type(
+            'abc gone\b\b &  \bABC (123)'
+        )
+
+        expected = "abc go & ABC (123)"
+        self.assertThat(
+            text_area.text,
+            Eventually(Equals(expected))
+        )
+
+
+class UbuntuKeyboardInputTypeStateChange(UbuntuKeyboardTests):
+    """Note: these tests are currently failing due to bug lp:1214694 (the
+    activeView detail isn't exposed correctly nor is it updated as expected
+    (i.e. when the view changes.))
+
+    """
+
+    scenarios = [
+        (
+            "Url",
+            dict(
+                label="Url",
+                hints=['Qt.ImhUrlCharactersOnly'],
+                expected_activeview="url"
+            )
+        ),
+        (
+            "Password",
+            dict(
+                label="Password",
+                hints=['Qt.ImhHiddenText', 'Qt.ImhSensitiveData'],
+                expected_activeview="password"
+            )
+        ),
+        (
+            "Email",
+            dict(
+                label="Email",
+                hints=['Qt.ImhEmailCharactersOnly'],
+                expected_activeview="email"
+            )
+        ),
+        (
+            "Number",
+            dict(
+                label="Number",
+                hints=['Qt.ImhFormattedNumbersOnly'],
+                expected_activeview="number"
+            )
+        ),
+        (
+            "Telephone",
+            dict(
+                label="Telephone",
+                hints=['Qt.ImhDigitsOnly'],
+                expected_activeview="phonenumber"
+            )
+        ),
+    ]
+
+    # Note: based on UX design doc
+    def test_keyboard_layout(self):
+        """The Keyboard must respond to the input type and change to be the
+        correct state.
+
+        """
+        text_area = self.launch_test_input_area(self.label, self.hints)
+        self.ensure_focus_on_input(text_area)
+        keyboard = Keyboard()
+        self.addCleanup(keyboard.dismiss)
+
+        self.assertThat(
+            keyboard.keyboard.activeView,
+            Eventually(Equals(self.expected_activeview))
+        )