Merge lp:~nataliabidart/ubuntu-sso-client/run-that-ui into lp:ubuntu-sso-client

[Natalia Bidart]

- Execute the UI as a separated process from the sso main thread
  (LP: #919330).

This branch provides the ability to run UIs in a separate process.

To test it IRL in Linux, you should do the following twice (one for the glib spawner, one for the Qt one):

* remove your U1 token
* run the sso service:
  GLib -> U1_DEBUG=True PATH=bin/:$PATH PYTHONPATH=. bin/ubuntu-sso-login
  Qt -> USE_QT_MAINLOOP=True U1_DEBUG=True PATH=bin/:$PATH PYTHONPATH=. bin/ubuntu-sso-login
* open the Ubuntu One Control Panel and login/register/retrieve password/etc (be careful that the sso service will shutdown itself if unused, re run if necessary)
* profit

Please note that we still have to code a fix for bug #930137.

[lp:~nataliabidart/ubuntu-sso-client/run-that-ui]

858. By Natalia Bidart on 2012-02-10

Merged updates from dependency branch.

859. By Natalia Bidart on 2012-02-10

Merged trunk in.

860. By Natalia Bidart on 2012-02-10

Avoig having double escapes on arguments.

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[Roberto Alsina (ralsina)]

+1 looks good to me

review: Approve

=== modified file 'ubuntu_sso/__init__.py'
--- ubuntu_sso/__init__.py	2010-10-07 21:09:01 +0000
+++ ubuntu_sso/__init__.py	2012-02-10 17:15:32 +0000
@@ -29,3 +29,7 @@
 DBUS_CREDENTIALS_IFACE = "com.ubuntu.sso.CredentialsManagement"
 
 NO_OP = lambda *args, **kwargs: None
+
+# return code for UIs
+USER_SUCCESS = 0
+USER_CANCELLATION = 10

=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2012-02-09 21:57:15 +0000
+++ ubuntu_sso/credentials.py	2012-02-10 17:15:32 +0000
@@ -23,27 +23,22 @@
  * register
  * login
 
-The first three return a Deferred that will be fired when the operation was
+All the methods return a Deferred that will be fired when the operation was
 completed.
 
-The second two use the 'success_cb', 'error_cb' and 'denial_cb' to signal the
-caller when the credentials were retrieved successfully, when there was an
-error or when the user denied the access to the application, respectively.
-
 For details, please read the Credentials class documentation.
 
 """
 
-import sys
-import traceback
-
 from functools import wraps
 
 from twisted.internet import defer
 
-from ubuntu_sso import NO_OP
+from ubuntu_sso import USER_CANCELLATION, USER_SUCCESS
 from ubuntu_sso.keyring import Keyring
 from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.utils import runner
+
 
 logger = setup_logging('ubuntu_sso.credentials')
 
@@ -53,44 +48,19 @@
 HELP_TEXT_KEY = 'help_text'
 WINDOW_ID_KEY = 'window_id'
 PING_URL_KEY = 'ping_url'
-UI_MODULE_KEY = 'ui_module'
-UI_CLASS_KEY = 'ui_class'
-SUCCESS_CB_KEY = 'success_cb'
-ERROR_CB_KEY = 'error_cb'
-DENIAL_CB_KEY = 'denial_cb'
-ERROR_KEY = 'error_message'
-ERROR_DETAIL_KEY = 'detailed_error'
-
-
-def handle_exceptions(msg):
-    """Handle exceptions using 'msg' as error message."""
-
-    def middle(f):
-        """Decorate 'f' to catch all errors."""
-
-        @wraps(f)
-        def inner(self, *a, **kw):
-            """Call 'f' within a try-except block.
-
-            If any exception occurs, self.error_cb is called and the exception
-            is logged.
-            """
-            result = None
-            try:
-                result = f(self, *a, **kw)
-            except:  # pylint: disable=W0702
-                logger.exception('%s (app_name: %s): %s.',
-                                 f.__name__, self.app_name, msg)
-                logger.error('%s (app_name: %s): Calling error_cb at %r.',
-                                 f.__name__, self.app_name, self.error_cb)
-                error_dict = {ERROR_KEY: msg,
-                              ERROR_DETAIL_KEY: traceback.format_exc()}
-                self.error_cb(error_dict)
-            return result
-
-        return inner
-
-    return middle
+UI_EXECUTABLE_KEY = 'ui_executable'
+
+
+class CredentialsError(Exception):
+    """Generic credentials error."""
+
+
+class UserCancellationError(CredentialsError):
+    """The user cancelled the process of authentication."""
+
+
+class UserNotValidatedError(CredentialsError):
+    """The user is not validated."""
 
 
 def handle_failures(msg):
@@ -104,20 +74,17 @@
         def inner(self, *a, **kw):
             """Call 'f' within a try-except block.
 
-            If any exception occurs, self.error_cb is called and the exception
-            is logged.
+            If any exception occurs, the exception is logged and re-raised.
+
             """
             result = None
             try:
                 result = yield f(self, *a, **kw)
-            except Exception:  # pylint: disable=W0703
+            except:
                 logger.exception('%s (app_name: %s): %s.',
                                  f.__name__, self.app_name, msg)
-                logger.error('%s (app_name: %s): Calling error_cb at %r.',
-                                 f.__name__, self.app_name, self.error_cb)
-                error_dict = {ERROR_KEY: msg,
-                              ERROR_DETAIL_KEY: traceback.format_exc()}
-                self.error_cb(error_dict)
+                raise
+
             defer.returnValue(result)
 
         return inner
@@ -130,13 +97,12 @@
 
     def __init__(self, app_name, tc_url=None, help_text='',
                  window_id=0, ping_url=None,
-                 ui_module='ubuntu_sso.gtk.gui', ui_class='UbuntuSSOClientGUI',
-                 success_cb=NO_OP, error_cb=NO_OP, denial_cb=NO_OP):
+                 ui_executable='ubuntu-sso-login-gtk'):
         """Return a Credentials management object.
 
         'app_name' is the application name to be displayed in the GUI.
 
-        'tc_url' is the URL pointing to Terms & Conditions. If None, no
+        'tc_url' is the url pointing to Terms & Conditions. If None, no
         TOS agreement will be displayed.
 
         'help_text' is an explanatory text for the end-users, will be shown
@@ -148,9 +114,9 @@
         'ping_url' is the url that will be pinged when a user registers/logins
         successfully. The user email will be attached to 'ping_url'.
 
-        'success_cb' will be called when the credentials were retrieved
-        successfully. Two params will be passed: the app_name and the
-        credentials per se. The credentials is a dictionary of the form:
+
+        When the credentials are retrieved successfully, a dictionary like the
+        one below is returned:
 
             {'token': <value>,
              'token_secret': <value>,
@@ -158,65 +124,42 @@
              'consumer_secret': <value>,
              'name': <the token name, matches "[app_name] @ [host name]">}
 
-        'error_cb' will be called when the credentials retrieval failed. Two
-        params will be passed: the app_name, and an error dict with 2 keys:
-        the error message (user friendly, not translatable so far), and
-        the detailed error (usually the traceback).
-
-        'denial_cb' will be called when the user denied the credentials to the
-        caller. A single param is passed: the app_name.
-
         """
         self.app_name = app_name
         self.help_text = help_text
         self.window_id = window_id
         self.ping_url = ping_url
         self.tc_url = tc_url
-        self.ui_module = ui_module
-        self.ui_class = ui_class
-        self._success_cb = success_cb
-        self._error_cb = error_cb
-        self.denial_cb = denial_cb
-        self.inner = None  # will hold the GUI or SSOLoginRoot instance
+        self.ui_executable = ui_executable
 
-    @handle_failures(msg='Problem while retrieving credentials')
     @defer.inlineCallbacks
-    def _login_success_cb(self, app_name, email):
-        """Store credentials when the login/registration succeeded.
-
-        Return 0 on success, and a non-zero value (or None) on error.
-
-        """
-        logger.info('Login/registration was successful for app %r, email %r',
-                    app_name, email)
-        creds = yield self.find_credentials()
-        if creds is not None:
-            assert len(creds) > 0, 'Creds are empty! This should not happen'
-            self.success_cb(creds)
-            defer.returnValue(0)
-
-    def _auth_denial_cb(self, app_name):
-        """The user decided not to allow the registration or login."""
-        logger.warning('Login/registration was denied to app %r', app_name)
-        self.denial_cb(app_name)
-
-    @handle_exceptions(msg='Problem opening the Ubuntu SSO user interface')
     def _show_ui(self, login_only):
         """Shows the UI, connect outcome signals."""
-
-        __import__(self.ui_module)
-        gui = sys.modules[self.ui_module]
-
-        self.inner = getattr(gui, self.ui_class)(app_name=self.app_name,
-                        tc_url=self.tc_url, help_text=self.help_text,
-                        ping_url=self.ping_url, window_id=self.window_id,
-                        login_only=login_only)
-
-        self.inner.login_success_callback = self._login_success_cb
-        self.inner.registration_success_callback = self._login_success_cb
-        self.inner.user_cancellation_callback = self._auth_denial_cb
-
-    @handle_exceptions(msg='Problem logging with email and password.')
+        args = [str(self.ui_executable)]
+        for arg in ('app_name', 'help_text', 'ping_url',
+                    'tc_url', 'window_id'):
+            value = getattr(self, arg)
+            if value:
+                args.append('--%s' % arg)
+                args.append("%s" % str(value))
+
+        if login_only:
+            args.append('--login_only')
+
+        return_code = yield runner.spawn_program(args)
+        logger.info('_show_ui: received from the ui return code %r.',
+                    return_code)
+
+        credentials = None
+        if return_code == USER_SUCCESS:
+            credentials = yield self.find_credentials()
+        elif return_code == USER_CANCELLATION:
+            raise UserCancellationError()
+        else:
+            raise CredentialsError(return_code)
+
+        defer.returnValue(credentials)
+
     def _do_login(self, email, password):
         """Login using email/password, connect outcome signals."""
         from ubuntu_sso.main import SSOLogin
@@ -234,62 +177,43 @@
 
             def LoginError(self, app_name, error):
                 """There was an error on login."""
+                error = CredentialsError(error['errtype'])
                 d.errback(error)
 
             def UserNotValidated(self, app_name, email):
                 """User is not validated."""
-                d.callback(None)
+                d.errback(UserNotValidatedError(email))
 
             # pylint: enable=C0103
 
-        self.inner = SSOLogin(proxy=DummyProxy())
-        self.inner.login(app_name=self.app_name,
-                         email=email, password=password)
-
-        def _success(result):
-            """Check if 'result' is a valid token, and callback properly."""
-            if result is not None:
-                return self._login_success_cb(self.app_name, email)
-            else:
-                error_dict = {
-                    'errtype': 'UserNotValidated',
-                    'message': email,
-                }
-                self._error_cb(self.app_name, error_dict)
-
-        d.addCallback(_success)
-        d.addErrback(lambda f: self._error_cb(self.app_name, f.value))
-
-    @handle_failures(msg='Problem while retrieving credentials')
+        inner = SSOLogin(proxy=DummyProxy())
+        inner.login(app_name=self.app_name,
+                    email=email, password=password,
+                    ping_url=self.ping_url)
+
+        d.addCallback(lambda _: self.find_credentials())
+        return d
+
     @defer.inlineCallbacks
     def _login_or_register(self, login_only, email=None, password=None):
-        """Get credentials if found else prompt the GUI."""
+        """Get credentials if found else prompt the GUI.
+
+        Will return either the credentials, or will raise UserCancellationError
+        if the user aborted the operation when the UI was opened.
+
+        """
         logger.info("_login_or_register: login_only=%r email=%r.",
-            login_only, email)
+                    login_only, email)
         token = yield self.find_credentials()
-        if token is not None and len(token) > 0:
-            self.success_cb(token)
-        elif token == {}:
+        if not token:
             if email and password:
-                self._do_login(email, password)
+                token = yield self._do_login(email, password)
             else:
-                self._show_ui(login_only)
-        else:
-            # something went wrong with find_credentials, already handled.
-            logger.info('_login_or_register: call to "find_credentials" went '
-                        'wrong, and was already handled.')
-
-    def error_cb(self, error_dict):
-        """Handle error and notify the caller."""
-        logger.error('Calling error callback at %r (error is %r).',
-                     self._error_cb, error_dict)
-        self._error_cb(self.app_name, error_dict)
-
-    def success_cb(self, creds):
-        """Handle success and notify the caller."""
-        logger.debug('Calling success callback at %r.', self._success_cb)
-        self._success_cb(self.app_name, creds)
-
+                token = yield self._show_ui(login_only)
+
+        defer.returnValue(token)
+
+    @handle_failures(msg='Problem while getting credentials from the keyring')
     @defer.inlineCallbacks
     def find_credentials(self):
         """Get the credentials for 'self.app_name'. Return {} if not there."""
@@ -298,20 +222,22 @@
                     'result is {}? %s', self.app_name, creds is None)
         defer.returnValue(creds if creds is not None else {})
 
-    @defer.inlineCallbacks
+    @handle_failures(msg='Problem while clearing credentials in the keyring')
     def clear_credentials(self):
         """Clear the credentials for 'self.app_name'."""
-        yield Keyring().delete_credentials(self.app_name)
+        return Keyring().delete_credentials(self.app_name)
 
-    @defer.inlineCallbacks
+    @handle_failures(msg='Problem while storing credentials in the keyring')
     def store_credentials(self, token):
         """Store the credentials for 'self.app_name'."""
-        yield Keyring().set_credentials(self.app_name, token)
+        return Keyring().set_credentials(self.app_name, token)
 
+    @handle_failures(msg='Problem while performing register')
     def register(self):
         """Get credentials if found else prompt the GUI to register."""
         return self._login_or_register(login_only=False)
 
+    @handle_failures(msg='Problem while performing login')
     def login(self, email=None, password=None):
         """Get credentials if found else prompt the GUI to login.
 

=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2012-02-09 21:57:15 +0000
+++ ubuntu_sso/gtk/gui.py	2012-02-10 17:15:32 +0000
@@ -33,6 +33,8 @@
 from ubuntu_sso import (
     main,
     NO_OP,
+    USER_CANCELLATION,
+    USER_SUCCESS,
     utils,
 )
 from ubuntu_sso.logger import setup_gui_logging
@@ -110,9 +112,6 @@
 HELP_TEXT_COLOR = parse_color("#bfbfbf")
 WARNING_TEXT_COLOR = parse_color("red")
 
-USER_CANCELLATION = 10
-LOGIN_SUCCESS = REGISTRATION_SUCCESS = 0
-
 
 def log_call(f):
     """Decorator to log call funtions."""
@@ -218,12 +217,6 @@
         window_id = kwargs.get('window_id', 0)
         self.close_callback = kwargs.get('close_callback', NO_OP)
         self.backend = None
-        # the following 3 callbacks will be removed as soon as
-        # the backend stop using them
-        self.login_success_callback = NO_OP
-        self.registration_success_callback = NO_OP
-        self.user_cancellation_callback = NO_OP
-
         self.user_email = None
         self.user_password = None
 
@@ -726,9 +719,8 @@
         while Gtk.events_pending():
             Gtk.main_iteration()
 
-        return_code = LOGIN_SUCCESS
+        return_code = USER_SUCCESS
         if not self._done:
-            self.user_cancellation_callback(self.app_name)
             return_code = USER_CANCELLATION
         logger.info('Return code will be %r.', return_code)
 
@@ -1081,7 +1073,6 @@
     @log_call
     def on_email_validated(self, app_name, email, *args, **kwargs):
         """User email was successfully verified."""
-        self.registration_success_callback(self.app_name, email)
         self.finish_success()
 
     @log_call
@@ -1097,7 +1088,6 @@
     @log_call
     def on_logged_in(self, app_name, email, *args, **kwargs):
         """User was successfully logged in."""
-        self.login_success_callback(self.app_name, email)
         self.finish_success()
 
     @log_call

=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2012-02-09 21:57:15 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2012-02-10 17:15:32 +0000
@@ -2108,7 +2108,7 @@
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called, ((gui.REGISTRATION_SUCCESS,), {}))
+        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
 
     def test_on_email_validation_error_proper_callback_is_called(self):
         """On EmailValidationError, USER_CANCELLATION is called."""
