Merge lp:~dobey/software-center/update-13-10 into lp:software-center/stable-13-10

[dobey]

[Rodney Dawes]

    Fix some RuntimeWarnings about old-style classes.
    Remove the old gtk+ based SSO UI, and rely on the system library and UI.
    Use the "Ubuntu One" token for authenticating to the server now.

[Marco Trevisan]

    Log zeitgeist events on application install/removal.

[Michael Vogt]

    Improve Unity launcher integration.

[Sv. Lockal]

    Fix UnicodeDecodeError for localized category names.

[Roberto Alsina (ralsina)]

review: Approve

[Alejandro J. Cura (alecu)]

+1

review: Approve

=== removed file 'bin/software-center-sso-gtk'
--- bin/software-center-sso-gtk	2013-04-17 17:36:54 +0000
+++ bin/software-center-sso-gtk	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright 2012 Canonical Ltd.
-#
-# This program 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.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-#
-
-"""Start the SSO GTK+ UI."""
-
-# Invalid name "software-center-sso-gtk", pylint: disable=C0103
-# Access to a protected member, pylint: disable=W0212
-
-import sys
-sys.path.insert(0, "/usr/share/software-center")
-
-from softwarecenter.sso import gui
-from ubuntu_sso.utils.ui import parse_args
-
-from dbus.mainloop.glib import DBusGMainLoop
-DBusGMainLoop(set_as_default=True)
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    gui.run(**dict(args._get_kwargs()))

=== modified file 'setup.py'
--- setup.py	2013-08-06 19:23:26 +0000
+++ setup.py	2013-09-17 17:52:06 +0000
@@ -95,7 +95,6 @@
         'softwarecenter.db.history_impl',
         'softwarecenter.distro',
         'softwarecenter.plugins',
-        'softwarecenter.sso',
         'softwarecenter.ui',
         'softwarecenter.ui.gtk3',
         'softwarecenter.ui.gtk3.dialogs',
@@ -117,8 +116,6 @@
          glob.glob("data/ui/gtk3/art/icons/*.png")),
         ('share/software-center/default_banner',
          glob.glob("data/default_banner/*")),
-        # sso
-        ('share/software-center/ui/sso/', glob.glob("data/ui/sso/*.ui")),
         # dbus
         ('../etc/dbus-1/system.d/',
          ["data/dbus/com.ubuntu.SoftwareCenter.conf"]),
@@ -137,6 +134,5 @@
         # extra software channels (can be distro specific)
         ('share/app-install/channels/',
          glob.glob("data/channels/%s/*.{eula,list}" % distro)),
-        ('lib/ubuntu-sso-client', ['bin/software-center-sso-gtk']),
     ],
 )

=== modified file 'softwarecenter/backend/installbackend_impl/aptd.py'
--- softwarecenter/backend/installbackend_impl/aptd.py	2012-12-14 16:44:25 +0000
+++ softwarecenter/backend/installbackend_impl/aptd.py	2013-09-17 17:52:06 +0000
@@ -716,6 +716,11 @@
                 trans = yield self.aptd_client.install_packages(
                     [app.pkgname], defer=True)
                 self._logger.info("run_transaction()")
+                # notify about the install so that the unity-launcher
+                # integration works
+                self.emit("transaction-started",
+                          app.pkgname, app.appname, trans.tid,
+                          TransactionTypes.INSTALL)
                 yield self._run_transaction(trans, app.pkgname, app.appname,
                                             "", metadata)
             except Exception as error:

=== modified file 'softwarecenter/backend/login_impl/login_sso.py'
--- softwarecenter/backend/login_impl/login_sso.py	2012-11-28 17:36:38 +0000
+++ softwarecenter/backend/login_impl/login_sso.py	2013-09-17 17:52:06 +0000
@@ -41,7 +41,7 @@
 
     def __init__(self, window_id, appname, help_text):
         super(LoginBackendDbusSSO, self).__init__()
