Merge lp:~chris.gagnon/messaging-app/autopilot-tests-with-contacts into lp:messaging-app

[Chris Gagnon]

[lp:~chris.gagnon/messaging-app/autopilot-tests-with-contacts]

78. By Chris Gagnon on 2014-02-14

remove toolbar from message page object, it's in the main view and going away.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:77
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~chris.gagnon/messaging-app/autopilot-tests-with-contacts/+merge/206552/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/messaging-app-ci/159/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/3256/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty-touch/2926/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/messaging-app-trusty-amd64-ci/74
    SUCCESS: http://jenkins.qa.ubuntu.com/job/messaging-app-trusty-armhf-ci/75
        deb: http://jenkins.qa.ubuntu.com/job/messaging-app-trusty-armhf-ci/75/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/messaging-app-trusty-i386-ci/74
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-trusty/2864/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3258
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3258/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2928
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-armhf/2928/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-runner-mako/5332/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/3981

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/messaging-app-ci/159/rebuild

review: Needs Fixing (continuous-integration)

[Tiago Salem Herrmann (tiagosh)]

the following package names are incorrect:
evolution-data-service should be evolution-data-server
address-boot-app-autopilot should be address-book-app-autopilot

review: Needs Fixing

[lp:~chris.gagnon/messaging-app/autopilot-tests-with-contacts]

79. By Chris Gagnon on 2014-02-17

fix build deps in control

Unmerged revisions

79. By Chris Gagnon on 2014-02-17

fix build deps in control

78. By Chris Gagnon on 2014-02-14

remove toolbar from message page object, it's in the main view and going away.

77. By Chris Gagnon on 2014-02-14

 use page objects for emulator

76. By Chris Gagnon on 2014-02-14

add a couple more tests

75. By Chris Gagnon on 2014-02-14

add test cases

=== modified file 'debian/control'
--- debian/control	2013-11-21 13:26:32 +0000
+++ debian/control	2014-02-14 19:29:11 +0000
@@ -42,6 +42,9 @@
          python-autopilot,
          ubuntu-ui-toolkit-autopilot,
          ofono-phonesim-autostart,
+         evolution-data-service,
+         address-boot-app-autopilot,
+         telephony-service,
 Description: autopilot tests for messaging-app
  This package contains the autopilot tests for messaging-app
  .

=== modified file 'tests/autopilot/messaging_app/__init__.py'
--- tests/autopilot/messaging_app/__init__.py	2013-07-15 20:33:33 +0000
+++ tests/autopilot/messaging_app/__init__.py	2014-02-14 19:29:11 +0000
@@ -1,5 +1,5 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
+# Copyright 2012 - 2014 Canonical
 #
 # This file is part of messaging-app.
 #
@@ -7,4 +7,4 @@
 # under the terms of the GNU General Public License version 3, as published
 # by the Free Software Foundation.
 
-"""Marumbi autopilot tests and emulators - top level package."""
+"""messaging-app autopilot tests and emulators - top level package."""

=== added directory 'tests/autopilot/messaging_app/data'
=== added file 'tests/autopilot/messaging_app/data/contacts.sync'
--- tests/autopilot/messaging_app/data/contacts.sync	1970-01-01 00:00:00 +0000
+++ tests/autopilot/messaging_app/data/contacts.sync	2014-02-14 19:29:11 +0000
@@ -0,0 +1,99 @@
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502C000000BE
+N:;Aa;;;
+X-EVOLUTION-FILE-AS:Aa
+ADR;TYPE=home:;;;;;;
+REV:2014-02-13T23:08:07Z(390)
+FN:Aa
+TEL;TYPE=mobile,home:1
+TEL;TYPE=work,landline:9
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502D000000BF
+N:;Aaa;;;
+X-EVOLUTION-FILE-AS:Aaa
+TEL;TYPE=mobile,home:11
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T01:56:20Z(92)
+FN:Aaa
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502D000000C0
+N:;Aaaa;;;
+X-EVOLUTION-FILE-AS:Aaaa
+TEL;TYPE=mobile,home:111
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T01:56:32Z(94)
+FN:Aaaa
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502D000000C1
+N:;Bbbb;;;
+X-EVOLUTION-FILE-AS:Bbbb
+TEL;TYPE=mobile,home:222
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T01:56:49Z(96)
+FN:Bbbb
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502D000000C2
+N:;Bb;;;
+X-EVOLUTION-FILE-AS:Bb
+TEL;TYPE=mobile,home:2
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T01:56:59Z(98)
+FN:Bb
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502E000000C3
+N:;Bbb;;;
+X-EVOLUTION-FILE-AS:Bbb
+ADR;TYPE=home:;;;;;;
+FN:Bbb
+TEL;TYPE=mobile,home:22
+REV:2014-02-12T01:57:18Z(102)
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502E000000C4
+N:;Cccc;;;
+X-EVOLUTION-FILE-AS:Cccc
+TEL;TYPE=mobile,home:333
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T14:22:48Z(104)
+FN:Cccc
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502E000000C5
+N:;Cc;;;
+X-EVOLUTION-FILE-AS:Cc
+TEL;TYPE=mobile,home:3
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T14:23:02Z(106)
+FN:Cc
+END:VCARD
+
+BEGIN:VCARD
+VERSION:3.0
+UID:pas-id-52FD502E000000C6
+N:;Ccc;;;
+X-EVOLUTION-FILE-AS:Ccc
+TEL;TYPE=mobile,home:33
+ADR;TYPE=home:;;;;;;
+REV:2014-02-12T14:23:18Z(108)
+FN:Ccc
+END:VCARD
\ No newline at end of file

=== modified file 'tests/autopilot/messaging_app/emulators.py'
--- tests/autopilot/messaging_app/emulators.py	2013-09-25 20:24:30 +0000
+++ tests/autopilot/messaging_app/emulators.py	2014-02-14 19:29:11 +0000
@@ -10,30 +10,416 @@
 
 """Messaging app autopilot emulators."""
 
+import dbus
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+
+from autopilot.input import Keyboard
+from autopilot.platform import model
 from ubuntuuitoolkit import emulators as toolkit_emulators
 
+
+class EmulatorException(Exception):
+        """Exception raised when there is an error with the emulator."""
+
+
 class MainView(toolkit_emulators.MainView):
     def __init__(self, *args):
         super(MainView, self).__init__(*args)