@@ -2122,7 +2122,7 @@
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called, ((gui.LOGIN_SUCCESS,), {}))
+        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
 
     def test_on_login_error_proper_callback_is_called(self):
         """On LoginError, USER_CANCELLATION is called."""
@@ -2145,7 +2145,7 @@
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called, ((gui.REGISTRATION_SUCCESS,), {}))
+        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
 
     def test_login_success_even_if_prior_login_error(self):
         """Only one callback is called with the final outcome.
@@ -2160,7 +2160,7 @@
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called, ((gui.LOGIN_SUCCESS,), {}))
+        self.assertEqual(self._called, ((gui.USER_SUCCESS,), {}))
 
     def test_user_cancelation_even_if_prior_registration_error(self):
         """Only one callback is called with the final outcome.

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2012-02-09 21:17:54 +0000
+++ ubuntu_sso/main/__init__.py	2012-02-10 17:15:32 +0000
@@ -29,14 +29,11 @@
 from ubuntu_sso.account import Account
 from ubuntu_sso.credentials import (
     Credentials,
-    DENIAL_CB_KEY,
-    ERROR_CB_KEY,
     HELP_TEXT_KEY,
     PING_URL_KEY,
-    SUCCESS_CB_KEY,
     TC_URL_KEY,
-    UI_CLASS_KEY,
-    UI_MODULE_KEY,
+    UI_EXECUTABLE_KEY,
+    UserCancellationError,
     WINDOW_ID_KEY,
 )
 from ubuntu_sso.keyring import get_token_name, Keyring