-        self.appname = appname
+        self.appname = 'Ubuntu One'
         self.help_text = help_text
         self.bus = dbus.SessionBus()
         obj = self.bus.get_object(bus_name=DBUS_BUS_NAME,
@@ -61,8 +61,7 @@
         self._credentials = None
 
     def _get_params(self):
-        p = {'ui_executable': 'software-center-sso-gtk',
-             }
+        p = {}
         if self.help_text:
             p['help_text'] = utf8(self.help_text)
         if self._window_id:

=== modified file 'softwarecenter/backend/unitylauncher.py'
--- softwarecenter/backend/unitylauncher.py	2012-11-23 22:57:21 +0000
+++ softwarecenter/backend/unitylauncher.py	2013-09-17 17:52:06 +0000
@@ -2,6 +2,7 @@
 #
 # Authors:
 #  Gary Lasker
+#  Michael Vogt
 #
 # 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
@@ -18,6 +19,8 @@
 
 import dbus
 import logging
+import os
+import tempfile
 
 LOG = logging.getLogger(__name__)
 
@@ -45,44 +48,68 @@
         self.trans_id = trans_id
 
 
-class TransactionDetails(object):
-    """ Simple class to keep track of aptdaemon transaction details for
-        use with the Unity launcher integration
-    """
-    def __init__(self,
-                 pkgname,
-                 appname,
-                 trans_id,
-                 trans_type):
-        self.pkgname = pkgname
-        self.appname = appname
-        self.trans_id = trans_id
-        self.trans_type = trans_type
-
-
 class UnityLauncher(object):
     """ Implements the integration between Software Center and the Unity
         launcher
     """
 
+    def __init__(self):
+        self._pkgname_to_temp_desktop_file = {}
+
+    def _get_launcher_dbus_iface(self):
+        bus = dbus.SessionBus()
+        launcher_obj = bus.get_object('com.canonical.Unity.Launcher',
+                                      '/com/canonical/Unity/Launcher')
+        launcher_iface = dbus.Interface(launcher_obj,
+                                        'com.canonical.Unity.Launcher')
+        return launcher_iface
+
+    def cancel_application_to_launcher(self, pkgname):
+        filename = self._pkgname_to_temp_desktop_file.pop(pkgname, None)
+        if filename:
+            os.unlink(filename)
+
+    def _get_temp_desktop_file(self, pkgname, launcher_info):
+        with tempfile.NamedTemporaryFile(prefix="software-center-agent:",
+                                         suffix=":%s.desktop" % pkgname,
+                                         delete=False) as fp:
+            s = """
+[Desktop Entry]
+Name=%(name)s
+Icon=%(icon_file_path)s
+Type=Application""" % {'name': launcher_info.name,
+                       'icon_file_path': launcher_info.icon_file_path,
+                       }
+            fp.write(s)
+            fp.flush()
+            LOG.debug("create temp desktop file '%s'" % fp.name)
+            return fp.name
+
     def send_application_to_launcher(self, pkgname, launcher_info):
         """ send a dbus message to the Unity launcher service to initiate
             the add-to-launcher functionality for the specified application
         """
-        LOG.debug("sending dbus signal to Unity launcher for application: ",
+
+        # stuff from the agent has no desktop file so we create a fake
+        # one here just for the install
+        if (launcher_info.installed_desktop_file_path ==
+            "software-center-agent"):
+            temp_desktop = self._get_temp_desktop_file(pkgname, launcher_info)
+            launcher_info.installed_desktop_file_path = temp_desktop
+            self._pkgname_to_temp_desktop_file[pkgname] = temp_desktop
+
+        LOG.debug("sending dbus signal to Unity launcher for application: %r",
                   launcher_info.name)
-        LOG.debug("  launcher_info.icon_file_path: ",
+        LOG.debug("  launcher_info: icon_file_path: %r ",
                      launcher_info.icon_file_path)
-        LOG.debug("  launcher_info.installed_desktop_file_path: ",
+        LOG.debug("  launcher_info.installed_desktop_file_path: %r",
                      launcher_info.installed_desktop_file_path)
-        LOG.debug("  launcher_info.trans_id: ", launcher_info.trans_id)
+        LOG.debug("  launcher_info.trans_id: %r", launcher_info.trans_id)
+        LOG.debug("  launcher_info.icon_x: %r icon_y: %r",
+                     launcher_info.icon_x, launcher_info.icon_y)
 
         try:
-            bus = dbus.SessionBus()
-            launcher_obj = bus.get_object('com.canonical.Unity.Launcher',
-                                          '/com/canonical/Unity/Launcher')
-            launcher_iface = dbus.Interface(launcher_obj,
-                                            'com.canonical.Unity.Launcher')
+            launcher_iface = self._get_launcher_dbus_iface()
             launcher_iface.AddLauncherItemFromPosition(
                     launcher_info.name,
                     launcher_info.icon_file_path,

=== added file 'softwarecenter/backend/zeitgeist_logger.py'
--- softwarecenter/backend/zeitgeist_logger.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/backend/zeitgeist_logger.py	2013-09-17 17:52:06 +0000
@@ -0,0 +1,97 @@
+# Copyright (C) 2013 Canonical
+#
+# Authors:
+#  Marco Trevisan <[e-mail]>
+#
+# 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; version 3.
+#
+# 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, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import logging
+from softwarecenter.utils import get_desktop_id
+
+LOG = logging.getLogger(__name__)
+APPLICATION_URI_PREFIX = "application://"
+HAVE_MODULE = False
+
+try:
+    from zeitgeist.client import ZeitgeistClient
+    from zeitgeist import datamodel as ZeitgeistDataModel
+    from zeitgeist.datamodel import (Event as ZeitgeistEvent,
+                                     Subject as ZeitgeistSubject)
+    HAVE_MODULE = True
+except ImportError:
+    LOG.warn("Support for Zeitgeist disabled")
+
+class ZeitgeistLogger(object):
+    def __init__(self, distro):
+        self.distro = distro
+
+    def __create_user_event(self):
+        event = ZeitgeistEvent()
+        event.actor = APPLICATION_URI_PREFIX + self.distro.get_app_id() + ".desktop"
+        event.manifestation = ZeitgeistDataModel.Manifestation.EVENT_MANIFESTATION.USER_ACTIVITY
+        return event
+
+    def __create_app_subject(self, desktop_file):
+        subject = ZeitgeistSubject()
+        subject.interpretation = ZeitgeistDataModel.Interpretation.SOFTWARE
+        subject.manifestation = ZeitgeistDataModel.Manifestation.SOFTWARE_ITEM
+        subject.uri = APPLICATION_URI_PREFIX + get_desktop_id(desktop_file);
+        subject.current_uri = subject.uri
+        subject.mimetype = "application/x-desktop"
+        return subject
+
+    def log_install_event(self, desktop_file):
+        """Logs an install event on Zeitgeist"""
+        if not HAVE_MODULE:
+            LOG.warn("No zeitgeist support, impossible to log event")
+            return False
+
+        if not desktop_file or not len(desktop_file):
+            LOG.warn("Invalid desktop file provided, impossible to log event")
+            return False
+
+        subject = self.__create_app_subject(desktop_file)
+
+        subject.text = "Installed with " + self.distro.get_app_name()
+        event = self.__create_user_event()
+        event.interpretation = ZeitgeistDataModel.Interpretation.EVENT_INTERPRETATION.CREATE_EVENT
+        event.append_subject(subject)
+        ZeitgeistClient().insert_event(event)
+
+        subject.text = "Accessed by " + self.distro.get_app_name()
+        event = self.__create_user_event()
+        event.interpretation = ZeitgeistDataModel.Interpretation.EVENT_INTERPRETATION.ACCESS_EVENT
+        event.append_subject(subject)
+        ZeitgeistClient().insert_event(event)
+        return True
+
+    def log_uninstall_event(self, desktop_file):
+        """Logs an uninstall event on Zeitgeist"""
+        if not HAVE_MODULE:
+            LOG.warn("No zeitgeist support, impossible to log event")
+            return False
+
+        if not desktop_file or not len(desktop_file):
+            LOG.warn("Invalid desktop file provided, impossible to log event")
+            return False
+
+        subject = self.__create_app_subject(desktop_file)
+        subject.text = "Uninstalled with " + self.distro.get_app_name()
+
+        event = self.__create_user_event()
+        event.interpretation = ZeitgeistDataModel.Interpretation.EVENT_INTERPRETATION.DELETE_EVENT
+        event.append_subject(subject)
+        ZeitgeistClient().insert_event(event)
+        return True
+

=== modified file 'softwarecenter/db/categories.py'
--- softwarecenter/db/categories.py	2012-12-14 16:44:25 +0000
+++ softwarecenter/db/categories.py	2013-09-17 17:52:06 +0000
@@ -291,7 +291,9 @@
 
         # debug print
         for cat in categories:
-            LOG.debug("%s %s %s" % (cat.name, cat.iconname, cat.query))
+            LOG.debug("%s %s %s" % (cat.name.decode('utf8'),
+                                    cat.iconname,
+                                    cat.query))
         return categories
 
     def _build_string_template_dict(self):

=== modified file 'softwarecenter/db/database.py'
--- softwarecenter/db/database.py	2012-12-14 16:44:25 +0000
+++ softwarecenter/db/database.py	2013-09-17 17:52:06 +0000
@@ -637,7 +637,7 @@
             yield doc
 
 
-class FakeMSetItem():
+class FakeMSetItem(object):
     def __init__(self, doc):
         self.document = doc
 

=== modified file 'softwarecenter/distro/__init__.py'
--- softwarecenter/distro/__init__.py	2012-11-28 16:58:59 +0000
+++ softwarecenter/distro/__init__.py	2013-09-17 17:52:06 +0000
@@ -59,6 +59,12 @@
         """
         return _("Software Center")
 
+    def get_app_id(self):
+        """
+        The application-id (as used on the .desktop file)
+        """
+        return "software-center"
+
     def get_app_description(self):
         """
         The description of the application displayed in the about dialog

=== modified file 'softwarecenter/distro/fedora.py'
--- softwarecenter/distro/fedora.py	2012-11-28 16:58:59 +0000
+++ softwarecenter/distro/fedora.py	2013-09-17 17:52:06 +0000
@@ -69,6 +69,9 @@
     def get_app_name(self):
         return _("Fedora Software Center")
 
+    def get_app_id(self):
+        return "fedora-software-center"
+
     def get_removal_warning_text(self, cache, pkg, appname, depends):
         primary = _("To remove %s, these items must be removed "
                     "as well:") % appname

=== modified file 'softwarecenter/distro/ubuntu.py'
--- softwarecenter/distro/ubuntu.py	2013-05-01 18:13:43 +0000
+++ softwarecenter/distro/ubuntu.py	2013-09-17 17:52:06 +0000
@@ -80,6 +80,9 @@
     def get_app_name(self):
         return _("Ubuntu Software Center")
 
+    def get_app_id(self):
+        return "ubuntu-software-center"
+
     def get_app_description(self):
         return _("Lets you choose from thousands of applications available "
                  "for Ubuntu.")

=== removed directory 'softwarecenter/sso'
=== removed file 'softwarecenter/sso/__init__.py'
--- softwarecenter/sso/__init__.py	2012-06-25 21:26:13 +0000
+++ softwarecenter/sso/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2009-2012 Canonical Ltd.
-#
-# This program 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.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-#
-
-"""Ubuntu Single Sign On GTK+ graphical interface."""

=== removed file 'softwarecenter/sso/gui.py'
--- softwarecenter/sso/gui.py	2012-11-28 17:05:41 +0000
+++ softwarecenter/sso/gui.py	1970-01-01 00:00:00 +0000
@@ -1,1168 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2010-2012 Canonical Ltd.
-#
-# This program 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.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-#
-
-"""The Ubuntu Single Sign On GTK+ graphical user interface."""
-
-import logging
-import os
-import sys
-import tempfile
-import webbrowser
-
-from functools import wraps, partial
-
-import dbus
-
-# pylint: disable=E0611,F0401
-from gi.repository import Gdk, Gtk
-from gi.repository.GdkX11 import X11Window
-# pylint: enable=E0611,F0401
-
-from ubuntu_sso import (
-    DBUS_BUS_NAME,
-    DBUS_ACCOUNT_PATH,
-    DBUS_IFACE_USER_NAME,
-    NO_OP,
-    USER_CANCELLATION,
-    USER_SUCCESS,
-)
-from ubuntu_sso.logger import setup_gui_logging
-from ubuntu_sso.utils import ui as ui_strings
-from ubuntu_sso.utils.ui import (
-    CAPTCHA_LOAD_ERROR,
-    CAPTCHA_RELOAD_TOOLTIP,
-    CONNECT_HELP_LABEL,
-    EMAIL_MISMATCH,
-    EMAIL_INVALID,
-    ERROR,
-    FIELD_REQUIRED,
-    FORGOTTEN_PASSWORD_BUTTON,
-    GENERIC_BACKEND_ERROR,
-    is_min_required_password,
-    is_correct_email,
-    JOIN_HEADER_LABEL,
-    LOADING,
-    LOGIN_BUTTON_LABEL,
-    LOGIN_HEADER_LABEL,
-    NEXT,
-    ONE_MOMENT_PLEASE,
-    PASSWORD_CHANGED,
-    PASSWORD_HELP,
-    PASSWORD_MISMATCH,
-    PASSWORD_TOO_WEAK,
-    REQUEST_PASSWORD_TOKEN_LABEL,
-    RESET_PASSWORD,
-    SET_NEW_PASSWORD_LABEL,
-    SUCCESS,
-    TC_BUTTON,
-    TC_NOT_ACCEPTED,
-    VERIFY_EMAIL_LABEL,
-    YES_TO_TC,
-    YES_TO_UPDATES,
-)
-
-# Instance of 'UbuntuSSOClientGUI' has no 'yyy' member
-# pylint: disable=E1101
-
-
-logger = setup_gui_logging('ubuntu_sso.gui.gtk')
-
-
-# pylint: disable=C0103
-def parse_color(color):
-    """Parse a string color into Gdk.Color."""
-    c = Gdk.RGBA()
-    result = c.parse(color)
-    if not result:
-        logger.warning('Could not parse color %r.', color)
-    return c
-# pylint: enable=C0103
-
-DEFAULT_WIDTH = 30
-# To be replaced by values from the theme (LP: #616526)
-HELP_TEXT_COLOR = parse_color("#bfbfbf")
-WARNING_TEXT_COLOR = parse_color("red")
-LARGE_MARKUP = u'<span size="x-large">%s</span>'
-
-
-# SSL properties and certs location
-STRICT_SSL_PROP = 'ssl-strict'
-CERTS_FILE_PROP = 'ssl-ca-file'
-CA_CERT_FILE = '/etc/ssl/certs/ca-certificates.crt'
-
-
-def log_call(f):
-    """Decorator to log call functions."""
-
-    @wraps(f)
-    def inner(*args, **kwargs):
-        """Execute 'f' logging the call as INFO."""
-        logger.info('%s: args %r, kwargs %r.', f.__name__, args, kwargs)
-        return f(*args, **kwargs)
-
-    return inner
-
-
-def get_sso_client():
-    bus = dbus.SessionBus()
-    obj = bus.get_object(bus_name=DBUS_BUS_NAME,
-                         object_path=DBUS_ACCOUNT_PATH,
-                         follow_name_owner_changes=True)
-    result = dbus.Interface(obj, dbus_interface=DBUS_IFACE_USER_NAME)
-    result.disconnect_from_signal = lambda _, sig: sig.remove()
-    return result
-
-
-def get_data_file(*args):
-    result = os.path.abspath(os.path.join(os.path.dirname(__file__),
-                                          '..', '..', 'data'))
-    if not os.path.exists(result):
-        import softwarecenter.paths
-        result = softwarecenter.paths.datadir
-
-    result = os.path.join(result, 'ui', 'sso', *args)
-    logger.info('Using data dir: %r', result)
-    return result
-
-
-class LabeledEntry(Gtk.Entry):
-    """An entry that displays the label within itself in a grey color."""
-
-    # Use of super on an old style class
-    # pylint: disable=E1002
-
-    def __init__(self, label, is_password=False, *args, **kwargs):
-        self.label = label
-        self.is_password = is_password
-        self.warning = None
-
-        super(LabeledEntry, self).__init__(*args, **kwargs)
-
-        self.set_width_chars(DEFAULT_WIDTH)
-        self._set_label(self, None)
-        self.set_tooltip_text(self.label)
-        self.connect('focus-in-event', self._clear_text)
-        self.connect('focus-out-event', self._set_label)
-        self.clear_warning()
-        self.show()
-
-    def _clear_text(self, *args, **kwargs):
-        """Clear text and restore text color."""
-        self.set_text(self.get_text())
-
-        # restore to theme's default
-        self.override_color(Gtk.StateFlags.NORMAL, None)
-
-        if self.is_password:
-            self.set_visibility(False)
-
-        return False  # propagate the event further
-
-    def _set_label(self, *args, **kwargs):
-        """Set the proper label and proper coloring."""
-        if self.get_text():
-            return
-
-        self.set_text(self.label)
-        self.override_color(Gtk.StateFlags.NORMAL, HELP_TEXT_COLOR)
-
-        if self.is_password:
-            self.set_visibility(True)
-
-        return False  # propagate the event further
-
-    def get_text(self):
-        """Get text only if it's not the label nor empty."""
-        result = super(LabeledEntry, self).get_text().decode('utf8')
-        if result == self.label or result.isspace():
-            result = u''
-        return result
-
-    def set_warning(self, warning_msg):
-        """Display warning as secondary icon, set 'warning_msg' as tooltip."""
-        self.warning = warning_msg
-        self.set_property('secondary-icon-stock', Gtk.STOCK_DIALOG_WARNING)
-        self.set_property('secondary-icon-sensitive', True)
-        self.set_property('secondary-icon-activatable', False)
-        self.set_property('secondary-icon-tooltip-text', warning_msg)
-
-    def clear_warning(self):
-        """Remove any warning."""
-        self.warning = None
-        self.set_property('secondary-icon-stock', None)
-        self.set_property('secondary-icon-sensitive', False)
-        self.set_property('secondary-icon-activatable', False)
-        self.set_property('secondary-icon-tooltip-text', None)
-
-
-class UbuntuSSOClientGUI(object):
-    """Ubuntu single sign-on GUI."""
-
-    def __init__(self, app_name, **kwargs):
-        """Create the GUI and initialize widgets."""
-        logger.debug('UbuntuSSOClientGUI: app_name %r, kwargs %r.',
-                     app_name, kwargs)
-
-        self._captcha_filename = tempfile.mktemp()
-        self._captcha_id = None
-        self._signals_receivers = {}
-        self._done = False  # whether the whole process was completed or not
-
-        self.app_name = app_name
-        self.app_label = u'<b>%s</b>' % self.app_name
-        self.ping_url = kwargs.get('ping_url', u'')
-        self.tc_url = kwargs.get('tc_url', u'')
-        self.help_text = kwargs.get('help_text', u'')
-        self.login_only = kwargs.get('login_only', False)
-        window_id = kwargs.get('window_id', 0)
-        self.close_callback = kwargs.get('close_callback', NO_OP)
-        self.backend = None
-        self.user_email = None
-        self.user_password = None
-
-        ui_filename = get_data_file('sso.ui')
-        builder = Gtk.Builder()
-        builder.add_from_file(ui_filename)
-        builder.connect_signals(self)
-
-        self.widgets = []
-        self.warnings = []
-        self.cancels = []
-        for obj in builder.get_objects():
-            name = getattr(obj, 'name', None)
-            if name is None and isinstance(obj, Gtk.Buildable):
-                # work around bug lp:507739
-                name = Gtk.Buildable.get_name(obj)
-            if name is None:
-                logging.warn("%s has no name (??)", obj)
-            else:
-                self.widgets.append(name)
-                setattr(self, name, obj)
-                if 'warning' in name:
-                    self.warnings.append(obj)
-                    obj.set_text('')
-                if 'cancel_button' in name:
-                    obj.connect('clicked', self.on_close_clicked)
-                    self.cancels.append(obj)
-
-        # Connect the activate-link signal here
-        # GtkBuilder in GTK 3 seems to not do this
-        self.login_button.connect('activate-link', self.on_activate_link)
-        self.forgotten_password_button.connect('activate-link',
-                                               self.on_activate_link)
-
-        self.entries = (u'name_entry', u'email1_entry', u'email2_entry',
-                        u'password1_entry', u'password2_entry',
-                        u'captcha_solution_entry', u'email_token_entry',
-                        u'login_email_entry', u'login_password_entry',
-                        u'reset_email_entry', u'reset_code_entry',
-                        u'reset_password1_entry', u'reset_password2_entry')
-
-        for name in self.entries:
-            label = getattr(ui_strings, name.upper())
-            is_password = 'password' in name
-            entry = LabeledEntry(label=label, is_password=is_password)
-            entry.set_activates_default(True)
-            setattr(self, name, entry)
-
-        self.window.set_icon_name('ubuntu-logo')
-
-        self.pages = (self.enter_details_vbox, self.processing_vbox,
-                      self.verify_email_vbox, self.finish_vbox,
-                      self.tc_browser_vbox, self.login_vbox,
-                      self.request_password_token_vbox,
-                      self.set_new_password_vbox)
-
-        self._signals = {
-            'CaptchaGenerated':
-                self._filter_by_app_name(self.on_captcha_generated),
-            'CaptchaGenerationError':
-                self._filter_by_app_name(self.on_captcha_generation_error),
-            'UserRegistered':
-                self._filter_by_app_name(self.on_user_registered),
-            'UserRegistrationError':
-                self._filter_by_app_name(self.on_user_registration_error),
-            'EmailValidated':
-                self._filter_by_app_name(self.on_email_validated),
-            'EmailValidationError':
-                self._filter_by_app_name(self.on_email_validation_error),
-            'LoggedIn':
-                self._filter_by_app_name(self.on_logged_in),
-            'LoginError':
-                self._filter_by_app_name(self.on_login_error),
-            'UserNotValidated':
-                self._filter_by_app_name(self.on_user_not_validated),
-            'PasswordResetTokenSent':
-                self._filter_by_app_name(self.on_password_reset_token_sent),
-            'PasswordResetError':
-                self._filter_by_app_name(self.on_password_reset_error),
-            'PasswordChanged':
-                self._filter_by_app_name(self.on_password_changed),
-            'PasswordChangeError':
-                self._filter_by_app_name(self.on_password_change_error),
-        }
-
-        if window_id != 0:
-            # be as robust as possible:
-            # if the window_id is not "good", set_transient_for will fail
-            # awfully, and we don't want that: if the window_id is bad we can
-            # still do everything as a standalone window. Also,
-            # window_foreign_new may return None breaking set_transient_for.
-            try:
-                display = Gdk.Display.get_default()
-                # this is not working, we need to create a XLib.window
-                # as a second parameter to foreign_new_for_display
-                win = X11Window.foreign_new_for_display(display, None)
-                self.window.realize()
-                self.window.window.set_transient_for(win)
-            except:  # pylint: disable=W0702
-                msg = 'UbuntuSSOClientGUI: failed set_transient_for win id %r'
-                logger.exception(msg, window_id)
-
-        self.yes_to_updates_checkbutton.hide()
-        self.start_backend()
-
-    def start_backend(self):
-        """Start the backend, show the window when ready."""
-        self.backend = get_sso_client()
-
-        logger.debug('UbuntuSSOClientGUI: backend created: %r', self.backend)
-
-        self._setup_signals()
-        self._append_pages()
-        self.window.show()
-
-    @property
-    def success_vbox(self):
-        """The success page."""
-        message = SUCCESS % {'app_name': self.app_name}
-        message = LARGE_MARKUP % message
-        self.finish_vbox.label.set_markup(message)
-        return self.finish_vbox
-
-    @property
-    def error_vbox(self):
-        """The error page."""
-        self.finish_vbox.label.set_markup(LARGE_MARKUP % ERROR)
-        return self.finish_vbox
-
-    # helpers
-
-    def _filter_by_app_name(self, f):
-        """Execute the decorated function only for 'self.app_name'."""
-
-        @wraps(f)
-        def inner(app_name, *args, **kwargs):
-            """Execute 'f' only if 'app_name' matches 'self.app_name'."""
-            result = None
-            if app_name == self.app_name:
-                result = f(app_name, *args, **kwargs)
-            else:
-                logger.info('%s: ignoring call since received app_name '
-                            '%r (expected %r)',
-                            f.__name__, app_name, self.app_name)
-            return result
-
-        return inner
-
-    def _setup_signals(self):
-        """Bind signals to callbacks to be able to test the pages."""
-        for signal, method in self._signals.items():
-            actual = self._signals_receivers.get(signal)
-            if actual is not None:
-                msg = 'Signal %r is already connected with %r.'
-                logger.warning(msg, signal, actual)
-
-            match = self.backend.connect_to_signal(signal, method)
-            self._signals_receivers[signal] = match
-
-    def _add_spinner_to_container(self, container, legend=None):
-        """Add a spinner to 'container'."""
-        spinner = Gtk.Spinner()
-        spinner.start()
-
-        label = Gtk.Label()
-        if legend:
-            label.set_text(legend)
-        else:
-            label.set_text(LOADING)
-
-        hbox = Gtk.HBox(spacing=5)
-        hbox.pack_start(spinner, expand=False, fill=True, padding=0)
-        hbox.pack_start(label, expand=False, fill=True, padding=0)
-
-        alignment = Gtk.Alignment(xalign=0.5, yalign=0.5,
-                                  xscale=0, yscale=0)
-        alignment.add(hbox)
-        alignment.show_all()
-
-        # remove children to avoid:
-        # GtkWarning: Attempting to add a widget with type GtkAlignment to a
-        # GtkEventBox, but as a GtkBin subclass a GtkEventBox can only contain
-        # one widget at a time
-        for child in container.get_children():
-            container.remove(child)
-        container.add(alignment)
-
-    def _set_warning_message(self, widget, message):
-        """Set 'message' as text for 'widget'."""
-        widget.set_text(message)
-        widget.override_color(Gtk.StateFlags.NORMAL, WARNING_TEXT_COLOR)
-        widget.show()
-
-    def _clear_warnings(self):
-        """Clear all warning messages."""
-        for widget in self.warnings:
-            widget.set_text('')
-        for widget in self.entries:
-            getattr(self, widget).clear_warning()
-
-    def _non_empty_input(self, widget):
-        """Return weather widget has non empty content."""
-        text = widget.get_text()
-        return bool(text and not text.isspace())
-
-    def _handle_error(self, remote_call, handler, error):
-        """Handle any error when calling the remote backend."""
-        logger.error('Remote call %r failed with: %r', remote_call, error)
-        errordict = {'message': GENERIC_BACKEND_ERROR}
-        handler(self.app_name, errordict)
-
-    # build pages
-
-    def _append_pages(self):
-        """Append all the requires pages to main widget."""
-        self._append_page(self._build_processing_page())
-        self._append_page(self._build_finish_page())
-        self._append_page(self._build_login_page())
-        self._append_page(self._build_request_password_token_page())
-        self._append_page(self._build_set_new_password_page())
-        self._append_page(self._build_verify_email_page())
-
-        if not self.login_only:
-            self._append_page(self._build_enter_details_page())
-            self._append_page(self._build_tc_page())
-            self.login_button.grab_focus()
-            self._set_current_page(self.enter_details_vbox)
-        else:
-            self.login_back_button.hide()
-            self.login_ok_button.grab_focus()
-            self.login_vbox.help_text = self.help_text
-            self._set_current_page(self.login_vbox)
-
-    def _append_page(self, page):
-        """Append 'page' to the 'window'."""
-        self.content.append_page(page, None)
-
-    def _set_header(self, header):
-        """Set 'header' as the window title and header."""
-        self.header_label.set_markup(LARGE_MARKUP % header)
-        self.window.set_title(self.header_label.get_text())  # avoid markup
-
-    def _set_current_page(self, current_page, warning_text=None):
-        """Hide all the pages but 'current_page'."""
-        if hasattr(current_page, 'header'):
-            self._set_header(current_page.header)
-
-        if hasattr(current_page, 'help_text'):
-            self.help_label.set_markup(current_page.help_text)
-
-        if warning_text is not None:
-            self._set_warning_message(self.warning_label, warning_text)
-        else:
-            self.warning_label.set_text('')
-
-        self.content.set_current_page(self.content.page_num(current_page))
-
-        if current_page.default_widget is not None:
-            current_page.default_widget.grab_default()
-
-    def _generate_captcha(self):
-        """Ask for a new captcha; update the ui to reflect the fact."""
-        logger.info('Calling generate_captcha with filename path at %r',
-                    self._captcha_filename)
-        self.warning_label.set_text('')
-        f = self.backend.generate_captcha
-        error_handler = partial(self._handle_error, f,
-                                self.on_captcha_generation_error)
-        f(self.app_name, self._captcha_filename,
-            reply_handler=NO_OP, error_handler=error_handler)
-        self._set_captcha_loading()
-
-    def _set_captcha_loading(self):
-        """Present a spinner to the user while the captcha is downloaded."""
-        self.captcha_image.hide()
-        self._add_spinner_to_container(self.captcha_loading)
-        self.captcha_loading.override_background_color(Gtk.StateFlags.NORMAL,
-                                                       parse_color('white'))
-        self.captcha_loading.show_all()
-        self.join_ok_button.set_sensitive(False)
-
-    def _set_captcha_image(self):
-        """Present a captcha image to the user to be resolved."""
-        self.captcha_loading.hide()
-        self.join_ok_button.set_sensitive(True)
-        self.captcha_image.set_from_file(self._captcha_filename)
-        self.captcha_image.show()
-
-    def _build_enter_details_page(self):
-        """Build the enter details page."""
-        d = {'app_name': self.app_label}
-        self.enter_details_vbox.header = JOIN_HEADER_LABEL % d
-        self.enter_details_vbox.help_text = self.help_text
-        self.enter_details_vbox.default_widget = self.join_ok_button
-        self.join_ok_button.set_can_default(True)
-
-        self.enter_details_vbox.pack_start(self.name_entry,
-            expand=False, fill=True, padding=0)
-        self.enter_details_vbox.reorder_child(self.name_entry, 0)
-        entry = self.captcha_solution_entry
-        self.captcha_solution_vbox.pack_start(entry,
-            expand=False, fill=True, padding=0)
-        msg = CAPTCHA_RELOAD_TOOLTIP
-        self.captcha_reload_button.set_tooltip_text(msg)
-
-        self.emails_hbox.pack_start(self.email1_entry,
-            expand=False, fill=True, padding=0)
-        self.emails_hbox.pack_start(self.email2_entry,
-            expand=False, fill=True, padding=0)
-
-        self.passwords_hbox.pack_start(self.password1_entry,
-            expand=False, fill=True, padding=0)
-        self.passwords_hbox.pack_start(self.password2_entry,
-            expand=False, fill=True, padding=0)
-        help_msg = '<small>%s</small>' % PASSWORD_HELP
-        self.password_help_label.set_markup(help_msg)
-
-        if not os.path.exists(self._captcha_filename):
-            self._generate_captcha()
-        else:
-            self._set_captcha_image()
-
-        msg = YES_TO_UPDATES % {'app_name': self.app_name}
-        self.yes_to_updates_checkbutton.set_label(msg)
-
-        msg = YES_TO_TC % {'app_name': self.app_name}
-        self.yes_to_tc_checkbutton.set_label(msg)
-        self.tc_button.set_label(TC_BUTTON)
-
-        if not self.tc_url:
-            self.tc_vbox.hide()
-        self.login_button.set_label(LOGIN_BUTTON_LABEL)
-
-        return self.enter_details_vbox
-
-    def _build_tc_page(self):
-        """Build the Terms & Conditions page."""
-        self.tc_browser_vbox.help_text = ''
-        self.tc_browser_vbox.default_widget = self.tc_back_button
-        self.tc_browser_vbox.default_widget.set_can_default(True)
-        return self.tc_browser_vbox
-
-    def _build_processing_page(self):
-        """Build the processing page with a spinner."""
-        self.processing_vbox.default_widget = None
-        self._add_spinner_to_container(self.processing_vbox,
-                                       legend=ONE_MOMENT_PLEASE)
-        return self.processing_vbox
-
-    def _build_verify_email_page(self):
-        """Build the verify email page."""
-        self.verify_email_vbox.default_widget = self.verify_token_button
-        self.verify_email_vbox.default_widget.set_can_default(True)
-
-        self.verify_email_details_vbox.pack_start(self.email_token_entry,
-            expand=False, fill=True, padding=0)
-        return self.verify_email_vbox
-
-    def _build_finish_page(self):
-        """Build the success page."""
-        self.finish_vbox.default_widget = self.finish_close_button
-        self.finish_vbox.default_widget.set_can_default(True)
-        self.finish_vbox.label = self.finish_label
-        return self.finish_vbox
-
-    def _build_login_page(self):
-        """Build the login page."""
-        d = {'app_name': self.app_label}
-        self.login_vbox.header = LOGIN_HEADER_LABEL % d
-        self.login_vbox.help_text = CONNECT_HELP_LABEL % d
-        self.login_vbox.default_widget = self.login_ok_button
-        self.login_vbox.default_widget.set_can_default(True)
-
-        self.login_details_vbox.pack_start(self.login_email_entry,
-            expand=True, fill=True, padding=0)
-        self.login_details_vbox.reorder_child(self.login_email_entry, 0)
-        self.login_details_vbox.pack_start(self.login_password_entry,
-            expand=True, fill=True, padding=0)
-        self.login_details_vbox.reorder_child(self.login_password_entry, 1)
-
-        msg = FORGOTTEN_PASSWORD_BUTTON
-        self.forgotten_password_button.set_label(msg)
-        self.login_ok_button.grab_focus()
-
-        return self.login_vbox
-
-    def _build_request_password_token_page(self):
-        """Build the login page."""
-        self.request_password_token_vbox.header = RESET_PASSWORD
-        text = REQUEST_PASSWORD_TOKEN_LABEL % {'app_name': self.app_label}
-        self.request_password_token_vbox.help_text = text
-        btn = self.request_password_token_ok_button
-        btn.set_can_default(True)
-        self.request_password_token_vbox.default_widget = btn
-
-        entry = self.reset_email_entry
-        self.request_password_token_details_vbox.pack_start(entry,
-            expand=False, fill=True, padding=0)
-        cb = self.on_reset_email_entry_changed
-        self.reset_email_entry.connect('changed', cb)
-        self.request_password_token_ok_button.set_label(NEXT)
-        self.request_password_token_ok_button.set_sensitive(False)
-
-        return self.request_password_token_vbox
-
-    def _build_set_new_password_page(self):
-        """Build the login page."""
-        self.set_new_password_vbox.header = RESET_PASSWORD
-        self.set_new_password_vbox.help_text = SET_NEW_PASSWORD_LABEL
-        btn = self.set_new_password_ok_button
-        btn.set_can_default(True)
-        self.set_new_password_vbox.default_widget = btn
-
-        for entry in (self.reset_code_entry,
-                      self.reset_password1_entry,
-                      self.reset_password2_entry):
-            self.set_new_password_details_vbox.pack_start(entry,
-                expand=False, fill=True, padding=0)
-
-        cb = self.on_set_new_password_entries_changed
-        self.reset_code_entry.connect('changed', cb)
-        self.reset_password1_entry.connect('changed', cb)
-        self.reset_password2_entry.connect('changed', cb)
-        help_msg = '<small>%s</small>' % PASSWORD_HELP
-        self.reset_password_help_label.set_markup(help_msg)
-
-        self.set_new_password_ok_button.set_label(RESET_PASSWORD)
-        self.set_new_password_ok_button.set_sensitive(False)
-
-        return self.set_new_password_vbox
-
-    def _validate_email(self, email1, email2=None):
-        """Validate 'email1', return error message if not valid.
-
-        If 'email2' is given, must match 'email1'.
-        """
-        if email2 is not None and email1 != email2:
-            return EMAIL_MISMATCH
-
-        if not email1:
-            return FIELD_REQUIRED
-
-        if not is_correct_email(email1):
-            return EMAIL_INVALID
-
-    def _validate_password(self, password1, password2=None):
-        """Validate 'password1', return error message if not valid.
-
-        If 'password2' is given, must match 'email1'.
-        """
-        if password2 is not None and password1 != password2:
-            return PASSWORD_MISMATCH
-
-        if not is_min_required_password(password1):
-            return PASSWORD_TOO_WEAK
-
-    # GTK callbacks
-
-    def destroy(self):
-        """Destroy this UI."""
-        self.window.hide()
-        self.window.destroy()
-
-    def connect(self, signal_name, handler, *args, **kwargs):
-        """Connect 'signal_name' with 'handler'."""
-        logger.debug('connect: signal %r, handler %r, args  %r, kwargs, %r',
-                     signal_name, handler, args, kwargs)
-        self.window.connect(signal_name, handler, *args, **kwargs)
-
-    def finish_success(self):
-        """The whole process was completed successfully. Show success page."""
-        self._done = True
-        self._set_current_page(self.success_vbox)
-
-    def finish_error(self):
-        """The whole process wasn't completed successfully. Show error page."""
-        self._done = True
-        self._set_current_page(self.error_vbox)
-
-    def on_activate_link(self, button):
-        """Do nothing, used for LinkButtons that are used as regular ones."""
-        return True
-
-    def on_close_clicked(self, *args, **kwargs):
-        """Call self.close_callback if defined."""
-        if os.path.exists(self._captcha_filename):
-            os.remove(self._captcha_filename)
-
-        for signal, match in self._signals_receivers.items():
-            self.backend.disconnect_from_signal(signal, match)
-
-        # hide the main window
-        if self.window is not None:
-            self.window.hide()
-
-        # process any pending events before callbacking with result
-        while Gtk.events_pending():
-            Gtk.main_iteration()
-
-        return_code = USER_SUCCESS
-        if not self._done:
-            return_code = USER_CANCELLATION
-        logger.info('Return code will be %r.', return_code)
-
-        # call user defined callback
-        logger.debug('Calling custom close_callback %r with params %r, %r',
-                    self.close_callback, args, kwargs)
-        self.close_callback(*args, **kwargs)
-
-        sys.exit(return_code)
-
-    def on_sign_in_button_clicked(self, *args, **kwargs):
-        """User wants to sign in, present the Login page."""
-        self._set_current_page(self.login_vbox)
-
-    def on_join_ok_button_clicked(self, *args, **kwargs):
-        """Submit info for processing, present the processing vbox."""
-        if not self.join_ok_button.is_sensitive():
-            return
-
-        self._clear_warnings()
-
-        error = False
-
-        name = self.name_entry.get_text()
-        if not name:
-            self.name_entry.set_warning(FIELD_REQUIRED)
-            logger.warning('on_join_ok_button_clicked: name not set.')
-            error = True
-
-        # check email
-        email1 = self.email1_entry.get_text()
-        email2 = self.email2_entry.get_text()
-        msg = self._validate_email(email1, email2)
-        if msg is not None:
-            self.email1_entry.set_warning(msg)
-            self.email2_entry.set_warning(msg)
-            logger.warning('on_join_ok_button_clicked: email is not valid.')
-            error = True
-
-        # check password
-        password1 = self.password1_entry.get_text()
-        password2 = self.password2_entry.get_text()
-        msg = self._validate_password(password1, password2)
-        if msg is not None:
-            self.password1_entry.set_warning(msg)
-            self.password2_entry.set_warning(msg)
-            logger.warning('on_join_ok_button_clicked: password is not valid.')
-            error = True
-
-        # check T&C
-        if self.tc_url and not self.yes_to_tc_checkbutton.get_active():
-            self._set_warning_message(self.tc_warning_label,
-                TC_NOT_ACCEPTED % {'app_name': self.app_name})
-            logger.warning('on_join_ok_button_clicked: terms and conditions '
-                           'not accepted.')
-            error = True
-
-        captcha_solution = self.captcha_solution_entry.get_text()
-        if not captcha_solution:
-            self.captcha_solution_entry.set_warning(FIELD_REQUIRED)
-            logger.warning('on_join_ok_button_clicked: captcha solution not '
-                           'set.')
-            error = True
-
-        if error:
-            logger.warning('on_join_ok_button_clicked: validation failed.')
-            return
-
-        logger.info('on_join_ok_button_clicked: validation success!')
-
-        self._set_current_page(self.processing_vbox)
-        self.user_email = email1
-        self.user_password = password1
-
-        logger.info('Calling register_user with email %r, password <hidden>,'
-                    ' name %r, captcha_id %r and captcha_solution %r.', email1,
-                    name, self._captcha_id, captcha_solution)
-
-        f = self.backend.register_user
-        error_handler = partial(self._handle_error, f,
-                                self.on_user_registration_error)
-        f(self.app_name, self.user_email, self.user_password, name,
-          self._captcha_id, captcha_solution,
-          reply_handler=NO_OP, error_handler=error_handler)
-
-    def on_verify_token_button_clicked(self, *args, **kwargs):
-        """The user entered the email token, let's verify!"""
-        if not self.verify_token_button.is_sensitive():
-            return
-
-        self._clear_warnings()
-
-        email_token = self.email_token_entry.get_text()
-        if not email_token:
-            self.email_token_entry.set_warning(FIELD_REQUIRED)
-            return
-
-        email = self.user_email
-        password = self.user_password
-
-        args = (self.app_name, email, password, email_token)
-        if self.ping_url:
-            f = self.backend.validate_email_and_ping
-            args = args + (self.ping_url,)
-        else:
-            f = self.backend.validate_email
-
-        logger.info('Calling validate_email with email %r, password <hidden>, '
-                    'app_name %r and email_token %r.', email, self.app_name,
-                    email_token)
-        error_handler = partial(self._handle_error, f,
-                                self.on_email_validation_error)
-        f(*args, reply_handler=NO_OP, error_handler=error_handler)
-
-        self._set_current_page(self.processing_vbox)
-
-    def on_login_connect_button_clicked(self, *args, **kwargs):
-        """User wants to connect!"""
-        if not self.login_ok_button.is_sensitive():
-            return
-
-        self._clear_warnings()
-
-        error = False
-
-        email = self.login_email_entry.get_text()
-        msg = self._validate_email(email)
-        if msg is not None:
-            self.login_email_entry.set_warning(msg)
-            error = True
-
-        password = self.login_password_entry.get_text()
-        if not password:
-            self.login_password_entry.set_warning(FIELD_REQUIRED)
-            error = True
-
-        if error:
-            return
-
-        args = (self.app_name, email, password)
-        if self.ping_url:
-            f = self.backend.login_and_ping
-            args = args + (self.ping_url,)
-        else:
-            f = self.backend.login
-
-        error_handler = partial(self._handle_error, f, self.on_login_error)
-        f(*args, reply_handler=NO_OP, error_handler=error_handler)
-
-        self._set_current_page(self.processing_vbox)
-        self.user_email = email
-        self.user_password = password
-
-    def on_login_back_button_clicked(self, *args, **kwargs):
-        """User wants to go to the previous page."""
-        self._set_current_page(self.enter_details_vbox)
-
-    def on_forgotten_password_button_clicked(self, *args, **kwargs):
-        """User wants to reset the password."""
-        self._set_current_page(self.request_password_token_vbox)
-
-    def on_request_password_token_ok_button_clicked(self, *args, **kwargs):
-        """User entered the email address to reset the password."""
-        if not self.request_password_token_ok_button.is_sensitive():
-            return
-
-        self._clear_warnings()
-
-        email = self.reset_email_entry.get_text()
-        msg = self._validate_email(email)
-        if msg is not None:
-            self.reset_email_entry.set_warning(msg)
-            return
-
-        logger.info('Calling request_password_reset_token with %r.', email)
-        f = self.backend.request_password_reset_token
-        error_handler = partial(self._handle_error, f,
-                                self.on_password_reset_error)
-        f(self.app_name, email,
-          reply_handler=NO_OP, error_handler=error_handler)
-
-        self._set_current_page(self.processing_vbox)
-
-    def on_request_password_token_back_button_clicked(self, *args, **kwargs):
-        """User wants to go to the previous page."""
-        self._set_current_page(self.login_vbox)
-
-    def on_reset_email_entry_changed(self, widget, *args, **kwargs):
-        """User is changing the 'widget' entry in the reset email page."""
-        sensitive = self._non_empty_input(widget)
-        self.request_password_token_ok_button.set_sensitive(sensitive)
-
-    def on_set_new_password_entries_changed(self, *args, **kwargs):
-        """User is changing the 'widget' entry in the reset password page."""
-        sensitive = True
-        for entry in (self.reset_code_entry,
-                      self.reset_password1_entry,
-                      self.reset_password2_entry):
-            sensitive &= self._non_empty_input(entry)
-        self.set_new_password_ok_button.set_sensitive(sensitive)
-
-    def on_set_new_password_ok_button_clicked(self, *args, **kwargs):
-        """User entered reset code and new passwords."""
-        if not self.set_new_password_ok_button.is_sensitive():
-            return
-
-        self._clear_warnings()
-
-        error = False
-
-        token = self.reset_code_entry.get_text()
-        if not token:
-            self.reset_code_entry.set_warning(FIELD_REQUIRED)
-            error = True
-
-        password1 = self.reset_password1_entry.get_text()
-        password2 = self.reset_password2_entry.get_text()
-        msg = self._validate_password(password1, password2)
-        if msg is not None:
-            self.reset_password1_entry.set_warning(msg)
-            self.reset_password2_entry.set_warning(msg)
-            error = True
-
-        if error:
-            return
-
-        email = self.reset_email_entry.get_text()
-        logger.info('Calling set_new_password with email %r, token %r and '
-                    'new password: <hidden>.', email, token)
-        f = self.backend.set_new_password
-        error_handler = partial(self._handle_error, f,
-                                self.on_password_change_error)
-        f(self.app_name, email, token, password1,
-          reply_handler=NO_OP, error_handler=error_handler)
-
-        self._set_current_page(self.processing_vbox)
-
-    def _webkit_init_ssl(self):
-        """Set the WebKit ssl strictness."""
-        # delay the import of webkit to be able to build without it
-        from gi.repository import WebKit  # pylint: disable=E0611
-
-        # Set the Soup session to be strict and use system CA certs
-        session = WebKit.get_default_session()
-        session.set_property(STRICT_SSL_PROP, True)
-        session.set_property(CERTS_FILE_PROP, CA_CERT_FILE)
-
-    def _add_webkit_browser(self):
-        """Add the webkit browser for the t&c."""
-        # delay the import of webkit to be able to build without it
-        from gi.repository import WebKit  # pylint: disable=E0611
-
-        self._webkit_init_ssl()
-
-        browser = WebKit.WebView()
-
-        browser.connect('notify::load-status',
-                        self.on_tc_browser_notify_load_status)
-        browser.connect('navigation-policy-decision-requested',
-                        self.on_tc_browser_navigation_requested)
-
-        settings = browser.get_settings()
-        settings.set_property("enable-plugins", False)
-        settings.set_property("enable-default-context-menu", False)
-
-        # webkit_web_view_open has been deprecated since version 1.1.1 and
-        # should not be used in newly-written code. Use
-        # webkit_web_view_load_uri() instead.
-        browser.load_uri(self.tc_url)
-        browser.show()
-        self.tc_browser_window.add(browser)
-
-    def on_tc_button_clicked(self, *args, **kwargs):
-        """The T&C button was clicked, create the browser and load terms."""
-        if self.tc_browser_window.get_child() is None:
-            self._add_webkit_browser()
-            self._set_current_page(self.processing_vbox)
-        else:
-            self._set_current_page(self.tc_browser_vbox)
-
-    def on_tc_back_button_clicked(self, *args, **kwargs):
-        """T & C 'back' button was clicked, return to the previous page."""
-        self._set_current_page(self.enter_details_vbox)
-
-    def on_tc_browser_notify_load_status(self, browser, *args, **kwargs):
-        """The T&C page is being loaded."""
-        from gi.repository import WebKit  # pylint: disable=E0611
-
-        if browser.get_load_status().real == WebKit.LoadStatus.FINISHED:
-            self._set_current_page(self.tc_browser_vbox)
-
-    def on_tc_browser_navigation_requested(self, browser, frame, request,
-                                           action, decision, *args, **kwargs):
-        """The user wants to navigate within the T&C browser."""
-        from gi.repository import WebKit  # pylint: disable=E0611
-
-        if action is not None and \
-           action.get_reason() == WebKit.WebNavigationReason.LINK_CLICKED:
-            if decision is not None:
-                decision.ignore()
-            url = action.get_original_uri()
-            webbrowser.open(url)
-        else:
-            if decision is not None:
-                decision.use()
-
-    def on_tc_browser_vbox_hide(self, *args, **kwargs):
-        """The T&C page is no longer being shown."""
-        children = self.tc_browser_window.get_children()
-        if len(children) > 0:
-            browser = children[0]
-            self.tc_browser_window.remove(browser)
-            browser.destroy()
-            del browser
-
-    def on_captcha_reload_button_clicked(self, *args, **kwargs):
-        """User clicked the reload captcha button."""
-        self._generate_captcha()
-
-    # backend callbacks
-
-    def _build_general_error_message(self, errordict):
-        """Concatenate __all__ and message from the errordict."""
-        result = None
-        msg1 = errordict.get('__all__')
-        msg2 = errordict.get('message')
-        if msg1 is not None and msg2 is not None:
-            result = '\n'.join((msg1, msg2))
-        else:
-            result = msg1 if msg1 is not None else msg2
-        return result
-
-    @log_call
-    def on_captcha_generated(self, app_name, captcha_id, *args, **kwargs):
-        """Captcha image has been generated and is available to be shown."""
-        if captcha_id is None:
-            logger.warning('on_captcha_generated: captcha_id is None for '
-                           'app_name %r.', app_name)
-        self._captcha_id = captcha_id
-        self._set_captcha_image()
-
-    @log_call
-    def on_captcha_generation_error(self, app_name, error, *args, **kwargs):
-        """Captcha image generation failed."""
-        self._set_warning_message(self.warning_label, CAPTCHA_LOAD_ERROR)
-        self._generate_captcha()
-
-    @log_call
-    def on_user_registered(self, app_name, email, *args, **kwargs):
-        """Registration can go on, user needs to verify email."""
-        help_text = VERIFY_EMAIL_LABEL % {'app_name': self.app_name,
-                                          'email': email}
-        self.verify_email_vbox.help_text = help_text
-        self._set_current_page(self.verify_email_vbox)
-
-    @log_call
-    def on_user_registration_error(self, app_name, error, *args, **kwargs):
-        """Error in the data provided for registration."""
-        msg = error.get('email')
-        if msg is not None:
-            self.email1_entry.set_warning(msg)
-            self.email2_entry.set_warning(msg)
-
-        msg = error.get('password')
-        if msg is not None:
-            self.password1_entry.set_warning(msg)
-            self.password2_entry.set_warning(msg)
-
-        msg = self._build_general_error_message(error)
-        self._generate_captcha()
-        self._set_current_page(self.enter_details_vbox, warning_text=msg)
-
-    @log_call
-    def on_email_validated(self, app_name, email, *args, **kwargs):
-        """User email was successfully verified."""
-        self.finish_success()
-
-    @log_call
-    def on_email_validation_error(self, app_name, error, *args, **kwargs):
-        """User email validation failed."""
-        msg = error.get('email_token')
-        if msg is not None:
-            self.email_token_entry.set_warning(msg)
-
-        msg = self._build_general_error_message(error)
-        self._set_current_page(self.verify_email_vbox, warning_text=msg)
-
-    @log_call
-    def on_logged_in(self, app_name, email, *args, **kwargs):
-        """User was successfully logged in."""
-        self.finish_success()
-
-    @log_call
-    def on_login_error(self, app_name, error, *args, **kwargs):
-        """User was not successfully logged in."""
-        msg = self._build_general_error_message(error)
-        self._set_current_page(self.login_vbox, warning_text=msg)
-
-    @log_call
-    def on_user_not_validated(self, app_name, email, *args, **kwargs):
-        """User was not validated."""
-        self.on_user_registered(app_name, email)
-
-    @log_call
-    def on_password_reset_token_sent(self, app_name, email, *args, **kwargs):
-        """Password reset token was successfully sent."""
-        msg = SET_NEW_PASSWORD_LABEL % {'email': email}
-        self.set_new_password_vbox.help_text = msg
-        self._set_current_page(self.set_new_password_vbox)
-
-    @log_call
-    def on_password_reset_error(self, app_name, error, *args, **kwargs):
-        """Password reset failed."""
-        msg = self._build_general_error_message(error)
-        self._set_current_page(self.login_vbox, warning_text=msg)
-
-    @log_call
-    def on_password_changed(self, app_name, email, *args, **kwargs):
-        """Password was successfully changed."""
-        self._set_current_page(self.login_vbox,
-                               warning_text=PASSWORD_CHANGED)
-
-    @log_call
-    def on_password_change_error(self, app_name, error, *args, **kwargs):
-        """Password reset failed."""
-        msg = self._build_general_error_message(error)
-        self._set_current_page(self.request_password_token_vbox,
-                               warning_text=msg)
-
-
-def run(**kwargs):
-    """Start the GTK mainloop and open the main window."""
-    UbuntuSSOClientGUI(close_callback=Gtk.main_quit, **kwargs)
-    Gtk.main()

=== removed directory 'softwarecenter/sso/tests'
=== removed file 'softwarecenter/sso/tests/__init__.py'
--- softwarecenter/sso/tests/__init__.py	2012-11-28 17:08:44 +0000
+++ softwarecenter/sso/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2009-2012 Canonical Ltd.
-#
-# This program 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.
-#
-
-"""Tests for the Ubuntu SSO GTK+ graphical interface."""
-
-APP_NAME = u'I ♥ Ubuntu'
-CAPTCHA_ID = u'test ñiña'
-CAPTCHA_SOLUTION = u'william Byrd ñandú'
-EMAIL = u'[e-mail]'
-EMAIL_TOKEN = u'B2P☺ gtf'
-HELP_TEXT = u'☛ Lorem ipsum dolor sit amet, consectetur adipiscing elit. ' \
-    'Nam sed lorem nibh. Suspendisse gravida nulla non nunc suscipit ' \
-    'pulvinar ' \
-    'tempus ut augue. Morbi consequat, ligula a elementum pretium, ' \
-    'dolor nulla tempus metus, sed viverra nisi risus non velit.'
-NAME = u'Juanito ☀ Pérez'
-PASSWORD = u'h3lloWorld☑ '
-PING_URL = u'http://localhost/ping-me/'
-RESET_PASSWORD_TOKEN = u'8G5Wtq'
-TC_URL = u'http://localhost/'
-UNKNOWN_ERROR = u'Something went very wrong! ☹'

=== removed file 'softwarecenter/sso/tests/test_gui.py'
--- softwarecenter/sso/tests/test_gui.py	2012-11-23 22:57:21 +0000
+++ softwarecenter/sso/tests/test_gui.py	1970-01-01 00:00:00 +0000
@@ -1,2300 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright 2010-2012 Canonical Ltd.
-#
-# This program 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.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
-
-"""Tests for the GUI for registration/login."""
-
-import itertools
-import logging
-import os
-
-from collections import defaultdict
-from functools import partial
-from unittest import skip, TestCase
-
-# pylint: disable=E0611
-from gi.repository import Gdk, Gtk, WebKit
-# pylint: enable=E0611
-from mock import patch
-
-from softwarecenter.sso import gui
-from softwarecenter.sso.tests import (
-    APP_NAME,
-    CAPTCHA_ID,
-    CAPTCHA_SOLUTION,
-    EMAIL,
-    EMAIL_TOKEN,
-    HELP_TEXT,
-    NAME,
-    PASSWORD,
-    PING_URL,
-    RESET_PASSWORD_TOKEN,
-    TC_URL,
-    UNKNOWN_ERROR,
-)
-
-# Access to a protected member 'yyy' of a client class
-# pylint: disable=W0212
-
-# Instance of 'UbuntuSSOClientGUI' has no 'yyy' member
-# pylint: disable=E1101,E1103
-
-# Use of super on an old style class
-# pylint: disable=E1002
-
-
-class FakedSSOBackend(object):
-    """Fake a SSO Backend."""
-
-    def __init__(self, *args, **kwargs):
-        self._args = args
-        self._kwargs = kwargs
-        self._called = {}
-        self.callbacks = defaultdict(list)
-
-        for i in ('generate_captcha', 'login', 'login_and_ping',
-                  'register_user', 'validate_email',
-                  'validate_email_and_ping',
-                  'request_password_reset_token',
-                  'set_new_password'):
-            setattr(self, i, self._record_call(i))
-
-    def connect_to_signal(self, signal_name, callback):
-        """Connect a callback to a given signal."""
-        self.callbacks[signal_name].append(callback)
-        return callback
-
-    def disconnect_from_signal(self, signal_name, match):
-        """Disconnect from a given signal."""
-        self.callbacks[signal_name].remove(match)
-        if len(self.callbacks[signal_name]) == 0:
-            self.callbacks.pop(signal_name)
-
-    def _record_call(self, func_name):
-        """Store values when calling 'func_name'."""
-
-        def inner(*args, **kwargs):
-            """Fake 'func_name'."""
-            self._called[func_name] = (args, kwargs)
-
-        return inner
-
-
-class FakedLogger(object):
-
-    def __init__(self):
-        self.records = defaultdict(list)
-        self.debug = partial(self.log, logging.DEBUG)
-        self.info = partial(self.log, logging.INFO)
-        self.warning = partial(self.log, logging.WARNING)
-        self.error = self.exception = partial(self.log, logging.ERROR)
-
-    def log(self, level, msg, *args):
-        """Fake a logging operation."""
-        self.records[level].append(msg % args)
-
-    def check(self, level, *msgs):
-        """Return whether there is a log entry for 'level' with 'msgs'."""
-        result = all(any(msg in r for r in self.records[level])
-                     for msg in msgs)
-        return result
-
-    def reset(self):
-        """Reset internal state."""
-        self.records.clear()
-
-
-class Settings(dict):
-    """Faked embedded browser settings."""
-
-    def get_property(self, prop_name):
-        """Alias for __getitem__."""
-        return self[prop_name]
-
-    def set_property(self, prop_name, newval):
-        """Alias for __setitem__."""
-        self[prop_name] = newval
-
-
-class FakedEmbeddedBrowser(Gtk.TextView):
-    """Faked an embedded browser."""
-
-    def __init__(self):
-        super(FakedEmbeddedBrowser, self).__init__()
-        self._props = {}
-        self._signals = defaultdict(list)
-        self._settings = Settings()
-
-    def connect(self, signal_name, callback):
-        """Connect 'signal_name' with 'callback'."""
-        self._signals[signal_name].append(callback)
-
-    def load_uri(self, uri):
-        """Navigate to the given 'uri'."""
-        self._props['uri'] = uri
-
-    def set_property(self, prop_name, newval):
-        """Set 'prop_name' to 'newval'."""
-        self._props[prop_name] = newval
-
-    def get_property(self, prop_name):
-        """Return the current value for 'prop_name'."""
-        return self._props[prop_name]
-
-    def get_settings(self,):
-        """Return the current settings."""
-        return self._settings
-
-    def get_load_status(self):
-        """Return the current load status."""
-        return WebKit.LoadStatus.FINISHED
-
-    def show(self):
-        """Show this instance."""
-        self.set_property('visible', True)
-
-
-class BasicTestCase(TestCase):
-    """Test case with a helper tracker."""
-
-    def setUp(self):
-        """Init."""
-        super(BasicTestCase, self).setUp()
-        self._called = False  # helper
-
-        self.memento = FakedLogger()
-        self.patch(gui, 'logger', self.memento)
-        self.patch(gui.sys, 'exit', lambda *a: None)
-
-    def _set_called(self, *args, **kwargs):
-        """Set _called to True."""
-        self._called = (args, kwargs)
-
-    def patch(self, obj, attr, new_value):
-        patcher = patch.object(obj, attr, new_value)
-        patcher.start()
-        self.addCleanup(patcher.stop)
-
-    def assert_color_equal(self, rgba_color, gdk_color):
-        """Check that 'rgba_color' is the same as 'gdk_color'."""
-        tmp = Gdk.RGBA()
-        assert tmp.parse(gdk_color.to_string())
-
-        msg = 'Text color must be %r (got %r instead).'
-        self.assertEqual(rgba_color, tmp, msg % (rgba_color, tmp))
-
-    def assert_backend_called(self, method, *args, **kwargs):
-        """Check that 'method(*args, **kwargs)' was called in the backend."""
-        self.assertIn(method, self.ui.backend._called)
-
-        call = self.ui.backend._called[method]
-        self.assertEqual(call[0], args)
-
-        reply_handler = call[1].pop('reply_handler')
-        self.assertEqual(reply_handler, gui.NO_OP)
-
-        error_handler = call[1].pop('error_handler')
-        self.assertEqual(error_handler.func, self.ui._handle_error)
-
-        self.assertEqual(call[1], kwargs)
-
-
-class LabeledEntryTestCase(BasicTestCase):
-    """Test suite for the labeled entry."""
-
-    def setUp(self):
-        """Init."""
-        super(LabeledEntryTestCase, self).setUp()
-        self.label = 'Test me please'
-        self.entry = gui.LabeledEntry(label=self.label)
-
-        # we need a window to be able to realize ourselves
-        window = Gtk.Window()
-        window.add(self.entry)
-        window.show_all()
-        self.addCleanup(window.hide)
-        self.addCleanup(window.destroy)
-
-    def grab_focus(self, focus_in=True):
-        """Grab focus on widget, if None use self.entry."""
-        direction = 'in' if focus_in else 'out'
-        self.entry.emit('focus-%s-event' % direction, None)
-
-    # Bad first argument 'LabeledEntry' given to super class
-    # pylint: disable=E1003
-    def assert_correct_label(self):
-        """Check that the entry has the correct label."""
-        # text content is correct
-        msg = 'Text content must be %r (got %r instead).'
-        expected = self.label
-        actual = super(gui.LabeledEntry, self.entry).get_text()
-        self.assertEqual(expected, actual, msg % (expected, actual))
-
-        # text color is correct
-        expected = gui.HELP_TEXT_COLOR
-        actual = self.entry.get_style().text[Gtk.StateFlags.NORMAL]
-        self.assert_color_equal(expected, actual)
-
-    def test_initial_text(self):
-        """Entry have the correct text at startup."""
-        self.assert_correct_label()
-
-    def test_width_chars(self):
-        """Entry have the correct width."""
-        self.assertEqual(self.entry.get_width_chars(), gui.DEFAULT_WIDTH)
-
-    def test_tooltip(self):
-        """Entry have the correct tooltip."""
-        msg = 'Tooltip must be %r (got %r instead).'
-        expected = self.label
-        actual = self.entry.get_tooltip_text()
-        # tooltip is correct
-        self.assertEqual(expected, actual, msg % (expected, actual))
-
-    def test_clear_entry_on_focus_in(self):
-        """Entry are cleared when focused."""
-        self.grab_focus()
-
-        msg = 'Entry must be cleared on focus in.'
-        self.assertEqual('', self.entry.get_text(), msg)
-
-    def test_text_defaults_to_theme_color_when_focus_in(self):
-        """Entry restore its text color when focused in."""
-        self.patch(self.entry, 'override_color', self._set_called)
-
-        self.grab_focus()
-
-        self.assertEqual(((Gtk.StateFlags.NORMAL, None), {}), self._called,
-                         'Entry text color must be restore on focus in.')
-
-    def test_refill_entry_on_focus_out_if_no_input(self):
-        """Entry is re-filled with label when focused out if no user input."""
-
-        self.grab_focus()  # grab focus
-        self.grab_focus(focus_in=False)  # loose focus
-
-        # Entry must be re-filled on focus out
-        self.assert_correct_label()
-
-    def test_refill_entry_on_focus_out_if_empty_input(self):
-        """Entry is re-filled with label when focused out if empty input."""
-
-        self.grab_focus()  # grab focus
-
-        self.entry.set_text('        ')  # add empty text to the entry
-
-        self.grab_focus(focus_in=False)  # loose focus
-
-        # Entry must be re-filled on focus out
-        self.assert_correct_label()
-
-    def test_preserve_input_on_focus_out_if_user_input(self):
-        """Entry is unmodified when focused out if user input."""
-        msg = 'Entry must be left unmodified on focus out when user input.'
-        expected = 'test me please'
-
-        self.grab_focus()  # grab focus
-
-        self.entry.set_text(expected)  # add empty text to the entry
-
-        self.grab_focus(focus_in=False)  # loose focus
-
-        self.assertEqual(expected, self.entry.get_text(), msg)
-
-    def test_preserve_input_on_focus_out_and_in_again(self):
-        """Entry is unmodified when focused out and then in again."""
-        msg = 'Entry must be left unmodified on focus out and then in again.'
-        expected = 'test me I mean it'
-
-        self.grab_focus()  # grab focus
-
-        self.entry.set_text(expected)  # add text to the entry
-
-        self.grab_focus(focus_in=False)  # loose focus
-        self.grab_focus()  # grab focus again!
-
-        self.assertEqual(expected, self.entry.get_text(), msg)
-
-    def test_get_text_ignores_label(self):
-        """Entry's text is only user input (label is ignored)."""
-        self.assertEqual(self.entry.get_text(), '')
-
-    def test_get_text_ignores_empty_input(self):
-        """Entry's text is only user input (empty text is ignored)."""
-        self.entry.set_text('       ')
-        self.assertEqual(self.entry.get_text(), '')
-
-    def test_get_text_doesnt_ignore_user_input(self):
-        """Entry's text is user input."""
-        self.entry.set_text('a')
-        self.assertEqual(self.entry.get_text(), 'a')
-
-    def test_no_warning_by_default(self):
-        """No secondary icon by default."""
-        self.assertEqual(self.entry.warning, None)
-        self.assertEqual(self.entry.get_property('secondary-icon-stock'),
-                         None)
-        self.assertEqual(self.entry.get_property('secondary-icon-sensitive'),
-                         False)
-        self.assertEqual(self.entry.get_property('secondary-icon-activatable'),
-                         False)
-        prop = self.entry.get_property('secondary-icon-tooltip-text')
-        self.assertEqual(prop, None)
-
-    def test_set_warning(self):
-        """Setting a warning show the proper secondary icon."""
-        msg = 'You failed!'
-        self.entry.set_warning(msg)
-        self.assertEqual(self.entry.warning, msg)
-        self.assertEqual(self.entry.get_property('secondary-icon-stock'),
-                         Gtk.STOCK_DIALOG_WARNING)
-        self.assertEqual(self.entry.get_property('secondary-icon-sensitive'),
-                         True)
-        self.assertEqual(self.entry.get_property('secondary-icon-activatable'),
-                         False)
-        prop = self.entry.get_property('secondary-icon-tooltip-text')
-        self.assertEqual(prop, msg)
-
-    def test_clear_warning(self):
-        """Clearing a warning no longer show the secondary icon."""
-        self.entry.clear_warning()
-        self.assertEqual(self.entry.warning, None)
-        self.assertEqual(self.entry.get_property('secondary-icon-stock'),
-                         None)
-        self.assertEqual(self.entry.get_property('secondary-icon-sensitive'),
-                         False)
-        self.assertEqual(self.entry.get_property('secondary-icon-activatable'),
-                         False)
-        prop = self.entry.get_property('secondary-icon-tooltip-text')
-        self.assertEqual(prop, None)
-
-
-class PasswordLabeledEntryTestCase(LabeledEntryTestCase):
-    """Test suite for the labeled entry when is_password is True."""
-
-    def setUp(self):
-        """Init."""
-        super(PasswordLabeledEntryTestCase, self).setUp()
-        self.entry.is_password = True
-
-    def test_password_fields_are_visible_at_startup(self):
-        """Password entries show the helping text at startup."""
-        self.assertTrue(self.entry.get_visibility(),
-                        'Password entry should be visible at start up.')
-
-    def test_password_field_is_visible_if_no_input_and_focus_out(self):
-        """Password entry show the label when focus out."""
-        self.grab_focus()  # user clicked or TAB'd to the entry
-        self.grab_focus(focus_in=False)  # loose focus
-        self.assertTrue(self.entry.get_visibility(),
-                        'Entry should be visible when focus out and no input.')
-
-    def test_password_fields_are_not_visible_when_editing(self):
-        """Password entries show the hidden chars instead of the password."""
-        self.grab_focus()  # user clicked or TAB'd to the entry
-        self.assertFalse(self.entry.get_visibility(),
-                         'Entry should not be visible when editing.')
-
-
-class UbuntuSSOClientTestCase(BasicTestCase):
-    """Basic setup and helper functions."""
-
-    gui_class = gui.UbuntuSSOClientGUI
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT)
-
-    def setUp(self):
-        """Init."""
-        super(UbuntuSSOClientTestCase, self).setUp()
-        self.patch(gui, 'get_sso_client', lambda: FakedSSOBackend())
-        self.pages = ('enter_details', 'processing', 'verify_email', 'finish',
-                      'tc_browser', 'login', 'request_password_token',
-                      'set_new_password')
-        self.ui = self.gui_class(**self.kwargs)
-        self.addCleanup(self.ui.destroy)
-        self.error = {'message': UNKNOWN_ERROR}
-
-    def assert_entries_are_packed_to_ui(self, container_name, entries):
-        """Every entry is properly packed in the ui 'container_name'."""
-        msg = 'Entry %r must be packed in %r but is not.'
-        container = getattr(self.ui, container_name)
-        for kind in entries:
-            name = '%s_entry' % kind
-            entry = getattr(self.ui, name)
-            self.assertIsInstance(entry, gui.LabeledEntry)
-            self.assertIn(entry, container, msg % (name, container_name))
-
-    def assert_warnings_visibility(self, visible=False):
-        """Every warning label should be 'visible'."""
-        msg = '%r should have %sempty content.'
-        for name in self.ui.widgets:
-            widget = getattr(self.ui, name)
-            if 'warning' in name:
-                self.assertEqual('', widget.get_text(),
-                                 msg % (name, '' if visible else 'non-'))
-            elif 'entry' in name:
-                self.assertEqual(widget.warning, '')
-
-    def assert_correct_label_warning(self, label, message):
-        """Check that a warning is shown displaying 'message'."""
-        # warning label is visible
-        self.assertTrue(label.get_property('visible'))
-
-        # warning content is correct
-        actual = label.get_text().decode('utf-8')
-        self.assertEqual(actual, message)
-
-        # content color is correct
-        # FIXME - New GTK+ 3.5 breaks this check - see bug #1014772
-        # expected = gui.WARNING_TEXT_COLOR
-        # actual = label.get_style().fg[Gtk.StateFlags.NORMAL]
-        # self.assert_color_equal(expected, actual)
-
-    def assert_correct_entry_warning(self, entry, message):
-        """Check that a warning is shown displaying 'message'."""
-        self.assertEqual(entry.warning, message)
-
-    def assert_pages_visibility(self, **kwargs):
-        """The page 'name' is the current page for the content notebook."""
-        msg = 'page %r must be self.ui.content\'s current page.'
-        (name, _), = kwargs.items()
-        page = getattr(self.ui, '%s_vbox' % name)
-        self.assertEqual(self.ui.content.get_current_page(),
-                         self.ui.content.page_num(page), msg % name)
-
-    def click_join_with_valid_data(self):
-        """Move to the next page after entering details."""
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-
-        self.ui.name_entry.set_text(NAME)
-        # match emails
-        self.ui.email1_entry.set_text(EMAIL)
-        self.ui.email2_entry.set_text(EMAIL)
-        # match passwords
-        self.ui.password1_entry.set_text(PASSWORD)
-        self.ui.password2_entry.set_text(PASSWORD)
-        if self.ui.tc_url:
-            # agree to TC, only if the tc_url is defined, so we catch errors
-            self.ui.yes_to_tc_checkbutton.set_active(True)
-        # resolve captcha properly
-        self.ui.captcha_solution_entry.set_text(CAPTCHA_SOLUTION)
-
-        self.ui.join_ok_button.clicked()
-
-    def click_verify_email_with_valid_data(self):
-        """Move to the next page after entering email token."""
-        self.click_join_with_valid_data()
-
-        # resolve email token properly
-        self.ui.email_token_entry.set_text(EMAIL_TOKEN)
-
-        self.ui.verify_token_button.clicked()
-
-    def click_connect_with_valid_data(self):
-        """Move to the next page after entering login info."""
-        # enter email
-        self.ui.login_email_entry.set_text(EMAIL)
-        # enter password
-        self.ui.login_password_entry.set_text(PASSWORD)
-
-        self.ui.login_ok_button.clicked()
-
-    def click_request_password_token_with_valid_data(self):
-        """Move to the next page after requesting for password reset token."""
-        # enter email
-        self.ui.reset_email_entry.set_text(EMAIL)
-
-        self.ui.request_password_token_ok_button.clicked()
-
-    def click_set_new_password_with_valid_data(self):
-        """Move to the next page after resetting password."""
-        # enter reset code
-        self.ui.reset_code_entry.set_text(RESET_PASSWORD_TOKEN)
-        # match passwords
-        self.ui.reset_password1_entry.set_text(PASSWORD)
-        self.ui.reset_password2_entry.set_text(PASSWORD)
-
-        self.ui.set_new_password_ok_button.clicked()
-
-
-class BasicUbuntuSSOClientTestCase(UbuntuSSOClientTestCase):
-    """Test suite for basic functionality."""
-
-    def test_main_window_is_visible_at_startup(self):
-        """The main window is shown at startup."""
-        self.assertTrue(self.ui.window.get_property('visible'))
-
-    def test_main_window_is_resizable(self):
-        """The main window can be resized."""
-        self.assertTrue(self.ui.window.get_property('resizable'))
-
-    def test_closing_main_window_calls_close_callback(self):
-        """The close_callback is called when closing the main window."""
-        self.ui.close_callback = self._set_called
-        self.ui.on_close_clicked()
-        self.assertTrue(self._called,
-                        'close_callback was called when window was closed.')
-
-    def test_close_callback_if_not_set(self):
-        """The close_callback is a no op if not set."""
-        self.ui.on_close_clicked()
-        # no crash when close_callback is not set
-
-    def test_app_name_is_stored(self):
-        """The app_name is stored for further use."""
-        self.assertIn(APP_NAME, self.ui.app_name)
-
-    def test_signals_are_removed(self):
-        """The hooked signals are removed at shutdown time."""
-        assert len(self.ui.backend.callbacks) > 0  # at least one callback
-
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self.ui.backend.callbacks, {})
-
-    def test_pages_are_packed_into_container(self):
-        """All the pages are packed in the main container."""
-        children = self.ui.content.get_children()
-        for page_name in self.pages:
-            page = getattr(self.ui, '%s_vbox' % page_name)
-            self.assertIn(page, children)
-
-    def test_initial_text_for_entries(self):
-        """Entries have the correct text at startup."""
-        msg = 'Text for %r must be %r (got %r instead).'
-        for name in self.ui.entries:
-            entry = getattr(self.ui, name)
-            expected = getattr(gui.ui_strings, name.upper())
-            actual = entry.label
-            # text content is correct
-            self.assertEqual(expected, actual, msg % (name, expected, actual))
-
-    def test_entries_activates_default(self):
-        """Entries have the activates default prop set."""
-        msg = '%r must have activates_default set to True.'
-        for name in self.ui.entries:
-            entry = getattr(self.ui, name)
-            self.assertTrue(entry.get_activates_default(), msg % (name,))
-
-    def test_password_fields_are_password(self):
-        """Password fields have the is_password flag set."""
-        msg = '%r should be a password LabeledEntry instance.'
-        passwords = filter(lambda name: 'password' in name,
-                           self.ui.entries)
-        for name in passwords:
-            widget = getattr(self.ui, name)
-            self.assertTrue(widget.is_password, msg % name)
-
-    def test_warning_fields_are_cleared(self):
-        """Every warning label should be cleared."""
-        self.assert_warnings_visibility()
-
-    def test_cancel_buttons_close_window(self):
-        """Every cancel button should close the window when clicked."""
-        self.patch(self.ui.backend, 'disconnect_from_signal', lambda *a: None)
-        msg = '%r should close the window when clicked.'
-        buttons = filter(lambda name: 'cancel_button' in name or
-                                      'close_button' in name, self.ui.widgets)
-        for name in buttons:
-            self.ui.close_callback = self._set_called
-            widget = getattr(self.ui, name)
-            widget.clicked()
-            self.assertEqual(self._called, ((widget,), {}), msg % name)
-            self._called = False
-
-    def test_window_icon(self):
-        """Main window has the proper icon."""
-        self.assertEqual('ubuntu-logo', self.ui.window.get_icon_name())
-
-    def test_finish_success_shows_success_page(self):
-        """When calling 'finish_success' the success page is shown."""
-        self.ui.finish_success()
-        self.assert_pages_visibility(finish=True)
-        self.assertEqual(gui.SUCCESS % {'app_name': APP_NAME},
-            self.ui.finish_vbox.label.get_text().decode('utf8'))
-        result = self.ui.finish_vbox.label.get_text().decode('utf8')
-        self.assertTrue(self.ui.app_name in result)
-
-    def test_finish_error_shows_error_page(self):
-        """When calling 'finish_error' the error page is shown."""
-        self.ui.finish_error()
-        self.assert_pages_visibility(finish=True)
-        self.assertEqual(gui.ERROR,
-                         self.ui.finish_vbox.label.get_text().decode('utf8'))
-
-
-@skip("Apparently, so far we can't use XLib dynamic bindings "
-      "to complete the call to X11Window.foreign_new_for_display.")
-class SetTransientForTestCase(UbuntuSSOClientTestCase):
-    """Test suite for setting the window as transient for another one."""
-
-    def test_transient_window_is_none_if_window_id_is_zero(self):
-        """The transient window is correct."""
-        self.patch(gui.X11Window, 'foreign_new_for_display', self._set_called)
-        ui = self.gui_class(window_id=0, **self.kwargs)
-        self.addCleanup(ui.destroy)
-
-        self.assertFalse(self._called, 'set_transient_for must not be called.')
-
-    def test_transient_window_is_correct(self):
-        """The transient window is correct."""
-        xid = 5
-        self.patch(gui.X11Window, 'foreign_new_for_display', self._set_called)
-        ui = self.gui_class(window_id=xid, **self.kwargs)
-        self.addCleanup(ui.destroy)
-
-        self.assertTrue(self.memento.check(logging.ERROR, 'set_transient_for'))
-        self.assertTrue(self.memento.check(logging.ERROR, str(xid)))
-        self.assertEqual(self._called, ((xid,), {}))
-
-    def test_transient_window_accepts_negative_id(self):
-        """The transient window accepts a negative window id."""
-        xid = -5
-        self.patch(gui.X11Window, 'foreign_new_for_display', self._set_called)
-        ui = self.gui_class(window_id=xid, **self.kwargs)
-        self.addCleanup(ui.destroy)
-
-        self.assertEqual(self._called, ((xid,), {}))
-
-
-class EnterDetailsTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user registration (enter details page)."""
-
-    def test_initial_text_for_header_label(self):
-        """The header must have the correct text at startup."""
-        msg = 'Text for the header must be %r (got %r instead).'
-        expected = gui.JOIN_HEADER_LABEL % {'app_name': APP_NAME}
-        actual = self.ui.header_label.get_text().decode('utf8')
-        # text content is correct
-        self.assertEqual(expected, actual, msg % (expected, actual))
-
-    def test_entries_are_packed_to_ui(self):
-        """Every entry is properly packed in the ui."""
-        for kind in ('email', 'password'):
-            container_name = '%ss_hbox' % kind
-            entries = ('%s%s' % (kind, i) for i in xrange(1, 3))
-            self.assert_entries_are_packed_to_ui(container_name, entries)
-
-        self.assert_entries_are_packed_to_ui('enter_details_vbox', ('name',))
-        self.assert_entries_are_packed_to_ui('captcha_solution_vbox',
-                                             ('captcha_solution',))
-        self.assert_entries_are_packed_to_ui('verify_email_details_vbox',
-                                             ('email_token',))
-
-    def test_initial_texts_for_checkbuttons(self):
-        """Check buttons have the correct text at startup."""
-        msg = 'Text for %r must be %r (got %r instead).'
-        expected = gui.YES_TO_UPDATES % {'app_name': APP_NAME}
-        actual = self.ui.yes_to_updates_checkbutton.get_label().decode('utf8')
-        self.assertEqual(expected, actual, msg % ('yes_to_updates_checkbutton',
-                                                  expected, actual))
-        expected = gui.YES_TO_TC % {'app_name': APP_NAME}
-        actual = self.ui.yes_to_tc_checkbutton.get_label().decode('utf8')
-        self.assertEqual(expected, actual,
-                         msg % ('yes_to_tc_checkbutton', expected, actual))
-
-    def test_updates_checkbutton_is_checked_at_startup(self):
-        """The 'yes to updates' checkbutton is checked by default."""
-        msg = '%r is checked by default.'
-        name = 'yes_to_updates_checkbutton'
-        widget = getattr(self.ui, name)
-        self.assertTrue(widget.get_active(), msg % name)
-
-    def test_tc_checkbutton_is_not_checked_at_startup(self):
-        """The 'yes to T&C' checkbutton is not checked by default."""
-        msg = '%r is checked by default.'
-        name = 'yes_to_tc_checkbutton'
-        widget = getattr(self.ui, name)
-        self.assertFalse(widget.get_active(), msg % name)
-
-    def test_vboxes_visible_properties(self):
-        """Only 'enter_details' vbox is visible at start up."""
-        self.assert_pages_visibility(enter_details=True)
-
-    def test_join_ok_button_clicked(self):
-        """Clicking 'join_ok_button' sends info to backend using 'register'."""
-        self.click_join_with_valid_data()
-
-        # assert register_user was called
-        self.assert_backend_called('register_user',
-            APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID, CAPTCHA_SOLUTION)
-
-    def test_join_ok_button_clicked_morphs_to_processing_page(self):
-        """Clicking 'join_ok_button' presents the processing vbox."""
-        self.click_join_with_valid_data()
-        self.assert_pages_visibility(processing=True)
-
-    def test_processing_vbox_displays_an_active_spinner(self):
-        """When processing the registration, an active spinner is shown."""
-        self.click_join_with_valid_data()
-
-        self.assertTrue(self.ui.processing_vbox.get_property('visible'),
-                        'the processing box should be visible.')
-
-        box = self.ui.processing_vbox.get_children()[0].get_children()[0]
-        self.assertEqual(2, len(box.get_children()),
-                         'processing_vbox must have two children.')
-
-        spinner, label = box.get_children()
-        self.assertIsInstance(spinner, Gtk.Spinner)
-        self.assertIsInstance(label, Gtk.Label)
-
-        self.assertTrue(spinner.get_property('visible'),
-                        'the processing spinner should be visible.')
-        self.assertTrue(spinner.get_property('active'),
-                        'the processing spinner should be active.')
-        self.assertTrue(label.get_property('visible'),
-                        'the processing label should be visible.')
-        self.assertEqual(label.get_text().decode('utf8'),
-                         gui.ONE_MOMENT_PLEASE,
-                        'the processing label text must be correct.')
-
-    def test_captcha_image_is_not_visible_at_startup(self):
-        """Captcha image is not shown at startup."""
-        self.assertFalse(self.ui.captcha_image.get_property('visible'),
-                        'the captcha_image should not be visible.')
-
-    def test_captcha_filename_is_different_each_time(self):
-        """The captcha image is different each time."""
-        ui = self.gui_class(**self.kwargs)
-        self.addCleanup(ui.destroy)
-
-        self.assertNotEqual(self.ui._captcha_filename, ui._captcha_filename)
-
-    def test_captcha_image_is_removed_when_exiting(self):
-        """The captcha image is removed at shutdown time."""
-        open(self.ui._captcha_filename, 'w').close()
-        assert os.path.exists(self.ui._captcha_filename)
-        self.ui.on_close_clicked()
-
-        self.assertFalse(os.path.exists(self.ui._captcha_filename),
-                         'captcha image must be removed when exiting.')
-
-    def test_captcha_image_is_a_spinner_at_first(self):
-        """Captcha image shows a spinner until the image is downloaded."""
-        self.assertTrue(self.ui.captcha_loading.get_property('visible'),
-                        'the captcha_loading box should be visible.')
-
-        box = self.ui.captcha_loading.get_children()[0].get_children()[0]
-        self.assertEqual(2, len(box.get_children()),
-                         'captcha_loading must have two children.')
-
-        spinner, label = box.get_children()
-        self.assertIsInstance(spinner, Gtk.Spinner)
-        self.assertIsInstance(label, Gtk.Label)
-
-        self.assertTrue(spinner.get_property('visible'),
-                        'the captcha_loading spinner should be visible.')
-        self.assertTrue(spinner.get_property('active'),
-                        'the captcha_loading spinner should be active.')
-        self.assertTrue(label.get_property('visible'),
-                        'the captcha_loading label should be visible.')
-        self.assertEqual(label.get_text().decode('utf8'), gui.LOADING,
-                        'the captcha_loading label text must be correct.')
-
-    def test_join_ok_button_is_disabled_until_captcha_is_available(self):
-        """The join_ok_button is not sensitive until captcha is available."""
-        self.assertFalse(self.ui.join_ok_button.is_sensitive())
-
-    def test_join_ok_button_is_enabled_when_captcha_is_available(self):
-        """The join_ok_button is sensitive when captcha is available."""
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-        self.assertTrue(self.ui.join_ok_button.is_sensitive())
-
-    def test_captcha_loading_is_hid_when_captcha_is_available(self):
-        """The captcha_loading is hid when captcha is available."""
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-        self.assertFalse(self.ui.captcha_loading.get_property('visible'),
-                         'captcha_loading is not visible.')
-
-    def test_captcha_id_is_stored_when_captcha_is_available(self):
-        """The captcha_id is stored when captcha is available."""
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-        self.assertEqual(CAPTCHA_ID, self.ui._captcha_id)
-
-    def test_captcha_image_is_requested_as_startup(self):
-        """The captcha image is requested at startup."""
-        # assert generate_captcha was called
-        self.assert_backend_called('generate_captcha',
-            APP_NAME, self.ui._captcha_filename)
-
-    def test_captcha_is_shown_when_available(self):
-        """The captcha image is shown when available."""
-        self.patch(self.ui.captcha_image, 'set_from_file', self._set_called)
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-        self.assertTrue(self.ui.captcha_image.get_property('visible'))
-        self.assertEqual(self._called, ((self.ui._captcha_filename,), {}))
-
-    def test_on_captcha_generated_logs_captcha_id_when_none(self):
-        """If the captcha id is None, a warning is logged."""
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=None)
-        self.assertTrue(self.memento.check(logging.WARNING, repr(APP_NAME)))
-        self.assertTrue(self.memento.check(logging.WARNING,
-                                           'captcha_id is None'))
-
-    def test_captcha_reload_button_visible(self):
-        """The captcha reload button is initially visible."""
-        self.assertTrue(self.ui.captcha_reload_button.get_visible(),
-                        "The captcha button is not visible")
-
-    def test_captcha_reload_button_reloads_captcha(self):
-        """The captcha reload button loads a new captcha."""
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-        self.patch(self.ui, '_generate_captcha', self._set_called)
-        self.ui.captcha_reload_button.clicked()
-        self.assertEqual(self._called, ((), {}))
-
-    def test_captcha_reload_button_has_tooltip(self):
-        """The captcha reload button has a tooltip."""
-        self.assertEqual(self.ui.captcha_reload_button.get_tooltip_text(),
-                         gui.CAPTCHA_RELOAD_TOOLTIP)
-
-    def test_login_button_has_correct_wording(self):
-        """The sign in button has the proper wording."""
-        actual = self.ui.login_button.get_label().decode('utf8')
-        self.assertEqual(gui.LOGIN_BUTTON_LABEL, actual)
-
-    def test_join_ok_button_does_nothing_if_clicked_but_disabled(self):
-        """The join form can only be submitted if the button is sensitive."""
-        self.patch(self.ui.email1_entry, 'get_text', self._set_called)
-
-        self.ui.join_ok_button.set_sensitive(False)
-        self.ui.join_ok_button.clicked()
-        self.assertFalse(self._called)
-
-        self.ui.join_ok_button.set_sensitive(True)
-        self.ui.join_ok_button.clicked()
-        self.assertTrue(self._called)
-
-    def test_user_and_pass_are_cached(self):
-        """Username and password are temporarily cached for further use."""
-        self.click_join_with_valid_data()
-        self.assertEqual(self.ui.user_email, EMAIL)
-        self.assertEqual(self.ui.user_password, PASSWORD)
-
-    def test_on_captcha_generation_error(self):
-        """on_captcha_generation_error shows an error and reloads captcha."""
-        self.patch(self.ui, '_generate_captcha', self._set_called)
-        self.ui.on_captcha_generation_error(APP_NAME, error=self.error)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          gui.CAPTCHA_LOAD_ERROR)
-        self.assertEqual(self._called, ((), {}))
-
-    def test_captcha_success_after_error(self):
-        """When captcha was retrieved after error, the warning is removed."""
-        self.ui.on_captcha_generation_error(APP_NAME, error=self.error)
-        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
-        self.assertEqual(self.ui.warning_label.get_text().decode('utf8'), '')
-
-    def test_has_tc_link(self):
-        """The T&C button and checkbox are shown if the link is provided"""
-        self.assertEqual(self.ui.tc_button.get_visible(), True)
-        self.assertEqual(self.ui.yes_to_tc_checkbutton.get_visible(), True)
-
-
-class NoTermsAndConditionsTestCase(EnterDetailsTestCase):
-    """Test suite for the user registration (with no t&c link)."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url='', help_text=HELP_TEXT)
-
-    def test_has_tc_link(self):
-        """The T&C button and checkbox are not shown if no link is provided"""
-        self.assertEqual(self.ui.tc_vbox.get_visible(), False)
-
-
-class TermsAndConditionsBrowserTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the terms & conditions browser."""
-
-    def setUp(self):
-        super(TermsAndConditionsBrowserTestCase, self).setUp()
-        self.patch(WebKit, 'WebView', FakedEmbeddedBrowser)
-        self.patch(self.ui, '_webkit_init_ssl', self._set_called)
-
-        self.ui.tc_button.clicked()
-        self.addCleanup(self.ui.tc_browser_vbox.hide)
-
-        children = self.ui.tc_browser_window.get_children()
-        assert len(children) == 1
-        self.browser = children[0]
-
-    def test_ssl_validation(self):
-        """The browser is set to validate SSL."""
-        self.assertEqual(self._called, ((), {}),
-                         '_webkit_init_ssl should be called when creating a '
-                         'webkit browser.')
-
-    def test_tc_browser_is_created_when_tc_page_is_shown(self):
-        """The browser is created when the TC button is clicked."""
-        self.ui.on_tc_browser_notify_load_status(self.browser)
-
-        children = self.ui.tc_browser_window.get_children()
-        self.assertEqual(1, len(children))
-
-    def test_is_visible(self):
-        """The browser is visible."""
-        self.assertIsInstance(self.browser, FakedEmbeddedBrowser)
-        self.assertTrue(self.browser.get_property('visible'))
-
-    def test_settings(self):
-        """The browser settings are correct."""
-        settings = self.browser.get_settings()
-        self.assertFalse(settings.get_property('enable-plugins'))
-        self.assertFalse(settings.get_property('enable-default-context-menu'))
-
-    def test_tc_browser_is_destroyed_when_tc_page_is_hid(self):
-        """The browser is destroyed when the TC page is hid."""
-        self.ui.on_tc_browser_notify_load_status(self.browser)
-        self.patch(self.browser, 'destroy', self._set_called)
-        self.ui.tc_browser_vbox.hide()
-        self.assertEqual(self._called, ((), {}))
-
-    def test_tc_browser_is_removed_when_tc_page_is_hid(self):
-        """The browser is removed when the TC page is hid."""
-        self.ui.on_tc_browser_notify_load_status(self.browser)
-
-        self.ui.tc_browser_vbox.hide()
-
-        children = self.ui.tc_browser_window.get_children()
-        self.assertEqual(0, len(children))
-
-    def test_tc_button_clicked_morphs_into_processing_page(self):
-        """Clicking the T&C button morphs into processing page."""
-        self.assert_pages_visibility(processing=True)
-
-    def test_tc_back_clicked_returns_to_previous_page(self):
-        """Terms & Conditions back button return to previous page."""
-        self.ui.on_tc_browser_notify_load_status(self.browser)
-        self.ui.tc_back_button.clicked()
-        self.assert_pages_visibility(enter_details=True)
-
-    def test_tc_button_has_the_proper_wording(self):
-        """Terms & Conditions has the proper wording."""
-        self.assertEqual(self.ui.tc_button.get_label().decode('utf8'),
-                         gui.TC_BUTTON)
-
-    def test_tc_has_no_help_text(self):
-        """The help text is removed."""
-        self.ui.on_tc_browser_notify_load_status(self.browser)
-        self.assertEqual('', self.ui.help_label.get_text().decode('utf8'))
-
-    def test_tc_browser_opens_the_proper_url(self):
-        """Terms & Conditions browser shows the proper uri."""
-        self.assertEqual(self.browser.get_property('uri'), TC_URL)
-
-    @skip('Connecting to notify::load-status makes U1 terms navigation fail.')
-    def test_notify_load_status_connected(self):
-        """The 'notify::load-status' signal is connected."""
-        expected = [self.ui.on_tc_browser_notify_load_status]
-        self.assertEqual(self.browser._signals['notify::load-status'],
-                         expected)
-
-    def test_notify_load_finished_connected(self):
-        """The 'load-finished' signal is connected."""
-        expected = [self.ui.on_tc_browser_notify_load_status]
-        self.assertEqual(self.browser._signals['notify::load-status'],
-                         expected)
-
-    def test_tc_loaded_morphs_into_tc_browser_vbox(self):
-        """When the Terms & Conditions is loaded, show the browser window."""
-        self.ui.on_tc_browser_notify_load_status(self.browser)
-        self.assert_pages_visibility(tc_browser=True)
-
-    def test_navigation_requested_connected(self):
-        """The 'navigation-policy-decision-requested' signal is connected."""
-        actual = self.browser._signals['navigation-policy-decision-requested']
-        expected = [self.ui.on_tc_browser_navigation_requested]
-        self.assertEqual(actual, expected)
-
-    def test_navigation_requested_succeeds_for_no_clicking(self):
-        """The navigation request succeeds when user hasn't clicked a link."""
-        action = WebKit.WebNavigationAction()
-        action.set_reason(WebKit.WebNavigationReason.OTHER)
-
-        decision = WebKit.WebPolicyDecision()
-        decision.use = self._set_called
-
-        kwargs = dict(browser=self.browser, frame=None, request=None,
-                      action=action, decision=decision)
-        self.ui.on_tc_browser_navigation_requested(**kwargs)
-        self.assertEqual(self._called, ((), {}))
-
-    def test_navigation_requested_ignores_clicked_links(self):
-        """The navigation request is ignored if a link was clicked."""
-        action = WebKit.WebNavigationAction()
-        action.set_reason(WebKit.WebNavigationReason.LINK_CLICKED)
-
-        decision = WebKit.WebPolicyDecision()
-        decision.ignore = self._set_called
-
-        self.patch(gui.webbrowser, 'open', lambda *args, **kwargs: None)
-
-        kwargs = dict(browser=self.browser, frame=None, request=None,
-                      action=action, decision=decision)
-        self.ui.on_tc_browser_navigation_requested(**kwargs)
-        self.assertEqual(self._called, ((), {}))
-
-    def test_navigation_requested_ignores_for_none(self):
-        """The navigation request is ignored the request if params are None."""
-        kwargs = dict(browser=None, frame=None, request=None,
-                      action=None, decision=None)
-        self.ui.on_tc_browser_navigation_requested(**kwargs)
-
-    def test_navigation_requested_opens_links_when_clicked(self):
-        """The navigation request is opened on user's default browser
-
-        (If the user opened a link by clicking into it).
-
-        """
-        url = 'http://something.com/yadda'
-        action = WebKit.WebNavigationAction()
-        action.set_reason(WebKit.WebNavigationReason.LINK_CLICKED)
-        action.set_original_uri(url)
-
-        decision = WebKit.WebPolicyDecision()
-        decision.ignore = gui.NO_OP
-
-        self.patch(gui.webbrowser, 'open', self._set_called)
-
-        kwargs = dict(browser=self.browser, frame=None, request=None,
-                      action=action, decision=decision)
-        self.ui.on_tc_browser_navigation_requested(**kwargs)
-        self.assertEqual(self._called, ((url,), {}))
-
-    def test_on_tc_button_clicked_no_child(self):
-        """Test the tc loading with no child."""
-        called = []
-
-        def fake_add_browser():
-            """Fake add browser."""
-            called.append('fake_add_browser')
-
-        self.patch(self.ui, '_add_webkit_browser', fake_add_browser)
-        self.patch(self.ui.tc_browser_window, 'get_child', lambda: None)
-
-        self.ui.on_tc_button_clicked()
-        self.assertIn('fake_add_browser', called)
-
-    def test_on_tc_button_clicked_child(self):
-        """Test the tc loading with child."""
-        called = []
-
-        def fake_add_browser(i_self):
-            """Fake add browser."""
-            called.append('fake_add_browser')
-
-        self.patch(self.ui, '_add_webkit_browser', fake_add_browser)
-
-        browser = WebKit.WebView()
-        self.ui.tc_browser_window.add(browser)
-        self.ui.on_tc_button_clicked()
-        self.assertNotIn('fake_add_browser', called)
-
-
-class RegistrationErrorTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user registration error handling."""
-
-    def setUp(self):
-        """Init."""
-        super(RegistrationErrorTestCase, self).setUp()
-        self.click_join_with_valid_data()
-
-    def test_previous_page_is_shown(self):
-        """On UserRegistrationError the previous page is shown."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
-        self.assert_pages_visibility(enter_details=True)
-
-    def test_captcha_is_reloaded(self):
-        """On UserRegistrationError the captcha is reloaded."""
-        self.patch(self.ui, '_generate_captcha', self._set_called)
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
-        self.assertEqual(self._called, ((), {}))
-
-    def test_warning_label_is_shown(self):
-        """On UserRegistrationError the warning label is shown."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          UNKNOWN_ERROR)
-
-    def test_specific_errors_from_backend_are_shown(self):
-        """Specific errors from backend are used."""
-        error = {'errtype': 'RegistrationError',
-                 'message': 'We\'re so doomed.',
-                 'email': 'Enter a valid e-mail address.',
-                 'password': 'I don\'t like your password.',
-                 '__all__': 'Wrong captcha solution.'}
-
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=error)
-
-        expected = '\n'.join((error['__all__'], error['message']))
-        self.assert_correct_label_warning(self.ui.warning_label, expected)
-        self.assert_correct_entry_warning(self.ui.email1_entry,
-                                          error['email'])
-        self.assert_correct_entry_warning(self.ui.email2_entry,
-                                          error['email'])
-        self.assert_correct_entry_warning(self.ui.password1_entry,
-                                          error['password'])
-        self.assert_correct_entry_warning(self.ui.password2_entry,
-                                          error['password'])
-
-
-class VerifyEmailTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user registration (verify email page)."""
-
-    method = 'validate_email'
-    method_args = (APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
-
-    def setUp(self):
-        """Init."""
-        super(VerifyEmailTestCase, self).setUp()
-        self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
-
-    def test_registration_successful_shows_verify_email_vbox(self):
-        """Receiving 'registration_successful' shows the verify email vbox."""
-        self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(verify_email=True)
-
-    def test_help_label_display_correct_wording(self):
-        """The help_label display VERIFY_EMAIL_LABEL."""
-        msg = 'help_label must read %r (got %r instead).'
-        actual = self.ui.help_label.get_label().decode('utf8')
-        expected = gui.VERIFY_EMAIL_LABEL % {'app_name': APP_NAME,
-                                             'email': EMAIL}
-        self.assertEqual(expected, actual, msg % (expected, actual))
-
-    def test_on_verify_token_button_clicked_calls_backend(self):
-        """Verify token button triggers call to backend."""
-        self.click_verify_email_with_valid_data()
-        self.assert_backend_called(self.method, *self.method_args)
-
-    def test_on_verify_token_button_clicked(self):
-        """Verify token uses cached user_email and user_password."""
-        self.ui.user_email = '[e-mail]'
-        self.ui.user_password = 'yadda-yedda'
-        method_args = list(self.method_args)
-        method_args[1] = self.ui.user_email
-        method_args[2] = self.ui.user_password
-
-        # resolve email token properly
-        self.ui.email_token_entry.set_text(EMAIL_TOKEN)
-
-        self.ui.on_verify_token_button_clicked()
-        self.assert_backend_called(self.method, *tuple(method_args))
-
-    def test_on_verify_token_button_shows_processing_page(self):
-        """Verify token button triggers call to backend."""
-        self.click_verify_email_with_valid_data()
-        self.assert_pages_visibility(processing=True)
-
-    def test_no_warning_messages_if_valid_data(self):
-        """No warning messages are shown if the data is valid."""
-        # this will certainly NOT generate warnings
-        self.click_verify_email_with_valid_data()
-        self.assert_warnings_visibility()
-
-    def test_on_email_validated_shows_finish_page(self):
-        """On email validated the finish page is shown."""
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(finish=True)
-
-    def test_on_email_validated_does_not_clear_the_help_text(self):
-        """On email validated the help text is not removed."""
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.assertEqual(self.ui.verify_email_vbox.help_text,
-                         self.ui.help_label.get_label().decode('utf8'))
-
-    def test_on_email_validation_error_verify_email_is_shown(self):
-        """On email validation error, the verify_email page is shown."""
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
-        self.assert_pages_visibility(verify_email=True)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          UNKNOWN_ERROR)
-
-    def test_specific_errors_from_backend_are_shown(self):
-        """Specific errors from backend are used."""
-        error = {'errtype': 'EmailValidationError',
-                 'message': 'We\'re so doomed.',
-                 'email_token': 'Enter a valid e-mail address.',
-                 '__all__': 'We all are gonna die.'}
-
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=error)
-
-        expected = '\n'.join((error['__all__'], error['message']))
-        self.assert_correct_label_warning(self.ui.warning_label, expected)
-        self.assert_correct_entry_warning(self.ui.email_token_entry,
-                                          error['email_token'])
-
-    def test_success_label_is_correct(self):
-        """The success message is correct."""
-        self.assertEqual(gui.SUCCESS % {'app_name': APP_NAME},
-                         self.ui.success_vbox.label.get_text().decode('utf8'))
-        markup = self.ui.success_vbox.label.get_label().decode('utf8')
-        self.assertTrue('<span size="x-large">' in markup)
-        self.assertTrue(self.ui.app_name in markup)
-
-    def test_error_label_is_correct(self):
-        """The error message is correct."""
-        self.assertEqual(gui.ERROR,
-                         self.ui.error_vbox.label.get_text().decode('utf8'))
-        markup = self.ui.error_vbox.label.get_label().decode('utf8')
-        self.assertTrue('<span size="x-large">' in markup)
-
-    def test_on_finish_close_button_clicked_closes_window(self):
-        """When done the window is closed."""
-        self.ui.finish_close_button.clicked()
-        self.assertFalse(self.ui.window.get_property('visible'))
-
-    def test_verify_token_button_does_nothing_if_clicked_but_disabled(self):
-        """The email token can only be submitted if the button is sensitive."""
-        self.patch(self.ui.email_token_entry, 'get_text', self._set_called)
-
-        self.ui.verify_token_button.set_sensitive(False)
-        self.ui.verify_token_button.clicked()
-        self.assertFalse(self._called)
-
-        self.ui.verify_token_button.set_sensitive(True)
-        self.ui.verify_token_button.clicked()
-        self.assertTrue(self._called)
-
-    def test_after_email_validated_finish_success(self):
-        """After email_validated is called, finish_success is called."""
-        self.patch(self.ui, 'finish_success', self._set_called)
-
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self._called, ((), {}))
-
-
-class VerifyEmailWithPingTestCase(VerifyEmailTestCase):
-    """Test suite for the user registration (verify email page)."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
-                  ping_url=PING_URL)
-    method = 'validate_email_and_ping'
-    method_args = (APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN, PING_URL)
-
-
-class VerifyEmailValidationTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user registration validation (verify email page)."""
-
-    def setUp(self):
-        """Init."""
-        super(VerifyEmailValidationTestCase, self).setUp()
-        self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
-
-    def test_warning_is_shown_if_empty_email_token(self):
-        """A warning message is shown if email token is empty."""
-        self.ui.email_token_entry.set_text('')
-
-        self.ui.verify_token_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.email_token_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('validate_email', self.ui.backend._called)
-
-    def test_no_warning_messages_if_valid_data(self):
-        """No warning messages are shown if the data is valid."""
-        # this will certainly NOT generate warnings
-        self.click_verify_email_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
-        """No warnings if the data is valid (with prior invalid data)."""
-        # this will certainly generate warnings
-        self.ui.verify_token_button.clicked()
-
-        # this will certainly NOT generate warnings
-        self.click_verify_email_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-
-class VerifyEmailLoginOnlyTestCase(VerifyEmailTestCase):
-    """Test suite for the user login (verify email page)."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
-                  login_only=True)
-
-
-class VerifyEmailValidationLoginOnlyTestCase(VerifyEmailValidationTestCase):
-    """Test suite for the user login validation (verify email page)."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
-                  login_only=True)
-
-
-class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user registration  validations."""
-
-    def setUp(self):
-        """Init."""
-        super(RegistrationValidationTestCase, self).setUp()
-        self.ui.join_ok_button.set_sensitive(True)
-
-    def test_warning_is_shown_if_name_empty(self):
-        """A warning message is shown if name is empty."""
-        self.ui.name_entry.set_text('')
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.name_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_empty_email(self):
-        """A warning message is shown if emails are empty."""
-        self.ui.email1_entry.set_text('')
-        self.ui.email2_entry.set_text('')
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.email1_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assert_correct_entry_warning(self.ui.email2_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_email_mismatch(self):
-        """A warning message is shown if emails doesn't match."""
-        self.ui.email1_entry.set_text(EMAIL)
-        self.ui.email2_entry.set_text(EMAIL * 2)
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.email1_entry,
-                                          gui.EMAIL_MISMATCH)
-        self.assert_correct_entry_warning(self.ui.email2_entry,
-                                          gui.EMAIL_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_invalid_email(self):
-        """A warning message is shown if email is invalid."""
-        self.ui.email1_entry.set_text('q')
-        self.ui.email2_entry.set_text('q')
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.email1_entry,
-                                          gui.EMAIL_INVALID)
-        self.assert_correct_entry_warning(self.ui.email2_entry,
-                                          gui.EMAIL_INVALID)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_password_help_is_always_shown(self):
-        """Password help text is correctly displayed."""
-        self.assertTrue(self.ui.password_help_label.get_property('visible'),
-                        'password help text is visible.')
-        self.assertEqual(self.ui.password_help_label.get_text().decode('utf8'),
-                         gui.PASSWORD_HELP)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_password_mismatch(self):
-        """A warning message is shown if password doesn't match."""
-        self.ui.password1_entry.set_text(PASSWORD)
-        self.ui.password2_entry.set_text(PASSWORD * 2)
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.password1_entry,
-                                          gui.PASSWORD_MISMATCH)
-        self.assert_correct_entry_warning(self.ui.password2_entry,
-                                          gui.PASSWORD_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_password_too_weak(self):
-        """A warning message is shown if password is too weak."""
-        # password will match but will be too weak
-        for pwd in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
-            self.ui.password1_entry.set_text(pwd)
-            self.ui.password2_entry.set_text(pwd)
-
-            self.ui.join_ok_button.clicked()
-
-            self.assert_correct_entry_warning(self.ui.password1_entry,
-                                              gui.PASSWORD_TOO_WEAK)
-            self.assert_correct_entry_warning(self.ui.password2_entry,
-                                              gui.PASSWORD_TOO_WEAK)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_tc_not_accepted(self):
-        """A warning message is shown if TC are not accepted."""
-        # don't agree to TC
-        self.ui.yes_to_tc_checkbutton.set_active(False)
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_label_warning(self.ui.tc_warning_label,
-            gui.TC_NOT_ACCEPTED % {'app_name': APP_NAME})
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_warning_is_shown_if_not_captcha_solution(self):
-        """A warning message is shown if TC are not accepted."""
-        # captcha solution will be empty
-        self.ui.captcha_solution_entry.set_text('')
-
-        self.ui.join_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.captcha_solution_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
-
-    def test_no_warning_messages_if_valid_data(self):
-        """No warning messages are shown if the data is valid."""
-        # this will certainly NOT generate warnings
-        self.click_join_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
-        """No warnings if the data is valid (with prior invalid data)."""
-        # this will certainly generate warnings
-        self.ui.join_ok_button.clicked()
-
-        # this will certainly NOT generate warnings
-        self.click_join_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-
-class LoginTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user login pages."""
-
-    method = 'login'
-    method_args = (APP_NAME, EMAIL, PASSWORD)
-
-    def setUp(self):
-        """Init."""
-        super(LoginTestCase, self).setUp()
-        self.ui.login_button.clicked()
-
-    def test_login_button_clicked_morphs_to_login_page(self):
-        """Clicking sig_in_button morphs window into login page."""
-        self.assert_pages_visibility(login=True)
-
-    def test_initial_text_for_header_label(self):
-        """The header must have the correct text when logging in."""
-        msg = 'Text for the header must be %r (got %r instead).'
-        expected = gui.LOGIN_HEADER_LABEL % {'app_name': APP_NAME}
-        actual = self.ui.header_label.get_text().decode('utf8')
-        self.assertEqual(expected, actual, msg % (expected, actual))
-
-    def test_initial_text_for_help_label(self):
-        """The help must have the correct text at startup."""
-        msg = 'Text for the help must be %r (got %r instead).'
-        expected = gui.CONNECT_HELP_LABEL % {'app_name': APP_NAME}
-        actual = self.ui.help_label.get_text().decode('utf8')
-        self.assertEqual(expected, actual, msg % (expected, actual))
-
-    def test_entries_are_packed_to_ui_for_login(self):
-        """Every entry is properly packed in the ui for the login page."""
-        entries = ('login_email', 'login_password')
-        self.assert_entries_are_packed_to_ui('login_details_vbox', entries)
-
-    def test_entries_are_packed_to_ui_for_set_new_password(self):
-        """Every entry is packed in the ui for the reset password page."""
-        entries = ('reset_code', 'reset_password1', 'reset_password2')
-        self.assert_entries_are_packed_to_ui('set_new_password_details_vbox',
-                                             entries)
-
-    def test_entries_are_packed_to_ui_for_request_password_token(self):
-        """Every entry is packed in the ui for the reset email page."""
-        container_name = 'request_password_token_details_vbox'
-        entries = ('reset_email',)
-        self.assert_entries_are_packed_to_ui(container_name, entries)
-
-    def test_on_login_back_button_clicked(self):
-        """Clicking login_back_button show registration page."""
-        self.ui.login_back_button.clicked()
-        self.assert_pages_visibility(enter_details=True)
-
-    def test_on_login_connect_button_clicked(self):
-        """Clicking login_ok_button calls backend.login."""
-        self.click_connect_with_valid_data()
-        self.assert_backend_called(self.method, *self.method_args)
-
-    def test_on_login_connect_button_clicked_morphs_to_processing_page(self):
-        """Clicking login_ok_button morphs to the processing page."""
-        self.click_connect_with_valid_data()
-        self.assert_pages_visibility(processing=True)
-
-    def test_on_logged_in_morphs_to_finish_page(self):
-        """When user logged in the finish page is shown."""
-        self.click_connect_with_valid_data()
-        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(finish=True)
-
-    def test_on_login_error_morphs_to_login_page(self):
-        """On user login error, the previous page is shown."""
-        self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
-        self.assert_pages_visibility(login=True)
-
-    def test_on_user_not_validated_morphs_to_verify_page(self):
-        """On user not validated, the verify page is shown."""
-        self.click_connect_with_valid_data()
-        self.ui.on_user_not_validated(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(verify_email=True)
-
-    def test_on_login_error_a_warning_is_shown(self):
-        """On user login error, a warning is shown with proper wording."""
-        self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          UNKNOWN_ERROR)
-
-    def test_specific_errors_from_backend_are_shown(self):
-        """Specific errors from backend are used."""
-        error = {'errtype': 'AuthenticationError',
-                 'message': 'We\'re so doomed.',
-                 '__all__': 'We all are gonna die.'}
-
-        self.ui.on_login_error(app_name=APP_NAME, error=error)
-
-        expected = '\n'.join((error['__all__'], error['message']))
-        self.assert_correct_label_warning(self.ui.warning_label, expected)
-
-    def test_back_to_registration_hides_warning(self):
-        """After user login error, warning is hidden when clicking 'Back'."""
-        self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
-        self.ui.login_back_button.clicked()
-        self.assert_warnings_visibility()
-
-    def test_login_ok_button_does_nothing_if_clicked_but_disabled(self):
-        """The join form can only be submitted if the button is sensitive."""
-        self.patch(self.ui.login_email_entry, 'get_text', self._set_called)
-
-        self.ui.login_ok_button.set_sensitive(False)
-        self.ui.login_ok_button.clicked()
-        self.assertFalse(self._called)
-
-        self.ui.login_ok_button.set_sensitive(True)
-        self.ui.login_ok_button.clicked()
-        self.assertTrue(self._called)
-
-    def test_user_and_pass_are_cached(self):
-        """Username and password are temporarily cached for further use."""
-        self.click_connect_with_valid_data()
-        self.assertEqual(self.ui.user_email, EMAIL)
-        self.assertEqual(self.ui.user_password, PASSWORD)
-
-    def test_after_login_success_finish_success(self):
-        """After logged_in is called, finish_success is called."""
-        self.patch(self.ui, 'finish_success', self._set_called)
-
-        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self._called, ((), {}))
-
-
-class LoginWithPingTestCase(LoginTestCase):
-    """Test suite for the login when the ping_url is set."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
-                  ping_url=PING_URL)
-    method = 'login_and_ping'
-    method_args = (APP_NAME, EMAIL, PASSWORD, PING_URL)
-
-
-class LoginValidationTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the user login validation."""
-
-    def setUp(self):
-        """Init."""
-        super(LoginValidationTestCase, self).setUp()
-        self.ui.login_button.clicked()
-
-    def test_warning_is_shown_if_empty_email(self):
-        """A warning message is shown if email is empty."""
-        self.ui.login_email_entry.set_text('')
-
-        self.ui.login_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.login_email_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('login', self.ui.backend._called)
-
-    def test_warning_is_shown_if_invalid_email(self):
-        """A warning message is shown if email is invalid."""
-        self.ui.login_email_entry.set_text('q')
-
-        self.ui.login_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.login_email_entry,
-                                          gui.EMAIL_INVALID)
-        self.assertNotIn('login', self.ui.backend._called)
-
-    def test_warning_is_shown_if_empty_password(self):
-        """A warning message is shown if password is empty."""
-        self.ui.login_password_entry.set_text('')
-
-        self.ui.login_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.login_password_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('login', self.ui.backend._called)
-
-    def test_no_warning_messages_if_valid_data(self):
-        """No warning messages are shown if the data is valid."""
-        # this will certainly NOT generate warnings
-        self.click_connect_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
-        """No warnings if the data is valid (with prior invalid data)."""
-        # this will certainly generate warnings
-        self.ui.login_ok_button.clicked()
-
-        # this will certainly NOT generate warnings
-        self.click_connect_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-
-class ResetPasswordTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the reset password functionality."""
-
-    def setUp(self):
-        """Init."""
-        super(ResetPasswordTestCase, self).setUp()
-        self.ui.login_button.clicked()
-        self.ui.forgotten_password_button.clicked()
-
-    def test_forgotten_password_button_has_the_proper_wording(self):
-        """The forgotten_password_button has the proper wording."""
-        actual = self.ui.forgotten_password_button.get_label()
-        self.assertEqual(actual.decode('utf8'), gui.FORGOTTEN_PASSWORD_BUTTON)
-
-    def test_on_forgotten_password_button_clicked_help_text(self):
-        """Clicking forgotten_password_button the help is properly changed."""
-        wanted = gui.REQUEST_PASSWORD_TOKEN_LABEL % {'app_name': APP_NAME}
-        self.assertEqual(self.ui.help_label.get_text().decode('utf8'), wanted)
-
-    def test_on_forgotten_password_button_clicked_header_label(self):
-        """Clicking forgotten_password_button the title is properly changed."""
-        self.assertEqual(self.ui.header_label.get_text().decode('utf8'),
-                         gui.RESET_PASSWORD)
-
-    def test_on_forgotten_password_button_clicked_ok_button(self):
-        """Clicking forgotten_password_button the ok button reads 'Next'."""
-        actual = self.ui.request_password_token_ok_button.get_label()
-        self.assertEqual(actual.decode('utf8'), gui.NEXT)
-
-    def test_on_forgotten_password_button_clicked_morphs_window(self):
-        """Clicking forgotten_password_button the proper page is shown."""
-        self.assert_pages_visibility(request_password_token=True)
-
-    def test_on_request_password_token_back_button_clicked(self):
-        """Clicking request_password_token_back_button show login screen."""
-        self.ui.request_password_token_back_button.clicked()
-        self.assert_pages_visibility(login=True)
-
-    def test_request_password_token_ok_button_disabled_until_email_added(self):
-        """The button is disabled until email added."""
-        is_sensitive = self.ui.request_password_token_ok_button.get_sensitive
-        self.assertFalse(is_sensitive())
-
-        self.ui.reset_email_entry.set_text('a')
-        self.assertTrue(is_sensitive())
-
-        self.ui.reset_email_entry.set_text('')
-        self.assertFalse(is_sensitive())
-
-        self.ui.reset_email_entry.set_text('         ')
-        self.assertFalse(is_sensitive())
-
-    def test_on_request_password_token_ok_button_clicked_morphs_window(self):
-        """Clicking request_password_token_ok_button morphs processing page."""
-        self.click_request_password_token_with_valid_data()
-        self.assert_pages_visibility(processing=True)
-
-    def test_on_request_password_token_ok_button_clicked_calls_backend(self):
-        """Clicking request_password_token_ok_button the backend is called."""
-        self.click_request_password_token_with_valid_data()
-        self.assert_backend_called('request_password_reset_token',
-            APP_NAME, EMAIL)
-
-    def test_on_password_reset_token_sent_morphs_window(self):
-        """When the reset token was sent, the reset password page is shown."""
-        self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
-        self.assert_pages_visibility(set_new_password=True)
-
-    def test_on_password_reset_token_sent_help_text(self):
-        """Clicking request_password_token_ok_button changes the help text."""
-        self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self.ui.help_label.get_text().decode('utf8'),
-                         gui.SET_NEW_PASSWORD_LABEL % {'email': EMAIL})
-
-    def test_on_password_reset_token_sent_ok_button(self):
-        """After request_password_token_ok_button the ok button is updated."""
-        self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
-
-        actual = self.ui.set_new_password_ok_button.get_label()
-        self.assertEqual(actual.decode('utf8'), gui.RESET_PASSWORD)
-
-    def test_on_password_reset_error_shows_login_page(self):
-        """When reset token wasn't successfully sent, login page is shown."""
-        self.ui.on_password_reset_error(app_name=APP_NAME, error=self.error)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          UNKNOWN_ERROR)
-        self.assert_pages_visibility(login=True)
-
-    def test_specific_errors_from_backend_are_shown(self):
-        """Specific errors from backend are used."""
-        error = {'errtype': 'ResetPasswordTokenError',
-                 'message': 'We\'re so doomed.',
-                 '__all__': 'We all are gonna die.'}
-
-        self.ui.on_password_reset_error(app_name=APP_NAME, error=error)
-
-        expected = '\n'.join((error['__all__'], error['message']))
-        self.assert_correct_label_warning(self.ui.warning_label, expected)
-
-    def test_ok_button_does_nothing_if_clicked_but_disabled(self):
-        """The password token can be requested if the button is sensitive."""
-        self.patch(self.ui.reset_email_entry, 'get_text', self._set_called)
-
-        self.ui.request_password_token_ok_button.set_sensitive(False)
-        self.ui.request_password_token_ok_button.clicked()
-        self.assertFalse(self._called)
-
-        self.ui.request_password_token_ok_button.set_sensitive(True)
-        self.ui.request_password_token_ok_button.clicked()
-        self.assertTrue(self._called)
-
-
-class ResetPasswordValidationTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the password reset validations."""
-
-    def test_warning_is_shown_if_empty_email(self):
-        """A warning message is shown if emails are empty."""
-        self.ui.reset_email_entry.set_text(' ')
-
-        self.ui.request_password_token_ok_button.set_sensitive(True)
-        self.ui.request_password_token_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.reset_email_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('request_password_reset_token',
-                         self.ui.backend._called)
-
-    def test_warning_is_shown_if_invalid_email(self):
-        """A warning message is shown if email is invalid."""
-        self.ui.reset_email_entry.set_text('q')
-
-        self.ui.request_password_token_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.reset_email_entry,
-                                          gui.EMAIL_INVALID)
-        self.assertNotIn('request_password_reset_token',
-                         self.ui.backend._called)
-
-    def test_no_warning_messages_if_valid_data(self):
-        """No warning messages are shown if the data is valid."""
-        # this will certainly NOT generate warnings
-        self.click_request_password_token_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
-        """No warnings if the data is valid (with prior invalid data)."""
-        # this will certainly generate warnings
-        self.ui.request_password_token_ok_button.clicked()
-
-        # this will certainly NOT generate warnings
-        self.click_request_password_token_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-
-class SetNewPasswordTestCase(UbuntuSSOClientTestCase):
-    """Test suite for setting a new password functionality."""
-
-    def setUp(self):
-        """Init."""
-        super(SetNewPasswordTestCase, self).setUp()
-        self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
-
-    def test_on_set_new_password_ok_button_disabled(self):
-        """The set_new_password_ok_button is disabled until values added."""
-        self.click_request_password_token_with_valid_data()
-        self.assertFalse(self.ui.set_new_password_ok_button.get_sensitive())
-
-        msg = 'set_new_password_ok_button must be sensitive (%s) for %r.'
-        entries = (self.ui.reset_code_entry,
-                   self.ui.reset_password1_entry,
-                   self.ui.reset_password2_entry)
-        for values in itertools.product(('', ' ', 'a'), repeat=3):
-            expected = True
-            for entry, val in zip(entries, values):
-                entry.set_text(val)
-                expected &= bool(val and not val.isspace())
-
-            actual = self.ui.set_new_password_ok_button.get_sensitive()
-            self.assertEqual(expected, actual, msg % (expected, values))
-
-    def test_on_set_new_password_ok_button_clicked_morphs_window(self):
-        """Clicking set_new_password_ok_button the processing page is shown."""
-        self.click_set_new_password_with_valid_data()
-        self.assert_pages_visibility(processing=True)
-
-    def test_on_set_new_password_ok_button_clicked_calls_backend(self):
-        """Clicking set_new_password_ok_button the backend is called."""
-        self.click_set_new_password_with_valid_data()
-        self.assert_backend_called('set_new_password',
-            APP_NAME, EMAIL, RESET_PASSWORD_TOKEN, PASSWORD)
-
-    def test_on_password_changed_shows_login_page(self):
-        """When password was successfully changed the login page is shown."""
-        self.ui.on_password_changed(app_name=APP_NAME, email=EMAIL)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          gui.PASSWORD_CHANGED)
-        self.assert_pages_visibility(login=True)
-
-    def test_on_password_change_error_shows_login_page(self):
-        """When password wasn't changed the reset password page is shown."""
-        self.ui.on_password_change_error(app_name=APP_NAME, error=self.error)
-        self.assert_correct_label_warning(self.ui.warning_label,
-                                          UNKNOWN_ERROR)
-        self.assert_pages_visibility(request_password_token=True)
-
-    def test_specific_errors_from_backend_are_shown(self):
-        """Specific errors from backend are used."""
-        error = {'errtype': 'NewPasswordError',
-                 'message': 'We\'re so doomed.',
-                 '__all__': 'We all are gonna die.'}
-
-        self.ui.on_password_change_error(app_name=APP_NAME, error=error)
-
-        expected = '\n'.join((error['__all__'], error['message']))
-        self.assert_correct_label_warning(self.ui.warning_label, expected)
-
-    def test_ok_button_does_nothing_if_clicked_but_disabled(self):
-        """The new password can only be set if the button is sensitive."""
-        self.patch(self.ui.reset_code_entry, 'get_text', self._set_called)
-
-        self.ui.set_new_password_ok_button.set_sensitive(False)
-        self.ui.set_new_password_ok_button.clicked()
-        self.assertFalse(self._called)
-
-        self.ui.set_new_password_ok_button.set_sensitive(True)
-        self.ui.set_new_password_ok_button.clicked()
-        self.assertTrue(self._called)
-
-
-class SetNewPasswordValidationTestCase(UbuntuSSOClientTestCase):
-    """Test suite for validations for setting a new password."""
-
-    def test_warning_is_shown_if_reset_code_empty(self):
-        """A warning message is shown if reset_code is empty."""
-        self.ui.reset_code_entry.set_text('')
-
-        self.ui.set_new_password_ok_button.set_sensitive(True)
-        self.ui.set_new_password_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.reset_code_entry,
-                                          gui.FIELD_REQUIRED)
-        self.assertNotIn('set_new_password', self.ui.backend._called)
-
-    def test_password_help_is_always_shown(self):
-        """Password help text is correctly displayed."""
-        visible = self.ui.reset_password_help_label.get_property('visible')
-        self.assertTrue(visible, 'password help text is visible.')
-        actual = self.ui.reset_password_help_label.get_text()
-        self.assertEqual(actual.decode('utf8'), gui.PASSWORD_HELP)
-        self.assertNotIn('set_new_password', self.ui.backend._called)
-
-    def test_warning_is_shown_if_password_mismatch(self):
-        """A warning message is shown if password doesn't match."""
-        self.ui.reset_password1_entry.set_text(PASSWORD)
-        self.ui.reset_password2_entry.set_text(PASSWORD * 2)
-
-        self.ui.set_new_password_ok_button.set_sensitive(True)
-        self.ui.set_new_password_ok_button.clicked()
-
-        self.assert_correct_entry_warning(self.ui.reset_password1_entry,
-                                          gui.PASSWORD_MISMATCH)
-        self.assert_correct_entry_warning(self.ui.reset_password2_entry,
-                                          gui.PASSWORD_MISMATCH)
-        self.assertNotIn('set_new_password', self.ui.backend._called)
-
-    def test_warning_is_shown_if_password_too_weak(self):
-        """A warning message is shown if password is too weak."""
-        # password will match but will be too weak
-        for pwd in ('', 'h3lloWo', PASSWORD.lower(), 'helloWorld'):
-            self.ui.reset_password1_entry.set_text(pwd)
-            self.ui.reset_password2_entry.set_text(pwd)
-
-            self.ui.set_new_password_ok_button.set_sensitive(True)
-            self.ui.set_new_password_ok_button.clicked()
-
-            self.assert_correct_entry_warning(self.ui.reset_password1_entry,
-                                              gui.PASSWORD_TOO_WEAK)
-            self.assert_correct_entry_warning(self.ui.reset_password2_entry,
-                                              gui.PASSWORD_TOO_WEAK)
-        self.assertNotIn('set_new_password', self.ui.backend._called)
-
-    def test_no_warning_messages_if_valid_data(self):
-        """No warning messages are shown if the data is valid."""
-        # this will certainly NOT generate warnings
-        self.click_set_new_password_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-    def test_no_warning_messages_if_valid_data_after_invalid_data(self):
-        """No warnings if the data is valid (with prior invalid data)."""
-        # this will certainly generate warnings
-        self.ui.set_new_password_ok_button.clicked()
-
-        # this will certainly NOT generate warnings
-        self.click_set_new_password_with_valid_data()
-
-        self.assert_warnings_visibility()
-
-
-class SignalsTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the backend signals."""
-
-    def test_all_the_signals_are_listed(self):
-        """All the backend signals are listed to be bound."""
-        for sig in ('CaptchaGenerated', 'CaptchaGenerationError',
-                    'UserRegistered', 'UserRegistrationError',
-                    'LoggedIn', 'LoginError', 'UserNotValidated',
-                    'EmailValidated', 'EmailValidationError',
-                    'PasswordResetTokenSent', 'PasswordResetError',
-                    'PasswordChanged', 'PasswordChangeError'):
-            self.assertIn(sig, self.ui._signals)
-
-    def test_signal_receivers_are_connected(self):
-        """Callbacks are connected to signals of interest."""
-        msg1 = 'callback %r for signal %r must be added to the backend.'
-        msg2 = 'callback %r for signal %r must be added to the ui log.'
-        for signal, method in self.ui._signals.items():
-            actual = self.ui.backend.callbacks.get(signal)
-            self.assertEqual([method], actual, msg1 % (method, signal))
-            actual = self.ui._signals_receivers.get(signal)
-            self.assertEqual(method, actual, msg2 % (method, signal))
-
-    def test_callbacks_only_log_when_app_name_doesnt_match(self):
-        """Callbacks do nothing but logging when app_name doesn't match."""
-        mismatch_app_name = self.ui.app_name * 2
-        for method in self.ui._signals.values():
-            msgs = ('ignoring', method.__name__, repr(mismatch_app_name))
-            method(mismatch_app_name, 'dummy')
-            self.assertTrue(self.memento.check(logging.INFO, *msgs))
-            self.memento.reset()
-
-    def test_on_captcha_generated_is_not_called(self):
-        """on_captcha_generated is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_captcha_generated', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['CaptchaGenerated'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_captcha_generation_error_is_not_called(self):
-        """on_captcha_generation_error is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_captcha_generation_error', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['CaptchaGenerationError'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_user_registered_is_not_called(self):
-        """on_user_registered is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_user_registered', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['UserRegistered'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_user_registration_error_is_not_called(self):
-        """on_user_registration_error is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_user_registration_error', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['UserRegistrationError'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_email_validated_is_not_called(self):
-        """on_email_validated is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_email_validated', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['EmailValidated'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_email_validation_error_is_not_called(self):
-        """on_email_validation_error is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_email_validation_error', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['EmailValidationError'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_logged_in_is_not_called(self):
-        """on_logged_in is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_logged_in', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['LoggedIn'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_login_error_is_not_called(self):
-        """on_login_error is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_login_error', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['LoginError'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_user_not_validated_is_not_called(self):
-        """on_user_not_validated is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_user_not_validated', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['UserNotValidated'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_password_reset_token_sent_is_not_called(self):
-        """on_password_reset_token_sent is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_password_reset_token_sent', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['PasswordResetTokenSent'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_password_reset_error_is_not_called(self):
-        """on_password_reset_error is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_password_reset_error', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['PasswordResetError'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_password_changed_is_not_called(self):
-        """on_password_changed is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_password_changed', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['PasswordChanged'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-    def test_on_password_change_error_is_not_called(self):
-        """on_password_change_error is not called if incorrect app_name."""
-        self.patch(self.ui, 'on_password_change_error', self._set_called)
-        mismatch_app_name = self.ui.app_name * 2
-        self.ui._signals['PasswordChangeError'](mismatch_app_name, 'dummy')
-        self.assertFalse(self._called)
-
-
-class LoginOnlyTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the login only GUI."""
-
-    kwargs = dict(app_name=APP_NAME, tc_url=None, help_text=HELP_TEXT,
-                  login_only=True)
-
-    def test_login_is_first_page(self):
-        """When starting, the login page is the first one."""
-        self.assert_pages_visibility(login=True)
-
-    def test_no_back_button(self):
-        """There is no back button in the login screen."""
-        self.assertFalse(self.ui.login_back_button.get_property('visible'))
-
-    def test_login_ok_button_has_the_focus(self):
-        """The login_ok_button has the focus."""
-        self.assertTrue(self.ui.login_ok_button.is_focus())
-
-    def test_help_text_is_used(self):
-        """The passed help_text is used."""
-        self.assertEqual(self.ui.help_label.get_text().decode('utf8'),
-                         HELP_TEXT)
-
-
-class ReturnCodeTestCase(UbuntuSSOClientTestCase):
-    """Test the return codes."""
-
-    def setUp(self):
-        super(ReturnCodeTestCase, self).setUp()
-        self.patch(gui.sys, 'exit', self._set_called)
-
-    def test_closing_main_window(self):
-        """When closing the main window, USER_CANCELLATION is called."""
-        self.ui.window.emit('delete-event', Gdk.Event())
-        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
-
-    def test_every_cancel_calls_proper_callback(self):
-        """When any cancel button is clicked, USER_CANCELLATION is called."""
-        self.patch(self.ui.backend, 'disconnect_from_signal', lambda *a: None)
-        msg = 'USER_CANCELLATION should be returned when %r is clicked.'
-        buttons = filter(lambda name: 'cancel_button' in name, self.ui.widgets)
-        for name in buttons:
-            widget = getattr(self.ui, name)
-            widget.clicked()
-            self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}),
-                             msg % name)
-            self._called = False
-
-    def test_on_user_registration_error_proper_callback_is_called(self):
-        """On UserRegistrationError, USER_CANCELLATION is called."""
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
-
-    def test_on_email_validated_proper_callback_is_called(self):
-        """On EmailValidated, REGISTRATION_SUCCESS is called."""
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
-
-    def test_on_email_validation_error_proper_callback_is_called(self):
-        """On EmailValidationError, USER_CANCELLATION is called."""
-        self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
-
-    def test_on_logged_in_proper_callback_is_called(self):
-        """On LoggedIn, LOGIN_SUCCESS is called."""
-        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
-
-    def test_on_login_error_proper_callback_is_called(self):
-        """On LoginError, USER_CANCELLATION is called."""
-        self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
-
-    def test_registration_success_even_if_prior_registration_error(self):
-        """Only one callback is called with the final outcome.
-
-        When the user successfully registers, REGISTRATION_SUCCESS is
-        called even if there were errors before.
-
-        """
-        self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
-        self.click_join_with_valid_data()
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
-
-    def test_login_success_even_if_prior_login_error(self):
-        """Only one callback is called with the final outcome.
-
-        When the user successfully logs in, LOGIN_SUCCESS is called even if
-        there were errors before.
-
-        """
-        self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
-        self.click_connect_with_valid_data()
-        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-        self.ui.on_close_clicked()
-
-        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
-
-    def test_user_cancelation_even_if_prior_registration_error(self):
-        """Only one callback is called with the final outcome.
-
-        When the user closes the window, USER_CANCELLATION is called even if
-        there were registration errors before.
-
-        """
-        self.click_join_with_valid_data()
-        self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
-        self.ui.join_cancel_button.clicked()
-
-        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
-
-    def test_user_cancelation_even_if_prior_login_error(self):
-        """Only one callback is called with the final outcome.
-
-        When the user closes the window, USER_CANCELLATION is called even if
-        there were login errors before.
-
-        """
-        self.click_connect_with_valid_data()
-        self.ui.on_login_error(app_name=APP_NAME, error=self.error)
-        self.ui.login_cancel_button.clicked()
-
-        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
-
-
-class DefaultButtonsTestCase(UbuntuSSOClientTestCase):
-    """Each UI page has a default button when visible."""
-
-    def setUp(self):
-        """Init."""
-        super(DefaultButtonsTestCase, self).setUp()
-        self.mapping = (
-            ('enter_details_vbox', 'join_ok_button'),
-            ('tc_browser_vbox', 'tc_back_button'),
-            ('verify_email_vbox', 'verify_token_button'),
-            ('login_vbox', 'login_ok_button'),
-            ('request_password_token_vbox',
-             'request_password_token_ok_button'),
-            ('set_new_password_vbox', 'set_new_password_ok_button'),
-            ('success_vbox', 'finish_close_button'),
-            ('error_vbox', 'finish_close_button'),
-            ('processing_vbox', None))
-
-    def test_pages_have_default_widget_set(self):
-        """Each page has a proper button as default widget."""
-        msg = 'Page %r must have %r as default_widget (got %r instead).'
-        for pname, bname in self.mapping:
-            page = getattr(self.ui, pname)
-            button = bname and getattr(self.ui, bname)
-            self.assertTrue(page.default_widget is button,
-                            msg % (pname, bname, page.default_widget))
-
-    def test_default_widget_can_default(self):
-        """Each default button can default."""
-        msg = 'Button %r must have can-default enabled.'
-        for _, bname in self.mapping:
-            if bname is not None:
-                button = getattr(self.ui, bname)
-                self.assertTrue(button.get_property('can-default'),
-                                msg % bname)
-
-    def test_set_current_page_grabs_focus_for_default_button(self):
-        """Setting the current page marks the default widget as default."""
-        msg = '%r "has_default" must be True when %r if the current page.'
-        for pname, bname in self.mapping:
-            if bname is not None:
-                page = getattr(self.ui, pname)
-                self.patch(page.default_widget, 'grab_default',
-                           self._set_called)
-                self.ui._set_current_page(page)
-                self.assertEqual(self._called, ((), {}), msg % (bname, pname))
-                self._called = False
-
-
-class RunTestCase(BasicTestCase):
-
-    def test_run(self):
-        """Calling run.gui() a UI instance is created."""
-        called = []
-        self.patch(gui, 'UbuntuSSOClientGUI',
-                   lambda **kw: called.append(('GUI', kw)))
-        self.patch(gui.Gtk, 'main',
-                   lambda: called.append('main'))
-
-        kwargs = dict(foo='foo', bar='bar', baz='yadda', yadda=0)
-        gui.run(**kwargs)
-
-        kwargs['close_callback'] = gui.Gtk.main_quit
-        self.assertEqual(called, [('GUI', kwargs), 'main'])

=== modified file 'softwarecenter/ui/gtk3/panes/availablepane.py'
--- softwarecenter/ui/gtk3/panes/availablepane.py	2012-12-14 16:44:25 +0000
+++ softwarecenter/ui/gtk3/panes/availablepane.py	2013-09-17 17:52:06 +0000
@@ -37,6 +37,7 @@
     NonAppVisibility,
     DEFAULT_SEARCH_LIMIT,
     TransactionTypes,
+    PURCHASE_TRANSACTION_ID,
 )
 from softwarecenter.utils import (
     convert_desktop_file_to_installed_location,
@@ -58,8 +59,8 @@
 
 from softwarecenter.backend.channel import SoftwareChannel
 from softwarecenter.backend.unitylauncher import (UnityLauncher,
-                                                  UnityLauncherInfo,
-                                                  TransactionDetails)
+                                                  UnityLauncherInfo)
+from softwarecenter.backend.zeitgeist_logger import ZeitgeistLogger
 
 LOG = logging.getLogger(__name__)
 
@@ -91,6 +92,58 @@
                                                None,
                                                ())}
 
+    class TransactionDetails(object):
+        """ Simple class to keep track of aptdaemon transaction details """
+        def __init__(self, db, pkgname, appname, trans_id, trans_type):
+            self.db = db
+            self.app = Application(pkgname=pkgname, appname=appname)
+            self.trans_id = trans_id
+            self.trans_type = trans_type
+            self.__app_details = None
+            self.__real_desktop = None
+
+            if trans_type != TransactionTypes.INSTALL:
+                self.guess_final_desktop_file()
+
+        @property
+        def app_details(self):
+            if not self.__app_details:
+                self.__app_details = self.app.get_details(self.db)
+            return self.__app_details
+
+        @property
+        def desktop_file(self):
+            return self.app_details.desktop_file
+
+        @property
+        def final_desktop_file(self):
+            return self.guess_final_desktop_file()
+
+        def guess_final_desktop_file(self):
+            if self.__real_desktop:
+                return self.__real_desktop
+
+            # convert the app-install desktop file location to the actual installed
+            # desktop file location (or in the case of a purchased item from the
+            # agent, generate the correct installed desktop file location)
+            desktop_file = (
+                convert_desktop_file_to_installed_location(self.desktop_file,
+                                                           self.app.pkgname))
+            # we only add items to the launcher that have a desktop file
+            if not desktop_file:
+                return
+            # do not add apps that have no Exec entry in their desktop file
+            # (e.g. wine, see LP: #848437 or ubuntu-restricted-extras,
+            # see LP: #913756), also, don't add the item if NoDisplay is
+            # specified (see LP: #1006483)
+            if (os.path.exists(desktop_file) and
+                    (not get_exec_line_from_desktop(desktop_file) or
+                    is_no_display_desktop_file(desktop_file))):
+                return
+
+            self.__real_desktop = desktop_file
+            return self.__real_desktop
+
     def __init__(self,
                  cache,
                  db,
@@ -118,9 +171,9 @@
 
         # integrate with the Unity launcher
         self.unity_launcher = UnityLauncher()
-        # keep track of applications that are queued to be added
-        # to the Unity launcher
-        self.unity_launcher_transaction_queue = {}
+
+        # keep track of transactions
+        self.transactions_queue = {}
 
     def init_view(self):
         if self.view_initialized:
@@ -212,17 +265,18 @@
             Gtk.Label(label=NavButtons.PURCHASE))
 
         # install backend
+        # FIXME: move this out of the available pane really
         self.backend.connect("transaction-started",
             self.on_transaction_started)
         self.backend.connect("transactions-changed",
             self.on_transactions_changed)
         self.backend.connect("transaction-finished",
             self.on_transaction_complete)
-        self.backend.connect("transaction-cancelled",
-            self.on_transaction_cancelled)
         # a transaction error is treated the same as a cancellation
         self.backend.connect("transaction-stopped",
             self.on_transaction_cancelled)
+        self.backend.connect("transaction-cancelled",
+            self.on_transaction_cancelled)
 
         # now we are initialized
         self.searchentry.set_sensitive(True)
@@ -375,8 +429,23 @@
 
     def on_transaction_started(self, backend, pkgname, appname, trans_id,
                                trans_type):
-        self._register_unity_launcher_transaction_started(pkgname, appname,
-                                                          trans_id, trans_type)
+        details = self.TransactionDetails(self.db, pkgname, appname, trans_id, trans_type)
+        self.transactions_queue[pkgname] = details
+
+        config = get_config()
+        if (trans_type == TransactionTypes.INSTALL and
+            trans_id != PURCHASE_TRANSACTION_ID and
+                config.add_to_unity_launcher and
+                softwarecenter.utils.is_unity_running()):
+            self._add_application_to_unity_launcher(details)
+
+    def on_transaction_cancelled(self, backend, result):
+        """ handle a transaction that has been cancelled
+        """
+        if result.pkgname:
+            self.unity_launcher.cancel_application_to_launcher(result.pkgname)
+        if result.pkgname in self.transactions_queue:
+            self.transactions_queue.pop(result.pkgname)
 
     def on_transactions_changed(self, backend, pending_transactions):
         """internal helper that keeps the action bar up-to-date by
