Merge lp:~nataliabidart/ubuntu-sso-client/fix-933632 into lp:ubuntu-sso-client

[Natalia Bidart]

- Make gettext return unicode strings. Also, transform arguments passed to
  the GLib spawnner to bytes (LP: #933632).

[Eric Casteleijn (thisfred)]

Looks good, great that the tests use unicode characters, nice incremental refactorings.

review: Approve

[Roberto Alsina (ralsina)]

Looks good to me!

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~nataliabidart/ubuntu-sso-client/fix-933632 into lp:ubuntu-sso-client 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_nm_state_asleep ... ...

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~nataliabidart/ubuntu-sso-client/fix-933632 into lp:ubuntu-sso-client 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_nm_state_asleep ... ...

[lp:~nataliabidart/ubuntu-sso-client/fix-933632]

884. By Natalia Bidart on 2012-02-18

Adapting mock so it works with LANG=C.

=== modified file 'setup.py'
--- setup.py	2012-02-14 20:49:45 +0000
+++ setup.py	2012-02-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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/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-18 14:14:18 +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):

=== 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-18 14:14:18 +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/current_user_sign_in_page.py'
--- ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-14 14:38:23 +0000
+++ ubuntu_sso/qt/current_user_sign_in_page.py	2012-02-18 14:14:18 +0000
@@ -16,7 +16,6 @@
 
 """Page to allow the user to login into Ubuntu Single Sign On."""
 
-import gettext
 from functools import partial
 
 from PyQt4 import QtGui, QtCore
@@ -27,6 +26,7 @@
 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,
@@ -38,7 +38,6 @@
 FORGOTTEN_PASSWORD_LINK_STYLE = '<a href="#">{forgotten_text}</a>'
 
 
-_ = gettext.gettext
 logger = setup_logging('ubuntu_sso.current_user_sign_in_page')
 
 
@@ -87,8 +86,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([

=== modified file 'ubuntu_sso/qt/gui.py'
--- ubuntu_sso/qt/gui.py	2012-02-14 14:38:23 +0000
+++ ubuntu_sso/qt/gui.py	2012-02-18 14:14:18 +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
@@ -40,7 +39,6 @@
 from ubuntu_sso.utils.ui import GENERIC_BACKEND_ERROR
 
 
-_ = gettext.gettext
 logger = setup_logging('ubuntu_sso.gui')
 
 

=== 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-18 14:14:18 +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/setup_account_page.py'
--- ubuntu_sso/qt/setup_account_page.py	2012-02-15 17:33:40 +0000
+++ ubuntu_sso/qt/setup_account_page.py	2012-02-18 14:14:18 +0000
@@ -55,7 +55,6 @@
     is_min_required_password,
     is_correct_email,
     JOIN_HEADER_LABEL,
-    NAME,
     NAME_ENTRY,
     NAME_INVALID,
     PASSWORD,
@@ -177,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)
@@ -200,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)

=== 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-18 14:14:18 +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/test_setup_account.py'
--- ubuntu_sso/qt/tests/test_setup_account.py	2012-02-16 14:37:19 +0000
+++ ubuntu_sso/qt/tests/test_setup_account.py	2012-02-18 14:14:18 +0000
@@ -232,7 +232,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/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2012-02-10 17:18:22 +0000
+++ ubuntu_sso/tests/__init__.py	2012-02-18 14:14:18 +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/runner/glib.py'
--- ubuntu_sso/utils/runner/glib.py	2012-02-10 17:03:56 +0000
+++ ubuntu_sso/utils/runner/glib.py	2012-02-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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-18 14:14:18 +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/ui.py'
--- ubuntu_sso/utils/ui.py	2012-02-13 20:27:48 +0000
+++ ubuntu_sso/utils/ui.py	2012-02-18 14:14:18 +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.