Merge lp:~nataliabidart/ubuntu-sso-client/stable-3-0-update-2.99.5 into lp:ubuntu-sso-client/stable-3-0

[Natalia Bidart]

- Updating from trunk up to revno 882:

[ Diego Sarmentero <email address hidden> ]
  - Fixed: Captcha is failing for the Qt UI (LP: #933679).
  - Add stylesheets for the Qt UI.
  - Fixed: Qt UI: must call the backend passing reply_handler
    and error_handler (LP: #931452).

[ Natalia B. Bidart <email address hidden> ]
  - Make gettext return unicode strings. Also, transform arguments passed to
    the GLib spawnner to bytes (LP: #933632).
  - Fix lint issue on nightlies build (LP: #934488).
  - Try to load the qt main/ implementation when possible, if not default
    to the glib (LP: #933534).
  - Make the bin_dir discoverable when running from the system installation
    (LP: #933039).

[ Roberto Alsina <email address hidden> ]
  - Implement timeout_func for the Qt frontend (LP: #933758).

[Roberto Alsina (ralsina)]

+1

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~nataliabidart/ubuntu-sso-client/stable-3-0-update-2.99.5 into lp:ubuntu-sso-client/stable-3-0 failed. Below is the output from the failed tests.

*** Running GTK test suite for ubuntu_sso ***
twisted.trial.unittest
  TestCase
    runTest ... [OK]
ubuntu_sso.keyring.tests.test_common
  TestGetHostname
    test_get_hostname ... [OK]
    test_get_hostname_uses_filesystem_encoding ... [OK]
  TestTokenNameBuilder
    test_get_complex_token_name_for_app_name ... [OK]
    test_get_complex_token_name_for_hostname ... [OK]
    test_get_simple_token_name ... [OK]
    test_get_unicode_appname_token_name ... [OK]
    test_get_utf8_hostname_token_name ... [OK]
twisted.trial.unittest
  TestCase
    runTest ... [OK]
ubuntu_sso.keyring.tests.test_linux
  TestKeyring
    test_delete_credentials ... [OK]
    test_get_credentials ... [OK]
    test_get_credentials_migrating_token ... [OK]
    test_get_old_cred_found ... [OK]
    test_get_old_cred_found_but_not_asked_for ... [OK]
    test_get_old_cred_not_found ... [OK]
    test_set_credentials ... [OK]
ubuntu_sso.networkstate.tests.test_linux
  NetworkManagerStateErrorsTestCase
    test_dbus_problem ... [OK]
    test_nm_not_running ... [OK]
  NetworkManagerStateTestCase
    test_nm_connecting_then_offline ... [OK]
    test_nm_connecting_then_offline_old ... [OK]
    test_nm_connecting_then_online ... [OK]
    test_nm_connecting_then_online_old ... [OK]
    test_nm_offline ... [OK]
    test_nm_offline_local ... [OK]
    test_nm_offline_old ... [OK]
    test_nm_offline_site ... [OK]
    test_nm_online_global ... [OK]
    test_nm_online_old ... [OK]
ubuntu_sso.tests
  TestCase
    runTest ... [OK]
ubuntu_sso.networkstate.tests.test_linux
  TestConnection
    test_is_machine_connected_nm_state_connected_global ... [OK]
    test_is_machine_connected_nm_state_connected_old ... [OK]
    test_is_machine_defer_error ... [OK]
    test_is_machine_disconnected_n...

=== added file 'data/Ubuntu-B.ttf'
Binary files data/Ubuntu-B.ttf	1970-01-01 00:00:00 +0000 and data/Ubuntu-B.ttf	2012-02-21 23:01:20 +0000 differ
=== added file 'data/Ubuntu-R.ttf'
Binary files data/Ubuntu-R.ttf	1970-01-01 00:00:00 +0000 and data/Ubuntu-R.ttf	2012-02-21 23:01:20 +0000 differ
=== added file 'data/balloon_shape.png'
Binary files data/balloon_shape.png	1970-01-01 00:00:00 +0000 and data/balloon_shape.png	2012-02-21 23:01:20 +0000 differ
=== added file 'data/password_hint_ok.png'
Binary files data/password_hint_ok.png	1970-01-01 00:00:00 +0000 and data/password_hint_ok.png	2012-02-21 23:01:20 +0000 differ
=== added file 'data/password_hint_warning.png'
Binary files data/password_hint_warning.png	1970-01-01 00:00:00 +0000 and data/password_hint_warning.png	2012-02-21 23:01:20 +0000 differ
=== added file 'data/qt/resources.qrc'
--- data/qt/resources.qrc	1970-01-01 00:00:00 +0000
+++ data/qt/resources.qrc	2012-02-21 23:01:20 +0000
@@ -0,0 +1,10 @@
+<RCC>
+  <qresource prefix="/">
+    <file>../password_hint_ok.png</file>
+    <file>../password_hint_warning.png</file>
+    <file>../Ubuntu-R.ttf</file>
+    <file>../Ubuntu-B.ttf</file>
+    <file>../balloon_shape.png</file>
+    <file>stylesheet.qss</file>
+  </qresource>
+</RCC>

=== modified file 'data/qt/setup_account.ui'
--- data/qt/setup_account.ui	2012-02-02 15:44:18 +0000
+++ data/qt/setup_account.ui	2012-02-21 23:01:20 +0000
@@ -221,6 +221,22 @@
         <number>3</number>
        </property>
        <item>
+        <spacer name="verticalSpacer_4">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeType">
+          <enum>QSizePolicy::Fixed</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>10</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
         <widget class="QLabel" name="password_label">
          <property name="font">
           <font>
@@ -283,6 +299,22 @@
         <number>3</number>
        </property>
        <item>
+        <spacer name="verticalSpacer_5">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeType">
+          <enum>QSizePolicy::Fixed</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>10</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item>
         <widget class="QLabel" name="confirm_password_label">
          <property name="font">
           <font>
@@ -576,7 +608,7 @@
      <item row="6" column="1" rowspan="2">
       <widget class="QLabel" name="password_assistance">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+        <sizepolicy hsizetype="Maximum" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
@@ -584,7 +616,7 @@
        <property name="minimumSize">
         <size>
          <width>220</width>
-         <height>0</height>
+         <height>100</height>
         </size>
        </property>
        <property name="maximumSize">
@@ -663,5 +695,6 @@
    </item>
   </layout>
  </widget>
+ <resources/>
  <connections/>
 </ui>

=== added file 'data/qt/stylesheet.qss'
--- data/qt/stylesheet.qss	1970-01-01 00:00:00 +0000
+++ data/qt/stylesheet.qss	2012-02-21 23:01:20 +0000
@@ -0,0 +1,119 @@
+QWidget {
+    font-family: "Ubuntu";
+    color: #333333;
+}
+
+QWizard,
+QDialog {
+    background-color: white;
+}
+
+QLabel#password_assistance {
+    border-image: url(":/balloon_shape.png");
+}
+
+QLineEdit {
+    border: 1px solid #aea79f;
+}
+
+QPushButton {
+    border-radius: 5px;
+    border-style: solid;
+    padding: 6px;
+    padding-left: 20px;
+    padding-right: 20px;
+    border-width: 1px;
+    height: 14px;
+}
+
+QPushButton[default="true"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #fe9e84,stop: 1.0 #dd4814);
+    color: white;
+    border-color: #999999;
+}
+
+QPushButton:hover[default="true"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #ffb19c,stop: 1.0 #dd4814);
+    color: white;
+    border-color: #999999;
+}
+
+QPushButton:pressed[default="true"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #b93f14,stop: 1.0 #dd4814);
+    color: white;
+    border-color: #999999;
+}
+
+QPushButton[default="false"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #ffffff,stop: 1.0 #e6e6e6);
+    color: #333333;
+    border-color: #999999;
+}
+
+QPushButton:hover[default="false"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #ffffff,stop: 1.0 #ededed);
+    color: #333333;
+    border-color: #999999;
+}
+
+QPushButton:pressed[default="false"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #d9d9d9,stop: 1.0 #fefefe);
+    color: #333333;
+    border-color: #999999;
+}
+
+QPushButton[DisabledState="true"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #eaeaea, stop: 1.0 #cacaca);
+    color: #595959;
+    border-color: #939389;
+}
+
+QPushButton[DisabledState="false"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #fe9e84,stop: 1.0 #dd4814);
+    color: white;
+    border-color: #999999;
+}
+
+QPushButton:hover[DisabledState="false"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #ffb19c,stop: 1.0 #dd4814);
+    color: white;
+    border-color: #999999;
+}
+
+QPushButton:pressed[DisabledState="false"] {
+    background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #b93f14,stop: 1.0 #dd4814);
+    color: white;
+    border-color: #999999;
+}
+
+QFrame#frm_box {
+    background: #ffffff;
+    border-radius: 5px;
+    border-style: solid;
+    border-color: #939389;
+    border-width: 1px;
+    color: white;
+    min-height: 100px;
+}
+
+QFrame#frm_box > QLabel {
+    font-size: 20px;
+}
+
+QLabel#title_label {
+    font-size: 20px;
+}
+
+QFrame#header {
+    padding: 10px;
+}

=== modified file 'run-tests'
--- run-tests	2012-02-09 22:19:31 +0000
+++ run-tests	2012-02-21 23:01:20 +0000
@@ -47,7 +47,7 @@
 fi
 
 echo "*** Running GTK test suite for ""$MODULE"" ***"
-$XVFB_CMDLINE u1trial --reactor=gi --gui -p "$QT_TESTS_PATH" -i "test_windows.py" "$MODULE"
+$XVFB_CMDLINE u1trial --reactor=gi --gui -p "$QT_TESTS_PATH" -i "test_windows.py,test_qt.py" "$MODULE"
 rm -rf _trial_temp
 
 # hack to avoid:

=== modified file 'setup.py'
--- setup.py	2012-02-15 16:32:29 +0000
+++ setup.py	2012-02-21 23:01:20 +0000
@@ -153,11 +153,6 @@
 
     def run(self):
         """Execute the command."""
-        # pylint: disable=W0703
-        try:
-            self._wrapuic()
-        except Exception, e:
-            self.warn("Error wrapping uic to use gettext: %s" % e)
         basepath = os.path.join('data',  'qt')
         # TODO: build the resource files so that we can include them
         #self.build_rc(os.path.join(basepath, 'icons_rc.py'),
@@ -172,40 +167,6 @@
 
         build_extra.build_extra.run(self)
 
-    # pylint: disable=E1002
-    _wrappeduic = False
-
-    @classmethod
-    def _wrapuic(cls):
-        """Wrap uic to use gettext's _() in place of tr()"""
-        if cls._wrappeduic:
-            return
-
-        from PyQt4.uic.Compiler import compiler, qtproxies, indenter
-
-        # pylint: disable=C0103
-        class _UICompiler(compiler.UICompiler):
-            """Speciallized compiler for qt .ui files."""
-            def createToplevelWidget(self, classname, widgetname):
-                o = indenter.getIndenter()
-                o.level = 0
-                o.write('from gettext import gettext as _')
-                return super(_UICompiler, self).createToplevelWidget(classname,
-                    widgetname)
-        compiler.UICompiler = _UICompiler
-
-        class _i18n_string(qtproxies.i18n_string):
-            """Provide a translated text."""
-
-            def __str__(self):
-                return "_('%s')" % self.string.encode('string-escape')
-
-        qtproxies.i18n_string = _i18n_string
-
-        cls._wrappeduic = True
-        # pylint: enable=C0103
-    # pylint: enable=E1002
-
 
 class SSOClean(DistUtilsExtra.auto.clean_build_tree):
     """Class to clean up after the build."""

=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2012-02-11 19:25:01 +0000
+++ ubuntu_sso/credentials.py	2012-02-21 23:01:20 +0000
@@ -148,7 +148,9 @@
             value = getattr(self, arg)
             if value:
                 args.append('--%s' % arg)
-                args.append("%s" % str(value))
+                if not isinstance(value, basestring):
+                    value = str(value)
+                args.append(value)
 
         if login_only:
             args.append('--login_only')

=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2012-02-11 19:25:01 +0000
+++ ubuntu_sso/gtk/gui.py	2012-02-21 23:01:20 +0000
@@ -111,6 +111,7 @@
 # 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>'
 
 
 def log_call(f):
@@ -173,9 +174,9 @@
 
     def get_text(self):
         """Get text only if it's not the label nor empty."""
-        result = super(LabeledEntry, self).get_text()
+        result = super(LabeledEntry, self).get_text().decode('utf8')
         if result == self.label or result.isspace():
-            result = ''
+            result = u''
         return result
 
     def set_warning(self, warning_msg):
@@ -209,10 +210,10 @@
         self._done = False  # whether the whole process was completed or not
 
         self.app_name = app_name
-        self.app_label = '<b>%s</b>' % self.app_name
-        self.ping_url = kwargs.get('ping_url', '')
-        self.tc_url = kwargs.get('tc_url', '')
-        self.help_text = kwargs.get('help_text', '')
+        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)
@@ -338,15 +339,14 @@
     def success_vbox(self):
         """The success page."""
         message = SUCCESS % {'app_name': self.app_name}
-        message = '<span size="x-large">%s</span>' % message
+        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('<span size="x-large">%s</span>' %
-                                          ERROR)
+        self.finish_vbox.label.set_markup(LARGE_MARKUP % ERROR)
         return self.finish_vbox
 
     # helpers
@@ -362,7 +362,7 @@
                 result = f(app_name, *args, **kwargs)
             else:
                 logger.info('%s: ignoring call since received app_name '\
-                            '"%s" (expected "%s")',
+                            '%r (expected %r)',
                             f.__name__, app_name, self.app_name)
             return result
 
@@ -459,8 +459,7 @@
 
     def _set_header(self, header):
         """Set 'header' as the window title and header."""
-        markup = '<span size="x-large">%s</span>'
-        self.header_label.set_markup(markup % 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):
@@ -792,9 +791,8 @@
         f = self.backend.register_user
         error_handler = partial(self._handle_error, f,
                                 self.on_user_registration_error)
-        f(unicode(self.app_name), email1.decode('utf8'),
-          password1.decode('utf8'), name.decode('utf8'),
-          unicode(self._captcha_id), captcha_solution.decode('utf8'),
+        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):
@@ -1035,7 +1033,7 @@
         """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 "%s".', app_name)
+                           'app_name %r.', app_name)
         self._captcha_id = captcha_id
         self._set_captcha_image()
 

=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2012-02-11 01:51:57 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2012-02-21 23:01:20 +0000
@@ -165,7 +165,7 @@
         tmp = Gdk.RGBA()
         assert tmp.parse(gdk_color.to_string())
 
-        msg = 'Text color must be "%s" (got "%s" instead).'
+        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):
@@ -211,7 +211,7 @@
     def assert_correct_label(self):
         """Check that the entry has the correct label."""
         # text content is correct
-        msg = 'Text content must be "%s" (got "%s" instead).'
+        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))
@@ -231,7 +231,7 @@
 
     def test_tooltip(self):
         """Entry have the correct tooltip."""
-        msg = 'Tooltip must be "%s" (got "%s" instead).'
+        msg = 'Tooltip must be %r (got %r instead).'
         expected = self.label
         actual = self.entry.get_tooltip_text()
         # tooltip is correct
@@ -404,7 +404,7 @@
 
     def assert_entries_are_packed_to_ui(self, container_name, entries):
         """Every entry is properly packed in the ui 'container_name'."""
-        msg = 'Entry "%s" must be packed in "%s" but is not.'
+        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
@@ -414,7 +414,7 @@
 
     def assert_warnings_visibility(self, visible=False):
         """Every warning label should be 'visible'."""
-        msg = '"%s" should have %sempty content.'
+        msg = '%r should have %sempty content.'
         for name in self.ui.widgets:
             widget = getattr(self.ui, name)
             if 'warning' in name:
@@ -429,7 +429,7 @@
         self.assertTrue(label.get_property('visible'))
 
         # warning content is correct
-        actual = label.get_text()
+        actual = label.get_text().decode('utf-8')
         self.assertEqual(actual, message)
 
         # content color is correct
@@ -547,7 +547,7 @@
 
     def test_initial_text_for_entries(self):
         """Entries have the correct text at startup."""
-        msg = 'Text for "%s" must be "%s" (got "%s" instead).'
+        msg = 'Text for %r must be %r (got %r instead).'
         for name in self.ui.entries:
             entry = getattr(self.ui, name)
             expected = getattr(gui.utils.ui, name.upper())
@@ -557,14 +557,14 @@
 
     def test_entries_activates_default(self):
         """Entries have the activates default prop set."""
-        msg = '"%s" must have activates_default set to True.'
+        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 = '"%s" should be a password LabeledEntry instance.'
+        msg = '%r should be a password LabeledEntry instance.'
         passwords = filter(lambda name: 'password' in name,
                            self.ui.entries)
         for name in passwords:
@@ -578,7 +578,7 @@
     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 = '"%s" should close the window when clicked.'
+        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:
@@ -597,15 +597,16 @@
         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())
-        result = self.ui.finish_vbox.label.get_text()
+            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())
+        self.assertEqual(gui.ERROR,
+                         self.ui.finish_vbox.label.get_text().decode('utf8'))
 
 
 class SetTransientForTestCase(UbuntuSSOClientTestCase):
@@ -649,9 +650,9 @@
 
     def test_initial_text_for_header_label(self):
         """The header must have the correct text at startup."""
-        msg = 'Text for the header must be "%s" (got "%s" instead).'
+        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()
+        actual = self.ui.header_label.get_text().decode('utf8')
         # text content is correct
         self.assertEqual(expected, actual, msg % (expected, actual))
 
@@ -670,26 +671,26 @@
 
     def test_initial_texts_for_checkbuttons(self):
         """Check buttons have the correct text at startup."""
-        msg = 'Text for "%s" must be "%s" (got "%s" instead).'
+        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()
+        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()
+        actual = self.ui.yes_to_tc_checkbutton.get_label().decode('utf8')
         self.assertEqual(expected, actual,
                          msg % ('yes_to_tc_checkbutton', expected, actual))
 
     def test_checkbutton_is_checked_at_startup(self):
         """Checkbuttons are checked by default."""
-        msg = '"%s" 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_checkbutton_isnt_checked_at_startup(self):
         """Checkbuttons are checked by default."""
-        msg = '"%s" is 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)
@@ -732,7 +733,8 @@
                         'the processing spinner should be active.')
         self.assertTrue(label.get_property('visible'),
                         'the processing label should be visible.')
-        self.assertEqual(label.get_text(), gui.ONE_MOMENT_PLEASE,
+        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):
@@ -775,7 +777,7 @@
                         '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(), gui.LOADING,
+        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):
@@ -814,7 +816,7 @@
     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, APP_NAME))
+        self.assertTrue(self.memento.check(logging.WARNING, repr(APP_NAME)))
         self.assertTrue(self.memento.check(logging.WARNING,
                                            'captcha_id is None'))
 
@@ -837,7 +839,7 @@
 
     def test_login_button_has_correct_wording(self):
         """The sign in button has the proper wording."""
-        actual = self.ui.login_button.get_label()
+        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):
@@ -870,7 +872,7 @@
         """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(), '')