@@ -385,92 +454,47 @@
         if self._is_custom_list_search(self.state.search_term):
             self._update_action_bar()
 
-    def on_transaction_complete(self, backend, result):
-        """ handle a transaction that has completed successfully
-        """
-        if result.pkgname in self.unity_launcher_transaction_queue:
-            transaction_details = (
-                self.unity_launcher_transaction_queue.pop(result.pkgname))
-            self._add_application_to_unity_launcher(transaction_details)
-
-    def on_transaction_cancelled(self, backend, result):
-        """ handle a transaction that has been cancelled
-        """
-        if result.pkgname in self.unity_launcher_transaction_queue:
-            self.unity_launcher_transaction_queue.pop(result.pkgname)
-
-    def _register_unity_launcher_transaction_started(self, pkgname, appname,
-                                                     trans_id, trans_type):
-        # at the start of the transaction, we gather details for use later
-        # when it is time to add the installed app to the Unity launcher,
-        # (see #972710). we only care about installs for the launcher
-        # mvo: use softwarecenter.utils explicitly here so that we can monkey
-        #      patch it in the test
-        config = get_config()
-        if (trans_type == TransactionTypes.INSTALL and
-                config.add_to_unity_launcher and
-                softwarecenter.utils.is_unity_running()):
-            transaction_details = TransactionDetails(
-                    pkgname, appname, trans_id, trans_type)
-            self.unity_launcher_transaction_queue[pkgname] = (
-                    transaction_details)
-
-    def _add_application_to_unity_launcher(self, transaction_details):
-        app = Application(pkgname=transaction_details.pkgname,
-                          appname=transaction_details.appname)
-        appdetails = app.get_details(self.db)
-        # convert the app-install desktop file location to the actual installed
-        # desktop file location (or in the case of a purchased item from the
-        # agent, generate the correct installed desktop file location)
-        installed_desktop_file_path = (
-            convert_desktop_file_to_installed_location(appdetails.desktop_file,
-                                                       app.pkgname))
-        # we only add items to the launcher that have a desktop file
-        if not installed_desktop_file_path:
-            return
+    def _add_application_to_unity_launcher(self, trans_details):
         # do not add apps that have no Exec entry in their desktop file
         # (e.g. wine, see LP: #848437 or ubuntu-restricted-extras,
         # see LP: #913756), also, don't add the item if NoDisplay is
         # specified (see LP: #1006483)