+        self.pointing_device = toolkit_emulators.get_pointing_device()
+        self.keyboard = Keyboard.create()
+        self.logger = logging.getLogger(__name__)
 
     def get_pagestack(self):
+        """Returns PageStack with objectName mainStack"""
         return self.select_single("PageStack", objectName="mainStack")
 
+    def click_new_message_button(self):
+        """Click "Compose/ new message" button from toolbar on main page"""
+
+        toolbar = self.open_toolbar()
+        toolbar.click_button("newMessageButton")
+        toolbar.animating.wait_for(False)
+
+    def click_select_button(self):
+        """Click select button from toolbar on main page"""
+
+        toolbar = self.open_toolbar()
+        toolbar.click_button("selectButton")
+        toolbar.animating.wait_for(False)
+
+    def get_thread_from_number(self, phone_number):
+        """Returns thread from number
+
+        :parameter phone_number: the phone_number of message thread
+
+        """
+
+        time.sleep(2)  # message is not always found on slow emulator
+        for thread in self.select_many('ThreadDelegate'):
+            for item in self.select_many('QQuickItem'):
+                if "phoneNumber" in item.get_properties():
+                    if item.get_properties()['phoneNumber'] == phone_number:
+                        return thread
+        raise EmulatorException('Could not find thread with the phone number '
+                                '{}'.format(phone_number))
+
+    def get_label(self, text):
+        """Returns label from text
+
+        :parameter text: the text of the label to return
+        """
+
+        return self.wait_select_single('Label', visible=True, text=text)
+
+    def get_main_page(self):
+        """Returns messages with objectName messagesPage"""
+
+        return self.wait_select_single("MainPage", objectName="")
+
+    def get_header(self):
+        """Returns header object"""
+
+        return self.select_single('Header', objectName='MainView_Header')
+
+    def get_dialog_buttons(self, visible=True):
+        """Returns DialogButtons
+
+        :parameter visible: the visible state of the dialog button
+        """
+
+        if visible:
+            return self.wait_select_single('DialogButtons', visible=True)
+        else:
+            return self.select_many('DialogButtons', visible=False)
+
+    def get_visible_cancel_dialog_button(self):
+        """Returns dialog Button with text Cancel"""
+
+        dialog_buttons = self.get_dialog_buttons()
+        return dialog_buttons.select_single('Button', text='Cancel')
+
+    def get_visible_delete_dialog_button(self):
+        """Returns dialog Button with text Delete"""
+
+        dialog_buttons = self.get_dialog_buttons()
+        return dialog_buttons.select_single('Button', text='Delete')
+
+    def click_cancel_dialog_button(self):
+        """Returns button, after clicking on dialog button cancel"""
+
+        button = self.get_visible_cancel_dialog_button()
+        self.pointing_device.click_object(button)
+        button.visible.wait_for(False)
+        return button
+
+    def click_delete_dialog_button(self):
+        """Returns button after clicking on dialog button delete"""
+
+        button = self.get_visible_delete_dialog_button()
+        self.pointing_device.click_object(button)
+        button.visible.wait_for(False)
+        return button
+
+    def long_press(self, obj):
+        """long press on object because press_duration is not honored on touch
+        see bug #1268782
+
+        :parameter obj: the object to long press on
+        """
+
+        self.pointing_device.move_to_object(obj)
+        self.pointing_device.press()
+        time.sleep(3)
+        self.pointing_device.release()
+
+    def close_osk(self):
+        """Swipe down to close on-screen keyboard"""
+
+        # killing the maliit-server closes the OSK
+        if model() is not 'Desktop':
+            subprocess.call(["pkill", "maliit-server"])
+            #wait for server to respawn
+            time.sleep(2)
+
+    def click_visible_label(self, text):
+        """Returns and clicks visible label with matching text
+
+        :parameter text: the text of the label you want to click
+        """
+
+        label = self.get_label(text)
+        self.pointing_device.click_object(label)
+        return label
+
+    def click_close_contact_button(self):
+        """Returns and clicks the close contact button"""
+
+        button = self.select_single('Button', text='close', visible=True)
+        self.pointing_device.click_object(button)
+        return button
+
+    def get_contact_list_view(self):
+        """Returns the contact list view"""
+
+        return self.select_single('ContactListView', text='')
+
+    def delete_thread(self, phone_number, direction='right'):
+        """Delete thread containing specified phone number
+
+        :parameter phone_number: phone number of thread to delete
+        :parameter direction: right or left, the direction to swipe to delete
+        """
+
+        thread = self.get_thread_from_number(phone_number)
+        delete = self.swipe_to_delete(thread, direction=direction)
+        delete_button = delete.wait_select_single('QQuickImage', visible=True)
+        self.pointing_device.click_object(delete_button)
+        thread.wait_until_destroyed()
+
+    def click_select_messages_button(self):
+        """Click select messages button from toolbar on messages page"""
+
+        toolbar = self.open_toolbar()
+        toolbar.click_button("selectMessagesButton")
+        toolbar.animating.wait_for(False)
+
+    def click_add_button(self):
+        """Returns and click add button from toolbar on messages page"""
+
+        toolbar = self.open_toolbar()
+        button = toolbar.wait_select_single("ActionItem", text=u"Add")
+        self.pointing_device.click_object(button)
+        toolbar.animating.wait_for(False)
+        return button
+
+    def click_call_button(self):
+        """Returns and click call button from toolbar on messages page"""
+
+        toolbar = self.open_toolbar()
+        button = toolbar.wait_select_single("ActionItem", text=u"Call")
+        self.pointing_device.click_object(button)
+        toolbar.animating.wait_for(False)
+        return button
+
+    def click_back_button(self):
+        """Returns and click back button from toolbar on messages page"""
+
+        toolbar = self.open_toolbar()
+        button = toolbar.wait_select_single("ActionItem", text=u"Back")
+        self.pointing_device.click_object(button)
+        toolbar.animating.wait_for(False)
+        return button
+
+    def delete_message(self, text, direction='right'):
+        """Deletes message with specified text
+
+        :parameter text: the text of the message you want to delete
+        :parameter direction: right or left, the direction to swipe to delete
+        """
+
+        message = self.get_message(text)
+        delete = self.swipe_to_delete(message, direction=direction)
+        delete_button = delete.wait_select_single('QQuickImage', visible=True)
+        self.pointing_device.click_object(delete_button)
+        message.wait_until_destroyed()
+
     def get_messages_page(self):