@@ -302,15 +299,12 @@
             self.shutdown_func()
 
     valid_keys = (HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY,
-                  UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY)
+                  UI_EXECUTABLE_KEY, WINDOW_ID_KEY)
 
     def _parse_args(self, args):
         """Retrieve values from the generic param 'args'."""
         result = dict(i for i in args.iteritems() if i[0] in self.valid_keys)
         result[WINDOW_ID_KEY] = int(args.get(WINDOW_ID_KEY, 0))
-        result[SUCCESS_CB_KEY] = self.CredentialsFound
-        result[ERROR_CB_KEY] = self.CredentialsError
-        result[DENIAL_CB_KEY] = self.AuthorizationDenied
         return result
 
     @log_call(logger.info)
@@ -403,6 +397,13 @@
         d.addCallback(_success_cb)
         d.addErrback(_error_cb, app_name)
 
+    def _process_failures(self, failure, app_name):
+        """Process failure returned by the Credentials module."""
+        if failure.check(UserCancellationError):
+            self.AuthorizationDenied(app_name)
+        else:
+            self.CredentialsError(app_name, failure.value)
+
     def clear_credentials(self, app_name, args):
         """Clear the credentials for an application.
 
@@ -439,13 +440,17 @@
         """Get credentials if found else prompt GUI to register."""
         self.ref_count += 1
         obj = Credentials(app_name, **self._parse_args(args))
-        obj.register()
+        d = obj.register()
+        d.addCallback(lambda creds: self.CredentialsFound(app_name, creds))
+        d.addErrback(self._process_failures, app_name)
 
     def login(self, app_name, args):
         """Get credentials if found else prompt GUI to login."""
         self.ref_count += 1
         obj = Credentials(app_name, **self._parse_args(args))
-        obj.login()
+        d = obj.login()
+        d.addCallback(lambda creds: self.CredentialsFound(app_name, creds))
+        d.addErrback(self._process_failures, app_name)
 
     def login_email_password(self, app_name, args):
         """Get credentials if found else try to login.