-        if (os.path.exists(installed_desktop_file_path) and
-                (not get_exec_line_from_desktop(installed_desktop_file_path) or
-                 is_no_display_desktop_file(installed_desktop_file_path))):
+        if (os.path.exists(trans_details.desktop_file) and
+                (not get_exec_line_from_desktop(trans_details.desktop_file) or
+                 is_no_display_desktop_file(trans_details.desktop_file))):
             return
 
         # now gather up the unity launcher info items and send the app to the
         # launcher service
-        launcher_info = self._get_unity_launcher_info(app, appdetails,
-                installed_desktop_file_path,
-                transaction_details.trans_id)
+        launcher_info = self._get_unity_launcher_info(trans_details)
         self.unity_launcher.send_application_to_launcher(
-                transaction_details.pkgname,
-                launcher_info)
-
-    def _get_unity_launcher_info(
-            self, app, appdetails, installed_desktop_file_path, trans_id):
+            trans_details.app.pkgname, launcher_info)
+
+    def on_transaction_complete(self, backend, result):
+        """ handle a transaction that has completed successfully
+        """
+        if result.pkgname in self.transactions_queue:
+            details = self.transactions_queue.pop(result.pkgname)
+
+            if details.trans_type == TransactionTypes.INSTALL:
+                ZeitgeistLogger(self.distro).log_install_event(details.final_desktop_file)
+            elif details.trans_type == TransactionTypes.REMOVE:
+                ZeitgeistLogger(self.distro).log_uninstall_event(details.final_desktop_file)
+
+    def _get_unity_launcher_info(self, trans_details):
         (icon_size, icon_x, icon_y) = (
-                self._get_onscreen_icon_details_for_launcher_service(app))
+                self._get_onscreen_icon_details_for_launcher_service(trans_details.app))
         icon_path = get_file_path_from_iconname(
                                 self.icons,
-                                iconname=appdetails.icon)
-        # Note that the transaction ID is not specified because we are firing
-        # the dbus signal at the very end of the installation now, and the
-        # corresponding fix in Unity is expecting this value to be empty (it
-        # would not be useful to the Unity launcher at this point anyway,
-        # as the corresponding transaction would be complete).
-        # Please see bug LP: #925014 and corresponding Unity branch for
-        # further details.
-        # TODO: If and when we re-implement firing the dbus signal at the
-        # start of the transaction, at that time we will need to replace
-        # the empty string below with the trans_id value.
-        launcher_info = UnityLauncherInfo(app.name,
-                                          appdetails.icon,
+                                iconname=trans_details.app_details.icon)
+        launcher_info = UnityLauncherInfo(trans_details.app.name,
+                                          trans_details.app_details.icon,
                                           icon_path,
                                           icon_x,
                                           icon_y,
                                           icon_size,
-                                          installed_desktop_file_path,
-                                          "")
+                                          trans_details.desktop_file,
+                                          trans_details.trans_id)
         return launcher_info
 
     def _get_onscreen_icon_details_for_launcher_service(self, app):