-        return self.select_single("Messages", objectName="messagesPage")
+        """Returns messages with objectName messagesPage"""
+
+        return self.wait_select_single("Messages", objectName="messagesPage")
+
+    def swipe_to_delete(self, obj, direction='right', offset=.1):
+        """Swipe and objet left or right
+
+        :parameter direction: right or left, the direction to swipe
+        :parameter offset: the ammount of space to offset at start of swipe
+        """
+
+        x, y, w, h = obj.globalRect
+
+        s_rx = x + (w * offset)
+        e_rx = w
+
+        s_lx = w - (w * offset)
+        e_lx = w * offset
+
+        sy = y + (h / 2)
+
+        if (direction == 'right'):
+            self.pointing_device.drag(s_rx, sy, e_rx, sy)
+            # wait for animation
+            time.sleep(.5)
+            return self.wait_select_single('QQuickItem',
+                                           objectName='confirmRemovalDialog',
+                                           visible=True)
+        elif (direction == 'left'):
+            self.pointing_device.drag(s_lx, sy, e_lx, sy)
+            # wait for animation
+            time.sleep(.5)
+            return self.wait_select_single('QQuickItem',
+                                           objectName='confirmRemovalDialog',
+                                           visible=True)
+        else:
+            raise EmulatorException(
+                'Invalid direction "{0}" used on swipe to delete function '
+                'direction can be right or left'.format(direction)
+            )
+
+    def receive_sms(self, sender, text):
+        """Receive an SMS based on sender number and text
+
+        :parameter sender: phone number the message is from
+        :parameter text: text you want to send in the message
+        """
+
+        # prepare and send a Qt GUI script to phonesim, over its private D-BUS
+        # set up by ofono-phonesim-autostart
+        script_dir = tempfile.mkdtemp(prefix="phonesim_script")
+        os.chmod(script_dir, 0o755)
+        with open(os.path.join(script_dir, "sms.js"), "w") as f:
+            f.write("""tabSMS.gbMessage1.leMessageSender.text = "%s";
+tabSMS.gbMessage1.leSMSClass.text = "1";
+tabSMS.gbMessage1.teSMSText.setPlainText("%s");
+tabSMS.gbMessage1.pbSendSMSMessage.click();
+""" % (sender, text))
+
+        with open("/run/lock/ofono-phonesim-dbus.address") as f:
+            phonesim_bus = f.read().strip()
+        bus = dbus.bus.BusConnection(phonesim_bus)
+        script_proxy = bus.get_object("org.ofono.phonesim", "/")
+        script_proxy.SetPath(script_dir)
+        script_proxy.Run("sms.js")
+        shutil.rmtree(script_dir)
+
+
+class Messages(MainView):
+    def __init__(self, *args):
+        super(Messages, self).__init__(*args)
+
+    def get_message(self, text):
+        """Returns message from text
+
+        :parameter text: the text or date of the label in the message
+
+        """
+
+        time.sleep(2)  # message is not always found on slow emulator
+        for message in self.select_many('MessageDelegate'):
+            for item in self.select_many('Label'):
+                if "text" in item.get_properties():
+                    if item.get_properties()['text'] == text:
+                        return message
+        raise EmulatorException('Could not find message with the text '
+                                '{}'.format(text))
 
     def get_newmessage_textfield(self):
-        return self.select_single("TextField", objectName="newPhoneNumberField")
+        """Returns TextField with objectName newPhoneNumberField"""
+
+        return self.select_single(
+            "TextField",
+            objectName="newPhoneNumberField",
+        )
+
+    def get_multiple_selection_list_view(self):
+        """Returns MultipleSelectionListView from the messages page"""
+
+        return self.select_single('MultipleSelectionListView')
 
     def get_newmessage_textarea(self):
-        return self.select_single("TextArea", objectName="")
+        """Returns TextArea with blank objectName"""
+
+        return self.select_single('TextArea', objectName='')
 
     def get_send_button(self):
+        """Returns Button with text Send"""
+
         return self.select_single('Button', text='Send')
 
-    def get_thread_from_number(self, number):
-        for item in self.select_many("QQuickItem"):
-            if "phoneNumber" in item.get_properties():
-                if item.get_properties()['phoneNumber'] == number:
-                    return item
-        return None
+    def get_toolbar_back_button(self):
+        """Returns toolbar button with objectName back_toolbar_button"""
+
+        return self.select_single(
+            'ActionItem',
+            objectName='back_toolbar_button',
+        )
+
+    def get_toolbar_select_messages_button(self):
+        """Returns toolbar button with objectName selectMessagesButton"""
+
+        return self.select_single(
+            'ActionItem',
+            objectName='selectMessagesButton',
+        )
+
+    def get_toolbar_add_contact_button(self):
+        """Returns toolbar button with objectName addContactButton"""
+
+        return self.select_single(
+            'ActionItem',
+            objectName='addContactButton',
+        )
+
+    def get_toolbar_contact_profile_button(self):
+        """Returns toolbar button with objectName contactProfileButton"""
+
+        return self.select_single(
+            'ActionItem',
+            objectName='contactProfileButton',
+        )
+
+    def get_toolbar_contact_call_button(self):
+        """Returns toolbar button with objectName contactCallButton"""
+
+        return self.select_single(
+            'ActionItem',
+            objectName='contactCallButton',
+        )
+
+    def type_message(self, message):
+        """Select and type message in new message text area in messages page
+
+        :parameter message: the message to type
+        """
+
+        text_entry = self.get_newmessage_textarea()
+        self.pointing_device.click_object(text_entry)
+        text_entry.focus.wait_for(True)
+        time.sleep(.3)
+        self.keyboard.type(str(message), delay=0.2)
+        self.logger.info(
+            'typed: "{}" expected: "{}"'.format(text_entry.text, message))
+
+    def type_contact_phone_num(self, num_or_contact):
+        """Select and type phone number or contact
+
+        :parameter num_or_contact: number or contact to type
+        """
+
+        text_entry = self.get_newmessage_textfield()
+        self.pointing_device.click_object(text_entry)
+        text_entry.focus.wait_for(True)
+        time.sleep(.3)
+        self.keyboard.type(str(num_or_contact), delay=0.2)
+        self.logger.info(
+            'typed "{}" expected "{}"'.format(text_entry.text, num_or_contact))
+
+    def click_send_button(self):
+        """Returns and click the send button on the message page"""
+
+        button = self.get_send_button()
+        button.enabled.wait_for(True)
+        self.pointing_device.click_object(button)
+        button.enabled.wait_for(False)
+        return button
+
+    def click_add_new_contact_button(self):
+        """Returns and clicks the add contact button on the message page"""
+
+        icon = self.select_single("Icon", name="new-contact")
+        self.pointing_device.click_object(icon)
+        return icon