@@ -458,7 +463,9 @@
         email = args.pop('email')
         password = args.pop('password')
         obj = Credentials(app_name, **self._parse_args(args))
-        obj.login(email=email, password=password)
+        d = obj.login(email=email, password=password)
+        d.addCallback(lambda creds: self.CredentialsFound(app_name, creds))
+        d.addErrback(self._process_failures, app_name)
 
 
 # pylint: enable=C0103

=== modified file 'ubuntu_sso/main/tests/__init__.py'
--- ubuntu_sso/main/tests/__init__.py	2012-01-04 20:30:13 +0000
+++ ubuntu_sso/main/tests/__init__.py	2012-02-10 17:15:32 +0000
@@ -38,9 +38,6 @@
 class FakedCredentials(object):
     """A very dummy Credentials object."""
 
-    def __init__(self, *a, **kw):
-        self.login = self.register = lambda *a, **kw: None
-
     def find_credentials(self, *a, **kw):
         """Retrieve credentials."""
         return defer.succeed(TOKEN)
@@ -52,3 +49,11 @@
     def store_credentials(self, *a, **kw):
         """Store credentials."""
         return defer.succeed(None)
+
+    def register(self, *a, **kw):
+        """Register."""
+        return defer.succeed(TOKEN)
+
+    def login(self, *a, **kw):
+        """Login."""
+        return defer.succeed(TOKEN)

=== modified file 'ubuntu_sso/main/tests/test_clients.py'
--- ubuntu_sso/main/tests/test_clients.py	2012-01-11 13:17:10 +0000
+++ ubuntu_sso/main/tests/test_clients.py	2012-02-10 17:15:32 +0000
@@ -259,9 +259,12 @@
 class CredentialsManagementProxyTestCase(AbstractTestCase):
     """Tests for the CredentialsManagementProxy DBus interface."""
 
+    args = dict(foo='bar', fuh='baz')
+    params = (APP_NAME, args)
+    success_signal = 'CredentialsFound'
     error_signal = 'CredentialsError'
-    args = dict(foo='bar', fuh='baz')
-    params = (APP_NAME, args)
+    backend_result = TOKEN
+    success_result = (APP_NAME, backend_result)
 
     @defer.inlineCallbacks
     def setUp(self):
@@ -285,9 +288,6 @@
     """Test the find_credentials method."""
 
     method = 'find_credentials'
-    success_signal = 'CredentialsFound'
-    backend_result = TOKEN
-    success_result = (APP_NAME, backend_result)
 
     @skipIfOS('win32', 'find_credentials_sync is only provided in Linux '
                        'due to compatibility issues with old clients.')
@@ -336,35 +336,19 @@
     success_result = (APP_NAME,)
 
 
-class CredentialsManagementOpsTestCase(CredentialsManagementProxyTestCase):
-    """Tests for the CredentialsManagementProxy login/register methods."""
-
-    success_signal = 'CredentialsFound'
-    success_result = (APP_NAME, TOKEN)
-
-    def _backend_succeed(self, *args, **kwargs):
-        """Make self.patchable_backend return self.backend_result."""
-        self.sso_service.cred_manager.CredentialsFound(APP_NAME, TOKEN)
-
-    def _backend_fail(self, *args, **kwargs):
-        """Make self.patchable_backend fail."""
-        self.sso_service.cred_manager.CredentialsError(APP_NAME,
-            dict(errtype='ValueError'))
-
-
-class RegisterTestCase(CredentialsManagementOpsTestCase):
+class RegisterTestCase(CredentialsManagementProxyTestCase):
     """Test the register method."""
 
     method = 'register'
 
 
-class LoginOnlyTestCase(CredentialsManagementOpsTestCase):
+class LoginOnlyTestCase(CredentialsManagementProxyTestCase):
     """Test the login method."""
 
     method = 'login'
 
 
-class LoginEmailPasswordTestCase(CredentialsManagementOpsTestCase):
+class LoginEmailPasswordTestCase(CredentialsManagementProxyTestCase):
     """Test the login method."""
 
     method = 'login_email_password'

=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2012-02-09 21:17:54 +0000
+++ ubuntu_sso/main/tests/test_common.py	2012-02-10 17:15:32 +0000
@@ -31,8 +31,7 @@
     UbuntuSSOService,
 )
 from ubuntu_sso.main import (HELP_TEXT_KEY, PING_URL_KEY,
-    TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
-    SUCCESS_CB_KEY, ERROR_CB_KEY, DENIAL_CB_KEY)
+    TC_URL_KEY, UI_EXECUTABLE_KEY, WINDOW_ID_KEY)
 from ubuntu_sso.main.tests import FakedCredentials
 from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
     CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, PING_URL, TOKEN,
@@ -540,7 +539,7 @@
     base_args = {
         HELP_TEXT_KEY: HELP_TEXT, PING_URL_KEY: PING_URL,
         TC_URL_KEY: TC_URL, WINDOW_ID_KEY: WINDOW_ID,
-        UI_CLASS_KEY: 'SuperUI', UI_MODULE_KEY: 'foo.bar.baz',
+        UI_EXECUTABLE_KEY: 'super-ui',
     }
 
     @defer.inlineCallbacks