+        self.assertEqual(self.ui.warning_label.get_text().decode('utf8'), '')
 
 
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
@@ -953,12 +955,13 @@
 
     def test_tc_button_has_the_proper_wording(self):
         """Terms & Conditions has the proper wording."""
-        self.assertEqual(self.ui.tc_button.get_label(), gui.TC_BUTTON)
+        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())
+        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."""
@@ -1115,8 +1118,8 @@
 
     def test_help_label_display_correct_wording(self):
         """The help_label display VERIFY_EMAIL_LABEL."""
-        msg = 'help_label must read "%s" (got "%s" instead).'
-        actual = self.ui.help_label.get_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))
@@ -1160,7 +1163,7 @@
         """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())
+                         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."""
@@ -1186,16 +1189,16 @@
     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())
-        markup = self.ui.success_vbox.label.get_label()
+                         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())
-        markup = self.ui.error_vbox.label.get_label()
+                         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):
@@ -1346,7 +1349,7 @@
         """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(),
+        self.assertEqual(self.ui.password_help_label.get_text().decode('utf8'),
                          gui.PASSWORD_HELP)
         self.assertNotIn('register_user', self.ui.backend._called)
 
@@ -1436,16 +1439,16 @@
 
     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 "%s" (got "%s" instead).'
+        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()
+        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 "%s" (got "%s" instead).'
+        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()
+        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):
@@ -1628,23 +1631,23 @@
 
     def test_forgotten_password_button_has_the_proper_wording(self):
         """The forgotten_password_button has the proper wording."""
-        self.assertEqual(self.ui.forgotten_password_button.get_label(),
-                         gui.FORGOTTEN_PASSWORD_BUTTON)
+        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(), wanted)
+        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(),
+        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'."""
-        self.assertEqual(self.ui.request_password_token_ok_button.get_label(),
-                         gui.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."""
@@ -1691,7 +1694,7 @@
         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(),
+        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):
@@ -1699,8 +1702,8 @@
         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.set_new_password_ok_button.get_label(),
-                         gui.RESET_PASSWORD)
+        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 successfuly sent the login page is shown."""
@@ -1872,8 +1875,8 @@
         """Password help text is correctly displayed."""
         visible = self.ui.reset_password_help_label.get_property('visible')
         self.assertTrue(visible, 'password help text is visible.')
-        self.assertEqual(self.ui.reset_password_help_label.get_text(),
-                         gui.PASSWORD_HELP)
+        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):
@@ -1951,7 +1954,7 @@
         """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.itervalues():
-            msgs = ('ignoring', method.__name__, mismatch_app_name)
+            msgs = ('ignoring', method.__name__, repr(mismatch_app_name))
             method(mismatch_app_name, 'dummy')
             self.assertTrue(self.memento.check(logging.INFO, *msgs))
             self.memento.records = []
@@ -2068,7 +2071,8 @@
 
     def test_help_text_is_used(self):
         """The passed help_text is used."""
-        self.assertEqual(self.ui.help_label.get_text(), HELP_TEXT)
+        self.assertEqual(self.ui.help_label.get_text().decode('utf8'),
+                         HELP_TEXT)
 
 
 class ReturnCodeTestCase(UbuntuSSOClientTestCase):
@@ -2087,7 +2091,7 @@
     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 "%s" is clicked.'
+        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)

=== modified file 'ubuntu_sso/keyring/tests/test_linux.py'
--- ubuntu_sso/keyring/tests/test_linux.py	2012-01-26 15:34:16 +0000
+++ ubuntu_sso/keyring/tests/test_linux.py	2012-02-21 23:01:20 +0000
@@ -26,7 +26,6 @@
 
 from ubuntu_sso import keyring as common_keyring
 from ubuntu_sso.keyring import linux as keyring
-from ubuntu_sso.tests import APP_NAME
 
 
 class MockItem(object):
@@ -168,9 +167,9 @@
         sample_creds = {"name": "sample creds name"}
         kr = keyring.Keyring()
         self.patch(keyring, "get_token_name", keyring.get_old_token_name)
-        yield kr.set_credentials(APP_NAME, sample_creds)
+        yield kr.set_credentials("app name", sample_creds)
 
-        result = yield kr.get_credentials(APP_NAME)
+        result = yield kr.get_credentials("app name")
         self.assertEqual(result, sample_creds)
 
     @inlineCallbacks

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2012-02-11 01:51:57 +0000
+++ ubuntu_sso/main/__init__.py	2012-02-21 23:01:20 +0000
@@ -318,7 +318,7 @@
     def CredentialsFound(self, app_name, credentials):
         """Signal thrown when the credentials are found."""
         self.ref_count -= 1
-        logger.info('%s: emitting CredentialsFound with app_name "%s".',
+        logger.info('%s: emitting CredentialsFound with app_name %r.',
                     self.__class__.__name__, app_name)
         self.proxy.CredentialsFound(app_name, credentials)
 

=== modified file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	2012-02-14 21:53:58 +0000
+++ ubuntu_sso/main/linux.py	2012-02-21 23:01:20 +0000
@@ -25,7 +25,6 @@
 
 """
 