=== modified file 'tests/autopilot/messaging_app/tests/__init__.py'
--- tests/autopilot/messaging_app/tests/__init__.py	2013-10-17 11:14:18 +0000
+++ tests/autopilot/messaging_app/tests/__init__.py	2014-02-14 19:29:11 +0000
@@ -1,5 +1,5 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2012 Canonical
+# Copyright 2012-2014 Canonical
 #
 # This file is part of messaging-app.
 #
@@ -13,19 +13,23 @@
 from autopilot.matchers import Eventually
 from autopilot.platform import model
 from autopilot.testcase import AutopilotTestCase
-from testtools.matchers import Equals, GreaterThan
-
+from testtools.matchers import Equals
+
+from address_book_app.helpers import (backup_evolution_contacts_db,
+                                      restore_evolution_contacts_db,
+                                      wipe_evolution_contacts_db)
+
+from messaging_app import emulators
 from ubuntuuitoolkit import emulators as toolkit_emulators
-from messaging_app import emulators
 
 import os
 import sys
-from time import sleep
 import logging
 import subprocess
 
 logger = logging.getLogger(__name__)
 
+
 # ensure we have an ofono account; we assume that we have these tools,
 # otherwise we consider this a test failure (missing dependencies)
 def tp_has_ofono():
@@ -47,6 +51,10 @@
 
     """
 
+    #Don't use keyboard on desktop
+    if model() == 'Desktop':
+        subprocess.call(['/sbin/initctl', 'stop', 'maliit-server'])
+
     if model() == 'Desktop':
         scenarios = [
             ('with mouse', dict(input_device_class=Mouse)),
@@ -56,12 +64,24 @@
             ('with touch', dict(input_device_class=Touch)),
         ]
 
-    local_location = "../../src/messaging-app"
+    local_location = '../../src/messaging-app'
 
     def setUp(self):
         self.pointing_device = Pointer(self.input_device_class.create())
         super(MessagingAppTestCase, self).setUp()
 
+        subprocess.call(['pkill', 'messaging-app'])
+
+        # backup and add contacts
+        current_dir = os.path.abspath(os.path.dirname(__file__))
+        self.test_contacts_db = os.path.abspath(
+            current_dir + "../../data/contacts.sync"
+        )
+
+        self.tmp_contacts_backup = backup_evolution_contacts_db()
+        wipe_evolution_contacts_db()
+        restore_evolution_contacts_db(self.test_contacts_db)
+
         if os.path.exists(self.local_location):
             self.launch_test_local()
         else:
@@ -69,27 +89,39 @@
 
         self.assertThat(self.main_view.visible, Eventually(Equals(True)))
 
+    def tearDown(self):
+        super(MessagingAppTestCase, self).tearDown()
+        # restore contacts
+        wipe_evolution_contacts_db()
+        restore_evolution_contacts_db(self.tmp_contacts_backup)
+        os.remove(self.tmp_contacts_backup)
+
     def launch_test_local(self):
         self.app = self.launch_test_application(
             self.local_location,
-            "--test-contacts",
+            '--test-contacts',
             app_type='qt',
             emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
     def launch_test_installed(self):
         if model() == 'Desktop':
             self.app = self.launch_test_application(
-                "messaging-app",
-                "--test-contacts",
+                'messaging-app',
+                '--test-contacts',
                 emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
         else:
             self.app = self.launch_test_application(
-               "messaging-app", 
-               "--test-contacts",
-               "--desktop_file_hint=/usr/share/applications/messaging-app.desktop",
-               app_type='qt',
-               emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
+                'messaging-app',
+                '--test-contacts',
+                '--desktop_file_hint='
+                '/usr/share/applications/messaging-app.desktop',
+                app_type='qt',
+                emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
     @property
     def main_view(self):
         return self.app.select_single(emulators.MainView)
+
+    @property
+    def message_page(self):
+        return self.app.select_single(emulators.Messages)

=== modified file 'tests/autopilot/messaging_app/tests/test_messaging.py'
--- tests/autopilot/messaging_app/tests/test_messaging.py	2013-12-12 00:25:27 +0000
+++ tests/autopilot/messaging_app/tests/test_messaging.py	2014-02-14 19:29:11 +0000
@@ -11,49 +11,46 @@
 
 from __future__ import absolute_import
 
+import os
 import subprocess
-import os
-import tempfile
-import shutil
 import time
 
-import dbus
-
+from autopilot.introspection import dbus
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
-from testtools import skipIf, skipUnless
 
 from messaging_app.tests import MessagingAppTestCase
 
-# determine whether we are running with phonesim
-try:
-    out = subprocess.check_output(["/usr/share/ofono/scripts/list-modems"],
-                                  stderr=subprocess.PIPE)
-    have_phonesim = out.startswith("[ /phonesim ]")
-except subprocess.CalledProcessError:
-    have_phonesim = False
-
-
-@skipUnless(have_phonesim,
-            "this test needs to run under with-ofono-phonesim")
-@skipIf(os.uname()[2].endswith("maguro"),
-        "tests cause Unity crashes on maguro")
+
 class TestMessaging(MessagingAppTestCase):
     """Tests for the communication panel."""
 
     def setUp(self):
+
+        # determine whether we are running with phonesim
+        try:
+            out = subprocess.check_output(
+                ['/usr/share/ofono/scripts/list-modems'],
+                stderr=subprocess.PIPE
+            )
+            have_phonesim = out.startswith('[ /phonesim ]')
+        except subprocess.CalledProcessError:
+            have_phonesim = False
+
+        self.assertTrue(have_phonesim)
+
         # provide clean history
         self.history = os.path.expanduser(
-            "~/.local/share/history-service/history.sqlite")
+            '~/.local/share/history-service/history.sqlite')
         if os.path.exists(self.history):
-            os.rename(self.history, self.history + ".orig")
-        subprocess.call(["pkill", "history-daemon"])
-        subprocess.call(["pkill", "-f", "telephony-service-handler"])
+            os.rename(self.history, self.history + '.orig')
+        subprocess.call(['pkill', 'history-daemon'])
+        subprocess.call(['pkill', '-f', 'telephony-service-handler'])
 
         super(TestMessaging, self).setUp()
 
         # no initial messages
-        self.thread_list = self.app.select_single(objectName="threadList")
+        self.thread_list = self.app.select_single(objectName='threadList')
         self.assertThat(self.thread_list.visible, Equals(True))
         self.assertThat(self.thread_list.count, Equals(0))
 
@@ -65,132 +62,624 @@
             os.unlink(self.history)
         except OSError:
             pass
-        if os.path.exists(self.history + ".orig"):
-            os.rename(self.history + ".orig", self.history)
-        subprocess.call(["pkill", "history-daemon"])
-        subprocess.call(["pkill", "-f", "telephony-service-handler"])
+        if os.path.exists(self.history + '.orig'):
+            os.rename(self.history + '.orig', self.history)
+        subprocess.call(['pkill', 'history-daemon'])
+        subprocess.call(['pkill', '-f', 'telephony-service-handler'])
 
         # on desktop, notify-osd may generate persistent popups (like for "SMS
         # received"), don't make that stay around for the tests
-        subprocess.call(["pkill", "-f", "notify-osd"])
+        subprocess.call(['pkill', '-f', 'notify-osd'])
+
+    def test_receive_message(self):
+        """Verify that we can receive a text message"""
+        # receive an sms message
+        self.main_view.receive_sms('0815', 'hello to Ubuntu')
+
+        # verify that we got the message
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+
+        # verify number
+        self.thread_list.select_single('Label', text='0815')
+        time.sleep(1)  # make it visible to human users for a sec
+        # verify text
+        self.thread_list.select_single('Label', text='hello to Ubuntu')
 
     def test_write_new_message(self):
-        self.click_new_message_button()
-
-        # type address number
-        text_entry = self.main_view.get_newmessage_textfield()
-        text_entry.activeFocus.wait_for(True)
-        self.keyboard.type("123")
-        self.assertThat(text_entry.text, Eventually(Equals("123")))
-
-        # type message
-        text_entry = self.main_view.get_newmessage_textarea()
-        self.pointing_device.click_object(text_entry)
-        # need to click twice, first time to hide the toolbar (LP#1207369)
-        self.pointing_device.click_object(text_entry)
-        text_entry.activeFocus.wait_for(True)
-        message = "hello from Ubuntu"
-        self.keyboard.type(message)
-        self.assertThat(text_entry.text, Eventually(Equals(message)))
-
-        # send
-        button = self.main_view.get_send_button()
-        self.assertThat(button.enabled, Eventually(Equals(True)))
-        self.pointing_device.click_object(button)
-        self.assertThat(button.enabled, Eventually(Equals(False)))
-
-        # verify that we get a bubble with our message
-        messages_page = self.main_view.select_single(objectName="messagesPage")
-        list_view = messages_page.select_single("MultipleSelectionListView")
-        self.assertThat(list_view.count, Eventually(Equals(1)))
-        l = list_view.select_single("Label", text="hello from Ubuntu")
-        self.assertNotEqual(l, None)
-
-        # switch back to main page with thread list
-        self.close_osk()
-
-        # TODO: this is a workaround to force the keyboard to close, as close_osk()
-        # doesn't seem to work on mako
-        self.pointing_device.click_object(button)
-        self.go_back()
-        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
-
-        # should show our message in the thread list
-        self.assertThat(self.thread_list.count, Equals(1))
-        # should show address number
-        l = self.thread_list.select_single("Label", text="123")
-        self.assertNotEqual(l, None)
-        # should show text
-        l = self.thread_list.select_single("Label", text="hello from Ubuntu")
-        self.assertNotEqual(l, None)
-
-    def test_receive_message(self):
-        self.receive_sms("0815", "hello to Ubuntu")
-
-        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
-        l = self.thread_list.select_single("Label", text="0815")
-        self.assertNotEqual(l, None)
-        time.sleep(1)  # make it visible to human users for a sec
-        # should show text
-        l = self.thread_list.select_single("Label", text="hello to Ubuntu")
-        self.assertNotEqual(l, None)
-
-    #
-    # Helper methods
-    #
-
-    def click_new_message_button(self):
-        """Click "New message" menu button and wait for "New message" page"""
-
-        self.main_view.open_toolbar()
-        toolbar = self.main_view.get_toolbar()
-        toolbar.click_button("newMessageButton")
-        self.assertThat(self.main_view.get_pagestack().depth,
-                        Eventually(Equals(2)))
-        self.assertThat(self.main_view.get_messages_page().visible,
-                        Eventually(Equals(True)))
-        self.assertThat(self.thread_list.visible, Equals(False))
-
-    def close_osk(self):
-        """Swipe down to close on-screen keyboard"""
-
-        # TODO: hack! this belongs into the Ubuntu UI toolkit emulator,
-        # LP#1239753
-        x1, y1, x2, y2 = self.main_view.globalRect
-        mid_x = (x2 - x1) // 2
-        mid_y = (y2 - y1) * 7 // 10
-        self.pointing_device.drag(mid_x, mid_y, mid_x, y2)
-        time.sleep(1)
-
-    def go_back(self):
-        """Click back button from toolbar"""
-
-        # will fail with i18n; this belongs into the Ubuntu UI toolkit
-        # emulator, LP#1239751
-        self.main_view.open_toolbar()
-        toolbar = self.main_view.get_toolbar()
-        back_button = toolbar.select_single("ActionItem", text=u"Back")
-        self.assertNotEqual(back_button, None)
-        self.pointing_device.click_object(back_button)
-
-    def receive_sms(self, sender, text):
-        """Receive an SMS"""
-
-        # prepare and send a Qt GUI script to phonesim, over its private D-BUS
-        # set up by ofono-phonesim-autostart
-        script_dir = tempfile.mkdtemp(prefix="phonesim_script")
-        os.chmod(script_dir, 0o755)
-        self.addCleanup(shutil.rmtree, script_dir)
-        with open(os.path.join(script_dir, "sms.js"), "w") as f:
-            f.write("""tabSMS.gbMessage1.leMessageSender.text = "%s";
-tabSMS.gbMessage1.leSMSClass.text = "1";
-tabSMS.gbMessage1.teSMSText.setPlainText("%s");
-tabSMS.gbMessage1.pbSendSMSMessage.click();
-""" % (sender, text))
-
-        with open("/run/lock/ofono-phonesim-dbus.address") as f:
-            phonesim_bus = f.read().strip()
-        bus = dbus.bus.BusConnection(phonesim_bus)
-        script_proxy = bus.get_object("org.ofono.phonesim", "/")
-        script_proxy.SetPath(script_dir)
-        script_proxy.Run("sms.js")
+        """Verify we can write and send a new text message"""
+        self.main_view.click_new_message_button()
+        #verify the thread list page is not visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type contact/number
+        phone_num = 123
+        self.message_page.type_contact_phone_num(phone_num)
+
+        # type message
+        message = 'hello from Ubuntu'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        # verify label text
+        self.message_page.get_message('hello from Ubuntu')
+
+        # switch back to main page with thread list
+        self.main_view.close_osk()
+        self.main_view.go_back()
+
+        # verify the main page with the contacts that have sent messages is
+        # visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
+
+        # verify a message in the thread list
+        self.assertThat(self.thread_list.count, Equals(1))
+        # verify our number
+        self.thread_list.select_single('Label', text='123')
+        # verify our text
+        self.thread_list.select_single('Label', text='hello from Ubuntu')
+
+    def test_deleting_message_long_press(self):
+        """Verify we can delete a message with a long press on the message"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '555-555-4321'
+        self.message_page.type_contact_phone_num(phone_num)
+        # type message
+        message = 'delete me'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        bubble = self.message_page.get_message(message)
+
+        self.main_view.close_osk()
+
+        # long press on bubble
+        self.main_view.long_press(bubble)
+
+        # select delete button
+        self.main_view.click_delete_dialog_button()
+
+        # verify message is deleted
+        bubble.wait_until_destroyed()
+
+    def test_cancel_deleting_message_long_press(self):
+        """Verify we can cancel deleting a message with a long press"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '5555551234'
+        self.message_page.type_contact_phone_num(phone_num)
+
+        # type message
+        message = 'do not delete'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        bubble = self.message_page.get_message(message)
+
+        self.main_view.close_osk()
+
+        # long press on bubble and verify cancel button does not delete message
+        self.main_view.long_press(bubble)
+        self.main_view.click_cancel_dialog_button()
+        time.sleep(5)  # on a slow machine it might return a false positive
+        #the bubble must exist
+        bubble = self.message_page.get_message(message)
+
+    def test_open_received_message(self):
+        """Verify we can open a txt message we have received"""
+        number = '5555555678'
+        message = 'open me'
+        # receive message
+        self.main_view.receive_sms(number, message)
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+        # click message thread
+        mess_thread = self.thread_list.wait_select_single('Label', text=number)
+        self.pointing_device.click_object(mess_thread)
+        self.message_page.get_message(message)
+        # send new message
+        self.message_page.type_message('{} 2'.format(message))
+        self.message_page.click_send_button()
+        # verify both messages are seen in list
+        self.message_page.get_message('{} 2'.format(message))
+        self.message_page.get_message(message)
+
+    def test_delete_multiple_messages(self):
+        """Verify we can delete multiple messages"""
+        number = '5555559876'
+        message = 'delete me'
+        # send 5 messages
+        for num in range(1, 6):
+            self.main_view.receive_sms(number, '{} {}'.format(message, num))
+            time.sleep(1)
+        # verify messages show up in thread
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+
+        mess_thread = self.thread_list.wait_select_single('Label', text=number)
+        self.pointing_device.click_object(mess_thread)
+
+        # long press on message 5
+        bubble5 = self.main_view.get_label('delete me 5')
+        self.main_view.long_press(bubble5)
+
+        # tap message 2 - 4
+        for num in range(2, 5):
+            bubble = self.main_view.get_label(
+                '{} {}'.format(message, num)
+            )
+            self.pointing_device.click_object(bubble)
+
+        # delete messages 2 - 5
+        self.main_view.click_delete_dialog_button()
+
+        #verify message 2 - 5 are destroyed
+        for num in range(2, 6):
+            try:
+                bubble = self.main_view.get_label(
+                    '{} {}'.format(message, num)
+                )
+                bubble.wait_until_destroyed()
+            ## if the message is not there it was already destroyed
+            except dbus.StateNotFoundError:
+                pass
+        #verify message bubble 1 exists
+        self.main_view.get_label('delete me 1')
+
+    def test_toolbar_delete_message(self):
+        """Verify we can use the toolbar to delete a message"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '555-555-4321'
+        self.message_page.type_contact_phone_num(phone_num)
+        # type message
+        message = 'delete me'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        bubble = self.message_page.get_message(message)
+
+        self.main_view.close_osk()
+
+        # press on select button and message then delete
+        self.main_view.click_select_messages_button()
+        self.pointing_device.click_object(bubble)
+        self.main_view.click_delete_dialog_button()
+        #verify messsage is gone
+        bubble.wait_until_destroyed()
+
+    def test_toolbar_delete_message_without_selecting_a_message(self):
+        """Verify we only delete messages that have been selected"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '555-555-4321'
+        self.message_page.type_contact_phone_num(phone_num)
+        # type message
+        message = 'dont delete me'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        self.message_page.get_message(message)
+
+        self.main_view.close_osk()
+
+        # press on select button then delete
+        self.main_view.click_select_messages_button()
+        self.main_view.click_delete_dialog_button()
+
+        #verify messsage is not gone
+        time.sleep(5)  # wait 5 seconds, the emulator is slow
+        list_view.select_single("Label", text=message)
+
+    def test_receive_text_with_letters_in_phone_number(self):
+        """verify we can receive a text message with letters for a phone #"""
+        number = 'letters'
+        message = 'open me'
+        # receive message
+        self.main_view.receive_sms(number, message)
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+        # click message thread
+        mess_thread = self.thread_list.wait_select_single(
+            'Label',
+            text='letters@'  # phonesim sends text with number as letters@
+        )
+        self.pointing_device.click_object(mess_thread)
+        self.message_page.get_message(message)
+        # send new message
+        self.message_page.type_message('{} 2'.format(message))
+        self.message_page.click_send_button()
+        # verify both messages are seen in list
+        self.message_page.get_message('{} 2'.format(message))
+        self.message_page.get_message(message)
+
+    def test_cancel_delete_thread_from_main_view(self):
+        """Verify we can cancel deleting a message thread"""
+        self.main_view.click_new_message_button()
+        #verify the thread list page is not visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type contact/number
+        phone_num = 123
+        self.message_page.type_contact_phone_num(phone_num)
+
+        # type message
+        message = 'hello from Ubuntu'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        # verify label text
+        self.message_page.get_message('hello from Ubuntu')
+
+        # switch back to main page with thread list
+        self.main_view.close_osk()
+        self.main_view.go_back()
+
+        # verify the main page with the contacts that have sent messages is
+        # visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
+
+        # verify a message in the thread list
+        self.assertThat(self.thread_list.count, Equals(1))
+        # verify our number
+        self.thread_list.select_single('Label', text='123')
+        # verify our text
+        self.thread_list.select_single('Label', text='hello from Ubuntu')
+        # use select button in toolbar
+        self.main_view.click_select_button()
+        # click cancel button
+        self.main_view.click_cancel_dialog_button()
+        # wait for slow emulator
+        time.sleep(5)
+        # verify our number was not deleted
+        self.thread_list.select_single('Label', text='123')
+        # verify our text was not deleted
+        self.thread_list.select_single('Label', text='hello from Ubuntu')
+
+    def test_delete_thread_from_main_view(self):
+        """Verify we can delete a message thread"""
+        self.main_view.click_new_message_button()
+        #verify the thread list page is not visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type contact/number
+        phone_num = 123
+        self.message_page.type_contact_phone_num(phone_num)
+
+        # type message
+        message = 'hello from Ubuntu'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        # verify label text
+        self.message_page.get_message('hello from Ubuntu')
+
+        # switch back to main page with thread list
+        self.main_view.close_osk()
+        self.main_view.go_back()
+
+        # verify the main page with the contacts that have sent messages is
+        # visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
+
+        # verify a message in the thread list
+        self.assertThat(self.thread_list.count, Equals(1))
+        # verify our number
+        mess_thread = self.thread_list.select_single('Label', text='123')
+        # verify our text
+        self.thread_list.select_single('Label', text='hello from Ubuntu')
+        # use select button in toolbar
+        self.main_view.click_select_button()
+        # click thread we want to delete
+        self.pointing_device.click_object(mess_thread)
+        # click cancel button
+        self.main_view.click_delete_dialog_button()
+        # verify our text was deleted
+        mess_thread.wait_until_destroyed()
+
+    def test_delete_message_thread_swipe_right(self):
+        """Verify we can delete a message thread by swiping right"""
+        # receive an sms message
+        self.main_view.receive_sms('0815', 'hello to Ubuntu')
+
+        # verify that we got the message
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+
+        # delete thread by swiping
+        self.main_view.delete_thread('0815')
+        self.assertThat(self.thread_list.count, Eventually(Equals(0)))
+
+    def test_delete_message_swipe_right(self):
+        """Verify we can delete a message by swiping right"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '555-555-4321'
+        self.message_page.type_contact_phone_num(phone_num)
+        # type message
+        message = 'delete me okay'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        self.message_page.get_message(message)
+
+        #delete message
+        self.message_page.delete_message(message)
+        self.assertThat(list_view.count, Eventually(Equals(0)))
+
+    def test_delete_message_thread_swipe_left(self):
+        """Verify we can delete a message thread by swiping left"""
+        # receive an sms message
+        self.main_view.receive_sms('0815', 'hello to Ubuntu')
+
+        # verify that we got the message
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+
+        # delete thread by swiping
+        self.main_view.delete_thread('0815', direction='left')
+        self.assertThat(self.thread_list.count, Eventually(Equals(0)))
+
+    def test_delete_message_swipe_left(self):
+        """Verify we can delete a message by swiping left"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '555-555-4321'
+        self.message_page.type_contact_phone_num(phone_num)
+        # type message
+        message = 'delete me okay'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        self.message_page.get_message(message)
+
+        #delete message
+        self.message_page.delete_message(message, direction='left')
+        self.assertThat(list_view.count, Eventually(Equals(0)))
+
+    def test_receive_long_message(self):
+        """Verify that we dont crash after receiving a realy long text message
+        """
+        # receive an sms message
+        message = str('loong' * 4000)
+        self.main_view.receive_sms('0815', message)
+
+        # verify that we got the message
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+
+        # verify number
+        self.thread_list.select_single('Label', text='0815')
+        time.sleep(1)  # make it visible to human users for a sec
+        # verify text
+        self.thread_list.select_single('Label', text=message)
+
+    def test_receiving_text_to_existing_contact(self):
+        """Verify contact name is used when receiving message from existing
+            contact
+        """
+        # receive an sms message
+        message = 'message from Bb'
+        self.main_view.receive_sms('2', message)
+
+        # verify that we got the message
+        self.assertThat(self.thread_list.count, Eventually(Equals(1)))
+
+        # verify number
+        self.thread_list.select_single('Label', text="Bb")
+        time.sleep(1)  # make it visible to human users for a sec
+        # verify text
+        self.thread_list.select_single('Label', text=message)
+
+    def test_send_message_using_new_contacts_button(self):
+        """Verify new contacts name lets you send a message to existing contact
+        """
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # type address number
+        phone_num = '111'
+        contact_name = 'Aaaa'
+
+        # use new contacts to select contact
+        self.message_page.click_add_new_contact_button()
+
+        contact_label = self.main_view.click_visible_label(contact_name)
+        self.main_view.click_visible_label(phone_num)
+
+        contact_label.wait_until_destroyed()
+
+        # type message
+        message = 'test message'
+        self.message_page.type_message(message)
+
+        # send
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        self.message_page.get_message(message)
+
+        # verify the header has the selected contact name
+        self.assertThat(self.main_view.get_header().title,
+                        Eventually(Equals(contact_name)))
+
+    def test_receive_text_from_contact_with_more_than_one_phone_number(self):
+        """Verify that a text can be received from a contact with more than one
+            phone number
+        """
+        message1 = '1 from Aa'
+        message2 = '2 from Aa'
+
+        # send messages
+        self.main_view.receive_sms('1', message1)
+        time.sleep(1)  # The last message needs to be displayed as the thread
+        self.main_view.receive_sms('9', message2)
+
+        # we should have 2 threads
+        self.assertThat(self.thread_list.count, Eventually(Equals(2)))
+
+        # verify contact name and both numbers are displayed
+        self.thread_list.select_many('Label', text='Aa')
+        time.sleep(2)  # make it human readable
+        self.thread_list.select_single('Label', text='Work')
+        self.thread_list.select_single('Label', text='Mobile')
+        # verify text
+        self.thread_list.select_single('Label', text=message2)
+        self.thread_list.select_single('Label', text=message1)
+
+    def test_contact_predictive_text(self):
+        """test predictive text when selecting contact"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        # select contact via predictive text
+        self.message_page.type_contact_phone_num('a')
+        self.main_view.click_visible_label('Aaa')
+
+        self.assertThat(self.main_view.get_header().title,
+                        Eventually(Equals('Aaa')))
+
+    def test_send_text_to_contact_with_more_than_one_number(self):
+        """Send a text to a contact with more than one number"""
+        message = 'Aa get this'
+
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        self.message_page.type_contact_phone_num('1')
+
+        self.message_page.type_message(message)
+
+        self.message_page.click_send_button()
+
+        # verify that we get a bubble with our message
+        list_view = self.message_page.get_multiple_selection_list_view()
+        self.assertThat(list_view.count, Eventually(Equals(1)))
+        # verify label text
+        self.message_page.get_message(message)
+
+        self.assertThat(self.main_view.get_header().title,
+                        Eventually(Equals('Aa')))
+
+        # switch back to main page with thread list
+        self.main_view.close_osk()
+        self.main_view.go_back()
+
+        # verify the main page with the contacts that have sent messages is
+        # visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
+
+        # verify a message in the thread list
+        self.assertThat(self.thread_list.count, Equals(1))
+        # verify our phone type and number
+        self.thread_list.select_single('Label', text='Aa')
+        self.thread_list.select_single('Label', text='Mobile')
+        # verify our text
+        self.thread_list.select_single('Label', text=message)
+
+    def test_more_than_one_message_to_contact_with_more_than_one_number(self):
+        """Send more than one message to a contact with more than one number"""
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        self.message_page.type_contact_phone_num('1')
+        self.message_page.type_message('message1')
+
+        self.message_page.click_send_button()
+
+        self.assertThat(self.main_view.get_header().title,
+                        Eventually(Equals('Aa')))
+
+        # switch back to main page with thread list
+        self.main_view.close_osk()
+        self.main_view.go_back()
+
+        # verify the main page with the contacts that have sent messages is
+        # visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
+
+        # verify a message in the thread list
+        self.assertThat(self.thread_list.count, Equals(1))
+        # verify our number
+        self.thread_list.select_single('Label', text='Aa')
+        self.thread_list.select_single('Label', text='message1')
+
+        # make second message
+        self.main_view.click_new_message_button()
+        self.assertThat(self.thread_list.visible, Eventually(Equals(False)))
+
+        self.message_page.type_contact_phone_num('9')
+        self.message_page.type_message('message9')
+
+        self.message_page.click_send_button()
+
+        self.assertThat(self.main_view.get_header().title,
+                        Eventually(Equals('Aa')))
+
+        # switch back to main page with thread list
+        self.main_view.close_osk()
+        self.main_view.go_back()
+
+        # verify the main page with the contacts that have sent messages is
+        # visible
+        self.assertThat(self.thread_list.visible, Eventually(Equals(True)))
+
+        # verify a message in the thread list
+        self.assertThat(self.thread_list.count, Equals(2))
+        # verify our number
+        self.thread_list.select_many('Label', text='Aa')
+        self.thread_list.select_single('Label', text='message1')
+        self.thread_list.select_single('Label', text='message9')

=== removed file 'tests/autopilot/messaging_app/tests/test_ui.py'
--- tests/autopilot/messaging_app/tests/test_ui.py	2013-11-04 13:13:15 +0000
+++ tests/autopilot/messaging_app/tests/test_ui.py	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-# Copyright 2013 Canonical
-#
-# This file is part of messaging-app.
-#
-# messaging-app is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-
-"""Pure UI tests for Messaging App"""
-
-from __future__ import absolute_import
-
-from autopilot.matchers import Eventually
-from testtools.matchers import Equals
-
-from messaging_app.tests import MessagingAppTestCase
-
-
-class TestUI(MessagingAppTestCase):
-    def test_new_message_panel(self):
-        """New message panel comes up with the toolbar button"""
-
-        # Click "New message" menu button
-        self.main_view.open_toolbar()
-        toolbar = self.main_view.get_toolbar()
-        toolbar.click_button("newMessageButton")
-
-        # wait for "New message" page
-        self.assertThat(self.main_view.get_pagestack().depth,
-                        Eventually(Equals(2)))
-        self.assertThat(self.main_view.get_messages_page().visible,
-                        Eventually(Equals(True)))
-
-        # type address number
-        text_entry = self.main_view.get_newmessage_textfield()
-        text_entry.activeFocus.wait_for(True)
-        self.keyboard.type("123")
-        self.assertThat(text_entry.text, Eventually(Equals("123")))
-
-        # type message
-        text_entry = self.main_view.get_newmessage_textarea()
-        self.pointing_device.click_object(text_entry)
-        # need to click twice, first time to hide the toolbar (LP#1207369)
-        self.pointing_device.click_object(text_entry)
-        text_entry.activeFocus.wait_for(True)
-        message = "hello from Ubuntu"
-        self.keyboard.type(message)
-        self.assertThat(text_entry.text, Eventually(Equals(message)))