@@ -661,14 +660,19 @@
 
     def test_register(self):
         """Keep proper track of ongoing requests."""
-        yield self.assert_refcounter_increased('register')
+        yield self.assert_refcounter_increased('register',
+                                               'CredentialsFound')
 
     def test_login(self):
         """Keep proper track of ongoing requests."""
-        yield self.assert_refcounter_increased('login')
+        yield self.assert_refcounter_increased('login',
+                                               'CredentialsFound')
 
     def test_several_requests(self):
         """Requests can be nested."""
+        # by patching the CredentialsFound signal, the counter is not decreased
+        self.patch(self.obj, 'CredentialsFound', lambda *a: None)
+
         self.obj.login(APP_NAME, self.args)
         self.obj.register(APP_NAME, self.args)
         self.obj.login(APP_NAME, self.args)
@@ -731,7 +735,6 @@
         """When ref count reaches 0, queue shutdown op."""
         self.patch(self.obj, 'timeout_func', self._set_called)
         self.obj.login(APP_NAME, self.args)
-        self.obj.CredentialsFound(APP_NAME, TOKEN)
 
         self.assertEqual(self._called,
                          ((TIMEOUT_INTERVAL, self.obj.shutdown), {}))
@@ -739,6 +742,8 @@
     def test_on_non_zero_ref_count_do_not_shutdown(self):
         """If ref count is not 0, do not queue shutdown op."""
         self.patch(self.obj, 'timeout_func', self._set_called)
+        # by patching the CredentialsFound signal, the counter is not decreased
+        self.patch(self.obj, 'CredentialsFound', lambda *a: None)
         self.obj.login(APP_NAME, self.args)
 
         self.assertEqual(self._called, False)
@@ -748,6 +753,8 @@
 
         def fake_timeout_func(interval, func):
             """Start a new request when the timer is started."""
+            # the counter is not decreased
+            self.patch(self.obj, 'CredentialsFound', lambda *a: None)
             self.obj.register(APP_NAME, self.args)
             assert self.obj.ref_count > 0
             func()
@@ -756,8 +763,7 @@
         self.patch(self.obj, 'shutdown_func', self._set_called)
 
         self.obj.login(APP_NAME, self.args)
-        self.obj.CredentialsFound(APP_NAME, TOKEN)
-        # counter reached 0, timeout_func was called
+        # counter reached 0, timeout_func was called and register was called
 
         self.assertEqual(self._called, False, 'shutdown_func was not called')
 
@@ -773,7 +779,6 @@
         self.patch(self.obj, 'shutdown_func', self._set_called)
 
         self.obj.login(APP_NAME, self.args)
-        self.obj.CredentialsFound(APP_NAME, TOKEN)
         # counter reached 0, timeout_func was called
 
         self.assertEqual(self._called, ((), {}), 'shutdown_func was called')
@@ -895,9 +900,6 @@
         yield super(CredentialsManagementOpsTestCase, self).setUp()
         self.args = dict((k, str(v)) for k, v in self.base_args.iteritems())
         self.cred_args = self.base_args.copy()
-        self.cred_args[SUCCESS_CB_KEY] = self.obj.CredentialsFound
-        self.cred_args[ERROR_CB_KEY] = self.obj.CredentialsError
-        self.cred_args[DENIAL_CB_KEY] = self.obj.AuthorizationDenied
 
     def test_register(self):
         """The registration is correct."""

=== modified file 'ubuntu_sso/qt/tests/show_gui.py'
--- ubuntu_sso/qt/tests/show_gui.py	2012-01-26 15:34:16 +0000
+++ ubuntu_sso/qt/tests/show_gui.py	2012-02-10 17:15:32 +0000
@@ -33,7 +33,7 @@
      TC_URL_KEY,
      HELP_TEXT_KEY,
      WINDOW_ID_KEY,
-     UI_MODULE_KEY,
+     UI_EXECUTABLE_KEY,
 )
 
 
@@ -58,7 +58,7 @@
             TC_URL_KEY: 'http://www.google.com',
             HELP_TEXT_KEY: 'This is a test.',
             WINDOW_ID_KEY: '0',
-            UI_MODULE_KEY: 'ubuntu_sso.qt.gui',
+            UI_EXECUTABLE_KEY: 'ubuntu-sso-login-gtk',
         })
     print "called ok"
     yield d

=== modified file 'ubuntu_sso/tests/__init__.py'
--- ubuntu_sso/tests/__init__.py	2012-01-24 22:26:45 +0000
+++ ubuntu_sso/tests/__init__.py	2012-02-10 17:15:32 +0000
@@ -33,8 +33,7 @@
 CAPTCHA_SOLUTION = u'william Byrd ñandú'
 EMAIL = u'[e-mail]'
 EMAIL_TOKEN = u'B2Pgtf'
-GTK_GUI_CLASS = 'UbuntuSSOClientGUI'
-GTK_GUI_MODULE = 'ubuntu_sso.gtk.gui'
+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,

=== modified file 'ubuntu_sso/tests/test_credentials.py'
--- ubuntu_sso/tests/test_credentials.py	2012-02-09 21:57:15 +0000
+++ ubuntu_sso/tests/test_credentials.py	2012-02-10 17:15:32 +0000
@@ -21,12 +21,12 @@
 from twisted.trial.unittest import TestCase
 from ubuntuone.devtools.handlers import MementoHandler
 
+import ubuntu_sso.main
+
 from ubuntu_sso import credentials