=== modified file 'softwarecenter/ui/gtk3/widgets/stars.py'
--- softwarecenter/ui/gtk3/widgets/stars.py	2012-11-28 17:23:44 +0000
+++ softwarecenter/ui/gtk3/widgets/stars.py	2013-09-17 17:52:06 +0000
@@ -49,7 +49,7 @@
     REACTIVE = -1
 
 
-class ShapeStar():
+class ShapeStar(object):
     def __init__(self, points, indent=0.61):
         self.coords = self._calc_coords(points, 1 - indent)
 

=== modified file 'softwarecenter/utils.py'
--- softwarecenter/utils.py	2013-07-09 14:31:33 +0000
+++ softwarecenter/utils.py	2013-09-17 17:52:06 +0000
@@ -511,20 +511,32 @@
     # lastly, just try checking directly for the desktop file based on the
     # pkgname itself for the case of for-purchase items, etc.
     if pkgname:
-        installed_desktop_file_path = "/usr/share/applications/%s.desktop" %\
-            pkgname
-        if os.path.exists(installed_desktop_file_path):
-            return installed_desktop_file_path
+        datadirs = GLib.get_system_data_dirs()
+        for dir in datadirs:
+            path = "%s/applications/%s.desktop" % (dir, pkgname)
+            if os.path.exists(path):
+                return path
+
         # files in the extras archive have their desktop filenames prepended
         # by "extras-", so we check for that also (LP: #1012877)