-import os
 import signal
 
 import dbus
@@ -439,10 +438,10 @@
     return defer.succeed(result)
 
 
-if os.environ.get('USE_QT_MAINLOOP'):
+try:
     from ubuntu_sso.main import qt
     source = qt
-else:
+except ImportError:  # no PyQt4.QtCore in the system
     from ubuntu_sso.main import glib
     source = glib
 

=== modified file 'ubuntu_sso/main/qt.py'
--- ubuntu_sso/main/qt.py	2012-01-26 14:54:13 +0000
+++ ubuntu_sso/main/qt.py	2012-02-21 23:01:20 +0000
@@ -22,10 +22,30 @@
 
 from PyQt4 import QtCore
 
-
-def timeout_func(*a, **kw):
+TIMERS = set()
+
+
+def timeout_func(interval, callback, *a, **kw):
     """Delay import of dynamic bindings to avoid crashes."""
-    # use a QTimer to simulate a looping call
+
+    # QTimers don't support priorities
+    kw.pop("priority", None)
+
+    timer = QtCore.QTimer()
+    TIMERS.add(timer)
+
+    def _callback():
+        """Call the real callback, with arguments, until it returns False."""
+        if timer in TIMERS:
+            result = callback(*a, **kw)
+            if not result:
+                timer.stop()
+                TIMERS.remove(timer)
+                # Probably overkill
+                timer.deleteLater()
+
+    timer.timeout.connect(_callback)
+    timer.start(interval)
 
 
 def shutdown_func(*a, **kw):

=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2012-02-10 17:18:22 +0000
+++ ubuntu_sso/main/tests/test_common.py	2012-02-21 23:01:20 +0000
@@ -919,7 +919,8 @@
     @defer.inlineCallbacks
     def setUp(self):
         yield super(CredentialsManagementOpsTestCase, self).setUp()
-        self.args = dict((k, str(v)) for k, v in self.base_args.iteritems())
+        self.args = dict(self.base_args)
+        self.args[WINDOW_ID_KEY] = str(self.args[WINDOW_ID_KEY])
         self.cred_args = self.base_args.copy()
 
     def test_register(self):
@@ -955,12 +956,16 @@
 class CredentialsManagementSignalsTestCase(CredentialsManagementTestCase):
     """Tests for the CredentialsManagement DBus signals."""
 
+    def assert_signal_logged(self, signal, *args):
+        """Check that signal info was properly logged."""
+        signal(APP_NAME, *args)
+        msgs = [self.obj.__class__.__name__,
+                signal.__name__, repr(APP_NAME)]
+        self.assertTrue(self.memento.check_info(*msgs))
+
     def test_credentials_found(self):
         """The CredentialsFound signal."""