-import ubuntu_sso.main
-from ubuntu_sso.credentials import (APP_NAME_KEY, HELP_TEXT_KEY, NO_OP,
-    PING_URL_KEY, TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
-    ERROR_KEY, ERROR_DETAIL_KEY)
-from ubuntu_sso.tests import (APP_NAME, EMAIL, GTK_GUI_CLASS, GTK_GUI_MODULE,
+from ubuntu_sso.credentials import (APP_NAME_KEY, HELP_TEXT_KEY,
+    PING_URL_KEY, TC_URL_KEY, UI_EXECUTABLE_KEY, WINDOW_ID_KEY)
+from ubuntu_sso.tests import (APP_NAME, EMAIL, GTK_GUI_EXE,
     HELP_TEXT, PASSWORD, PING_URL, TC_URL, TOKEN, WINDOW_ID)
 
 
@@ -42,19 +42,18 @@
 
 KWARGS = {
     APP_NAME_KEY: APP_NAME,
-    TC_URL_KEY: TC_URL,
     HELP_TEXT_KEY: HELP_TEXT,
     WINDOW_ID_KEY: WINDOW_ID,
     PING_URL_KEY: PING_URL,
-    UI_MODULE_KEY: 'ubuntu_sso.tests.test_credentials',
-    UI_CLASS_KEY: 'FakedClientGUI',
+    TC_URL_KEY: TC_URL,
+    UI_EXECUTABLE_KEY: 'foo-bar-baz',
 }
 
 UI_KWARGS = {
     APP_NAME_KEY: APP_NAME,
+    HELP_TEXT_KEY: HELP_TEXT,
     PING_URL_KEY: PING_URL,
     TC_URL_KEY: TC_URL,
-    HELP_TEXT_KEY: HELP_TEXT,
     WINDOW_ID_KEY: WINDOW_ID,
 }
 
@@ -63,39 +62,17 @@
     """An error to be used while testing."""
 
 
-class FailingClient(object):
-    """Fake a failing client."""
-
-    err_msg = 'A failing class.'
-
-    def __init__(self, *args, **kwargs):
-        raise SampleMiscException(self.err_msg)
-
-
-class FakedClientGUI(object):
-    """Fake a SSO GUI."""
-
-    def __init__(self, *args, **kwargs):
-        self.args = args
-        self.kwargs = kwargs
-        self.login_success_callback = None
-        self.registration_success_callback = None
-        self.user_cancellation_callback = None
-
-
 class FakedSSOLogin(object):
     """Fake a SSOLogin."""
 
-    args = []
-    kwargs = {}
+    proxy = None
 
     def __init__(self, proxy):
         """Nothing."""
+        FakedSSOLogin.proxy = proxy
 
     def login(self, *args, **kwargs):
         """Fake login."""
-        self.args = args
-        self.kwargs = kwargs
 
 
 class BasicTestCase(TestCase):
@@ -125,53 +102,12 @@
     def setUp(self):
         """Init."""
         yield super(CredentialsTestCase, self).setUp()
-        self.obj = credentials.Credentials(success_cb=self.success,
-                                           error_cb=self.error,
-                                           denial_cb=self.denial,
-                                           **KWARGS)
-
-    def success(self, *args, **kwargs):
-        """To be called on success."""
-        self._set_called('success', *args, **kwargs)
-
-    def error(self, *args, **kwargs):
-        """To be called on error."""
-        self._set_called('error', *args, **kwargs)
-
-    def denial(self, *args, **kwargs):
-        """To be called on credentials denial."""
-        self._set_called('denial', *args, **kwargs)
-
-    def assert_error_cb_called(self, msg, detailed_error=None):
-        """Check that self.error_cb was called with proper arguments."""
-        self.assertEqual(len(self._called), 2)
-        self.assertEqual(self._called[0][0], 'error')
-        self.assertEqual(self._called[0][1], APP_NAME)
-        error_dict = self._called[0][2]
-        self.assertEqual(error_dict[ERROR_KEY], msg)
-        if detailed_error is not None:
-            self.assertIn(str(detailed_error), error_dict[ERROR_DETAIL_KEY])
-        else:
-            self.assertNotIn(ERROR_DETAIL_KEY, error_dict)
-        self.assertEqual(self._called[1], {})
+        self.obj = credentials.Credentials(**KWARGS)
 
 
 class CredentialsCallbacksTestCase(CredentialsTestCase):
     """Test suite for the Credentials callbacks."""
 
-    def test_callbacks_are_stored(self):
-        """Creation callbacks are stored."""
-        self.assertEqual(self.obj._success_cb, self.success)
-        self.assertEqual(self.obj._error_cb, self.error)
-        self.assertEqual(self.obj.denial_cb, self.denial)
-
-    def test_callbacks_default_to_no_op(self):
-        """The callbacks are a no-operation if not given."""
-        self.obj = credentials.Credentials(**KWARGS)
-        self.assertEqual(self.obj._success_cb, NO_OP)
-        self.assertEqual(self.obj._error_cb, NO_OP)
-        self.assertEqual(self.obj.denial_cb, NO_OP)
-
     def test_creation_parameters_are_stored(self):
         """Creation parameters are stored."""
         for key, value in KWARGS.iteritems():
@@ -209,78 +145,13 @@
 
         self.assertEqual(getattr(self.obj, PING_URL_KEY), None)
 
-    def test_ui_class_defaults_to_gtk(self):
+    def test_ui_executable_defaults_to_gtk(self):
         """The ui class defaults to gtk."""
         newkw = KWARGS.copy()
-        newkw.pop(UI_CLASS_KEY)
-        self.obj = credentials.Credentials(**newkw)
-
-        self.assertEqual(getattr(self.obj, UI_CLASS_KEY), GTK_GUI_CLASS)
-
-    def test_ui_module_defaults_to_gtk(self):
-        """The ui module defaults to gtk."""
-        newkw = KWARGS.copy()
-        newkw.pop(UI_MODULE_KEY)
-        self.obj = credentials.Credentials(**newkw)
-
-        self.assertEqual(getattr(self.obj, UI_MODULE_KEY), GTK_GUI_MODULE)
-
-    def test_success_cb(self):
-        """Success callback calls the caller."""
-        self.obj.gui = None
-        self.obj.success_cb(creds=TOKEN)
-
-        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}),
-                         'caller _success_cb was called.')
-
-    def test_error_cb(self):
-        """Error callback calls the caller."""
-        error_dict = {'foo': 'bar'}
-        self.obj.error_cb(error_dict=error_dict)
-
-        self.assertEqual(self._called, (('error', APP_NAME, error_dict), {}),
-                         'caller _error_cb was called.')
-
-
-class CredentialsLoginSuccessTestCase(CredentialsTestCase):
-    """Test suite for the Credentials login success callback."""
-
-    @defer.inlineCallbacks
-    def test_cred_not_found(self):
-        """On auth success, if cred not found, self.error_cb is called."""
-        self.patch(credentials.Keyring, 'get_credentials',
-                   lambda kr, app: defer.succeed(None))
-
-        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
-
-        msg = 'Creds are empty! This should not happen'
-        self.assert_error_cb_called(msg='Problem while retrieving credentials',
-                                    detailed_error=AssertionError(msg))
-        self.assertEqual(result, None)
-
-    @defer.inlineCallbacks
-    def test_cred_error(self):
-        """On auth success, if cred failed, self.error_cb is called."""
-        expected_error = SampleMiscException()
-        self.patch(credentials.Keyring, 'get_credentials',
-                   lambda kr, app: defer.fail(expected_error))
-
-        result = yield self.obj._login_success_cb(APP_NAME, EMAIL)
-
-        msg = 'Problem while retrieving credentials'
-        self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
-        self.assertEqual(result, None)
-        self.assertTrue(self.memento.check_exception(SampleMiscException))
-
-
-class CredentialsAuthDeniedTestCase(CredentialsTestCase):
-    """Test suite for the Credentials auth denied callback."""
-
-    def test_auth_denial_cb(self):
-        """On auth denied, self.denial_cb is called."""
-        self.obj._auth_denial_cb(app_name=APP_NAME)
-
-        self.assertEqual(self._called, (('denial', APP_NAME), {}))
+        newkw.pop(UI_EXECUTABLE_KEY)
+        self.obj = credentials.Credentials(**newkw)
+
+        self.assertEqual(getattr(self.obj, UI_EXECUTABLE_KEY), GTK_GUI_EXE)
 
 
 class FindCredentialsTestCase(CredentialsTestCase):