-        extras_desktop_file_path = \
-            "/usr/share/applications/extras-%s.desktop" % pkgname
-        if os.path.exists(extras_desktop_file_path):
-            return extras_desktop_file_path
+        for dir in datadirs:
+            path = "%s/applications/extras-%s.desktop" % (dir, pkgname)
+            if os.path.exists(path):
+                return path
     LOG.warn("Could not determine the installed desktop file path for "
              "app-install desktop file: '%s'" % app_install_data_file_path)
     return ""
 
+def get_desktop_id(desktop_file):
+    """ Gets a desktop-id from a .desktop file path"""
+    datadirs = [(i if i[-1] == '/' else i+'/') + 'applications/' for i in \
+                GLib.get_system_data_dirs() + [GLib.get_user_data_dir()]]
+
+    for dir in datadirs:
+        if desktop_file.startswith(dir):
+            return desktop_file[len(dir):].replace('/', '-')
+
+    return desktop_file
 
 def clear_token_from_ubuntu_sso_sync(appname):
     """ send a dbus signal to the com.ubuntu.sso service to clear

=== modified file 'tests/gtk3/test_navhistory.py'
--- tests/gtk3/test_navhistory.py	2012-08-22 06:49:53 +0000
+++ tests/gtk3/test_navhistory.py	2013-09-17 17:52:06 +0000
@@ -12,7 +12,7 @@
 from softwarecenter.ui.gtk3.session.displaystate import DisplayState
 
 
-class MockButton():
+class MockButton(object):
 
     def __init__(self):
         self.sensitive = True

=== renamed file 'tests/gtk3/test_unity_launcher_integration.py' => 'tests/gtk3/test_unity_launcher_integration_gui.py'
--- tests/gtk3/test_unity_launcher_integration.py	2012-09-18 08:36:43 +0000
+++ tests/gtk3/test_unity_launcher_integration_gui.py	2013-09-17 17:52:06 +0000
@@ -1,11 +1,9 @@
-import os
 import unittest
 
 from gi.repository import Gtk
 from mock import Mock, patch
 
 from tests.utils import (
-    DATA_DIR,
     do_events,
     do_events_with_sleep,
     setup_test_env,
@@ -19,14 +17,13 @@
 
 from softwarecenter.enums import TransactionTypes
 from softwarecenter.ui.gtk3.panes.availablepane import AvailablePane
-from softwarecenter.utils import convert_desktop_file_to_installed_location
 from tests.gtk3.windows import get_test_window_availablepane
 
 # Tests for Ubuntu Software Center's integration with the Unity launcher,
 # see https://wiki.ubuntu.com/SoftwareCenter#Learning%20how%20to%20launch%20an%20application
 
 
-class TestUnityLauncherIntegration(unittest.TestCase):
+class TestUnityLauncherIntegrationGUI(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
@@ -39,9 +36,9 @@
 
         # patch is_unity_running so that the test works inside a e.g.
         # ADT
-        patcher = patch("softwarecenter.utils.is_unity_running")
-        mock = patcher.start()
-        mock.return_value = True
+        patch("softwarecenter.utils.is_unity_running").start().return_value = True
+        patch("softwarecenter.backend.unitylauncher.UnityLauncher"
+              "._get_launcher_dbus_iface").start().return_value = Mock()
 
     @classmethod
     def tearDownClass(cls):
@@ -117,15 +114,13 @@
         self.expected_launcher_info = UnityLauncherInfo("software-center",
                 "softwarecenter",
                 0, 0, 0, 0, # these values are set in availablepane
-                "/usr/share/applications/ubuntu-software-center.desktop",
-                "")
+                "/usr/share/app-install/desktop/software-center:ubuntu-software-center.desktop",
+                "testid101")
         self._install_from_list_view(test_pkgname)
         self.assertTrue(mock_send_application_to_launcher.called)
         args, kwargs = mock_send_application_to_launcher.call_args
         self._check_send_application_to_launcher_args(*args, **kwargs)
-        # insure that the unity launcher transaction queue is cleared
-        self.assertEqual(
-            self.available_pane.unity_launcher_transaction_queue, {})
+
 
     @patch('softwarecenter.ui.gtk3.panes.availablepane.UnityLauncher'
            '.send_application_to_launcher')
@@ -139,16 +134,13 @@
         self.expected_launcher_info = UnityLauncherInfo("software-center",
                 "softwarecenter",
                 0, 0, 0, 0, # these values are set in availablepane
-                "/usr/share/applications/ubuntu-software-center.desktop",
-                "")
+                "/usr/share/app-install/desktop/software-center:ubuntu-software-center.desktop",
+                "testid101")
         self._navigate_to_appdetails_and_install(test_pkgname)
         self.assertTrue(mock_send_application_to_launcher.called)
         args, kwargs = mock_send_application_to_launcher.call_args
         self._check_send_application_to_launcher_args(*args, **kwargs)
-        # insure that the unity launcher transaction queue is cleared
-        self.assertEqual(
-            self.available_pane.unity_launcher_transaction_queue, {})
-        
+
     @patch('softwarecenter.ui.gtk3.panes.availablepane.UnityLauncher'
            '.send_application_to_launcher')
     def test_unity_launcher_integration_disabled(self,
@@ -158,27 +150,18 @@
         test_pkgname = "software-center"
         self._navigate_to_appdetails_and_install(test_pkgname)
         self.assertFalse(mock_send_application_to_launcher.called)
-        # insure that the unity launcher transaction queue is cleared
-        self.assertEqual(
-            self.available_pane.unity_launcher_transaction_queue, {})
-       
-    @patch('softwarecenter.ui.gtk3.panes.availablepane'
-           '.convert_desktop_file_to_installed_location')
+
     @patch('softwarecenter.ui.gtk3.panes.availablepane.UnityLauncher'
            '.send_application_to_launcher')
-    # NOTE: the order of attributes in the method call appears reversed, this
-    # is because the patch decorators above are executed from innermost to
-    # outermost
     def test_unity_launcher_integration_launcher(self,
-                mock_send_application_to_launcher,
-                mock_convert_desktop_file_to_installed_location):
+                mock_send_application_to_launcher):
         # this is a 3-tuple of (pkgname, desktop-file, expected_result)
         TEST_CASES = (
             # normal app
             ("software-center", "/usr/share/app-install/desktop/"\
                  "software-center:ubuntu-software-center.desktop", True),
             # NoDisplay=True line
-            ("wine", "/usr/share/app-install/desktop/"\
+            ("wine1.4", "/usr/share/app-install/desktop/"\
                  "wine1.4:wine.desktop", False),
             # No Exec= line
             ("bzr", "/usr/share/app-install/desktop/"\
@@ -187,21 +170,23 @@
         # run the test over all test-cases
         self.config.add_to_unity_launcher = True
         for test_pkgname, app_install_desktop_file_path, res in TEST_CASES:
-            # setup the mock
-            mock_convert_desktop_file_to_installed_location.return_value = (
-                app_install_desktop_file_path)
             # this is the tofu of the test
             self._navigate_to_appdetails_and_install(test_pkgname)
             # verify
-            self.assertEqual(mock_send_application_to_launcher.called, res)
+            self.assertEqual(
+                mock_send_application_to_launcher.called, 
+                res,
+                "expected %s for pkg: %s but got: %s" % (
+                    res, test_pkgname, 
+                    mock_send_application_to_launcher.called))
             # and reset again to ensure we don't get the call info from
             # the previous call(s)
             mock_send_application_to_launcher.reset_mock()
 
     @patch('softwarecenter.ui.gtk3.panes.availablepane.UnityLauncher'
-           '.send_application_to_launcher')
+           '.cancel_application_to_launcher')
     def test_unity_launcher_integration_cancelled_install(self,
-                                         mock_send_application_to_launcher):
+                                         mock_cancel_launcher):
         # test the automatic add to launcher enabled functionality when
         # installing an app from the details view, and then cancelling
         # the install (see LP: #1027209)
@@ -213,17 +198,14 @@
         do_events()
         self._simulate_install_events(app,
                                       result_event="transaction-cancelled")
-        # ensure that we do not send the application to the launcher
-        # on a cancelled installation
-        self.assertFalse(mock_send_application_to_launcher.called)
-        # insure that the unity launcher transaction queue is cleared
-        self.assertEqual(
-            self.available_pane.unity_launcher_transaction_queue, {})
-        
+        # ensure that we cancel the send
+        self.assertTrue(
+            mock_cancel_launcher.called)
+
     @patch('softwarecenter.ui.gtk3.panes.availablepane.UnityLauncher'
-           '.send_application_to_launcher')
+           '.cancel_application_to_launcher')
     def test_unity_launcher_integration_installation_failure(self,
-                                         mock_send_application_to_launcher):
+                                         mock_cancel_launcher):
         # test the automatic add to launcher enabled functionality when
         # a failure is detected during the transaction (aptd emits a
         # "transaction-stopped" signal for this case)
@@ -237,52 +219,9 @@
         # error is encountered
         self._simulate_install_events(app,
                                       result_event="transaction-stopped")
-        # ensure that we do not send the application to the launcher
-        # on a failed installation
-        self.assertFalse(mock_send_application_to_launcher.called)
-        # insure that the unity launcher transaction queue is cleared
-        self.assertEqual(
-            self.available_pane.unity_launcher_transaction_queue, {})
-
-
-class DesktopFilepathConversionTestCase(unittest.TestCase):
-        
-    def test_normal(self):
-        # test 'normal' case
-        app_install_desktop_path = os.path.join(DATA_DIR, "app-install",
-            "desktop", "deja-dup:deja-dup.desktop")
-        installed_desktop_path = convert_desktop_file_to_installed_location(
-                app_install_desktop_path, "deja-dup")
-        self.assertEqual(installed_desktop_path, os.path.join(DATA_DIR, 
-                         "applications", "deja-dup.desktop"))
-
-    def test_encoded_subdir(self):
-        # test encoded subdirectory case, e.g. e.g. kde4_soundkonverter.desktop
-        app_install_desktop_path = os.path.join(DATA_DIR, "app-install",
-            "desktop", "soundkonverter:kde4__soundkonverter.desktop")
-        installed_desktop_path = convert_desktop_file_to_installed_location(
-                app_install_desktop_path, "soundkonverter")
-        self.assertEqual(installed_desktop_path, os.path.join(DATA_DIR,
-                         "applications", "kde4", "soundkonverter.desktop"))
-
-    def test_purchase_via_software_center_agent(self):
-        # test the for-purchase case (uses "software-center-agent" as its
-        # appdetails.desktop_file value)
-        # FIXME: this will only work if update-manager is installed
-        app_install_desktop_path = "software-center-agent"
-        installed_desktop_path = convert_desktop_file_to_installed_location(
-                app_install_desktop_path, "update-manager")
-        self.assertEqual(installed_desktop_path,
-                         "/usr/share/applications/update-manager.desktop")
-
-    def test_no_value(self):
-        # test case where we don't have a value for app_install_desktop_path
-        # (e.g. for a local .deb install, see bug LP: #768158)
-        installed_desktop_path = convert_desktop_file_to_installed_location(
-                None, "update-manager")
-        # FIXME: this will only work if update-manager is installed
-        self.assertEqual(installed_desktop_path,
-                         "/usr/share/applications/update-manager.desktop")
+        # ensure that we cancel the send
+        self.assertTrue(
+            mock_cancel_launcher.called)
 
 
 if __name__ == "__main__":

=== added file 'tests/gtk3/test_zeitgeist_logger_gui.py'
--- tests/gtk3/test_zeitgeist_logger_gui.py	1970-01-01 00:00:00 +0000
+++ tests/gtk3/test_zeitgeist_logger_gui.py	2013-09-17 17:52:06 +0000
@@ -0,0 +1,95 @@
+import unittest
+
+from mock import Mock, patch
+from tests.utils import setup_test_env
+
+setup_test_env()
+
+from softwarecenter.db.application import Application
+
+from softwarecenter.enums import TransactionTypes
+from tests.gtk3.windows import get_test_window_availablepane
+
+
+class TestZeitgeistLoggerGUI(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        # we can only have one instance of availablepane, so create it here
+        cls.win = get_test_window_availablepane()
+        cls.available_pane = cls.win.get_data("pane")
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.win.destroy()
+
+    def setUp(self):
+        zl = "softwarecenter.backend.zeitgeist_logger.ZeitgeistLogger";
+        self.log_install_event = patch(zl + ".log_install_event").start()
+        self.log_uninstall_event = patch(zl + ".log_uninstall_event").start()
+
+    def __emit_backend_event(self, pkgname, event):
+        mock_result = Mock()
+        mock_result.pkgname = pkgname
+        self.available_pane.backend.emit(event, mock_result)
+
+    def __start_backend_transaction(self, pkgname, type=TransactionTypes.INSTALL):
+        app = Application("", pkgname)
+        self.available_pane.backend.emit("transaction-started",
+                                         app.pkgname, app.appname,
+                                         "testid101", type)
+
+    def test_zeitgeist_logger_init_on_start(self):
+        test_pkgname = "software-center"
+        self.__start_backend_transaction(test_pkgname)
+        self.assertFalse(self.log_install_event.called)
+        self.assertFalse(self.log_uninstall_event.called)
+        self.assertEqual(len(self.available_pane.transactions_queue), 1)
+        self.assertTrue(test_pkgname in self.available_pane.transactions_queue)
+
+    def test_zeitgeist_logger_cancel_on_cancel(self):
+        test_pkgname = "software-center"
+        self.__start_backend_transaction(test_pkgname)
+        self.assertTrue(test_pkgname in self.available_pane.transactions_queue)
+
+        self.__emit_backend_event(test_pkgname, "transaction-cancelled")
+        self.assertEqual(len(self.available_pane.transactions_queue), 0)
+        self.assertFalse(self.log_install_event.called)
+        self.assertFalse(self.log_uninstall_event.called)
+
+    def test_zeitgeist_logger_cancel_on_stop(self):
+        test_pkgname = "software-center"
+        self.__start_backend_transaction(test_pkgname)
+        self.assertTrue(test_pkgname in self.available_pane.transactions_queue)
+
+        self.__emit_backend_event(test_pkgname, "transaction-stopped")
+        self.assertEqual(len(self.available_pane.transactions_queue), 0)
+        self.assertFalse(self.log_install_event.called)
+        self.assertFalse(self.log_uninstall_event.called)
+
+    def test_zeitgeist_logger_logs_install_on_finished(self):
+        test_pkgname = "software-center"
+        self.__start_backend_transaction(test_pkgname)
+        transaction = self.available_pane.transactions_queue[test_pkgname]
+
+        self.__emit_backend_event(test_pkgname, "transaction-finished")
+        self.assertTrue(self.log_install_event.called)
+        self.assertFalse(self.log_uninstall_event.called)
+        self.assertEqual(len(self.available_pane.transactions_queue), 0)
+        [args] = self.log_install_event.call_args[0]
+        self.assertEqual(args, transaction.real_desktop_file)
+
+    def test_zeitgeist_logger_logs_uninstall_on_finished(self):
+        test_pkgname = "software-center"
+        self.__start_backend_transaction(test_pkgname, TransactionTypes.REMOVE)
+        transaction = self.available_pane.transactions_queue[test_pkgname]
+
+        self.__emit_backend_event(test_pkgname, "transaction-finished")
+        self.assertFalse(self.log_install_event.called)
+        self.assertTrue(self.log_uninstall_event.called)
+        self.assertEqual(len(self.available_pane.transactions_queue), 0)
+        [args] = self.log_uninstall_event.call_args[0]
+        self.assertEqual(args, transaction.real_desktop_file)
+
+if __name__ == "__main__":
+    unittest.main()

=== modified file 'tests/gtk3/windows.py'
--- tests/gtk3/windows.py	2012-11-28 15:54:20 +0000
+++ tests/gtk3/windows.py	2013-09-17 17:52:06 +0000
@@ -8,7 +8,7 @@
 import xapian
 
 from gi.repository import Gdk, Gtk, GLib
-from mock import Mock
+from mock import Mock, patch
 
 import softwarecenter.distro
 import softwarecenter.log
@@ -254,6 +254,7 @@
     cache = get_test_pkg_info()
     icons = get_test_gtk3_icon_cache()
     backend = get_test_install_backend()
+    distro = softwarecenter.distro.get_distro()
 
     manager = appmanager.get_appmanager()
     if manager is None:
@@ -265,7 +266,12 @@
     navhistory_forward_action = Gtk.Action("navhistory_forward_action",
         "Forward", "Forward", None)
 
-    w = availablepane.AvailablePane(cache, db, 'Ubuntu', icons,
+    zl = "softwarecenter.backend.zeitgeist_logger.ZeitgeistLogger";
+    patch(zl + ".log_install_event").start().return_value = False
+    patch(zl + ".log_uninstall_event").start().return_value = False
+    patch("softwarecenter.utils.is_unity_running").start().return_value = False
+
+    w = availablepane.AvailablePane(cache, db, distro, icons,
         navhistory_back_action, navhistory_forward_action)
     w.init_view()
     w.show()

=== added file 'tests/test_unity_launcher.py'
--- tests/test_unity_launcher.py	1970-01-01 00:00:00 +0000
+++ tests/test_unity_launcher.py	2013-09-17 17:52:06 +0000
@@ -0,0 +1,48 @@
+import unittest
+
+from mock import (
+    Mock,
+    patch,
+    )
+
+from softwarecenter.backend.unitylauncher import (
+    UnityLauncherInfo,
+    UnityLauncher,
+    )
+
+from tests.utils import setup_test_env
+setup_test_env()
+
+
+class TestUnityLauncherIntegration(unittest.TestCase):
+    """ tests the sc utils """
+
+    @patch("softwarecenter.backend.unitylauncher.UnityLauncher"
+           "._get_launcher_dbus_iface")
+    def test_apps_from_sc_agent(self, mock_dbus_iface):
+        mock_iface = Mock()
+        mock_dbus_iface.return_value = mock_iface
+        launcher_info = UnityLauncherInfo(
+            name="Meep", icon_name="icon-meep", 
+            icon_file_path="/tmp/icon-meep.png", icon_x=15, icon_y=18,
+            icon_size=48, installed_desktop_file_path="software-center-agent",
+            trans_id="dkfjklsdf")
+        unity_launcher = UnityLauncher()
+        unity_launcher.send_application_to_launcher("meep-pkg", launcher_info)
+        args = mock_iface.AddLauncherItemFromPosition.call_args[0]
+        # basic verify
+        self.assertEqual(args[0], "Meep")
+        # ensure that the a app from software-center-agent got a temp desktop
+        # file
+        self.assertTrue(args[5].startswith("/tmp/"))
+        self.assertEqual(open(args[5]).read(),"""
+[Desktop Entry]
+Name=Meep
+Icon=/tmp/icon-meep.png
+Type=Application""")
+
+
+if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
+    unittest.main()

=== modified file 'tests/test_utils.py'
--- tests/test_utils.py	2012-11-22 11:31:04 +0000
+++ tests/test_utils.py	2013-09-17 17:52:06 +0000
@@ -18,6 +18,7 @@
     get_test_gtk3_icon_cache,
     setup_test_env,
     UTILS_DIR,
+    DATA_DIR,
 )
 setup_test_env()
 
@@ -35,7 +36,9 @@
     get_title_from_html,
     get_uuid,
     get_recommender_uuid,
+    get_desktop_id,
     is_no_display_desktop_file,
+    convert_desktop_file_to_installed_location,
     make_string_from_list,
     release_filename_in_lists_from_deb_line,
     safe_makedirs,
@@ -121,6 +124,16 @@
         d = "/usr/share/app-install/desktop/software-center:ubuntu-software-center.desktop"
         self.assertFalse(is_no_display_desktop_file(d))
 
+    def test_get_desktop_id(self):
+        self.assertEqual(get_desktop_id("/usr/share/applications/ubuntu-software-center.desktop"),
+                                        "ubuntu-software-center.desktop")
+        self.assertEqual(get_desktop_id("/usr/share/applications/kde4-anyapp.desktop"),
+                                        "kde4-anyapp.desktop")
+        self.assertEqual(get_desktop_id("/usr/share/applications/kde4/anyapp.desktop"),
+                                        "kde4-anyapp.desktop")
+        self.assertEqual(get_desktop_id("/my/own/path/application.desktop"),
+                                        "/my/own/path/application.desktop")
+
     def test_split_icon_ext(self):
         for unchanged in ["foo.bar.baz", "foo.bar", "foo",
                           "foo.pngx", "foo.png.xxx"]:
@@ -317,5 +330,44 @@
         save_person_to_config("meep")
         self.assertEqual(get_person_from_config(), "meep")
 
+
+class DesktopFilepathConversionTestCase(unittest.TestCase):
+    def test_normal(self):
+        # test 'normal' case
+        app_install_desktop_path = os.path.join(DATA_DIR, "app-install",
+            "desktop", "deja-dup:deja-dup.desktop")
+        installed_desktop_path = convert_desktop_file_to_installed_location(
+                app_install_desktop_path, "deja-dup")
+        self.assertEqual(installed_desktop_path, os.path.join(DATA_DIR, 
+                         "applications", "deja-dup.desktop"))
+
+    def test_encoded_subdir(self):
+        # test encoded subdirectory case, e.g. e.g. kde4_soundkonverter.desktop
+        app_install_desktop_path = os.path.join(DATA_DIR, "app-install",
+            "desktop", "soundkonverter:kde4__soundkonverter.desktop")
+        installed_desktop_path = convert_desktop_file_to_installed_location(
+                app_install_desktop_path, "soundkonverter")
+        self.assertEqual(installed_desktop_path, os.path.join(DATA_DIR,
+                         "applications", "kde4", "soundkonverter.desktop"))
+
+    def test_purchase_via_software_center_agent(self):
+        # test the for-purchase case (uses "software-center-agent" as its
+        # appdetails.desktop_file value)
+        # FIXME: this will only work if update-manager is installed
+        app_install_desktop_path = "software-center-agent"
+        installed_desktop_path = convert_desktop_file_to_installed_location(
+                app_install_desktop_path, "update-manager")
+        self.assertEqual(installed_desktop_path,
+                         "/usr/share/applications/update-manager.desktop")
+
+    def test_no_value(self):
+        # test case where we don't have a value for app_install_desktop_path
+        # (e.g. for a local .deb install, see bug LP: #768158)
+        installed_desktop_path = convert_desktop_file_to_installed_location(
+                None, "update-manager")
+        # FIXME: this will only work if update-manager is installed
+        self.assertEqual(installed_desktop_path,
+                         "/usr/share/applications/update-manager.desktop")
+
 if __name__ == "__main__":
     unittest.main()

=== added file 'tests/test_zeitgeist_logger.py'
--- tests/test_zeitgeist_logger.py	1970-01-01 00:00:00 +0000
+++ tests/test_zeitgeist_logger.py	2013-09-17 17:52:06 +0000
@@ -0,0 +1,86 @@
+import unittest
+
+from mock import patch
+from softwarecenter.distro import get_distro
+from softwarecenter.backend.zeitgeist_logger import ZeitgeistLogger
+from tests.utils import setup_test_env
+
+setup_test_env()
+
+class TestZeitgeistLogger(unittest.TestCase):
+    """ tests the zeitgeist logger """
+
+    def setUp(self):
+        from softwarecenter.backend import zeitgeist_logger
+        if not zeitgeist_logger.HAVE_MODULE:
+            self.skipTest("Zeitgeist module missing, impossible to test")
+
+        from zeitgeist import datamodel
+        self.distro = get_distro()
+        self.logger = ZeitgeistLogger(self.distro)
+        self.datamodel = datamodel
+
+    def _verify_event(self, event):
+        self.assertEqual(event.actor, "application://" +
+                         self.distro.get_app_id() + ".desktop")
+        self.assertEqual(event.manifestation,
+                         self.datamodel.Manifestation.EVENT_MANIFESTATION.USER_ACTIVITY)
+
+    def _verify_subject(self, subject, desktop):
+        self.assertEqual(subject.interpretation, self.datamodel.Interpretation.SOFTWARE)
+        self.assertEqual(subject.manifestation, self.datamodel.Manifestation.SOFTWARE_ITEM)
+        self.assertEqual(subject.uri, "application://" + desktop)
+        self.assertEqual(subject.current_uri, subject.uri)
+        self.assertEqual(subject.mimetype, "application/x-desktop")
+
+    def test_construction(self):
+        self.assertEqual(self.logger.distro, self.distro)
+
+    @patch("zeitgeist.client.ZeitgeistClient.insert_event")
+    def test_log_install_event(self, mock_insert_event):
+        test_desktop = "software-center.desktop"
+        self.assertTrue(self.logger.log_install_event(test_desktop))
+        self.assertTrue(mock_insert_event.called)
+        self.assertEqual(mock_insert_event.call_count, 2)
+        [event] = mock_insert_event.call_args_list[0][0]
+        self._verify_event(event)
+        self.assertEqual(event.interpretation,
+                         self.datamodel.Interpretation.EVENT_INTERPRETATION.CREATE_EVENT)
+        self.assertEqual(len(event.subjects), 1)
+        self._verify_subject(event.subjects[0], test_desktop)
+
+        [event] = mock_insert_event.call_args_list[1][0]
+        self._verify_event(event)
+        self.assertEqual(event.interpretation,
+                         self.datamodel.Interpretation.EVENT_INTERPRETATION.ACCESS_EVENT)
+        self.assertEqual(len(event.subjects), 1)
+        self._verify_subject(event.subjects[0], test_desktop)
+
+    @patch("zeitgeist.client.ZeitgeistClient.insert_event")
+    def test_log_install_event_invalid_desktop(self, mock_insert_event):
+        self.assertFalse(self.logger.log_install_event(""))
+        self.assertFalse(mock_insert_event.called)
+
+    @patch("zeitgeist.client.ZeitgeistClient.insert_event")
+    def test_log_uninstall_event(self, mock_insert_event):
+        test_desktop = "software-center.desktop"
+        self.assertTrue(self.logger.log_uninstall_event(test_desktop))
+        self.assertTrue(mock_insert_event.called)
+        self.assertEqual(mock_insert_event.call_count, 1)
+        [event] = mock_insert_event.call_args_list[0][0]
+        self._verify_event(event)
+        self.assertEqual(event.interpretation,
+                         self.datamodel.Interpretation.EVENT_INTERPRETATION.DELETE_EVENT)
+        self.assertEqual(len(event.subjects), 1)
+        self._verify_subject(event.subjects[0], test_desktop)
+
+    @patch("zeitgeist.client.ZeitgeistClient.insert_event")
+    def test_log_uninstall_event_invalid_desktop(self, mock_insert_event):
+        self.assertFalse(self.logger.log_uninstall_event(""))
+        self.assertFalse(mock_insert_event.called)
+
+
+if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
+    unittest.main()