-        self.obj.CredentialsFound(APP_NAME, TOKEN)
-        msgs = (self.obj.__class__.__name__,
-                self.obj.CredentialsFound.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
+        self.assert_signal_logged(self.obj.CredentialsFound, TOKEN)
 
         msg = 'credentials must not be logged (found %r in log).'
         for val in TOKEN.itervalues():
@@ -968,24 +973,15 @@
 
     def test_credentials_not_found(self):
         """The CredentialsNotFound signal."""
-        self.obj.CredentialsNotFound(APP_NAME)
-        msgs = (self.obj.__class__.__name__,
-                self.obj.CredentialsNotFound.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
+        self.assert_signal_logged(self.obj.CredentialsNotFound)
 
     def test_credentials_cleared(self):
         """The CredentialsCleared signal."""
-        self.obj.CredentialsCleared(APP_NAME)
-        msgs = (self.obj.__class__.__name__,
-                self.obj.CredentialsCleared.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
+        self.assert_signal_logged(self.obj.CredentialsCleared)
 
     def test_credentials_stored(self):
         """The CredentialsStored signal."""
-        self.obj.CredentialsStored(APP_NAME)
-        msgs = (self.obj.__class__.__name__,
-                self.obj.CredentialsStored.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
+        self.assert_signal_logged(self.obj.CredentialsStored)
 
     def test_credentials_error(self):
         """The CredentialsError signal."""
@@ -993,15 +989,12 @@
         self.obj.CredentialsError(APP_NAME, error)
         msgs = (self.obj.__class__.__name__,
                 self.obj.CredentialsError.__name__,
-                APP_NAME, str(error))
+                repr(APP_NAME), repr(error))
         self.assertTrue(self.memento.check_error(*msgs))
 
     def test_authorization_denied(self):
         """The AuthorizationDenied signal."""
-        self.obj.AuthorizationDenied(APP_NAME)
-        msgs = (self.obj.__class__.__name__,
-                self.obj.AuthorizationDenied.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
+        self.assert_signal_logged(self.obj.AuthorizationDenied)
 
 
 class UbuntuSSOServiceTestCase(BaseTestCase):

=== added file 'ubuntu_sso/main/tests/test_qt.py'
--- ubuntu_sso/main/tests/test_qt.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/tests/test_qt.py	2012-02-21 23:01:20 +0000
@@ -0,0 +1,69 @@
+# -*- 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/>.
+"""Qt specific tests for the main module."""
+
+# pylint: disable=F0401
+from PyQt4 import QtCore
+from twisted.internet import defer
+
+from ubuntu_sso.main import qt
+from ubuntu_sso.tests import TestCase
+
+
+class MiscTestCase(TestCase):
+    """Tests for module level misc functions."""
+
+    def clean_timers(self):
+        """Remove all timers."""
+        qt.TIMERS = set()
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(MiscTestCase, self).setUp()
+        self.addCleanup(self.clean_timers)
+
+    def test_timeout_func_ignores_priority(self):
+        """Should not pass priority as argument."""
+        qt.timeout_func(0, self._set_called, priority="crazy")
+        QtCore.QCoreApplication.instance().processEvents()
+        self.assertEqual(self._called, ((), {}))
+
+    def test_timeout_func_keeps_reference(self):
+        """Should keep a reference to the timer created."""
+        self.assertEqual(len(qt.TIMERS), 0)
+        qt.timeout_func(0, self._set_called, priority="crazy")
+        self.assertEqual(len(qt.TIMERS), 1)
+
+    def test_timeout_func_removes_reference(self):
+        """Remove reference to timer when callback returns False."""
+        self.assertEqual(len(qt.TIMERS), 0)
+        qt.timeout_func(0, self._set_called, priority="crazy")
+        self.assertEqual(len(qt.TIMERS), 1)
+        QtCore.QCoreApplication.instance().processEvents()
+        self.assertEqual(len(qt.TIMERS), 0)
+
+    def test_timeout_func_timer_activation(self):
+        """The timer should be activated with the right period."""
+        self.assertEqual(len(qt.TIMERS), 0)
+        qt.timeout_func(1337, self._set_called, priority="crazy")
+        self.assertEqual(len(qt.TIMERS), 1)
+        self.assertEqual(list(qt.TIMERS)[0].interval(), 1337)
+
+    def test_timeout_func_argument_passing(self):
+        """The right arguments should be passed to the callback."""
+        qt.timeout_func(0, self._set_called, 1, name="a")
+        QtCore.QCoreApplication.instance().processEvents()
+        self.assertEqual(self._called, ((1,), {"name": "a"}))

=== modified file 'ubuntu_sso/qt/__init__.py'
--- ubuntu_sso/qt/__init__.py	2012-02-09 18:28:40 +0000
+++ ubuntu_sso/qt/__init__.py	2012-02-21 23:01:20 +0000
@@ -16,21 +16,11 @@
 
 """The Qt graphical interface for the Ubuntu Single Sign On Client."""
 
-import gettext
 import collections
 
 
-_ = gettext.gettext
-
 ERROR_ALL = '__all__'
 ERROR_MESSAGE = 'message'
-LOCAL_FOLDERS_TITLE = _("Syncing your computer with the cloud")
-LOCAL_FOLDERS_SPACE_HEADER = _("Space (%s)")
-LOCAL_FOLDERS_OFFER_LABEL = _("The folders you have selected to sync "
-    "take over your %(quota)s space. You can remove some folders or add "
-    "some extra space")
-LOCAL_FOLDERS_CALCULATING = _("Calculating")
-NEXT = _("Next")
 
 
 # Based on the gtk implementation

=== modified file 'ubuntu_sso/qt/common.py'
--- ubuntu_sso/qt/common.py	2012-02-09 19:21:09 +0000
+++ ubuntu_sso/qt/common.py	2012-02-21 23:01:20 +0000
@@ -18,6 +18,7 @@
 """Common functionality used by the UI modules."""
 
 import re
+
 from ubuntu_sso.utils.ui import (
     PASSWORD_DIGIT,
     PASSWORD_LENGTH,

=== modified file 'ubuntu_sso/qt/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-21 23:01:20 +0000
@@ -16,15 +16,17 @@
 
 """Page to allow the user to login into Ubuntu Single Sign On."""
 
-import gettext
+from functools import partial
 
 from PyQt4 import QtGui, QtCore
 from twisted.internet import defer
 
+from ubuntu_sso import NO_OP
 from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt.gui import SSOWizardPage
 from ubuntu_sso.logger import setup_logging
 from ubuntu_sso.utils.ui import (
+    CANCEL_BUTTON,
     EMAIL_LABEL,
     FORGOTTEN_PASSWORD_BUTTON,
     is_correct_email,
@@ -33,10 +35,10 @@
 )
 
 
-FORGOTTEN_PASSWORD_LINK_STYLE = '<a href="#">{forgotten_text}</a>'
-
-
-_ = gettext.gettext
+FORGOTTEN_PASSWORD_LINK_STYLE = ('<a href="#" style="color:#dd4814;">'
+                                 '{forgotten_text}</a>')
+
+
 logger = setup_logging('ubuntu_sso.current_user_sign_in_page')
 
 
@@ -85,8 +87,7 @@
 
     def initializePage(self):
         """Setup UI details."""
-        self.setButtonText(QtGui.QWizard.CancelButton,
-            _("Cancel"))
+        self.setButtonText(QtGui.QWizard.CancelButton, CANCEL_BUTTON)
         # Layout without custom button 1,
         # without finish button
         self.wizard().setButtonLayout([
@@ -103,6 +104,10 @@
         self.ui.sign_in_button.style().polish(
             self.ui.sign_in_button)
 
+    def cleanupPage(self):
+        """Reset the wizard buttons."""
+        self.wizard().setButtonLayout([QtGui.QWizard.Stretch])
+
     def _set_translated_strings(self):
         """Set the translated strings."""
         logger.debug('CurrentUserSignInPage._set_translated_strings')
@@ -147,19 +152,24 @@
             args = args + (self.ping_url,)
         else:
             f = self.backend.login
-        f(*args)
+
+        self.overlay.show()
+        error_handler = partial(self._handle_error, f, self.on_login_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
 
     def on_login_error(self, app_name, error):
         """There was an error when login in."""
         # let the user know
         logger.error('Got error when login %s, error: %s',
             self.app_name, error)
+        self.overlay.hide()
         self.message_box.critical(self, self.app_name,
             build_general_error_message(error))
 
     def on_logged_in(self, app_name, result):
         """We managed to log in."""
         logger.info('Logged in for %s', app_name)
+        self.overlay.hide()
         email = unicode(self.ui.email_edit.text())
         self.userLoggedIn.emit(app_name, email)
         logger.debug('Wizard.loginSuccess emitted.')

=== modified file 'ubuntu_sso/qt/email_verification_page.py'
--- ubuntu_sso/qt/email_verification_page.py	2012-02-13 14:04:27 +0000
+++ ubuntu_sso/qt/email_verification_page.py	2012-02-21 23:01:20 +0000
@@ -16,9 +16,12 @@
 
 """Email Verification page UI."""
 
+from functools import partial
+
 from PyQt4 import QtCore
 from twisted.internet import defer
 
+from ubuntu_sso import NO_OP
 from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt.gui import SSOWizardPage
 from ubuntu_sso.logger import setup_logging
@@ -115,7 +118,9 @@
         logger.info('Calling validate_email with email %r, password <hidden>, '
                     'app_name %r and email_token %r.', self.email,
                     self.app_name, code)
-        f(*args)
+        error_handler = partial(self._handle_error, f,
+                                self.on_email_validation_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
 
     def on_email_validated(self, app_name, *args, **kwargs):
         """Signal thrown after the email is validated."""

=== modified file 'ubuntu_sso/qt/enhanced_check_box.py'
--- ubuntu_sso/qt/enhanced_check_box.py	2012-02-02 15:57:02 +0000
+++ ubuntu_sso/qt/enhanced_check_box.py	2012-02-21 23:01:20 +0000
@@ -18,7 +18,7 @@
 
 """Customized Check Box to support links."""
 
-from PyQt4 import QtGui
+from PyQt4 import QtGui, QtCore
 
 
 class EnhancedCheckBox(QtGui.QCheckBox):
@@ -28,9 +28,12 @@
         QtGui.QCheckBox.__init__(self)
         hbox = QtGui.QHBoxLayout()
         self.text_label = QtGui.QLabel(text)
+        self.text_label.setAlignment(QtCore.Qt.AlignTop)
         self.text_label.setOpenExternalLinks(True)
         padding = self.iconSize().width()
-        self.text_label.setStyleSheet("padding-left: {0}px;".format(padding))
+        self.text_label.setStyleSheet("margin-top: -3px;"
+                                      "padding-left: {0}px;".format(padding))
+        hbox.setContentsMargins(padding, 0, 0, 0)
         hbox.addWidget(self.text_label)
         self.setLayout(hbox)
 

=== modified file 'ubuntu_sso/qt/forgotten_password_page.py'
--- ubuntu_sso/qt/forgotten_password_page.py	2012-02-13 21:50:16 +0000
+++ ubuntu_sso/qt/forgotten_password_page.py	2012-02-21 23:01:20 +0000
@@ -16,9 +16,12 @@
 
 """Forgotten Password page UI."""
 
+from functools import partial
+
 from PyQt4 import QtCore
 from twisted.internet import defer
 
+from ubuntu_sso import NO_OP
 from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
 from ubuntu_sso.utils.ui import (
     EMAIL_LABEL,
@@ -139,12 +142,21 @@
     def _connect_ui(self):
         """Connect the diff signals from the Ui."""
         self.email_address_line_edit.textChanged.connect(self._validate)
-        self.send_button.clicked.connect(
-                            lambda: self.backend.request_password_reset_token(
-                                                self.app_name,
-                                                self.email_address))
+
+        self.send_button.clicked.connect(self.request_new_password)
         self.try_again_button.clicked.connect(self.on_try_again)
 
+    def request_new_password(self):
+        """Send the request password operation."""
+        args = (self.app_name, self.email_address)
+        f = self.backend.request_password_reset_token
+
+        error_handler = partial(self._handle_error, f,
+            self.on_password_reset_error)
+
+        self.overlay.show()
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
+
     def _validate(self):
         """Validate that we have an email."""
         email = unicode(self.email_address_line_edit.text())
@@ -163,12 +175,14 @@
     def on_password_reset_token_sent(self, app_name, result):
         """Action taken when we managed to get the password reset done."""
         # ignore the result and move to the reset page
+        self.overlay.hide()
         self.passwordResetTokenSent.emit()
     # pylint: enable=W0212
 
     def on_password_reset_error(self, app_name, error):
         """Action taken when there was an error requesting the reset."""
         # set the error message
+        self.overlay.hide()
         msg = REQUEST_PASSWORD_TOKEN_TECH_ERROR
         if error['errtype'] == 'ResetPasswordTokenError':
             # the account provided is wrong, lets tell the user to try

=== modified file 'ubuntu_sso/qt/gui.py'
--- ubuntu_sso/qt/gui.py	2012-02-13 16:16:03 +0000
+++ ubuntu_sso/qt/gui.py	2012-02-21 23:01:20 +0000
@@ -15,7 +15,6 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Qt implementation of the UI."""
 
-import gettext
 from functools import wraps
 
 # pylint: disable=F0401,E0611
@@ -23,8 +22,8 @@
 from PyQt4.QtCore import Qt
 from PyQt4.QtGui import (
     QApplication,
-    QWidget,
     QCursor,
+    QFrame,
     QHBoxLayout,
     QVBoxLayout,
     QMessageBox,
@@ -37,18 +36,19 @@
 from ubuntu_sso import main
 from ubuntu_sso.qt.loadingoverlay import LoadingOverlay
 from ubuntu_sso.logger import setup_logging
-
-
-_ = gettext.gettext
+from ubuntu_sso.utils.ui import GENERIC_BACKEND_ERROR
+
+
 logger = setup_logging('ubuntu_sso.gui')
 
 
-class Header(QWidget):
+class Header(QFrame):
     """Header Class for Title and Subtitle in all wizard pages."""
 
     def __init__(self):
         """Create a new instance."""
-        QWidget.__init__(self)
+        super(Header, self).__init__()
+        self.setObjectName('header')
         vbox = QVBoxLayout(self)
         vbox.setContentsMargins(0, 0, 0, 10)
         self.title_label = QLabel()
@@ -149,6 +149,12 @@
             match = self.backend.connect_to_signal(signal, method)
             self._signals_receivers[signal] = match
 
+    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)
+
 
 class EnhancedLineEdit(object):
     """Represents and enhanced lineedit.

=== modified file 'ubuntu_sso/qt/main.py'
--- ubuntu_sso/qt/main.py	2012-02-13 15:43:59 +0000
+++ ubuntu_sso/qt/main.py	2012-02-21 23:01:20 +0000
@@ -18,14 +18,26 @@
 
 import sys
 
-from PyQt4 import QtGui
+from PyQt4 import QtGui, QtCore
 
+# Module used to include the resources into this file
+# Unused import resources_rc, pylint: disable=W0611
+from ubuntu_sso.qt.ui import resources_rc
+# pylint: enable=W0611
 from ubuntu_sso.qt.ubuntu_sso_wizard import UbuntuSSOClientGUI
 
 
 def main(**kwargs):
     """Start the QT mainloop and open the main window."""
     app = QtGui.QApplication(sys.argv)
+
+    QtGui.QFontDatabase.addApplicationFont(':/Ubuntu-R.ttf')
+    QtGui.QFontDatabase.addApplicationFont(':/Ubuntu-B.ttf')
+
+    # Apply Style Sheet -- The windows version may be different
+    qss = QtCore.QResource(":/stylesheet.qss")
+    app.setStyleSheet(qss.data())
+
     # Unused variable 'ui', pylint: disable=W0612
     ui = UbuntuSSOClientGUI(close_callback=app.exit, **kwargs)
     app.exec_()

=== modified file 'ubuntu_sso/qt/network_detection_page.py'
--- ubuntu_sso/qt/network_detection_page.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/qt/network_detection_page.py	2012-02-21 23:01:20 +0000
@@ -16,17 +16,17 @@
 
 """Pages from SSO."""
 
-
-import gettext
-
 from twisted.internet import defer
 from PyQt4 import QtGui
 
 from ubuntu_sso import networkstate
 
 from ubuntu_sso.qt.ui import network_detection_ui
-
-_ = gettext.gettext
+from ubuntu_sso.utils.ui import (
+    CLOSE_AND_SETUP_LATER,
+    NETWORK_DETECTION_TITLE,
+    TRY_AGAIN_BUTTON,
+)
 
 
 class NetworkDetectionPage(QtGui.QWizardPage):
@@ -35,7 +35,7 @@
 
     def __init__(self, banner_pixmap=None, parent=None):
         super(NetworkDetectionPage, self).__init__(parent)
-        self.setTitle(_("Network detection"))
+        self.setTitle(NETWORK_DETECTION_TITLE)
         self.ui = network_detection_ui.Ui_Form()
         self.ui.setupUi(self)
         if banner_pixmap is not None:
@@ -47,9 +47,9 @@
         """Set UI details."""
         self.wizard()._next_id = None
 
-        self.setButtonText(QtGui.QWizard.CustomButton1, _("Try again"))
+        self.setButtonText(QtGui.QWizard.CustomButton1, TRY_AGAIN_BUTTON)
         self.setButtonText(QtGui.QWizard.CancelButton,
-            _("Close window and set up later"))
+            CLOSE_AND_SETUP_LATER)
         self.wizard().setButtonLayout([
             QtGui.QWizard.Stretch,
             QtGui.QWizard.CustomButton1,

=== modified file 'ubuntu_sso/qt/reset_password_page.py'
--- ubuntu_sso/qt/reset_password_page.py	2012-02-10 21:09:38 +0000
+++ ubuntu_sso/qt/reset_password_page.py	2012-02-21 23:01:20 +0000
@@ -16,11 +16,14 @@
 
 """Reset Password page UI."""
 
+from functools import partial
+
 from PyQt4.QtCore import SIGNAL
 from PyQt4.QtCore import pyqtSignal
 from PyQt4.QtGui import QApplication
 from twisted.internet import defer
 
+from ubuntu_sso import NO_OP
 from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
 from ubuntu_sso.qt import common
@@ -175,14 +178,15 @@
 
     def on_password_changed(self, app_name, result):
         """Let user know that the password was changed."""
+        self.overlay.hide()
         email = unicode(self.wizard().forgotten.ui.email_line_edit.text())
-        self.overlay.hide()
         self.passwordChanged.emit(email)
 
     def on_password_change_error(self, app_name, error):
         """Let the user know that there was an error."""
         logger.error('Got error changing password for %s, error: %s',
                      self.app_name, error)
+        self.overlay.hide()
         self.message_box.critical(self, self.app_name,
             build_general_error_message(error))
 
@@ -193,7 +197,12 @@
         password = unicode(self.ui.password_line_edit.text())
         logger.info('Setting new password for %r and email %r with code %r',
                     self.app_name, email, code)
-        self.backend.set_new_password(self.app_name, email, code, password)
+        args = (self.app_name, email, code, password)
+        f = self.backend.set_new_password
+        error_handler = partial(self._handle_error, f,
+            self.on_password_change_error)
+        self.overlay.show()
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
 
     def is_correct_password_confirmation(self, password):
         """Return if the password is correct."""

=== modified file 'ubuntu_sso/qt/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-02-21 23:01:20 +0000
@@ -19,6 +19,7 @@
 import StringIO
 import tempfile
 import os
+from functools import partial
 
 # pylint: disable=F0401
 try:
@@ -30,6 +31,7 @@
 from PyQt4 import QtGui, QtCore
 from twisted.internet import defer
 
+from ubuntu_sso import NO_OP
 from ubuntu_sso.qt import build_general_error_message
 from ubuntu_sso.qt import common
 from ubuntu_sso.qt.gui import SSOWizardEnhancedEditPage
@@ -53,7 +55,6 @@
     is_min_required_password,
     is_correct_email,
     JOIN_HEADER_LABEL,
-    NAME,
     NAME_ENTRY,
     NAME_INVALID,
     PASSWORD,
@@ -123,8 +124,8 @@
                         privacy_policy=privacy_policy_link)
 
         self.terms_checkbox = enhanced_check_box.EnhancedCheckBox(terms)
+        self.ui.hlayout_check.addWidget(self.terms_checkbox)
         self.terms_checkbox.setVisible(bool(toc_link or policy_link))
-        self.ui.hlayout_check.addWidget(self.terms_checkbox)
 
         self.set_up_button = None
         self.captcha_received = False
@@ -175,7 +176,7 @@
         self.set_up_button.clicked.connect(self.set_next_validation)
         self.set_up_button.setEnabled(False)
 
-        self.ui.name_label.setText(NAME)
+        self.ui.name_label.setText(NAME_ENTRY)
         self.ui.email_label.setText(EMAIL)
         self.ui.confirm_email_label.setText(RETYPE_EMAIL)
         self.ui.password_label.setText(PASSWORD)
@@ -198,7 +199,7 @@
     #pylint: enable=C0103
 
     def _set_translated_strings(self):
-        """Set the different gettext translated strings."""
+        """Set the strings."""
         logger.debug('SetUpAccountPage._set_translated_strings')
         # set the translated string
         self.ui.name_label.setText(NAME_ENTRY)
@@ -259,7 +260,7 @@
         captcha_solution = unicode(self.ui.captcha_solution_edit.text())
 
         # Check for len(name) > 0 to ensure that a bool is assigned to enabled
-        if self.terms_checkbox.isVisible():
+        if not self.terms_checkbox.isVisible():
             checkbox_terms = True
         else:
             checkbox_terms = self.terms_checkbox.isChecked()
@@ -281,10 +282,14 @@
         # lets clean behind us, do we have the old file arround?
         if self.captcha_file and os.path.exists(self.captcha_file):
             os.unlink(self.captcha_file)
-        fd = tempfile.TemporaryFile(mode='r')
+        fd = tempfile.NamedTemporaryFile()
         file_name = fd.name
         self.captcha_file = file_name
-        self.backend.generate_captcha(self.app_name, file_name)
+        args = (self.app_name, file_name)
+        f = self.backend.generate_captcha
+        error_handler = partial(self._handle_error, f,
+            self.on_captcha_generation_error)
+        f(*args, reply_handler=NO_OP, error_handler=error_handler)
         self.on_captcha_refreshing()
 
     def _set_titles(self):
@@ -393,9 +398,12 @@
         # validate the current info of the form, try to perform the action
         # to register the user, and then move foward
         if self.validate_form():
-            self.backend.register_user(self.app_name, email,
-                                       password, name, captcha_id,
-                                       captcha_solution)
+            args = (self.app_name, email, password, name, captcha_id,
+                captcha_solution)
+            f = self.backend.register_user
+            error_handler = partial(self._handle_error, f,
+                self.on_user_registration_error)
+            f(*args, reply_handler=NO_OP, error_handler=error_handler)
             # Update validation page's title, which contains the email
             self.userRegistered.emit(email, password)
     # pylint: enable=W0212

=== modified file 'ubuntu_sso/qt/sign_in_page.py'
--- ubuntu_sso/qt/sign_in_page.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/qt/sign_in_page.py	2012-02-21 23:01:20 +0000
@@ -16,19 +16,17 @@
 
 """Page to allow the user to sign in."""
 
-import gettext
-
 from PyQt4 import QtGui, QtCore
 
 from ubuntu_sso.qt.gui import SSOWizardPage
 from ubuntu_sso.logger import setup_logging
 from ubuntu_sso.utils.ui import (
+    CLOSE_AND_SETUP_LATER,
     EXISTING_ACCOUNT_CHOICE_BUTTON,
     SET_UP_ACCOUNT_CHOICE_BUTTON,
 )
 
 
-_ = gettext.gettext
 logger = setup_logging('ubuntu_sso.sing_in_page')
 
 
@@ -76,7 +74,7 @@
 
     def initializePage(self):
         """Setup UI details."""
-        self.ui.cancel_button.setText(_("Close window and setup later"))
+        self.ui.cancel_button.setText(CLOSE_AND_SETUP_LATER)
         self.ui.cancel_button.clicked.connect(self.singInCanceled.emit)
         # Layout without custom button 1,
         # without finish button

=== modified file 'ubuntu_sso/qt/tests/__init__.py'
--- ubuntu_sso/qt/tests/__init__.py	2012-02-09 18:28:40 +0000
+++ ubuntu_sso/qt/tests/__init__.py	2012-02-21 23:01:20 +0000
@@ -21,7 +21,10 @@
 from twisted.trial.unittest import TestCase
 from ubuntu_sso.qt import loadingoverlay
 
-from ubuntu_sso import main
+from ubuntu_sso import (
+    main,
+    NO_OP,
+)
 
 
 class FakedObject(object):
@@ -29,7 +32,7 @@
 
     next_result = None
     exposed_methods = ['connect_to_signal',
-        'generate_captcha']
+        'generate_captcha', 'request_password_reset_token']
 
     def __init__(self, *args, **kwargs):
         self._args = args
@@ -384,6 +387,23 @@
         """Store 'args' and 'kwargs' for test assertions."""
         self._called = (args, kwargs)
 
+    # pylint: disable=E1101, W0212
+    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, NO_OP)
+
+        error_handler = call[1].pop('error_handler')
+        self.assertEqual(error_handler.func, self.ui._handle_error)
+
+        self.assertEqual(call[1], kwargs)
+    # pylint: enable=E1101, W0212
+
 
 class BaseTestCaseUI(TestCase):
     """Base Test Case."""

=== modified file 'ubuntu_sso/qt/tests/test_current_user_sign_in_page.py'
--- ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-02-13 17:19:05 +0000
+++ ubuntu_sso/qt/tests/test_current_user_sign_in_page.py	2012-02-21 23:01:20 +0000
@@ -25,6 +25,7 @@
     BaseTestCase,
     FakedBackend,
     FakedObject,
+    FakeOverlay,
     FakePageUiStyle,
     FakeSignal,
     FakeWizard,
@@ -40,6 +41,7 @@
     @defer.inlineCallbacks
     def setUp(self):
         yield super(CurrentUserSignInTestCase, self).setUp()
+        self.patch(gui, "LoadingOverlay", FakeOverlay)
         self.patch(gui.main, "get_sso_client", FakedBackend)
         self.signals_results = []
         self.patch(current_user_sign_in_page.CurrentUserSignInPage,
@@ -48,18 +50,20 @@
             "passwordForgotten", FakeSignal())
         self.patch(current_user_sign_in_page.CurrentUserSignInPage,
             "userNotValidated", FakeSignal())
+        self.app_name = 'my_app'
         self.ui = current_user_sign_in_page.CurrentUserSignInPage(
             current_user_sign_in_ui.Ui_CurrentUserSignInPage(),
             '',
+            app_name=self.app_name,
             parent=None)
         self.wizard = FakeWizard()
         self.patch(self.ui, 'wizard', lambda: self.wizard)
 
     def test_init(self):
         """Test the construction of the object."""
-        self.assertTrue('LoggedIn' in self.ui._signals)
-        self.assertTrue('LoginError' in self.ui._signals)
-        self.assertTrue('UserNotValidated' in self.ui._signals)
+        self.assertIn('LoggedIn', self.ui._signals)
+        self.assertIn('LoginError', self.ui._signals)
+        self.assertIn('UserNotValidated', self.ui._signals)
         self.assertTrue(callable(self.ui._signals['LoggedIn']))
         self.assertTrue(callable(self.ui._signals['LoginError']))
         self.assertTrue(callable(self.ui._signals['UserNotValidated']))
@@ -81,9 +85,9 @@
         self.patch(self.ui, "_connect_ui",
             faked_object._connect_ui)
         self.ui.setup_page()
-        self.assertTrue('_set_translated_strings' in faked_object._called)
-        self.assertTrue('_setup_signals' in faked_object._called)
-        self.assertTrue('_connect_ui' in faked_object._called)
+        self.assertIn('_set_translated_strings', faked_object._called)
+        self.assertIn('_setup_signals', faked_object._called)
+        self.assertIn('_connect_ui', faked_object._called)
     # pylint: enable=E1101
 
     def test_on_user_not_validated(self):
@@ -98,7 +102,7 @@
             self.signals_results.append((email, password))
         self.ui.userNotValidated.connect(slot)
         self.ui.on_user_not_validated()
-        self.assertTrue((email, password) in self.signals_results)
+        self.assertIn((email, password), self.signals_results)
 
     def test_initialize_page(self):
         """Test the initialization method."""
@@ -110,8 +114,8 @@
         self.ui.initializePage()
         self.assertEqual(wizard.buttons_text[QtGui.QWizard.CancelButton],
             "Cancel")
-        self.assertTrue(('setButtonLayout',
-            (([QtGui.QWizard.BackButton, QtGui.QWizard.Stretch],), {})) in
+        self.assertIn(('setButtonLayout',
+            (([QtGui.QWizard.BackButton, QtGui.QWizard.Stretch],), {})),
             wizard.called)
         self.assertTrue(button.properties['default'])
         self.assertFalse(button.isEnabled())
@@ -178,12 +182,14 @@
         self.patch(FakedObject, "exposed_methods", exposed_methods)
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
-        self.ui.ui.email_edit.setText('valid@email')
-        self.ui.ui.password_edit.setText('123456')
+        email = 'valid@email'
+        password = '123456'
+        self.ui.ui.email_edit.setText(email)
+        self.ui.ui.password_edit.setText(password)
         self.ui.login()
-        self.assertTrue('login_and_ping' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['login_and_ping'],
-            ((None, u'valid@email', u'123456', ping), {}))
+        self.assertEqual(self.ui.overlay.show_counter, 1)
+        self.assert_backend_called('login_and_ping',
+            self.app_name, email, password, ping)
 
     def test_login_without_ping(self):
         """Test the login method."""
@@ -192,12 +198,14 @@
         self.patch(FakedObject, "exposed_methods", exposed_methods)
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
-        self.ui.ui.email_edit.setText('valid@email')
-        self.ui.ui.password_edit.setText('123456')
+        email = 'valid@email'
+        password = '123456'
+        self.ui.ui.email_edit.setText(email)
+        self.ui.ui.password_edit.setText(password)
         self.ui.login()
-        self.assertTrue('login' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['login'],
-            ((None, u'valid@email', u'123456'), {}))
+        self.assertEqual(self.ui.overlay.show_counter, 1)
+        self.assert_backend_called('login',
+            self.app_name, email, password)
 
     def test_on_login_error(self):
         """Test the on_login_error method."""
@@ -206,6 +214,7 @@
         self.ui.app_name = app_name
         error = {'errtype': 'UserNotValidated'}
         self.ui.on_login_error(app_name, error)
+        self.assertEqual(self.ui.overlay.hide_counter, 2)
         expected = ((self.ui, 'my_app', ''), {})
         self.assertTrue(expected, self._called)
 
@@ -221,7 +230,8 @@
             self.signals_results.append((app, email))
         self.ui.userLoggedIn.connect(slot)
         self.ui.on_logged_in(app_name, None)
-        self.assertTrue((app_name, email) in self.signals_results)
+        self.assertEqual(self.ui.overlay.hide_counter, 2)
+        self.assertIn((app_name, email), self.signals_results)
 
     def test_on_forgotten_password(self):
         """Test the on_forgotten_password method."""
@@ -231,7 +241,7 @@
             self.signals_results.append(1)
         self.ui.passwordForgotten.connect(slot)
         self.ui.on_forgotten_password()
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)
 
     def test_on_forgotten_password_link_clicked(self):
         """Test the on_forgotten_password method."""
@@ -241,4 +251,4 @@
             self.signals_results.append(1)
         self.ui.passwordForgotten.connect(slot)
         self.ui.ui.forgot_password_label.linkActivated.emit("link")
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)

=== modified file 'ubuntu_sso/qt/tests/test_email_verification.py'
--- ubuntu_sso/qt/tests/test_email_verification.py	2012-02-13 14:04:27 +0000
+++ ubuntu_sso/qt/tests/test_email_verification.py	2012-02-21 23:01:20 +0000
@@ -51,8 +51,8 @@
 
     def test_init(self):
         """Test the construction of the object."""
-        self.assertTrue('EmailValidated' in self.ui._signals)
-        self.assertTrue('EmailValidationError' in self.ui._signals)
+        self.assertIn('EmailValidated', self.ui._signals)
+        self.assertIn('EmailValidationError', self.ui._signals)
         self.assertTrue(callable(self.ui._signals['EmailValidated']))
         self.assertTrue(callable(self.ui._signals['EmailValidationError']))
         self.assertEqual(self.ui.backend, FakedBackend.sso_login)
@@ -70,8 +70,8 @@
         self.patch(self.ui, "_connect_ui_elements",
             faked_object._connect_ui_elements)
         self.ui.setup_page()
-        self.assertTrue('_setup_signals' in faked_object._called)
-        self.assertTrue('_connect_ui_elements' in faked_object._called)
+        self.assertIn('_setup_signals', faked_object._called)
+        self.assertIn('_connect_ui_elements', faked_object._called)
     # pylint: enable=E1101
 
     def test_verification_code(self):
@@ -166,7 +166,7 @@
             self.signals_results.append((app, email))
         self.ui.registrationSuccess.connect(slot)
         self.ui.on_email_validated(app_name)
-        self.assertTrue((app_name, email) in self.signals_results)
+        self.assertIn((app_name, email), self.signals_results)
 
     def test_validate_email_with_ping(self):
         """Test the login method."""
@@ -185,9 +185,8 @@
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
         self.ui.validate_email()
-        self.assertTrue('validate_email_and_ping' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['validate_email_and_ping'],
-            ((app_name, email, password, code, ping), {}))
+        self.assert_backend_called('validate_email_and_ping',
+            app_name, email, password, code, ping)
 
     def test_validate_email_without_ping(self):
         """Test the login method."""
@@ -206,6 +205,5 @@
         faked_object = FakedObject()
         self.patch(self.ui, "backend", faked_object)
         self.ui.validate_email()
-        self.assertTrue('validate_email' in self.ui.backend._called)
-        self.assertEqual(self.ui.backend._called['validate_email'],
-            ((app_name, email, password, code), {}))
+        self.assert_backend_called('validate_email',
+            app_name, email, password, code)

=== modified file 'ubuntu_sso/qt/tests/test_enhanced_check_box.py'
--- ubuntu_sso/qt/tests/test_enhanced_check_box.py	2012-02-02 15:57:02 +0000
+++ ubuntu_sso/qt/tests/test_enhanced_check_box.py	2012-02-21 23:01:20 +0000
@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-
-# Authors: Diego Sarmentero <[e-mail]>
 #
 # Copyright 2011 Canonical Ltd.
 #
@@ -18,8 +16,6 @@
 
 """Tests for the EnhancedCheckBox widget."""
 
-import re
-
 from PyQt4 import QtCore
 
 from ubuntu_sso.qt import enhanced_check_box
@@ -34,9 +30,6 @@
         check = enhanced_check_box.EnhancedCheckBox("text")
         self.assertEqual(check.text(), "text")
         self.assertTrue(check.text_label.openExternalLinks())
-        style_sheet = unicode(check.text_label.styleSheet())
-        size = re.sub("\D", "", style_sheet)
-        self.assertEqual(check.iconSize().width(), int(size))
         self.assertEqual(check.receivers(
             QtCore.SIGNAL('stateChanged(int)')), 1)
 

=== modified file 'ubuntu_sso/qt/tests/test_forgotten_password.py'
--- ubuntu_sso/qt/tests/test_forgotten_password.py	2012-02-13 21:50:16 +0000
+++ ubuntu_sso/qt/tests/test_forgotten_password.py	2012-02-21 23:01:20 +0000
@@ -25,6 +25,7 @@
     BaseTestCase,
     FakedBackend,
     FakedObject,
+    FakeOverlay,
     FakePageUiStyle,
     FakeSignal,
     FakeWizard,
@@ -40,23 +41,36 @@
     def setUp(self):
         yield super(ForgottenPasswordTestCase, self).setUp()
         self.signals_results = []
+        self.patch(gui, "LoadingOverlay", FakeOverlay)
+        self.patch(gui.main, "get_sso_client", FakedBackend)
         self.patch(forgotten_password_page.ForgottenPasswordPage,
             "passwordResetTokenSent", FakeSignal())
-        self.patch(gui.main, "get_sso_client", FakedBackend)
+        self.app_name = 'my_app'
         self.ui = forgotten_password_page.ForgottenPasswordPage(
             forgotten_password_ui.Ui_ForgottenPasswordPage(),
-            parent=None)
+            app_name=self.app_name, parent=None)
         self.wizard = FakeWizard()
         self.patch(self.ui, 'wizard', lambda: self.wizard)
 
     def test_init(self):
         """Test the construction of the object."""
-        self.assertTrue('PasswordResetTokenSent' in self.ui._signals)
-        self.assertTrue('PasswordResetError' in self.ui._signals)
+        self.assertIn('PasswordResetTokenSent', self.ui._signals)
+        self.assertIn('PasswordResetError', self.ui._signals)
         self.assertTrue(callable(self.ui._signals['PasswordResetTokenSent']))
         self.assertTrue(callable(self.ui._signals['PasswordResetError']))
         self.assertEqual(self.ui.backend, FakedBackend.sso_login)
 
+    def test_request_new_password(self):
+        """Test the request_new_password function."""
+        app_name = 'my_app'
+        email = '[e-mail]'
+        self.ui.app_name = app_name
+        self.ui.ui.email_line_edit.setText(email)
+        self.ui.request_new_password()
+        self.assertEqual(self.ui.overlay.show_counter, 1)
+        self.assert_backend_called('request_password_reset_token',
+            app_name, email)
+
     def test_setup_page(self):
         """Test that the backend is received and the methods are called."""
         exposed_methods = [
@@ -78,11 +92,11 @@
         self.patch(self.ui, "_register_fields",
             faked_object._register_fields)
         self.ui.setup_page()
-        self.assertTrue('_setup_signals' in faked_object._called)
-        self.assertTrue('_set_translated_strings' in faked_object._called)
-        self.assertTrue('_connect_ui' in faked_object._called)
-        self.assertTrue('_set_enhanced_line_edit' in faked_object._called)
-        self.assertTrue('_register_fields' in faked_object._called)
+        self.assertIn('_setup_signals', faked_object._called)
+        self.assertIn('_set_translated_strings', faked_object._called)
+        self.assertIn('_connect_ui', faked_object._called)
+        self.assertIn('_set_enhanced_line_edit', faked_object._called)
+        self.assertIn('_register_fields', faked_object._called)
 
     def test_email_widget(self):
         """Test the email_widget property."""
@@ -120,6 +134,12 @@
         self.assertEqual(value, self.ui.ui.send_button)
         self.assertTrue(isinstance(value, QtGui.QPushButton))
 
+    def test_send_button_clicked(self):
+        """Test the send_button property."""
+        self.ui.send_button.clicked.emit(True)
+        self.assert_backend_called('request_password_reset_token',
+            self.app_name, '')
+
     def test_try_again_widget(self):
         """Test the try_again_widget property."""
         value = self.ui.try_again_widget
@@ -211,6 +231,7 @@
             self.signals_results.append(1)
         self.ui.passwordResetTokenSent.connect(slot)
         self.ui.on_password_reset_token_sent('app_name', {})
+        self.assertEqual(self.ui.overlay.hide_counter, 2)
         self.assertTrue(1 in self.signals_results)
 
     def test_on_password_reset_error(self):
@@ -227,6 +248,7 @@
         self.assertFalse(self.ui.email_widget.isVisible())
         self.assertFalse(self.ui.forgotted_password_intro_label.isVisible())
         self.assertTrue(self.ui.try_again_widget.isVisible())
+        self.assertEqual(self.ui.overlay.hide_counter, 2)
 
     def test_on_password_reset_error_with_token_error(self):
         """Test on_password_reset_error method."""

=== modified file 'ubuntu_sso/qt/tests/test_network_detection.py'
--- ubuntu_sso/qt/tests/test_network_detection.py	2012-02-02 15:44:18 +0000
+++ ubuntu_sso/qt/tests/test_network_detection.py	2012-02-21 23:01:20 +0000
@@ -60,10 +60,8 @@
             "wizard", FakeWizardButtonStyle)
         self.network_detection.initializePage()
         self.assertTrue(self.network_detection.btn_try_again.isDefault())
-        self.assertTrue(
-            'polish' in self.network_detection.btn_try_again.data)
-        self.assertTrue(
-            'unpolish' in self.network_detection.btn_try_again.data)
+        self.assertIn('polish', self.network_detection.btn_try_again.data)
+        self.assertIn('unpolish', self.network_detection.btn_try_again.data)
         self.assertEqual(
             self.network_detection.btn_try_again.data['polish'],
             self.network_detection.btn_try_again)

=== modified file 'ubuntu_sso/qt/tests/test_reset_password.py'
--- ubuntu_sso/qt/tests/test_reset_password.py	2012-02-09 18:09:29 +0000
+++ ubuntu_sso/qt/tests/test_reset_password.py	2012-02-21 23:01:20 +0000
@@ -19,7 +19,6 @@
 
 from PyQt4 import QtGui, QtCore
 from twisted.internet import defer
-from twisted.trial.unittest import TestCase
 
 from ubuntu_sso.utils.ui import (
     PASSWORD1_ENTRY,
@@ -33,7 +32,12 @@
     RESET_TITLE,
 )
 from ubuntu_sso.qt.ui.reset_password_ui import Ui_ResetPasswordPage
-from ubuntu_sso.qt.tests import FakedBackend
+from ubuntu_sso.qt.tests import (
+    BaseTestCase,
+    FakedBackend,
+    FakedObject,
+    FakeWizard,
+)
 
 
 class FakePasswordAssistance(object):
@@ -50,52 +54,76 @@
         FakePasswordAssistance._called = False
 
 
-class ResetPasswordTestCase(TestCase):
+# We need this Fake until a future refactor.
+class FakeForgottenPage(object):
+
+    """Fake Forgotten Page."""
+
+    def __init__(self):
+        self.ui = self
+        self.email_line_edit = self
+        self.line_text = ''
+
+    # pylint: disable=C0103
+    def setText(self, text):
+        """Fake setText for Line edit."""
+        self.line_text = text
+    # pylint: enable=C0103
+
+    def text(self):
+        """Fake text for line edit."""
+        return self.line_text
+
+
+class ResetPasswordTestCase(BaseTestCase):
     """Test the ResetPasswordPage code."""
 
     @defer.inlineCallbacks
     def setUp(self):
         yield super(ResetPasswordTestCase, self).setUp()
         self.patch(gui.main, "get_sso_client", FakedBackend)
-        self.page = ResetPasswordPage(Ui_ResetPasswordPage(),
-                                                'app_name',
-                                                None)
+        self.app_name = 'my_app'
+        self.ui = ResetPasswordPage(Ui_ResetPasswordPage(),
+                                                app_name=self.app_name,
+                                                parent=None)
+        self.wizard = FakeWizard()
+        self.patch(self.ui, 'wizard', lambda: self.wizard)
         self.fake = FakePasswordAssistance()
 
     def test_init(self):
         """Check the initial state of ResetPassword."""
-        self.assertEqual(self.page.ui.password_line_edit.receivers(
+        self.assertEqual(self.ui.ui.password_line_edit.receivers(
             QtCore.SIGNAL('textEdited(QString)')), 1)
-        self.assertEqual(self.page.ui.confirm_password_line_edit.receivers(
+        self.assertEqual(self.ui.ui.confirm_password_line_edit.receivers(
             QtCore.SIGNAL('textEdited(QString)')), 1)
 
     def test_initialize(self):
         """Check the Title and Subtitle."""
-        self.page.show()
-        self.page.initializePage()
-        self.addCleanup(self.page.hide)
-        self.assertEqual(self.page.header.title_label.text(), RESET_TITLE)
-        self.assertEqual(self.page.header.subtitle_label.text(),
+        self.ui.show()
+        self.ui.initializePage()
+        self.addCleanup(self.ui.hide)
+        self.assertEqual(self.ui.header.title_label.text(), RESET_TITLE)
+        self.assertEqual(self.ui.header.subtitle_label.text(),
             RESET_SUBTITLE)
-        self.assertEqual(self.page.ui.password_label.text(), PASSWORD1_ENTRY)
-        self.assertEqual(self.page.ui.confirm_password_label.text(),
+        self.assertEqual(self.ui.ui.password_label.text(), PASSWORD1_ENTRY)
+        self.assertEqual(self.ui.ui.confirm_password_label.text(),
             PASSWORD2_ENTRY)
-        self.assertEqual(self.page.ui.reset_code.text(), RESET_CODE_ENTRY)
+        self.assertEqual(self.ui.ui.reset_code.text(), RESET_CODE_ENTRY)
 
     def test_focus_changed_password_visibility(self):
         """Check visibility changes when focus_changed() is executed."""
-        self.page.show()
-        self.addCleanup(self.page.hide)
-        self.page.focus_changed(None, self.page.ui.password_line_edit)
-        self.assertTrue(self.page.ui.password_assistance.isVisible())
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        self.ui.focus_changed(None, self.ui.ui.password_line_edit)
+        self.assertTrue(self.ui.ui.password_assistance.isVisible())
 
     def test_show_hide_event(self):
         """Check connections to focusChanged on show and hide event."""
-        self.page.show()
-        self.addCleanup(self.page.hide)
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
         self.assertEqual(QtGui.QApplication.instance().receivers(
             QtCore.SIGNAL("focusChanged(QWidget*, QWidget*)")), 1)
-        self.page.hide()
+        self.ui.hide()
         self.assertEqual(QtGui.QApplication.instance().receivers(
             QtCore.SIGNAL("focusChanged(QWidget*, QWidget*)")), 0)
 
@@ -105,22 +133,40 @@
         """Check functions execution when focus_changed() is executed."""
         self.patch(common, 'password_default_assistance', self.fake.call)
         self.addCleanup(self.fake.clenaup)
-        self.page.show()
-        self.addCleanup(self.page.hide)
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
         self.assertFalse(FakePasswordAssistance._called)
-        self.page.focus_changed(None, self.page.ui.password_line_edit)
-        self.assertTrue(self.page.ui.password_assistance.isVisible())
+        self.ui.focus_changed(None, self.ui.ui.password_line_edit)
+        self.assertTrue(self.ui.ui.password_assistance.isVisible())
         self.assertTrue(FakePasswordAssistance._called)
 
     def test_focus_changed_2(self):
         """Check functions execution when focus_changed() is executed."""
         self.patch(common, 'password_check_match', self.fake.call)
         self.addCleanup(self.fake.clenaup)
-        self.page.show()
-        self.addCleanup(self.page.hide)
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
         self.assertFalse(FakePasswordAssistance._called)
-        self.page.focus_changed(None, self.page.ui.confirm_password_line_edit)
-        self.assertTrue(self.page.ui.password_assistance.isVisible())
+        self.ui.focus_changed(None, self.ui.ui.confirm_password_line_edit)
+        self.assertTrue(self.ui.ui.password_assistance.isVisible())
         self.assertTrue(FakePasswordAssistance._called)
 
     # pylint: enable=W0212
+
+    def test_set_new_password(self):
+        """Test set_new_password method."""
+        email = '[e-mail]'
+        code = 'code'
+        password = 'password'
+        forgotten = FakeForgottenPage()
+        forgotten.setText(email)
+        self.patch(self.wizard, "forgotten", forgotten)
+        exposed_methods = ['set_new_password']
+        self.patch(FakedObject, "exposed_methods", exposed_methods)
+        faked_object = FakedObject()
+        self.patch(self.ui, "backend", faked_object)
+        self.ui.ui.reset_code_line_edit.setText(code)
+        self.ui.ui.password_line_edit.setText(password)
+        self.ui.set_new_password()
+        self.assert_backend_called('set_new_password',
+            self.app_name, email, code, password)

=== modified file 'ubuntu_sso/qt/tests/test_setup_account.py'
--- ubuntu_sso/qt/tests/test_setup_account.py	2012-02-10 21:09:38 +0000
+++ ubuntu_sso/qt/tests/test_setup_account.py	2012-02-21 23:01:20 +0000
@@ -44,11 +44,13 @@
         self.signals_results = []
         self.patch(setup_account_page.SetupAccountPage,
             "userRegistered", FakeSignal())
+        self.app_name = 'my_app'
         self.ui = setup_account_page.SetupAccountPage(
             setup_account_ui.Ui_SetUpAccountPage(),
             'subtitle',
             'toc_link',
             'policy_link',
+            app_name=self.app_name,
             parent=None)
         self.wizard = FakeWizard()
         self.patch(self.ui, 'wizard', lambda: self.wizard)
@@ -75,6 +77,41 @@
             setup_account_page.ERROR % setup_account_page.EMPTY_NAME)
         self.ui.hide()
 
+    def test_enable_setup_button_with_visible_check(self):
+        """Test _enable_setup_button method with terms check visible."""
+        self.ui.ui.name_edit.setText('name')
+        email = '[e-mail]'
+        self.ui.ui.email_edit.setText(email)
+        self.ui.ui.confirm_email_edit.setText(email)
+        password = 'T3st3rqwe'
+        self.ui.ui.password_edit.setText(password)
+        self.ui.ui.confirm_password_edit.setText(password)
+        self.ui.ui.captcha_solution_edit.setText('captcha solution')
+        self.ui.terms_checkbox.setChecked(True)
+
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        self.ui.terms_checkbox.setVisible(True)
+        self.ui.ui.captcha_solution_edit.textEdited.emit('')
+        self.assertTrue(self.ui.set_up_button.isEnabled())
+
+    def test_enable_setup_button_without_visible_check(self):
+        """Test _enable_setup_button method with terms check not visible."""
+        self.ui.ui.name_edit.setText('name')
+        email = '[e-mail]'
+        self.ui.ui.email_edit.setText(email)
+        self.ui.ui.confirm_email_edit.setText(email)
+        password = 'T3st3rqwe'
+        self.ui.ui.password_edit.setText(password)
+        self.ui.ui.confirm_password_edit.setText(password)
+        self.ui.ui.captcha_solution_edit.setText('captcha solution')
+
+        self.ui.show()
+        self.addCleanup(self.ui.hide)
+        self.ui.terms_checkbox.setVisible(False)
+        self.ui.ui.captcha_solution_edit.textEdited.emit('')
+        self.assertTrue(self.ui.set_up_button.isEnabled())
+
     def test_password_default_assistance(self):
         """Status when the password line edit receive focus and shows popup.
 
@@ -155,7 +192,10 @@
             self.signals_results.append((email, password))
         self.ui.userRegistered.connect(slot)
         self.ui.set_next_validation()
-        self.assertTrue((email, password) in self.signals_results)
+        self.assertIn((email, password), self.signals_results)
+        self.assert_backend_called('register_user',
+            self.app_name, email, password, name, captcha_id,
+            captcha_solution)
 
     def test_set_next_validation(self):
         """Test on_user_registered method."""
@@ -169,7 +209,13 @@
             self.signals_results.append((email, password))
         self.ui.userRegistered.connect(slot)
         self.ui.on_user_registered('app_name', None)
-        self.assertTrue((email, password) in self.signals_results)
+        self.assertIn((email, password), self.signals_results)
+
+    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',
+            self.app_name, self.ui.captcha_file)
 
 
 class SetupAccountFakeWizardTestCase(BaseTestCase):
@@ -221,7 +267,8 @@
         self.assertFalse(self.ui.captcha_received)
 
         # labels
-        self.assertEqual(self.ui.ui.name_label.text(), setup_account_page.NAME)
+        self.assertEqual(self.ui.ui.name_label.text(),
+                         setup_account_page.NAME_ENTRY)
         self.assertEqual(self.ui.ui.email_label.text(),
             setup_account_page.EMAIL)
         self.assertEqual(self.ui.ui.confirm_email_label.text(),

=== modified file 'ubuntu_sso/qt/tests/test_sign_in_page.py'
--- ubuntu_sso/qt/tests/test_sign_in_page.py	2012-02-10 21:09:38 +0000
+++ ubuntu_sso/qt/tests/test_sign_in_page.py	2012-02-21 23:01:20 +0000
@@ -55,7 +55,7 @@
             self.signals_results.append(1)
         self.ui.existingAccountSelected.connect(slot)
         self.ui._set_next_existing()
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)
 
     def test_set_next_new(self):
         """Test _set_next_existing method."""
@@ -65,5 +65,5 @@
             self.signals_results.append(1)
         self.ui.newAccountSelected.connect(slot)
         self.ui._set_next_new()
-        self.assertTrue(1 in self.signals_results)
+        self.assertIn(1, self.signals_results)
     # pylint: enable=W0212

=== modified file 'ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-02-13 20:37:57 +0000
+++ ubuntu_sso/qt/tests/test_ubuntu_sso_wizard.py	2012-02-21 23:01:20 +0000
@@ -89,6 +89,6 @@
         self.ui.show()
         self.addCleanup(self.ui.hide)
         self.ui.sign_in_page.ui.cancel_button.clicked.emit(True)
-        self.assertTrue('close' in faked_object._called)
-        self.assertTrue('reject' not in faked_object._called)
+        self.assertIn('close', faked_object._called)
+        self.assertNotIn('reject', faked_object._called)
     # pylint: enable=W0212, E1101

=== modified file 'ubuntu_sso/qt/ubuntu_sso_wizard.py'
--- ubuntu_sso/qt/ubuntu_sso_wizard.py	2012-02-14 18:42:00 +0000
+++ ubuntu_sso/qt/ubuntu_sso_wizard.py	2012-02-21 23:01:20 +0000
@@ -151,6 +151,7 @@
         self.setWizardStyle(QWizard.ModernStyle)
         self.button(QWizard.CancelButton).clicked.connect(
                                                     self.on_user_cancelation)
+        self.resize(550, 500)
 
     # pylint: disable=C0103
     def nextId(self):

=== modified file 'ubuntu_sso/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2012-02-10 17:18:22 +0000
+++ ubuntu_sso/tests/__init__.py	2012-02-21 23:01:20 +0000
@@ -26,20 +26,20 @@
 
 from ubuntu_sso.keyring import get_token_name
 
-APP_NAME = u'The Super App!'
+APP_NAME = u'I ♥ Ubuntu'
 CAPTCHA_ID = u'test ñiña'
 CAPTCHA_PATH = os.path.abspath(os.path.join(os.curdir, 'ubuntu_sso', 'tests',
                                             'files', 'captcha.png'))
 CAPTCHA_SOLUTION = u'william Byrd ñandú'
 EMAIL = u'[e-mail]'
-EMAIL_TOKEN = u'B2Pgtf'
+EMAIL_TOKEN = u'B2P☺ gtf'
 GTK_GUI_EXE = 'ubuntu-sso-login-gtk'
-HELP_TEXT = """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'
+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/'
 POLICY_URL = u'http://localhost/policy/'
 RESET_PASSWORD_TOKEN = u'8G5Wtq'

=== modified file 'ubuntu_sso/utils/__init__.py'
--- ubuntu_sso/utils/__init__.py	2012-02-11 19:25:01 +0000
+++ ubuntu_sso/utils/__init__.py	2012-02-21 23:01:20 +0000
@@ -54,9 +54,11 @@
 
     # otherwise, try to load 'dir_constant' from installation path
     try:
+        # Unused variable 'ubuntu_sso', pylint: disable=W0612, F0401, E0611
+        import ubuntu_sso.constants
         module = sys.modules.get('ubuntu_sso.constants')
         return getattr(module, dir_constant)
-    except AttributeError:
+    except (ImportError, AttributeError):
         msg = '_get_dir: can not build a valid path. Giving up. ' \
               '__file__ is %r, constants module not available.'
         logger.error(msg, __file__)
@@ -69,7 +71,9 @@
     found, return the value of the PROJECT_DIR.
 
     """
-    return _get_dir(dir_name=DATA_SUFFIX, dir_constant='PROJECT_DIR')
+    result = _get_dir(dir_name=DATA_SUFFIX, dir_constant='PROJECT_DIR')
+    assert result is not None, '%r dir can not be None.' % DATA_SUFFIX
+    return result
 
 
 def get_data_file(*args):
@@ -84,7 +88,9 @@
     found, return the value of the BIN_DIR.
 
     """
-    return _get_dir(dir_name=BIN_SUFFIX, dir_constant='BIN_DIR')
+    result = _get_dir(dir_name=BIN_SUFFIX, dir_constant='BIN_DIR')
+    assert result is not None, '%r dir can not be None.' % BIN_SUFFIX
+    return result
 
 
 class RequestHead(urllib2.Request):

=== modified file 'ubuntu_sso/utils/runner/glib.py'
--- ubuntu_sso/utils/runner/glib.py	2012-02-10 17:03:56 +0000
+++ ubuntu_sso/utils/runner/glib.py	2012-02-21 23:01:20 +0000
@@ -27,7 +27,7 @@
 logger = setup_logging("ubuntu_sso.utils.runner.glib")
 
 
-NO_SUCH_FILE_OR_DIR = '(No such file or directory)'
+NO_SUCH_FILE_OR_DIR = 'No such file or directory'
 
 
 def spawn_program(args, reply_handler, error_handler):
@@ -66,8 +66,17 @@
             GLib.SpawnFlags.STDOUT_TO_DEV_NULL | \
             GLib.SpawnFlags.STDERR_TO_DEV_NULL
     pid = None
+
+    bytes_args = []
+    for arg in args:
+        if isinstance(arg, unicode):
+            arg = arg.encode('utf-8')
+        if not isinstance(arg, basestring):
+            arg = str(arg)
+        bytes_args.append(arg)
+
     try:
-        pid, _, _, _ = GLib.spawn_async(argv=args, flags=flags)
+        pid, _, _, _ = GLib.spawn_async(argv=bytes_args, flags=flags)
     except GLib.GError, e:
         handle_error(e)
     else:

=== added file 'ubuntu_sso/utils/runner/tests/test_glib.py'
--- ubuntu_sso/utils/runner/tests/test_glib.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/tests/test_glib.py	2012-02-21 23:01:20 +0000
@@ -0,0 +1,132 @@
+# -*- 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/>.
+
+"""Tests for the glib runner helper module."""
+
+import subprocess
+
+# pylint: disable=E0611
+from gi.repository import GLib
+# pylint: enable=E0611
+from twisted.internet import defer
+
+from ubuntu_sso.utils import runner
+from ubuntu_sso.utils.runner import glib
+from ubuntu_sso.utils.runner.tests.test_runner import SpawnProgramTestCase
+
+
+class FakedSignal(object):
+    """Fake a glib signal."""
+
+    def __init__(self, name):
+        self.name = name
+        self._handlers = []
+
+    def connect(self, handler):
+        """Connect 'handler' with this signal."""
+        self._handlers.append(handler)
+
+    def emit(self, *args, **kwargs):
+        """Emit this signal."""
+        for handler in self._handlers:
+            handler(*args, **kwargs)
+
+
+class FakedProcess(object):
+    """Fake a glib Process."""
+
+    _argv = _flags = None
+    _pid = 123456
+    _pids = []
+    _status_code = 0
+
+    SpawnFlags = GLib.SpawnFlags
+    GError = GLib.GError
+
+    def __init__(self):
+        self.pid = lambda: self._pid
+        self.started = FakedSignal('started')
+        self.finished = FakedSignal('finished')
+        self.error = FakedSignal('error')
+
+    def spawn_async(self, argv, flags):
+        """Spwan a process."""
+        if 'None' in argv:
+            exc = GLib.GError()
+            exc.message = str('Can not handle None')
+            exc.code = 24
+            raise exc
+
+        self._argv = argv
+        self._flags = flags
+
+        try:
+            subprocess.call(argv)
+        except Exception, e:
+            exc = GLib.GError()
+            exc.message = str(e)
+            exc.code = 42
+            raise exc
+
+        self._pids.append(self._pid)
+        return (self._pid, None, None, None)
+
+    def child_watch_add(self, pid, child_watch):
+        """Addd a child watch."""
+        if pid in self._pids:
+            child_watch(pid, self._status_code)
+
+    def spawn_close_pid(self, pid):
+        """Close the 'pid'."""
+        self._pids.remove(pid)
+
+
+class GLibSpawnProgramTestCase(SpawnProgramTestCase):
+    """The test suite for the spawn_program method (using GLib)."""
+
+    use_reactor = False
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(GLibSpawnProgramTestCase, self).setUp()
+        # Since we can't mix plan glib runner and the gireactor, we patch
+        # GLib.spawn_async and fake the conditions so the glib runner is chosen
+        self.process = FakedProcess()
+        self.patch(glib, 'GLib', self.process)
+        self.patch(runner, 'is_twisted_reactor_installed', lambda: False)
+        self.patch(runner, 'is_qt4_main_loop_installed', lambda: False)
+
+    # Access to a protected member _flags, _argv of a client class
+    # pylint: disable=W0212
+
+    @defer.inlineCallbacks
+    def test_flags_are_correct(self):
+        """The flags are the correct ones."""
+        yield self.spawn_fn(self.args)
+
+        flags = GLib.SpawnFlags.DO_NOT_REAP_CHILD | \
+                GLib.SpawnFlags.SEARCH_PATH | \
+                GLib.SpawnFlags.STDOUT_TO_DEV_NULL | \
+                GLib.SpawnFlags.STDERR_TO_DEV_NULL
+        self.assertEqual(self.process._flags, flags)
+
+    @defer.inlineCallbacks
+    def test_argv_is_bytes(self):
+        """The argv parameter is converted to bytes."""
+        yield self.spawn_fn(self.args)
+
+        bytes_args = [a.encode('utf-8') for a in self.args]
+        self.assertEqual(self.process._argv, bytes_args)

=== modified file 'ubuntu_sso/utils/runner/tests/test_qt.py'
--- ubuntu_sso/utils/runner/tests/test_qt.py	2012-02-10 15:44:28 +0000
+++ ubuntu_sso/utils/runner/tests/test_qt.py	2012-02-21 23:01:20 +0000
@@ -64,8 +64,16 @@
             self.started.emit()
 
             args = (program,) + tuple(arguments)
+
+            # subprocess expects bytes
+            bytes_args = []
+            for arg in args:
+                if isinstance(arg, unicode):
+                    arg = arg.encode('utf-8')
+                bytes_args.append(arg)
+
             try:
-                subprocess.call(args)
+                subprocess.call(bytes_args)
             except OSError, e:
                 if e.errno == 2:
                     self.error.emit(self.FailedToStart)

=== modified file 'ubuntu_sso/utils/runner/tests/test_runner.py'
--- ubuntu_sso/utils/runner/tests/test_runner.py	2012-02-08 02:13:03 +0000
+++ ubuntu_sso/utils/runner/tests/test_runner.py	2012-02-21 23:01:20 +0000
@@ -24,21 +24,23 @@
 from ubuntu_sso.utils import runner
 
 
-TEST_ME_DIR = 'test-me'
+TEST_ME_DIR = u'test-me-more-♥'
+TEST_ME_DIR_BYTES = TEST_ME_DIR.encode('utf-8')
 
 
 class SpawnProgramTestCase(TestCase):
     """The test suite for the spawn_program method."""
 
     timeout = 3
-    args = ('python', '-c', 'import os; os.system("mkdir %s")' % TEST_ME_DIR)
+    args = (u'python', u'-c',
+            u'import os; os.system("mkdir %s")' % TEST_ME_DIR)
 
     @defer.inlineCallbacks
     def setUp(self):
         yield super(SpawnProgramTestCase, self).setUp()
-        assert not os.path.exists(TEST_ME_DIR)
-        self.addCleanup(lambda: os.path.exists(TEST_ME_DIR) and
-                                os.rmdir(TEST_ME_DIR))
+        assert not os.path.exists(TEST_ME_DIR_BYTES)
+        self.addCleanup(lambda: os.path.exists(TEST_ME_DIR_BYTES) and
+                                os.rmdir(TEST_ME_DIR_BYTES))
 
     def spawn_fn(self, args):
         """The target function to test."""
@@ -46,8 +48,8 @@
 
     def assert_command_was_run(self):
         """The spawnned commnad was correctly run."""
-        self.assertTrue(os.path.exists(TEST_ME_DIR))
-        self.assertTrue(os.path.isdir(TEST_ME_DIR))
+        self.assertTrue(os.path.exists(TEST_ME_DIR_BYTES))
+        self.assertTrue(os.path.isdir(TEST_ME_DIR_BYTES))
 
     @defer.inlineCallbacks
     def test_program_is_spawned(self):

=== modified file 'ubuntu_sso/utils/runner/tx.py'
--- ubuntu_sso/utils/runner/tx.py	2012-02-08 18:29:39 +0000
+++ ubuntu_sso/utils/runner/tx.py	2012-02-21 23:01:20 +0000
@@ -68,6 +68,14 @@
     program = args[0]
     argv = args[1:]
 
+    bytes_args = []
+    for arg in argv:
+        if isinstance(arg, unicode):
+            arg = arg.encode('utf-8')
+        if not isinstance(arg, basestring):
+            arg = str(arg)
+        bytes_args.append(arg)
+
     if program and not os.access(program, os.X_OK):
         # handle searching the executable in the PATH, since
         # twisted will not solve that for us :-/
@@ -81,7 +89,7 @@
                 break
 
     try:
-        d = utils.getProcessOutputAndValue(program, argv, env=os.environ)
+        d = utils.getProcessOutputAndValue(program, bytes_args, env=os.environ)
     except OSError, e:
         error_handler(msg=e, failed_to_start=True)
     except Exception, e:

=== modified file 'ubuntu_sso/utils/tests/test_common.py'
--- ubuntu_sso/utils/tests/test_common.py	2012-02-11 19:25:01 +0000
+++ ubuntu_sso/utils/tests/test_common.py	2012-02-21 23:01:20 +0000
@@ -124,8 +124,7 @@
         self.patch(utils.os.path, 'exists', lambda path: False)
         sys.modules[CONSTANTS_MODULE] = None
 
-        result = self.get_dir()
-        self.assertTrue(result is None)
+        self.assertRaises(AssertionError, self.get_dir)
         msg = 'get_dir: can not build a valid path.'
         self.assertTrue(self.memento.check_error(msg))
 

=== modified file 'ubuntu_sso/utils/ui.py'
--- ubuntu_sso/utils/ui.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/utils/ui.py	2012-02-21 23:01:20 +0000
@@ -21,11 +21,12 @@
 
 from ubuntu_sso.logger import setup_logging
 
+
+gettext.install('ubuntu-sso-client', unicode=True)
 logger = setup_logging('ubuntu_sso.utils.ui')
 
 
-gettext.textdomain('ubuntu-sso-client')
-_ = gettext.gettext
+# Undefined variable '_', pylint: disable=E0602
 
 # all the text that is used in the gui
 AGREE_TO_PRIVACY_POLICY = _('By signing up to {app_name} you agree to '
@@ -33,11 +34,13 @@
 AGREE_TO_TERMS = _('By signing up to {app_name} you agree to '
     'our {terms_and_conditions}')
 AGREE_TO_TERMS_AND_PRIVACY_POLICY = AGREE_TO_TERMS + _(' and {privacy_policy}')
+CANCEL_BUTTON = _('Cancel')
 CAPTCHA_SOLUTION_ENTRY = _('Type the characters above')
 CAPTCHA_LOAD_ERROR = _('There was a problem getting the captcha, '
                        'reloading...')
 CAPTCHA_RELOAD_TOOLTIP = _('Reload')
 CAPTCHA_REQUIRED_ERROR = _('The captcha is a required field')
+CLOSE_AND_SETUP_LATER = _('Close window and setup later')
 CONGRATULATIONS = _("Congratulations, {app_name} is installed!")
 PROXY_CREDS_DIALOG_TITLE = _('Add proxy settings')
 PROXY_CREDS_HEADER = _('You are connecting through a proxy.')
@@ -76,10 +79,10 @@
 LOGIN_HEADER_LABEL = _('Connect to %(app_name)s')
 LOGIN_PASSWORD_ENTRY = _('Password')
 LOGIN_PASSWORD_LABEL = LOGIN_PASSWORD_ENTRY
-NAME = _("Name")
 NAME_ENTRY = _('Name')
 NAME_INVALID = _('The name must not be empty.')
 NEXT = _('Next')
+NETWORK_DETECTION_TITLE = _('Network detection')
 ONE_MOMENT_PLEASE = _('One moment please...')
 PASSWORD = _("Create a password")
 PASSWORD_CHANGED = _('Your password was successfully changed.')
@@ -140,6 +143,8 @@
 YES_TO_TC = _('I agree with the %(app_name)s terms and conditions')
 YES_TO_UPDATES = _('Yes! Email me %(app_name)s tips and updates.')
 
+# pylint: enable=E0602
+
 
 def get_password_strength(password):
     """Return the strength of the password.