@@ -367,89 +238,128 @@
     operation = 'register'
     login_only = False
     kwargs = {}
-    inner_class = FakedClientGUI
 
     @defer.inlineCallbacks
     def setUp(self):
         yield super(RegisterTestCase, self).setUp()
-        self.inner_kwargs = UI_KWARGS.copy()
-        self.inner_kwargs['login_only'] = self.login_only
+        self.deferred = defer.Deferred()
+        self.patch_inner(self.fake_inner)
+        self.inner_args = [
+            KWARGS[UI_EXECUTABLE_KEY],
+            '--app_name', APP_NAME,
+            '--help_text', HELP_TEXT,
+            '--ping_url', PING_URL,
+            '--tc_url', TC_URL,
+            '--window_id', str(WINDOW_ID),
+        ]
+        if self.login_only:
+            self.inner_args.append('--login_only')
+
+        self._next_inner_result = 0
+
         self.method_call = getattr(self.obj, self.operation)
 
+    def patch_inner(self, f):
+        """Patch the inner call."""
+        self.patch(credentials.runner, 'spawn_program', f)
+
+    def fake_inner(self, args):
+        """Fake the runner.spawn_program."""
+        self.deferred.callback(args)
+
+        if self._next_inner_result == credentials.USER_SUCCESS:
+            # fake that tokens were retrieved from the UI
+            self.patch(credentials.Keyring, 'get_credentials',
+                       lambda kr, app: defer.succeed(TOKEN))
+
+        return defer.succeed(self._next_inner_result)
+
+    def fail_inner(self, args):
+        """Make the inner call fail."""
+        return defer.fail(SampleMiscException(args))
+
+    def assert_exc_msg_logged(self, exception_class, msg):
+        """Check that 'msg' was logged as part as the logger.exception call."""
+        for rec in self.memento.records:
+            if rec.exc_info and rec.exc_info[0] == exception_class:
+                self.assertIn(msg, rec.getMessage())
+                break
+
     @defer.inlineCallbacks
     def test_with_existent_token(self):
         """The operation returns the credentials if already in keyring."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(TOKEN))
 
-        yield self.method_call(**self.kwargs)
+        result = yield self.method_call(**self.kwargs)
 
-        self.assertEqual(self._called, (('success', APP_NAME, TOKEN), {}))
+        self.assertEqual(result, TOKEN)
+        self.assertFalse(self.deferred.called, 'No program was spawnned.')
 
     @defer.inlineCallbacks
-    def test_without_existent_token(self):
+    def test_without_existent_token_and_return_code_success(self):
         """The operation returns the credentials gathered by the inner call."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
-
-        yield self.method_call(**self.kwargs)
-
-        self.assertEqual(self.obj.inner.kwargs, self.inner_kwargs)
+        self._next_inner_result = credentials.USER_SUCCESS
+
+        result = yield self.method_call(**self.kwargs)
+        self.assertEqual(result, TOKEN)
+
+        # the ui was opened and proper params were passed
+        args = yield self.deferred
+        self.assertEqual(self.inner_args, args)
+
+    @defer.inlineCallbacks
+    def test_without_existent_token_and_return_code_cancel(self, exc=None):
+        """The operation returns exc if defined, else UserCancellationError."""
+        self.patch(credentials.Keyring, 'get_credentials',
+                   lambda kr, app: defer.succeed(None))
+        self._next_inner_result = credentials.USER_CANCELLATION
+
+        if exc is None:
+            exc = credentials.UserCancellationError
+        yield self.assertFailure(self.method_call(**self.kwargs), exc)
+
+    @defer.inlineCallbacks
+    def test_without_existent_token_and_return_other(self, result=None):
+        """The operation returns CredentialsError with 'result'."""
+        self.patch(credentials.Keyring, 'get_credentials',
+                   lambda kr, app: defer.succeed(None))
+        self._next_inner_result = credentials.USER_CANCELLATION * 2  # other
+
+        exc = yield self.assertFailure(self.method_call(**self.kwargs),
+                                       credentials.CredentialsError)
+        if result is None:
+            result = self._next_inner_result
+        self.assertEqual(exc.args, (result,))
 
     @defer.inlineCallbacks
     def test_with_exception_on_credentials(self):
         """The operation calls the error callback if a exception occurs."""
-        expected_error = SampleMiscException()
         self.patch(credentials.Keyring, 'get_credentials',
-                   lambda kr, app: defer.fail(expected_error))
-
-        yield self.method_call(**self.kwargs)
-
-        msg = 'Problem while retrieving credentials'
-        self.assert_error_cb_called(msg=msg, detailed_error=expected_error)
+                   lambda kr, app: defer.fail(SampleMiscException()))
+
+        yield self.assertFailure(self.method_call(**self.kwargs),
+                                 SampleMiscException)
+
         self.assertTrue(self.memento.check_exception(SampleMiscException))
+        msg = 'Problem while getting credentials from the keyring'
+        self.assert_exc_msg_logged(SampleMiscException, msg)
 
     @defer.inlineCallbacks
-    def test_with_exception_on_inner_call(self, msg=None):
+    def test_with_exception_on_inner_call(self):
         """The operation calls the error callback if a exception occurs."""
         self.patch(credentials.Keyring, 'get_credentials',
                    lambda kr, app: defer.succeed(None))
-        self.obj.ui_class = 'FailingClient'
-
-        yield self.method_call(**self.kwargs)
-
-        if msg is None:
-            msg = 'Problem opening the Ubuntu SSO user interface'
-        self.assert_error_cb_called(msg=msg,
-            detailed_error=SampleMiscException(FailingClient.err_msg))
-        self.assertTrue(self.memento.check_exception(SampleMiscException,
-                                                     FailingClient.err_msg))
-
-    @defer.inlineCallbacks
-    def test_connects_inner_signals(self):
-        """Inner callbacks are properly connected."""
-        self.patch(credentials.Keyring, 'get_credentials',
-                   lambda kr, app: defer.succeed(None))
-        yield self.method_call(**self.kwargs)
-
-        self.assertEqual(self.obj.inner.login_success_callback,
-                         self.obj._login_success_cb)
-        self.assertEqual(self.obj.inner.registration_success_callback,
-                         self.obj._login_success_cb)
-        self.assertEqual(self.obj.inner.user_cancellation_callback,
-                         self.obj._auth_denial_cb)
-
-    @defer.inlineCallbacks
-    def test_inner_object_is_created(self):
-        """The inner object is created and stored."""
-        self.patch(credentials.Keyring, 'get_credentials',
-                   lambda kr, app: defer.succeed(None))
-
-        yield self.method_call(**self.kwargs)
-
-        self.assertIsInstance(self.obj.inner, self.inner_class)
-        self.assertEqual(self.obj.inner.args, ())
-        self.assertEqual(self.obj.inner.kwargs, self.inner_kwargs)
+        self.patch_inner(self.fail_inner)
+
+        yield self.assertFailure(self.method_call(**self.kwargs),
+                                 SampleMiscException)
+
+        self.assertTrue(self.memento.check_exception(SampleMiscException))
+        msg = 'Problem while performing %s' % self.operation
+        self.assert_exc_msg_logged(SampleMiscException, msg)
 
 
 class LoginTestCase(RegisterTestCase):
@@ -465,22 +375,46 @@
     operation = 'login'
     login_only = True
     kwargs = {'email': EMAIL, 'password': PASSWORD}
-    inner_class = FakedSSOLogin
 
     @defer.inlineCallbacks
     def setUp(self):
         yield super(LoginEmailPasswordTestCase, self).setUp()
-        self.inner_kwargs = self.kwargs.copy()
-        self.inner_kwargs[APP_NAME_KEY] = APP_NAME
         self.patch(ubuntu_sso.main, 'SSOLogin', FakedSSOLogin)
-
-    def test_with_exception_on_inner_call(self, msg=None):
-        """The operation calls the error callback if a exception occurs."""
-        self.patch(ubuntu_sso.main, 'SSOLogin', FailingClient)
-        msg = 'Problem logging with email and password.'
-        return super(LoginEmailPasswordTestCase,
-                     self).test_with_exception_on_inner_call(msg=msg)
-
-    def test_connects_inner_signals(self):
-        """Inner callbacks are properly connected."""
-        # there is no inner callbacks for the SSOLoginRoot object
+        self.patch_inner(self.fake_inner)
+        self.inner_args = dict(app_name=APP_NAME,
+                               email=EMAIL, password=PASSWORD,
+                               ping_url=PING_URL)
+
+    def patch_inner(self, f):
+        """Patch the inner call."""
+        self.patch(FakedSSOLogin, 'login', f)
+
+    def fake_inner(self, **kwargs):
+        """Fake the runner.spawn_program."""
+        self.deferred.callback(kwargs)
+
+        if self._next_inner_result == credentials.USER_SUCCESS:
+            # fake that tokens were retrieved from the UI
+            self.patch(credentials.Keyring, 'get_credentials',
+                       lambda kr, app: defer.succeed(TOKEN))
+            FakedSSOLogin.proxy.LoggedIn(APP_NAME, EMAIL)
+        elif self._next_inner_result == credentials.USER_CANCELLATION:
+            FakedSSOLogin.proxy.UserNotValidated(APP_NAME, EMAIL)
+        else:
+            FakedSSOLogin.proxy.LoginError(APP_NAME, {'errtype': 'foo'})
+
+    def fail_inner(self, **kwargs):
+        """Make the inner call fail."""
+        raise SampleMiscException(kwargs)
+
+    def test_without_existent_token_and_return_code_cancel(self, exc=None):
+        """The operation returns UserNotValidatedError."""
+        exc = credentials.UserNotValidatedError
+        return super(LoginEmailPasswordTestCase, self).\
+               test_without_existent_token_and_return_code_cancel(exc=exc)
+
+    def test_without_existent_token_and_return_other(self, result=None):
+        """The operation returns CredentialsError with 'result'."""
+        result = 'foo'
+        return super(LoginEmailPasswordTestCase, self).\
+               test_without_existent_token_and_return_other(result=result)

=== modified file 'ubuntu_sso/utils/runner/glib.py'
--- ubuntu_sso/utils/runner/glib.py	2012-02-10 14:05:09 +0000
+++ ubuntu_sso/utils/runner/glib.py	2012-02-10 17:15:32 +0000
@@ -19,11 +19,6 @@
 import os
 
 # pylint: disable=E0611,F0401
-try:
-    from shlex import quote
-except ImportError:
-    from pipes import quote
-
 from gi.repository import GLib
 # pylint: enable=E0611,F0401
 
@@ -66,9 +61,6 @@
         msg = 'GError is: code %r, message %r' % (gerror.code, gerror.message)
         error_handler(msg=msg, failed_to_start=failed_to_start)
 
-    # escape arguments
-    args = [quote(a) for a in args]
-
     flags = GLib.SpawnFlags.DO_NOT_REAP_CHILD | \
             GLib.SpawnFlags.SEARCH_PATH | \
             GLib.SpawnFlags.STDOUT_TO_DEV_NULL | \