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

[Natalia Bidart]

[ Alejandro J. Cura <email address hidden> ]
  - An async, proxy-enabled replacement for lazr.restfulclient
  - Fix filter that broke maverick and lucid build; removed demo script that
    gives lint error.
  - Proxy aware webclient with QtNetwork and libsoup backends, and integration
    tests (LP: #884963 LP: #884968 LP: #884970 LP: #884971 LP: #911844).
  - Silence warnings printed by dbus on the test run (LP: #912920).
[ Natalia B. Bidart <email address hidden> ]
  - Remove duplications and unify code for IPC using Twisted's Perspective
    Broker between ubuntu-sso-client and ubuntuone-client (LP: #834730).
[ Diego Sarmentero <email address hidden> ]
  - Fixed: Missing page: No network detected (LP: #804610).

[Roberto Alsina (ralsina)]

+1

review: Approve

[dobey (dobey)]

review: Approve

=== modified file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	2011-09-22 14:29:21 +0000
+++ ubuntu_sso/account.py	2012-01-17 16:51:50 +0000
@@ -96,15 +96,12 @@
 class Account(object):
     """Login and register users using the Ubuntu Single Sign On service."""
 
-    def __init__(self, sso_service_class=None):
+    def __init__(self, service_url=None):
         """Create a new SSO Account manager."""
-        if sso_service_class is None:
-            self.sso_service_class = ServiceRoot
+        if service_url is not None:
+            self.service_url = service_url
         else:
-            self.sso_service_class = sso_service_class
-
-        self.service_url = os.environ.get('USSOC_SERVICE_URL', SERVICE_URL)
-
+            self.service_url = os.environ.get('USSOC_SERVICE_URL', SERVICE_URL)
         logger.info('Created a new SSO access layer for service url %r',
                      self.service_url)
 
@@ -134,7 +131,7 @@
         """Generate a captcha using the SSO service."""
         logger.debug('generate_captcha: requesting captcha, filename: %r',
                      filename)
-        sso_service = self.sso_service_class(None, self.service_url)
+        sso_service = ServiceRoot(None, self.service_url)
         captcha = sso_service.captchas.new()
 
         # download captcha and save to 'filename'
@@ -156,7 +153,7 @@
         logger.debug('register_user: email: %r password: <hidden>, '
                      'displayname: %r, captcha_id: %r, captcha_solution: %r',
                      email, displayname, captcha_id, captcha_solution)
-        sso_service = self.sso_service_class(None, self.service_url)
+        sso_service = ServiceRoot(None, self.service_url)
         if not self._valid_email(email):
             logger.error('register_user: InvalidEmailError for email: %r',
                          email)
@@ -185,7 +182,7 @@
         logger.debug('login: email: %r password: <hidden>, token_name: %r',
                      email, token_name)
         basic = BasicHttpAuthorizer(email, password)
-        sso_service = self.sso_service_class(basic, self.service_url)
+        sso_service = ServiceRoot(basic, self.service_url)
         service = sso_service.authentications.authenticate
 
         try:
@@ -209,7 +206,7 @@
                                         token['consumer_key'],
                                         token['consumer_secret'],
                                         oauth_token)
-            sso_service = self.sso_service_class(authorizer, self.service_url)
+            sso_service = ServiceRoot(authorizer, self.service_url)
 
         me_info = sso_service.accounts.me()
         key = 'preferred_email'
@@ -232,7 +229,7 @@
                                            token['consumer_key'],
                                            token['consumer_secret'],
                                            oauth_token)
-        sso_service = self.sso_service_class(authorizer, self.service_url)
+        sso_service = ServiceRoot(authorizer, self.service_url)
         result = sso_service.accounts.validate_email(email_token=email_token)
         logger.info('validate_email: email: %r result: %r', email, result)
         if 'errors' in result:
@@ -245,7 +242,7 @@
 
     def request_password_reset_token(self, email):
         """Request a token to reset the password for the account 'email'."""
-        sso_service = self.sso_service_class(None, self.service_url)
+        sso_service = ServiceRoot(None, self.service_url)
         service = sso_service.registrations.request_password_reset_token
         try:
             result = service(email=email)
@@ -266,7 +263,7 @@
         'request_password_reset_token'.
 
         """
-        sso_service = self.sso_service_class(None, self.service_url)
+        sso_service = ServiceRoot(None, self.service_url)
         service = sso_service.registrations.set_new_password
         try:
             result = service(email=email, token=token,

=== modified file 'ubuntu_sso/credentials.py'
--- ubuntu_sso/credentials.py	2012-01-03 16:04:29 +0000
+++ ubuntu_sso/credentials.py	2012-01-17 16:51:50 +0000
@@ -44,7 +44,6 @@
 from functools import wraps
 
 from twisted.internet import defer
-from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntu_sso import NO_OP, utils
 from ubuntu_sso.keyring import Keyring
@@ -105,7 +104,7 @@
         """Decorate 'f' to catch all errors."""
 
         @wraps(f)
-        @inlineCallbacks
+        @defer.inlineCallbacks
         def inner(self, *a, **kw):
             """Call 'f' within a try-except block.
 
@@ -123,7 +122,7 @@
                 error_dict = {ERROR_KEY: msg,
                               ERROR_DETAIL_KEY: traceback.format_exc()}
                 self.error_cb(error_dict)
-            returnValue(result)
+            defer.returnValue(result)
 
         return inner
 
@@ -185,7 +184,7 @@
         self.inner = None  # will hold the GUI or SSOLoginRoot instance
 
     @handle_failures(msg='Problem while retrieving credentials')
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def _login_success_cb(self, app_name, email):
         """Store credentials when the login/registration succeeded.
 
@@ -209,7 +208,7 @@
                     return
 
             self.success_cb(creds)
-            returnValue(0)
+            defer.returnValue(0)
 
     def _auth_denial_cb(self, app_name):
         """The user decided not to allow the registration or login."""
@@ -265,16 +264,49 @@
     @handle_exceptions(msg='Problem logging with email and password.')
     def _do_login(self, email, password):
         """Login using email/password, connect outcome signals."""
-        from ubuntu_sso.main import SSOLoginRoot
-        self.inner = SSOLoginRoot()
-        self.inner.login(app_name=self.app_name, email=email,
-                         password=password,
-                         result_cb=self._login_success_cb,
-                         error_cb=self._error_cb,
-                         not_validated_cb=self._error_cb)
+        from ubuntu_sso.main import SSOLogin
+
+        d = defer.Deferred()
+
+        class DummyProxy(object):
+            """A temporary proxy to handle non-traditional login."""
+
+            # pylint: disable=C0103
+
+            def LoggedIn(self, app_name, result):
+                """User was logged in."""
+                d.callback(result)
+
+            def LoginError(self, app_name, error):
+                """There was an error on login."""
+                d.errback(error)
+
+            def UserNotValidated(self, app_name, email):
+                """User is not validated."""
+                d.callback(None)
+
+            # 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')
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def _login_or_register(self, login_only, email=None, password=None):
         """Get credentials if found else prompt the GUI."""
         logger.info("_login_or_register: login_only=%r email=%r.",
@@ -303,20 +335,20 @@
         logger.debug('Calling success callback at %r.', self._success_cb)
         self._success_cb(self.app_name, creds)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def find_credentials(self):
         """Get the credentials for 'self.app_name'. Return {} if not there."""
         creds = yield Keyring().get_credentials(self.app_name)
         logger.info('find_credentials: self.app_name %r, '
                     'result is {}? %s', self.app_name, creds is None)
-        returnValue(creds if creds is not None else {})
+        defer.returnValue(creds if creds is not None else {})
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def clear_credentials(self):
         """Clear the credentials for 'self.app_name'."""
         yield Keyring().delete_credentials(self.app_name)
 
-    @inlineCallbacks
+    @defer.inlineCallbacks
     def store_credentials(self, token):
         """Store the credentials for 'self.app_name'."""
         yield Keyring().set_credentials(self.app_name, token)
@@ -325,11 +357,15 @@
         """Get credentials if found else prompt the GUI to register."""
         return self._login_or_register(login_only=False)
 
-    def login(self):
-        """Get credentials if found else prompt the GUI to login."""
-        return self._login_or_register(login_only=True)
-
-    def login_email_password(self, email, password):
-        """Get credentials if found else login using email and password."""
-        return self._login_or_register(login_only=True,
-                                       email=email, password=password)
+    def login(self, email=None, password=None):
+        """Get credentials if found else prompt the GUI to login.
+
+        if 'email' and 'password' are given, do not prompt the user and use
+        that to retrieve a token.
+
+        """
+        if email is None or password is None:
+            return self._login_or_register(login_only=True)
+        else:
+            return self._login_or_register(login_only=True,
+                                           email=email, password=password)

=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2011-11-09 21:21:47 +0000
+++ ubuntu_sso/logger.py	2012-01-17 16:51:50 +0000
@@ -25,6 +25,7 @@
 import os
 import sys
 
+from functools import wraps
 from logging.handlers import RotatingFileHandler
 
 from ubuntu_sso.xdg_base_directory import unicode_path, xdg_cache_home
@@ -61,3 +62,22 @@
         logger.addHandler(debug_handler)
 
     return logger
+
+
+def log_call(log_func):
+    """Decorator to log, using 'log_func', calls to functions."""
+
+    def middle(f):
+        """Return a function that will act as 'f' but will log the call."""
+
+        @wraps(f)
+        def inner(instance, *a, **kw):
+            """Call 'f(*a, **kw)' and return its result. Log that call."""
+            log_func('%r: emitting %r with args %r and kwargs %r',
+                     instance.__class__.__name__, f.__name__, a, kw)
+            result = f(instance, *a, **kw)
+            return result
+
+        return inner
+
+    return middle

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2011-12-19 19:35:06 +0000
+++ ubuntu_sso/main/__init__.py	2012-01-17 16:51:50 +0000
@@ -1,9 +1,5 @@
 # -*- coding: utf-8 -*-
 #
-# Author: Natalia Bidart <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-# Author: Manuel de la Pena <[e-mail]>
-#
 # Copyright 2011 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -17,10 +13,18 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Main object implementations."""
+"""Single Sign On client main module.
+
+Provides a utility which accepts requests to the Ubuntu Single Sign On
+service. The OAuth process is handled, including adding the OAuth access token
+to the local keyring.
+
+"""
 
 import sys
 
+from twisted.internet import defer
+
 from ubuntu_sso.account import Account
 from ubuntu_sso.credentials import (
     Credentials,
@@ -35,16 +39,30 @@
     WINDOW_ID_KEY,
 )
 from ubuntu_sso.keyring import get_token_name, Keyring
-from ubuntu_sso.logger import setup_logging
+from ubuntu_sso.logger import setup_logging, log_call
 
 
 logger = setup_logging("ubuntu_sso.main")
 U1_PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
 TIMEOUT_INTERVAL = 10000  # 10 seconds
 
+# pylint: disable=C0103
+
+if sys.platform == 'win32':
+    from ubuntu_sso.main import windows
+    source = windows
+    TIMEOUT_INTERVAL = 10000000000  # forever (hack)
+else:
+    from ubuntu_sso.main import linux
+    source = linux
+
+UbuntuSSOProxy = source.UbuntuSSOProxy
+get_sso_client = source.get_sso_client
+thread_execute = source.blocking
+
 
 def except_to_errdict(e):
-    """Turn an exception into a dictionary to return thru DBus."""
+    """Turn an exception into a dictionary to return thru IPC."""
     result = {
         "errtype": e.__class__.__name__,
     }
@@ -58,35 +76,71 @@
     return result
 
 
-class SSOLoginRoot(object):
+class SSOLogin(object):
     """Login thru the Single Sign On service."""
 
-    def __init__(self, sso_login_processor_class=Account,
-                 sso_service_class=None):
+    def __init__(self, proxy):
         """Initiate the Login object."""
-        self.sso_login_processor_class = sso_login_processor_class
-        self.processor = self.sso_login_processor_class(
-                                    sso_service_class=sso_service_class)
-
-    def generate_captcha(self, app_name, filename, result_cb,
-                         error_cb):
+        self.processor = Account()
+        self.proxy = proxy
+
+    @log_call(logger.debug)
+    def CaptchaGenerated(self, app_name, result):
+        """Signal thrown after the captcha is generated."""
+        self.proxy.CaptchaGenerated(app_name, result)
+
+    @log_call(logger.debug)
+    def CaptchaGenerationError(self, app_name, error):
+        """Signal thrown when there's a problem generating the captcha."""
+        error_dict = except_to_errdict(error)
+        self.proxy.CaptchaGenerationError(app_name, error_dict)
+
+    def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
             return self.processor.generate_captcha(filename)
-        thread_execute(f, app_name, result_cb, error_cb)
+        thread_execute(f, app_name,
+                       self.CaptchaGenerated, self.CaptchaGenerationError)
+
+    @log_call(logger.debug)
+    def UserRegistered(self, app_name, result):
+        """Signal thrown when the user is registered."""
+        self.proxy.UserRegistered(app_name, result)
+
+    @log_call(logger.debug)
+    def UserRegistrationError(self, app_name, error):
+        """Signal thrown when there's a problem registering the user."""
+        error_dict = except_to_errdict(error)
+        self.proxy.UserRegistrationError(app_name, error_dict)
 
     def register_user(self, app_name, email, password, name, captcha_id,
-                      captcha_solution, result_cb, error_cb):
+                      captcha_solution):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
             return self.processor.register_user(email, password, name,
                                                 captcha_id, captcha_solution)
-        thread_execute(f, app_name, result_cb, error_cb)
-
-    def login(self, app_name, email, password, result_cb,
-              error_cb, not_validated_cb):
+        thread_execute(f, app_name,
+                       self.UserRegistered, self.UserRegistrationError)
+
+    @log_call(logger.debug)
+    def LoggedIn(self, app_name, result):
+        """Signal thrown when the user is logged in."""
+        self.proxy.LoggedIn(app_name, result)
+
+    @log_call(logger.debug)
+    def LoginError(self, app_name, error):
+        """Signal thrown when there is a problem in the login."""
+        error_dict = except_to_errdict(error)
+        self.proxy.LoginError(app_name, error_dict)
+
+    @log_call(logger.debug)
+    def UserNotValidated(self, app_name, email):
+        """Signal thrown when the user is not validated."""
+        self.proxy.UserNotValidated(app_name, email)
+
+    def login(self, app_name, email, password):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
@@ -103,18 +157,25 @@
             is_validated = self.processor.is_validated(credentials)
             logger.debug('user is validated? %r.', is_validated)
             if is_validated:
-                # pylint: disable=E1101
                 d = Keyring().set_credentials(app_name, credentials)
-                d.addCallback(lambda _: result_cb(app_name, email))
-                d.addErrback(lambda failure: \
-                             error_cb(app_name,
-                                      except_to_errdict(failure.value)))
+                d.addCallback(lambda _: self.LoggedIn(app_name, email))
+                d.addErrback(lambda f: self.LoginError(app_name, f.value))
             else:
-                not_validated_cb(app_name, email)
-        thread_execute(f, app_name, success_cb, error_cb)
-
-    def validate_email(self, app_name, email, password, email_token,
-                       result_cb, error_cb):
+                self.UserNotValidated(app_name, email)
+        thread_execute(f, app_name, success_cb, self.LoginError)
+
+    @log_call(logger.debug)
+    def EmailValidated(self, app_name, result):
+        """Signal thrown after the email is validated."""
+        self.proxy.EmailValidated(app_name, result)
+
+    @log_call(logger.debug)
+    def EmailValidationError(self, app_name, error):
+        """Signal thrown when there's a problem validating the email."""
+        error_dict = except_to_errdict(error)
+        self.proxy.EmailValidationError(app_name, error_dict)
+
+    def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
 
         def f():
@@ -126,33 +187,54 @@
 
         def success_cb(app_name, credentials):
             """Validation finished successfully."""
-            # pylint: disable=E1101
             d = Keyring().set_credentials(app_name, credentials)
-            d.addCallback(lambda _: result_cb(app_name, email))
-            failure_cb = lambda f: error_cb(app_name, f.value)
+            d.addCallback(lambda _: self.EmailValidated(app_name, email))
+            failure_cb = lambda f: self.EmailValidationError(app_name, f.value)
             d.addErrback(failure_cb)
 
-        thread_execute(f, app_name, success_cb, error_cb)
-
-    def request_password_reset_token(self, app_name, email,
-                                     result_cb, error_cb):
+        thread_execute(f, app_name, success_cb, self.EmailValidationError)
+
+    @log_call(logger.debug)
+    def PasswordResetTokenSent(self, app_name, result):
+        """Signal thrown when the token is succesfully sent."""
+        self.proxy.PasswordResetTokenSent(app_name, result)
+
+    @log_call(logger.debug)
+    def PasswordResetError(self, app_name, error):
+        """Signal thrown when there's a problem sending the token."""
+        error_dict = except_to_errdict(error)
+        self.proxy.PasswordResetError(app_name, error_dict)
+
+    def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
             return self.processor.request_password_reset_token(email)
-        thread_execute(f, app_name, result_cb, error_cb)
-
-    def set_new_password(self, app_name, email, token, new_password,
-                         result_cb, error_cb):
+        thread_execute(f, app_name,
+                       self.PasswordResetTokenSent, self.PasswordResetError)
+
+    @log_call(logger.debug)
+    def PasswordChanged(self, app_name, result):
+        """Signal thrown when the token is succesfully sent."""
+        self.proxy.PasswordChanged(app_name, result)
+
+    @log_call(logger.debug)
+    def PasswordChangeError(self, app_name, error):
+        """Signal thrown when there's a problem sending the token."""
+        error_dict = except_to_errdict(error)
+        self.proxy.PasswordChangeError(app_name, error_dict)
+
+    def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
             return self.processor.set_new_password(email, token,
                                                    new_password)
-        thread_execute(f, app_name, result_cb, error_cb)
-
-
-class CredentialsManagementRoot(object):
+        thread_execute(f, app_name,
+                       self.PasswordChanged, self.PasswordChangeError)
+
+
+class CredentialsManagement(object):
     """Object that manages credentials.
 
     Every exposed method in this class requires one mandatory argument:
@@ -178,27 +260,12 @@
 
     """
 
-    def __init__(self, timeout_func, shutdown_func, found_cb, error_cb,
-                 denied_cb, *args, **kwargs):
-        """Create a new instance.
-
-        - 'found_cb' is a callback that will be executed when the credentials
-        were found.
-
-        - 'error_cb' is a callback that will be executed when there was an
-        error getting the credentials.
-
-        - 'denied_cb' is a callback that will be executed when the user denied
-        the use of the crendetials.
-
-        """
-        super(CredentialsManagementRoot, self).__init__(*args, **kwargs)
+    def __init__(self, timeout_func, shutdown_func, proxy):
+        super(CredentialsManagement, self).__init__()
         self._ref_count = 0
         self.timeout_func = timeout_func
         self.shutdown_func = shutdown_func
-        self.found_cb = found_cb
-        self.error_cb = error_cb
-        self.denied_cb = denied_cb
+        self.proxy = proxy
 
     def _get_ref_count(self):
         """Get value of ref_count."""
@@ -236,12 +303,54 @@
         """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.found_cb
-        result[ERROR_CB_KEY] = self.error_cb
-        result[DENIAL_CB_KEY] = self.denied_cb
+        result[SUCCESS_CB_KEY] = self.CredentialsFound
+        result[ERROR_CB_KEY] = self.CredentialsError
+        result[DENIAL_CB_KEY] = self.AuthorizationDenied
         return result
 
-    def find_credentials(self, app_name, args, success_cb, error_cb):
+    @log_call(logger.info)
+    def AuthorizationDenied(self, app_name):
+        """Signal thrown when the user denies the authorization."""
+        self.ref_count -= 1
+        self.proxy.AuthorizationDenied(app_name)
+
+    # do not use log_call decorator since we should not log credentials
+    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".',
+                    self.__class__.__name__, app_name)
+        self.proxy.CredentialsFound(app_name, credentials)
+
+    @log_call(logger.info)
+    def CredentialsNotFound(self, app_name):
+        """Signal thrown when the credentials are not found."""
+        self.ref_count -= 1
+        self.proxy.CredentialsNotFound(app_name)
+
+    @log_call(logger.info)
+    def CredentialsCleared(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+        self.ref_count -= 1
+        self.proxy.CredentialsCleared(app_name)
+
+    @log_call(logger.info)
+    def CredentialsStored(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+        self.ref_count -= 1
+        self.proxy.CredentialsStored(app_name)
+
+    @log_call(logger.error)
+    def CredentialsError(self, app_name, error):
+        """Signal thrown when there is a problem getting the credentials."""
+        self.ref_count -= 1
+        if isinstance(error, dict):
+            error_dict = error
+        else:
+            error_dict = except_to_errdict(error)
+        self.proxy.CredentialsError(app_name, error_dict)
+
+    def find_credentials(self, app_name, args, success_cb=None, error_cb=None):
         """Look for the credentials for an application.
 
         - 'app_name': the name of the application which credentials are
@@ -249,21 +358,47 @@
 
         - 'args' is a dictionary, currently not used.
 
-        - 'success_cb' is a callback that will be execute if the operation was
+        - 'success_cb', if not None, will be executed if the operation was
         a success.
 
-        - 'error_cb' is a callback that will be executed if the operation had
+        - 'error_cb', if not None, will be executed if the operation had
         an error.
 
         """
+        def _analize_creds(credentials):
+            """Find credentials and notify using signals."""
+            if credentials is not None and len(credentials) > 0:
+                self.CredentialsFound(app_name, credentials)
+            else:
+                self.CredentialsNotFound(app_name)
+
+        def _tweaked_success_cb(creds):
+            """Decrease ref counter and call 'success_cb'."""
+            self.ref_count -= 1
+            success_cb(creds)
+
+        if success_cb is None:
+            _success_cb = _analize_creds
+        else:
+            _success_cb = _tweaked_success_cb
+
+        def _tweaked_error_cb(error, app):
+            """Decrease ref counter and call 'error_cb', modifying the dict."""
+            self.ref_count -= 1
+            error_cb(except_to_errdict(error.value))
+
+        if error_cb is None:
+            _error_cb = lambda f, _: self.CredentialsError(app_name, f.value)
+        else:
+            _error_cb = _tweaked_error_cb
+
         self.ref_count += 1
         obj = Credentials(app_name)
         d = obj.find_credentials()
-        # pylint: disable=E1101
-        d.addCallback(success_cb)
-        d.addErrback(error_cb, app_name)
+        d.addCallback(_success_cb)
+        d.addErrback(_error_cb, app_name)
 
-    def clear_credentials(self, app_name, args, success_cb, error_cb):
+    def clear_credentials(self, app_name, args):
         """Clear the credentials for an application.
 
         - 'app_name': the name of the application which credentials are
@@ -271,21 +406,14 @@
 
         - 'args' is a dictionary, currently not used.
 
-        - 'success_cb' is a callback that will be execute if the operation was
-        a success.
-
-        - 'error_cb' is a callback that will be executed if the operation had
-        an error.
-
         """
         self.ref_count += 1
         obj = Credentials(app_name)
         d = obj.clear_credentials()
-        # pylint: disable=E1101
-        d.addCallback(success_cb)
-        d.addErrback(error_cb, app_name)
+        d.addCallback(lambda _: self.CredentialsCleared(app_name))
+        d.addErrback(lambda f: self.CredentialsError(app_name, f.value))
 
-    def store_credentials(self, app_name, args, success_cb, error_cb):
+    def store_credentials(self, app_name, args):
         """Store the token for an application.
 
         - 'app_name': the name of the application which credentials are
@@ -295,18 +423,12 @@
         the following mandatory keys: 'token', 'token_key', 'consumer_key',
         'consumer_secret'.
 
-        - 'success_cb' is a callback that will be execute if the operation was
-        a success.
-
-        - 'error_cb' is a callback that will be executed if the operation had
-        an error.
         """
         self.ref_count += 1
         obj = Credentials(app_name)
         d = obj.store_credentials(args)
-        # pylint: disable=E1101
-        d.addCallback(success_cb)
-        d.addErrback(error_cb, app_name)
+        d.addCallback(lambda _: self.CredentialsStored(app_name))
+        d.addErrback(lambda f: self.CredentialsError(app_name, f.value))
 
     def register(self, app_name, args):
         """Get credentials if found else prompt GUI to register."""
@@ -331,23 +453,47 @@
         email = args.pop('email')
         password = args.pop('password')
         obj = Credentials(app_name, **self._parse_args(args))
-        obj.login_email_password(email=email, password=password)
-
-
-# pylint: disable=C0103
-
-if sys.platform == 'win32':
-    from ubuntu_sso.main import windows
-    source = windows
-    TIMEOUT_INTERVAL = 10000000000  # forever
-else:
-    from ubuntu_sso.main import linux
-    source = linux
-
-CredentialsManagement = source.CredentialsManagement
-get_sso_login_backend = source.get_sso_login_backend
-main = source.main
-SSOLogin = source.SSOLogin
-thread_execute = source.blocking
+        obj.login(email=email, password=password)
+
 
 # pylint: enable=C0103
+
+class UbuntuSSOService(object):
+    """Manager that exposes the diff referenceable objects."""
+
+    def __init__(self):
+        self.proxy = UbuntuSSOProxy(self)
+        self.sso_login = None
+        self.cred_manager = None
+
+    @defer.inlineCallbacks
+    def start(self):
+        """Start the service."""
+        logger.debug('Starting up Ubuntu SSO service...')
+        try:
+            yield self.proxy.start()
+        except:
+            logger.exception('Can not start Ubuntu SSO service:')
+            raise
+        else:
+            logger.info('Ubuntu SSO service started.')
+
+        self.sso_login = SSOLogin(proxy=self.proxy.sso_login)
+        self.cred_manager = CredentialsManagement(
+                                timeout_func=source.timeout_func,
+                                shutdown_func=source.shutdown_func,
+                                proxy=self.proxy.cred_manager)
+
+    def shutdown(self):
+        """Shutdown the service."""
+        return self.proxy.shutdown()
+
+
+def main():
+    """Run the backend service."""
+    logger.info('Setting up Ubuntu SSO service.')
+    source.start_setup()
+    service = UbuntuSSOService()
+    d = service.start()
+    d.addBoth(source.finish_setup)
+    source.main()

=== modified file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	2011-12-19 19:35:06 +0000
+++ ubuntu_sso/main/linux.py	2012-01-17 16:51:50 +0000
@@ -13,23 +13,26 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Single Sign On login handler.
-
-An utility which accepts requests for Ubuntu Single Sign On login over D-Bus.
-
-The OAuth process is handled, including adding the OAuth access token to the
-local keyring.
+"""Main module implementation specific for linux.
+
+This module should never import from the multiplatform one (main/__init__.py),
+but the other way around. Likewise, this module should *not* have any logic
+regarding error processing or decision making about when to send a given
+signal.
+
+Also, most of the logging is being made in the main module to avoid
+duplication between the different platform implementations.
 
 """
 
 import threading
 import signal
-import sys
 
 import dbus.mainloop.glib
 import dbus.service
 import gtk
 
+from twisted.internet import defer
 
 from ubuntu_sso import (
     DBUS_ACCOUNT_PATH,
@@ -39,13 +42,7 @@
     DBUS_IFACE_USER_NAME,
     NO_OP,
 )
-from ubuntu_sso.account import Account
 from ubuntu_sso.logger import setup_logging
-from ubuntu_sso.main import (
-    CredentialsManagementRoot,
-    SSOLoginRoot,
-    except_to_errdict,
-)
 
 
 # Disable the invalid name warning, as we have a lot of DBus style names
@@ -62,162 +59,124 @@
         try:
             result_cb(app_name, f())
         except Exception, e:  # pylint: disable=W0703
-            msg = "Exception while running DBus blocking code in a thread:"
+            msg = "Exception while running blocking code in a thread:"
             logger.exception(msg)
-            error_cb(app_name, except_to_errdict(e))
+            error_cb(app_name, e)
     threading.Thread(target=_in_thread).start()
 
 
-class SSOLogin(dbus.service.Object):
+class SSOLoginProxy(dbus.service.Object):
     """Login thru the Single Sign On service."""
 
     # Operator not preceded by a space (fails with dbus decorators)
     # pylint: disable=C0322
 
-    def __init__(self, bus_name, object_path=DBUS_ACCOUNT_PATH,
-                 sso_login_processor_class=Account,
-                 sso_service_class=None):
+    def __init__(self, root, *args, **kwargs):
         """Initiate the Login object."""
-        dbus.service.Object.__init__(self, object_path=object_path,
-                                     bus_name=bus_name)
-        self.root = SSOLoginRoot(sso_login_processor_class, sso_service_class)
+        super(SSOLoginProxy, self).__init__(*args, **kwargs)
+        self.root = root
 
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def CaptchaGenerated(self, app_name, result):
         """Signal thrown after the captcha is generated."""
-        logger.debug('SSOLogin: emitting CaptchaGenerated with app_name "%s" '
-                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def CaptchaGenerationError(self, app_name, error):
         """Signal thrown when there's a problem generating the captcha."""
-        logger.debug('SSOLogin: emitting CaptchaGenerationError with '
-                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ss')
     def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
-        self.root.generate_captcha(app_name, filename,
-                                   self.CaptchaGenerated,
-                                   self.CaptchaGenerationError)
+        self.root.sso_login.generate_captcha(app_name, filename)
 
     # register_user signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def UserRegistered(self, app_name, result):
         """Signal thrown when the user is registered."""
-        logger.debug('SSOLogin: emitting UserRegistered with app_name "%s" '
-                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def UserRegistrationError(self, app_name, error):
         """Signal thrown when there's a problem registering the user."""
-        logger.debug('SSOLogin: emitting UserRegistrationError with '
-                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssssss')
     def register_user(self, app_name, email, password, name,
                       captcha_id, captcha_solution):
         """Call the matching method in the processor."""
-        self.root.register_user(app_name, email, password, name, captcha_id,
-                                captcha_solution,
-                                self.UserRegistered,
-                                self.UserRegistrationError)
+        self.root.sso_login.register_user(app_name, email, password, name,
+            captcha_id, captcha_solution)
 
     # login signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def LoggedIn(self, app_name, result):
         """Signal thrown when the user is logged in."""
-        logger.debug('SSOLogin: emitting LoggedIn with app_name "%s" '
-                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def LoginError(self, app_name, error):
         """Signal thrown when there is a problem in the login."""
-        logger.debug('SSOLogin: emitting LoginError with '
-                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def UserNotValidated(self, app_name, result):
         """Signal thrown when the user is not validated."""
-        logger.debug('SSOLogin: emitting UserNotValidated with app_name "%s" '
-                     'and result %r', app_name, result)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='sss')
     def login(self, app_name, email, password):
         """Call the matching method in the processor."""
-        self.root.login(app_name, email, password, self.LoggedIn,
-                        self.LoginError, self.UserNotValidated)
+        self.root.sso_login.login(app_name, email, password)
 
     # validate_email signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def EmailValidated(self, app_name, result):
         """Signal thrown after the email is validated."""
-        logger.debug('SSOLogin: emitting EmailValidated with app_name "%s" '
-                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def EmailValidationError(self, app_name, error):
         """Signal thrown when there's a problem validating the email."""
-        logger.debug('SSOLogin: emitting EmailValidationError with '
-                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssss')
     def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
-        self.root.validate_email(app_name, email, password, email_token,
-                                 self.EmailValidated,
-                                 self.EmailValidationError)
+        self.root.sso_login.validate_email(app_name,
+            email, password, email_token)
 
     # request_password_reset_token signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def PasswordResetTokenSent(self, app_name, result):
         """Signal thrown when the token is succesfully sent."""
-        logger.debug('SSOLogin: emitting PasswordResetTokenSent with app_name '
-                     '"%s" and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def PasswordResetError(self, app_name, error):
         """Signal thrown when there's a problem sending the token."""
-        logger.debug('SSOLogin: emitting PasswordResetError with '
-                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ss')
     def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
-        self.root.request_password_reset_token(app_name, email,
-                                               self.PasswordResetTokenSent,
-                                               self.PasswordResetError)
+        self.root.sso_login.request_password_reset_token(app_name, email)
 
     # set_new_password signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
     def PasswordChanged(self, app_name, result):
         """Signal thrown when the token is succesfully sent."""
-        logger.debug('SSOLogin: emitting PasswordChanged with app_name "%s" '
-                     'and result %r', app_name, result)
 
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
     def PasswordChangeError(self, app_name, error):
         """Signal thrown when there's a problem sending the token."""
-        logger.debug('SSOLogin: emitting PasswordChangeError with '
-                     'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssss')
     def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
-        self.root.set_new_password(app_name, email, token, new_password,
-                                   self.PasswordChanged,
-                                   self.PasswordChangeError)
-
-
-class CredentialsManagement(dbus.service.Object):
-    """DBus object that manages credentials.
+        self.root.sso_login.set_new_password(app_name,
+            email, token, new_password)
+
+
+class CredentialsManagementProxy(dbus.service.Object):
+    """Object that manages credentials.
 
     Every exposed method in this class requires one mandatory argument:
 
@@ -242,67 +201,36 @@
 
     """
 
-    def __init__(self, timeout_func, shutdown_func, *args, **kwargs):
-        super(CredentialsManagement, self).__init__(*args, **kwargs)
-        self.root = CredentialsManagementRoot(timeout_func, shutdown_func,
-                                              self.CredentialsFound,
-                                              self.CredentialsError,
-                                              self.AuthorizationDenied)
+    def __init__(self, root, *args, **kwargs):
+        super(CredentialsManagementProxy, self).__init__(*args, **kwargs)
+        self.root = root
 
     # Operator not preceded by a space (fails with dbus decorators)
     # pylint: disable=C0322
 
-    def _process_failure(self, failure, app_name):
-        """Process the 'failure' and emit CredentialsError."""
-        self.CredentialsError(app_name, except_to_errdict(failure.value))
-
-    def shutdown(self):
-        """If no ongoing requests, call self.shutdown_func."""
-        logger.debug('shutdown!, ref_count is %r.', self.root.ref_count)
-        self.root.shutdown()
-
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
     def AuthorizationDenied(self, app_name):
         """Signal thrown when the user denies the authorization."""
-        self.root.ref_count -= 1
-        logger.info('%s: emitting AuthorizationDenied with app_name "%s".',
-                    self.__class__.__name__, app_name)
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
     def CredentialsFound(self, app_name, credentials):
         """Signal thrown when the credentials are found."""
-        self.root.ref_count -= 1
-        logger.info('%s: emitting CredentialsFound with app_name "%s".',
-                    self.__class__.__name__, app_name)
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
     def CredentialsNotFound(self, app_name):
         """Signal thrown when the credentials are not found."""
-        self.root.ref_count -= 1
-        logger.info('%s: emitting CredentialsNotFound with app_name "%s".',
-                    self.__class__.__name__, app_name)
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
     def CredentialsCleared(self, app_name):
         """Signal thrown when the credentials were cleared."""
-        self.root.ref_count -= 1
-        logger.info('%s: emitting CredentialsCleared with app_name "%s".',
-                    self.__class__.__name__, app_name)
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
     def CredentialsStored(self, app_name):
         """Signal thrown when the credentials were cleared."""
-        self.root.ref_count -= 1
-        logger.info('%s: emitting CredentialsStored with app_name "%s".',
-                    self.__class__.__name__, app_name)
 
     @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
     def CredentialsError(self, app_name, error_dict):
         """Signal thrown when there is a problem getting the credentials."""
-        self.root.ref_count -= 1
-        logger.error('%s: emitting CredentialsError with app_name "%s" and '
-                     'error_dict %r.', self.__class__.__name__, app_name,
-                     error_dict)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
@@ -315,16 +243,7 @@
         - 'args' is a dictionary, currently not used.
 
         """
-
-        def success_cb(credentials):
-            """Find credentials and notify using signals."""
-            if credentials is not None and len(credentials) > 0:
-                self.CredentialsFound(app_name, credentials)
-            else:
-                self.CredentialsNotFound(app_name)
-
-        self.root.find_credentials(app_name, args, success_cb,
-                                   self._process_failure)
+        self.root.cred_manager.find_credentials(app_name, args)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature="sa{ss}", out_signature="a{ss}",
@@ -337,20 +256,13 @@
 
         """
 
-        def decrease_counter_success(credentials):
-            """Call 'reply_handler' and decrease the root ref counter."""
-            reply_handler(credentials)
-            self.root.ref_count -= 1
-
-        def decrease_counter_error(failure, app_name):
-            """Call 'error_handler' and decrease the root ref counter."""
-            error_dict = except_to_errdict(failure.value)
-            error_handler(dbus.service.DBusException(error_dict))
-            self.root.ref_count -= 1
-
-        self.root.find_credentials(app_name, args,
-                                   success_cb=decrease_counter_success,
-                                   error_cb=decrease_counter_error)
+        def _drop_dict(error_dict):
+            """Call 'error_handler' properly."""
+            error_handler(dbus.service.DBusException(error_dict['errtype']))
+
+        self.root.cred_manager.find_credentials(app_name, args,
+                                   success_cb=reply_handler,
+                                   error_cb=_drop_dict)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
@@ -363,9 +275,7 @@
         - 'args' is a dictionary, currently not used.
 
         """
-        self.root.clear_credentials(app_name, args,
-                                lambda _: self.CredentialsCleared(app_name),
-                                self._process_failure)
+        self.root.cred_manager.clear_credentials(app_name, args)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
@@ -380,21 +290,19 @@
         'consumer_secret'.
 
         """
-        self.root.store_credentials(app_name, args,
-                                lambda _: self.CredentialsStored(app_name),
-                                self._process_failure)
+        self.root.cred_manager.store_credentials(app_name, args)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
     def register(self, app_name, args):
         """Get credentials if found else prompt GUI to register."""
-        self.root.register(app_name, args)
+        self.root.cred_manager.register(app_name, args)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
     def login(self, app_name, args):
         """Get credentials if found else prompt GUI to login."""
-        self.root.login(app_name, args)
+        self.root.cred_manager.login(app_name, args)
 
     @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
                          in_signature='sa{ss}', out_signature='')
@@ -406,12 +314,121 @@
         returned trough the CredentialsFound signal.
 
         """
-        self.root.login_email_password(app_name, args)
-
-
-def get_sso_login_backend():
-    """Get the backend for the Login service."""
-    raise NotImplementedError()
+        self.root.cred_manager.login_email_password(app_name, args)
+
+
+class UbuntuSSOProxy(object):
+    """Object that exposes the diff referenceable objects."""
+
+    def __init__(self, root):
+        self.root = root
+        self.bus = dbus.SessionBus()
+        self.sso_login = None
+        self.cred_manager = None
+
+    def start(self):
+        """Start listening, nothing async to be done in this platform."""
+        # Register DBus service for making sure we run only one instance
+        name = self.bus.request_name(DBUS_BUS_NAME,
+                                     dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
+        if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
+            raise AlreadyStartedError()
+
+        bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=self.bus)
+        self.sso_login = SSOLoginProxy(self.root,
+                                       bus_name=bus_name,
+                                       object_path=DBUS_ACCOUNT_PATH)
+        self.cred_manager = CredentialsManagementProxy(self.root,
+                                bus_name=bus_name,
+                                object_path=DBUS_CREDENTIALS_PATH)
+
+        return defer.succeed(None)
+
+    def shutdown(self):
+        """Shutdown the service."""
+        self.sso_login.remove_from_connection()
+        self.cred_manager.remove_from_connection()
+        self.bus.release_name(DBUS_BUS_NAME)
+        return defer.succeed(None)
+
+
+# ============================== client classes ==============================
+
+
+class RemoteClient(object):
+    """Client that can perform calls to remote DBus object."""
+
+    bus_name = None
+    path = None
+    interface = None
+
+    def __init__(self):
+        self.bus = dbus.SessionBus()
+        obj = self.bus.get_object(bus_name=self.bus_name,
+                                  object_path=self.path,
+                                  follow_name_owner_changes=True)
+        self.dbus_iface = dbus.Interface(obj, dbus_interface=self.interface)
+        self.dbus_iface.call_method = self.call_method
+        self.dbus_iface.disconnect_from_signal = lambda _, sig: sig.remove()
+
+    def call_method(self, method_name, *args, **kwargs):
+        """Call asynchronously 'method_name(*args)'.
+
+        Return a deferred that will be fired when the call finishes.
+
+        """
+        d = defer.Deferred()
+
+        reply_handler = kwargs.get('reply_handler', None)
+        if reply_handler is not None:
+            d.addCallback(lambda a: reply_handler(*a))
+
+        error_handler = kwargs.get('error_handler', None)
+        if error_handler is not None:
+            d.addErrback(lambda f: error_handler(f.value))
+
+        self.bus.call_async(
+            bus_name=self.bus_name, object_path=self.path,
+            dbus_interface=self.interface, method=method_name,
+            signature=None, args=args,
+            reply_handler=lambda *a: d.callback(a),
+            error_handler=d.errback)
+
+        return d
+
+
+class SSOLoginClient(RemoteClient):
+    """Access the UserManagement DBus interface."""
+
+    bus_name = DBUS_BUS_NAME
+    path = DBUS_ACCOUNT_PATH
+    interface = DBUS_IFACE_USER_NAME
+
+
+class CredentialsManagementClient(RemoteClient):
+    """Access the CredentialsManagement DBus interface."""
+
+    bus_name = DBUS_BUS_NAME
+    path = DBUS_CREDENTIALS_PATH
+    interface = DBUS_CREDENTIALS_IFACE
+
+
+class UbuntuSSOClient(object):
+    """Base client that provides remote access to the sso API."""
+
+    def __init__(self):
+        self.sso_login = SSOLoginClient().dbus_iface
+        self.cred_manager = CredentialsManagementClient().dbus_iface
+
+    def disconnect(self):
+        """No need to disconnect DBus proxy objects."""
+        return defer.succeed(None)
+
+
+def get_sso_client():
+    """Get a client to access the SSO service."""
+    result = UbuntuSSOClient()
+    return defer.succeed(result)
 
 
 def sighup_handler(*a, **kw):
@@ -422,32 +439,32 @@
     #
     # gtk.main_quit and the logger methods are safe to be called from any
     # thread. Just don't call other random stuff here.
-    logger.info("Stoping Ubuntu SSO login manager since SIGHUP was received.")
+    logger.info("Stoping Ubuntu SSO service since SIGHUP was received.")
     gtk.main_quit()
 
 
-def main():
-    """Run the backend service."""
+class AlreadyStartedError(Exception):
+    """The backend service has already been started."""
+
+
+timeout_func = gtk.timeout_add
+shutdown_func = gtk.main_quit
+
+
+def start_setup():
+    """Setup the env to run the service."""
     dbus.mainloop.glib.threads_init()
     gtk.gdk.threads_init()
     dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 
-    bus = dbus.SessionBus()
-    # Register DBus service for making sure we run only one instance
-    name = bus.request_name(DBUS_BUS_NAME,
-                            dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-    if name == dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-        logger.error("Ubuntu SSO login manager already running, quitting.")
-        sys.exit(0)
-
-    logger.debug("Hooking up SIGHUP with handler %r.", sighup_handler)
-    signal.signal(signal.SIGHUP, sighup_handler)
-
-    logger.info("Starting Ubuntu SSO login manager for bus %r.", DBUS_BUS_NAME)
-    bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
-    SSOLogin(bus_name, object_path=DBUS_ACCOUNT_PATH)
-    CredentialsManagement(timeout_func=gtk.timeout_add,
-                          shutdown_func=gtk.main_quit,
-                          bus_name=bus_name, object_path=DBUS_CREDENTIALS_PATH)
-
-    gtk.main()
+
+def finish_setup(result):
+    """Run the specific mainloop only if no failure ocurred."""
+    if result is None:  # no failure ocurred, start the service
+        logger.debug("Hooking up SIGHUP with handler %r.", sighup_handler)
+        signal.signal(signal.SIGHUP, sighup_handler)
+        gtk.main()
+
+
+def main():
+    """Run the specific mainloop."""

=== modified file 'ubuntu_sso/main/tests/__init__.py'
--- ubuntu_sso/main/tests/__init__.py	2011-02-24 13:06:07 +0000
+++ ubuntu_sso/main/tests/__init__.py	2012-01-17 16:51:50 +0000
@@ -15,3 +15,40 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Test the different main implementations."""
+
+import sys
+
+from twisted.internet import defer
+
+from ubuntu_sso.tests import TOKEN
+
+# Invalid name "BaseTestCase"
+# pylint: disable=C0103
+
+if sys.platform == 'win32':
+    from ubuntu_sso.utils.tests.test_ipc import BaseIPCTestCase
+    BaseTestCase = BaseIPCTestCase
+else:
+    from ubuntuone.devtools.testcases.dbus import DBusTestCase
+    BaseTestCase = DBusTestCase
+
+# pylint: enable=C0103
+
+
+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)
+
+    def clear_credentials(self, *a, **kw):
+        """Clear credentials."""
+        return defer.succeed(None)
+
+    def store_credentials(self, *a, **kw):
+        """Store credentials."""
+        return defer.succeed(None)

=== added file 'ubuntu_sso/main/tests/test_clients.py'
--- ubuntu_sso/main/tests/test_clients.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/main/tests/test_clients.py	2012-01-17 16:51:50 +0000
@@ -0,0 +1,373 @@
+# -*- 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 main SSO client code."""
+
+from twisted.internet import defer
+from ubuntuone.devtools.testcases import skipIfOS
+
+from ubuntu_sso import main
+from ubuntu_sso.tests import (
+    APP_NAME,
+    CAPTCHA_ID,
+    CAPTCHA_SOLUTION,
+    EMAIL,
+    EMAIL_TOKEN,
+    NAME,
+    PASSWORD,
+    TOKEN,
+)
+from ubuntu_sso.main.tests import BaseTestCase, FakedCredentials
+
+FILENAME = 'sample filename'
+
+
+class FakedKeyring(object):
+    """A faked Keyring object."""
+
+    _keys = {}
+
+    def get_credentials(self, app_name):
+        """Return the credentials for app_name."""
+        return defer.succeed(self._keys.get(app_name, {}))
+
+    def delete_credentials(self, app_name):
+        """Delete the credentials for app_name."""
+        self._keys.pop(app_name, None)
+        return defer.succeed(None)
+
+    def set_credentials(self, app_name, token):
+        """Store the credentials for app_name."""
+        self._keys[app_name] = token
+        return defer.succeed(None)
+
+
+class AbstractTestCase(BaseTestCase):
+    """The base test case with platform specific support."""
+
+    timeout = 2
+    method = None
+    backend_method = method
+    params = ()
+    success_signal = None
+    backend_result = None
+    success_result = None
+    error_signal = None
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(AbstractTestCase, self).setUp()
+        self.keyring = FakedKeyring()
+        self.patch(main, 'Keyring', lambda: self.keyring)
+
+        # avoid putting stuff in the mainloops
+        self.patch(main.source, 'timeout_func', lambda *a: None)
+        self.patch(main.source, 'shutdown_func', lambda *a: None)
+
+        self.sso_service = main.UbuntuSSOService()
+        yield self.sso_service.start()
+        self.addCleanup(self.sso_service.shutdown)
+
+        self.sso_client = yield main.get_sso_client()
+        self.addCleanup(self.sso_client.disconnect)
+
+        self.client = self.patchable_backend = None
+
+        if self.backend_method is None:
+            self.backend_method = self.method
+
+    def _backend_succeed(self, *args, **kwargs):
+        """Make self.patchable_backend return self.backend_result."""
+        return self.backend_result
+
+    def _backend_fail(self, *args, **kwargs):
+        """Make self.patchable_backend raise an exception."""
+        raise ValueError((args, kwargs))
+
+    @defer.inlineCallbacks
+    def assert_method_correct(self, success_signal, error_signal,
+                              patched_backend_method, expected_result=None):
+        """Calling 'self.method' works ok.
+
+        Check that 'success_signal' is emitted, and make the test fail if
+        error_signal is received.
+
+        The self.patchable_backend will be patched with
+        'patched_backend_method'.
+
+        """
+        if self.method is None:
+            defer.returnValue(None)
+
+        d = defer.Deferred()
+
+        cb = lambda *a: d.callback(a)
+        match = self.client.connect_to_signal(success_signal, cb)
+        self.addCleanup(self.client.disconnect_from_signal,
+                        success_signal, match)
+
+        eb = lambda *a: d.errback(AssertionError(a))
+        match = self.client.connect_to_signal(error_signal, eb)
+        self.addCleanup(self.client.disconnect_from_signal,
+                        error_signal, match)
+
+        self.patch(self.patchable_backend, self.backend_method,
+                   patched_backend_method)
+
+        yield self.client.call_method(self.method, *self.params)
+
+        result = yield d
+        self.assertEqual(expected_result, result)
+
+    def test_success(self):
+        """Test that the 'method' works ok."""
+        success_signal = self.success_signal
+        error_signal = self.error_signal
+        patched_backend_method = self._backend_succeed
+        expected_result = self.success_result
+
+        return self.assert_method_correct(success_signal, error_signal,
+                    patched_backend_method, expected_result)
+
+    def test_error(self):
+        """Test that the 'method' fails as expected."""
+        success_signal = self.error_signal
+        error_signal = self.success_signal
+        patched_backend_method = self._backend_fail
+        expected_result = (APP_NAME, dict(errtype='ValueError'))
+
+        return self.assert_method_correct(success_signal, error_signal,
+                    patched_backend_method, expected_result)
+
+
+class SSOLoginProxyTestCase(AbstractTestCase):
+    """Test the SSOLoginProxy interface."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(SSOLoginProxyTestCase, self).setUp()
+        self.client = self.sso_client.sso_login
+        self.patchable_backend = self.sso_service.sso_login.processor
+
+
+class GenerateCaptchaTestCase(SSOLoginProxyTestCase):
+    """Test the generate_captcha method."""
+
+    method = 'generate_captcha'
+    params = (APP_NAME, FILENAME)
+    success_signal = 'CaptchaGenerated'
+    error_signal = 'CaptchaGenerationError'
+    backend_result = 'a captcha id'
+    success_result = (APP_NAME, backend_result)
+
+
+class RegisterUserTestCase(SSOLoginProxyTestCase):
+    """Test the register_user method."""
+
+    method = 'register_user'
+    params = (APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID, CAPTCHA_SOLUTION)
+    success_signal = 'UserRegistered'
+    error_signal = 'UserRegistrationError'
+    backend_result = EMAIL
+    success_result = (APP_NAME, backend_result)
+
+
+class LoginTestCase(SSOLoginProxyTestCase):
+    """Test the login method."""
+
+    method = 'login'
+    params = (APP_NAME, EMAIL, PASSWORD)
+    success_signal = 'LoggedIn'
+    error_signal = 'LoginError'
+    backend_result = TOKEN
+    success_result = (APP_NAME, EMAIL)
+
+    @defer.inlineCallbacks
+    def test_success(self):
+        """Test that the 'method' works ok when the user is validated."""
+        self.patch(self.patchable_backend, 'is_validated', lambda _: True)
+
+        yield super(LoginTestCase, self).test_success()
+
+        expected_credentials = yield self.keyring.get_credentials(APP_NAME)
+        self.assertEqual(expected_credentials, TOKEN)
+
+    def test_not_validated(self):
+        """Test that the 'method' works ok when the user is not validated."""
+        self.patch(self.patchable_backend, 'is_validated', lambda _: False)
+        self.patch(self, 'success_signal', 'UserNotValidated')
+
+        return super(LoginTestCase, self).test_success()
+
+    def test_error_when_setting_credentials(self):
+        """The 'error_signal' is emitted when credentials can't be set."""
+        self.patch(self.patchable_backend, 'is_validated', lambda _: True)
+        exc = TypeError('foo')
+        self.patch(self.keyring, 'set_credentials', lambda *a: defer.fail(exc))
+        patched_backend_method = lambda *a, **kw: self.backend_result
+        expected_result = (APP_NAME, dict(errtype='TypeError', message='foo'))
+
+        return self.assert_method_correct('LoginError', 'LoggedIn',
+                    patched_backend_method, expected_result)
+
+
+class ValidateEmailTestCase(SSOLoginProxyTestCase):
+    """Test the validate_email method."""
+
+    method = 'validate_email'
+    params = (APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
+    success_signal = 'EmailValidated'
+    error_signal = 'EmailValidationError'
+    backend_result = TOKEN
+    success_result = (APP_NAME, EMAIL)
+
+
+class RequestPasswordResetTokenTestCase(SSOLoginProxyTestCase):
+    """Test the request_password_reset_token method."""
+
+    method = 'request_password_reset_token'
+    params = (APP_NAME, EMAIL)
+    success_signal = 'PasswordResetTokenSent'
+    error_signal = 'PasswordResetError'
+    backend_result = EMAIL
+    success_result = (APP_NAME, backend_result)
+
+
+class SetNewPasswordTestCase(SSOLoginProxyTestCase):
+    """Test the set_new_password method."""
+
+    method = 'set_new_password'
+    params = (APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
+    success_signal = 'PasswordChanged'
+    error_signal = 'PasswordChangeError'
+    backend_result = EMAIL
+    success_result = (APP_NAME, backend_result)
+
+
+class CredentialsManagementProxyTestCase(AbstractTestCase):
+    """Tests for the CredentialsManagementProxy DBus interface."""
+
+    error_signal = 'CredentialsError'
+    args = dict(foo='bar', fuh='baz')
+    params = (APP_NAME, args)
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(CredentialsManagementProxyTestCase, self).setUp()
+        self.credentials = FakedCredentials()
+        self.patch(main, 'Credentials', lambda *a, **kw: self.credentials)
+
+        self.client = self.sso_client.cred_manager
+        self.patchable_backend = self.credentials
+
+    def _backend_succeed(self, *args, **kwargs):
+        """Make self.patchable_backend return self.backend_result."""
+        return defer.succeed(self.backend_result)
+
+    def _backend_fail(self, *args, **kwargs):
+        """Make self.patchable_backend return a failed deferred."""
+        return defer.fail(ValueError((args, kwargs)))
+
+
+class FindCredentialsTestCase(CredentialsManagementProxyTestCase):
+    """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.')
+    @defer.inlineCallbacks
+    def test_find_credentials_sync(self):
+        """The credentials are asked and returned in a sync call."""
+        d = defer.Deferred()
+
+        self.client.call_method('find_credentials_sync',
+                                APP_NAME, self.args,
+                                reply_handler=d.callback,
+                                error_handler=d.errback)
+        creds = yield d
+        self.assertEqual(creds, TOKEN)
+
+    @skipIfOS('win32', 'find_credentials_sync is only provided in Linux '
+                       'due to compatibility issues with old clients.')
+    @defer.inlineCallbacks
+    def test_find_credentials_sync_error(self):
+        """If find_credentials_sync fails, error_handler is called."""
+        self.patch(self.credentials, 'find_credentials', self._backend_fail)
+        d = defer.Deferred()
+
+        self.client.call_method('find_credentials_sync',
+                                APP_NAME, self.args,
+                                reply_handler=d.errback,
+                                error_handler=d.callback)
+        error = yield d
+        error = error.args[0]
+        self.assertEqual(error, 'ValueError')
+
+
+class ClearCredentialsTestCase(CredentialsManagementProxyTestCase):
+    """Test the clear_credentials method."""
+
+    method = 'clear_credentials'
+    success_signal = 'CredentialsCleared'
+    success_result = (APP_NAME,)
+
+
+class StoreCredentialsTestCase(CredentialsManagementProxyTestCase):
+    """Test the store_credentials method."""
+
+    method = 'store_credentials'
+    success_signal = 'CredentialsStored'
+    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):
+    """Test the register method."""
+
+    method = 'register'
+
+
+class LoginOnlyTestCase(CredentialsManagementOpsTestCase):
+    """Test the login method."""
+
+    method = 'login'
+
+
+class LoginEmailPasswordTestCase(CredentialsManagementOpsTestCase):
+    """Test the login method."""
+
+    method = 'login_email_password'
+    backend_method = 'login'
+    args = dict(email=EMAIL, password=PASSWORD)
+    params = (APP_NAME, args)

=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2011-09-27 14:06:12 +0000
+++ ubuntu_sso/main/tests/test_common.py	2012-01-17 16:51:50 +0000
@@ -1,12 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# test_main - tests for ubuntu_sso.main
-#
-# Author: Natalia Bidart <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-# Author: Manuel de la Pena <[e-mail]>
-#
-# Copyright 2009-2010 Canonical Ltd.
+# Copyright 2009-2011 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
@@ -19,161 +13,923 @@
 #
 # 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 share by diff platforms."""
-
-from unittest import TestCase
-
-from mocker import MockerTestCase, MATCH
-
+"""Tests for the main SSO client code."""
+
+import logging
+
+from twisted.internet import defer
+from ubuntuone.devtools.handlers import MementoHandler
+
+from ubuntu_sso import main
 from ubuntu_sso.main import (
     CredentialsManagement,
+    except_to_errdict,
     SSOLogin,
+    thread_execute,
+    TIMEOUT_INTERVAL,
+    UbuntuSSOService,
 )
-
-
-class SSOLoginMockedTestCase(MockerTestCase):
-    """Test that the call are relied correctly."""
-
-    def setUp(self):
-        """Setup tests."""
-        super(SSOLoginMockedTestCase, self).setUp()
-        self.root = self.mocker.mock()
-        mockbusname = self.mocker.mock()
-        mockbus = self.mocker.mock()
-        mockbusname.get_bus()
-        self.mocker.result(mockbus)
-        self.login = SSOLogin(mockbus)
-        self.login.root = self.root
-        self.mocker.reset()
-
-    def test_generate_captcha(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        filename = 'file'
-        self.root.generate_captcha(app_name, filename,
-                                   MATCH(callable), MATCH(callable))
-        self.mocker.replay()
-        self.login.generate_captcha(app_name, filename)
-
-    def test_register_user(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        email = 'email'
-        password = 'pwd'
-        name = 'display name'
-        captcha_id = 'id'
-        captcha_solution = 'hello'
-        self.root.register_user(app_name, email, password, name, captcha_id,
-                                captcha_solution,
-                                MATCH(callable), MATCH(callable))
-        self.mocker.replay()
-        self.login.register_user(app_name, email, password, name, captcha_id,
-                                 captcha_solution)
-
-    def test_login(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        email = 'email'
-        password = 'password'
-        self.root.login(app_name, email, password,
-                        MATCH(callable), MATCH(callable),
-                        MATCH(callable))
-        self.mocker.mock()
-        self.mocker.replay()
-        self.login.login(app_name, email, password)
-
-    def test_validate_email(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        email = 'email'
-        password = 'passwrd'
-        email_token = 'token'
-        self.root.validate_email(app_name, email, password, email_token,
-                                 MATCH(callable),
-                                 MATCH(callable))
-        self.mocker.replay()
-        self.login.validate_email(app_name, email, password, email_token)
-
-    def test_request_password_reset_token(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        email = 'email'
-        self.root.request_password_reset_token(app_name, email,
-                                               MATCH(callable),
-                                               MATCH(callable))
-        self.mocker.replay()
-        self.login.request_password_reset_token(app_name, email)
-
-    def test_set_new_password(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        email = 'email'
-        token = 'token'
-        new_password = 'new'
-        self.root.set_new_password(app_name, email, token, new_password,
-                                   MATCH(callable),
-                                   MATCH(callable))
-        self.mocker.replay()
-        self.login.set_new_password(app_name, email, token, new_password)
-
-
-class CredentialsManagementMockedTestCase(MockerTestCase, TestCase):
-    """Test that the call are relied correctly."""
-
-    def setUp(self):
-        """Setup tests."""
-        super(CredentialsManagementMockedTestCase, self).setUp()
-        self.root = self.mocker.mock()
-        self.cred = CredentialsManagement(None, None)
-        self.cred.root = self.root
-
+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)
+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,
+    WINDOW_ID, Recorder, TestCase)
+
+
+# Access to a protected member 'yyy' of a client class
+# pylint: disable=W0212
+
+
+class SampleException(Exception):
+    """The exception that will be thrown by the fake thread_execute."""
+
+
+def fake_ok_thread_execute(f, app, cb, eb):
+    """A fake thread_execute function that succeeds."""
+    cb(app, f())
+
+
+def fake_err_thread_execute(f, app, cb, eb):
+    """A fake thread_execute function that fails."""
+    try:
+        f()
+    except Exception, e:  # pylint: disable=W0703
+        eb(app, except_to_errdict(e))
+    else:
+        eb(app, except_to_errdict(SampleException()))
+
+
+class FakedProxy(Recorder):
+    """A faked multiplatform proxy."""
+
+
+class FakedAccount(Recorder):
+    """A faked Account processor."""
+
+
+class FakedCredentialsFactory(Recorder):
+    """A very dummy Credentials object."""
+
+    credentials = FakedCredentials()
+
+    # pylint: disable=C0103
+
+    def Credentials(self, *a, **kw):
+        """Return always the same Credentials instance."""
+        return self.credentials
+
+    # pylint: enable=C0103
+
+
+class TestExceptToErrdictException(Exception):
+    """A dummy exception for the following testcase."""
+
+
+class ExceptToErrdictTestCase(TestCase):
+    """Tests for the except_to_errdict function."""
+
+    def test_first_arg_is_dict(self):
+        """If the first arg is a dict, use it as the base dict."""
+        sample_dict = {
+            "errorcode1": "error message 1",
+            "errorcode2": "error message 2",
+            "errorcode3": "error message 3",
+        }
+        e = TestExceptToErrdictException(sample_dict)
+        result = except_to_errdict(e)
+
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        for k in sample_dict.keys():
+            self.assertIn(k, result)
+            self.assertEqual(result[k], sample_dict[k])
+
+    def test_first_arg_is_str(self):
+        """If the first arg is a str, use it as the message."""
+        sample_string = "a sample string"
+        e = TestExceptToErrdictException(sample_string)
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        self.assertEqual(result["message"], sample_string)
+
+    def test_first_arg_is_unicode(self):
+        """If the first arg is a unicode, use it as the message."""
+        sample_string = u"a sample string"
+        e = TestExceptToErrdictException(sample_string)
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        self.assertEqual(result["message"], sample_string)
+
+    def test_no_args_at_all(self):
+        """If there are no args, use the class docstring."""
+        e = TestExceptToErrdictException()
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+        self.assertEqual(result["message"], e.__class__.__doc__)
+
+    def test_some_other_thing_as_first_arg(self):
+        """If first arg is not basestring nor dict, then repr all args."""
+        sample_args = (None, u"unicode2\ufffd", "errorcode3")
+        e = TestExceptToErrdictException(*sample_args)
+        result = except_to_errdict(e)
+        self.assertEqual(result["errtype"], e.__class__.__name__)
+
+
+class BaseTestCase(TestCase):
+    """Base test case."""
+
+    timeout = 2
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(BaseTestCase, self).setUp()
+        self.proxy = FakedProxy()
+
+    def assert_recorder_called(self, fake, method, *args, **kwargs):
+        """Check that 'fake.method(*args, **kwargs)' was called."""
+        self.assertEqual(fake._called[method], [(args, kwargs)])
+
+
+class SSOLoginTestCase(BaseTestCase):
+    """Test the SSOLogin class."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(SSOLoginTestCase, self).setUp()
+
+        def ksc(keyring, k, val):
+            """Assert over token and app_name."""
+            self.assertEqual(k, APP_NAME)
+            self.assertEqual(val, TOKEN)
+            self.keyring_was_set = True
+            self.keyring_values = k, val
+            return defer.succeed(None)
+
+        self.patch(main.Keyring, "set_credentials", ksc)
+        self.patch(main, 'Account', FakedAccount)
+        self.patch(main, "thread_execute", fake_ok_thread_execute)
+        self.keyring_was_set = False
+        self.keyring_values = None
+
+        self.obj = SSOLogin(self.proxy)
+
+    def test_creation(self):
+        """Test that the object creation is successful."""
+        self.assertIsInstance(self.obj.processor, main.Account)
+        self.assertTrue(self.obj.proxy is self.proxy)
+
+    @defer.inlineCallbacks
+    def test_generate_captcha(self):
+        """Test that the captcha method works ok."""
+        d = defer.Deferred()
+        filename = "sample filename"
+        expected_result = "expected result"
+
+        self.patch(self.obj, "CaptchaGenerated", lambda *a: d.callback(a))
+        self.patch(self.obj, "CaptchaGenerationError", d.errback)
+
+        self.obj.processor._next_result = expected_result
+        self.obj.generate_captcha(APP_NAME, filename)
+
+        app_name, result = yield d
+        self.assertEqual(result, expected_result)
+        self.assertEqual(app_name, APP_NAME)
+        self.assert_recorder_called(self.obj.processor, 'generate_captcha',
+            filename)
+
+    @defer.inlineCallbacks
+    def test_register_user(self):
+        """Test that the register_user method works ok."""
+        d = defer.Deferred()
+        expected_result = "expected result"
+
+        self.patch(self.obj, "UserRegistered", lambda *a: d.callback(a))
+        self.patch(self.obj, "UserRegistrationError", d.errback)
+
+        self.obj.processor._next_result = expected_result
+        self.obj.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                               CAPTCHA_SOLUTION)
+
+        app_name, result = yield d
+        self.assertEqual(result, expected_result)
+        self.assertEqual(app_name, APP_NAME)
+        self.assert_recorder_called(self.obj.processor, 'register_user',
+            EMAIL, PASSWORD, NAME, CAPTCHA_ID, CAPTCHA_SOLUTION)
+
+    @defer.inlineCallbacks
+    def test_login(self):
+        """Test that the login method works ok."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "LoggedIn", lambda *a: d.callback(a))
+        self.patch(self.obj, "LoginError", d.errback)
+        self.patch(self.obj, "UserNotValidated", d.errback)
+
+        self.obj.processor._next_result = TOKEN
+        self.obj.login(APP_NAME, EMAIL, PASSWORD)
+
+        app_name, result = yield d
+        self.assertEqual(result, EMAIL)
+        self.assertEqual(app_name, APP_NAME)
+        self.assertTrue(self.keyring_was_set, "The keyring should be set")
+        self.assert_recorder_called(self.obj.processor, 'login',
+            EMAIL, PASSWORD, main.get_token_name(APP_NAME))
+
+    @defer.inlineCallbacks
+    def test_validate_email(self):
+        """Test that the validate_email method works ok."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "EmailValidated", lambda *a: d.callback(a))
+        self.patch(self.obj, "EmailValidationError", d.errback)
+
+        self.obj.processor._next_result = TOKEN
+        self.obj.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
+
+        app_name, result = yield d
+        self.assertEqual(result, EMAIL)
+        self.assertEqual(app_name, APP_NAME)
+        self.assertTrue(self.keyring_was_set, "The keyring should be set")
+        self.assert_recorder_called(self.obj.processor, 'validate_email',
+            EMAIL, PASSWORD, EMAIL_TOKEN, main.get_token_name(APP_NAME))
+
+    @defer.inlineCallbacks
+    def test_request_password_reset_token(self):
+        """Test that the request_password_reset_token method works ok."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "PasswordResetTokenSent",
+                   lambda *a: d.callback(a))
+        self.patch(self.obj, "PasswordResetError", d.errback)
+
+        self.obj.processor._next_result = EMAIL
+        self.obj.request_password_reset_token(APP_NAME, EMAIL)
+
+        app_name, result = yield d
+        self.assertEqual(result, EMAIL)
+        self.assertEqual(app_name, APP_NAME)
+        self.assert_recorder_called(self.obj.processor,
+            'request_password_reset_token', EMAIL)
+
+    @defer.inlineCallbacks
+    def test_set_new_password(self):
+        """Test that the set_new_password method works ok."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "PasswordChanged", lambda *a: d.callback(a))
+        self.patch(self.obj, "PasswordChangeError", d.errback)
+
+        self.obj.processor._next_result = EMAIL
+        self.obj.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
+
+        app_name, result = yield d
+        self.assertEqual(result, EMAIL)
+        self.assertEqual(app_name, APP_NAME)
+        self.assert_recorder_called(self.obj.processor,
+            'set_new_password', EMAIL, EMAIL_TOKEN, PASSWORD)
+
+
+class SSOLoginWithErrorTestCase(SSOLoginTestCase):
+    """Test the SSOLogin class."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(SSOLoginWithErrorTestCase, self).setUp()
+        self.patch(main, "thread_execute", fake_err_thread_execute)
+
+    @defer.inlineCallbacks
+    def test_generate_captcha(self):
+        """Test that the captcha method fails as expected."""
+        d = defer.Deferred()
+        filename = "sample filename"
+
+        self.patch(self.obj, "CaptchaGenerated", d.errback)
+        self.patch(self.obj, "CaptchaGenerationError",
+                   lambda *a: d.callback(a))
+        self.obj.generate_captcha(APP_NAME, filename)
+
+        app_name, errdict = yield d
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertEqual(app_name, APP_NAME)
+
+    @defer.inlineCallbacks
+    def test_register_user(self):
+        """Test that the register_user method fails as expected."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "UserRegistered", d.errback)
+        self.patch(self.obj, "UserRegistrationError", lambda *a: d.callback(a))
+        self.obj.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+
+        app_name, errdict = yield d
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertEqual(app_name, APP_NAME)
+
+    @defer.inlineCallbacks
+    def test_login(self):
+        """The login method fails as expected when get_token_name fails."""
+        d = defer.Deferred()
+
+        def fake_gtn(*args):
+            """A fake get_token_name that fails."""
+            raise SampleException()
+
+        self.patch(main, "get_token_name", fake_gtn)
+        self.patch(self.obj, "LoggedIn", d.errback)
+        self.patch(self.obj, "LoginError", lambda *a: d.callback(a))
+        self.patch(self.obj, "UserNotValidated", d.errback)
+        self.obj.login(APP_NAME, EMAIL, PASSWORD)
+
+        app_name, errdict = yield d
+        self.assertEqual(app_name, APP_NAME)
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+
+    @defer.inlineCallbacks
+    def test_login_set_credentials(self):
+        """The login method fails as expected when set_credentials fails."""
+        d = defer.Deferred()
+
+        def fake_set_creds(*args):
+            """A fake Keyring.set_credentials that fails."""
+            return defer.fail(SampleException())
+
+        self.patch(main.Keyring, "set_credentials", fake_set_creds)
+        fail = lambda app, res: d.errback((app, res))
+        self.patch(self.obj, "LoggedIn", fail)
+        self.patch(self.obj, "LoginError", lambda *a: d.callback(a))
+        self.patch(self.obj, "UserNotValidated", fail)
+        self.obj.login(APP_NAME, EMAIL, PASSWORD)
+
+        app_name, errdict = yield d
+        self.assertEqual(app_name, APP_NAME)
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+
+    @defer.inlineCallbacks
+    def test_validate_email(self):
+        """Test that the validate_email method fails as expected."""
+        d = defer.Deferred()
+
+        def fake_gtn(*args):
+            """A fake get_token_name that fails."""
+            raise SampleException()
+
+        self.patch(main, "get_token_name", fake_gtn)
+
+        self.patch(self.obj, "EmailValidated", d.errback)
+        self.patch(self.obj, "EmailValidationError", lambda *a: d.callback(a))
+        self.obj.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
+
+        app_name, errdict = yield d
+        self.assertEqual(app_name, APP_NAME)
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertFalse(self.keyring_was_set, "Keyring should not be set")
+
+    @defer.inlineCallbacks
+    def test_request_password_reset_token(self):
+        """Test the request_password_reset_token method fails as expected."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "PasswordResetTokenSent", d.errback)
+        self.patch(self.obj, "PasswordResetError", lambda *a: d.callback(a))
+        self.obj.request_password_reset_token(APP_NAME, EMAIL)
+
+        app_name, errdict = yield d
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertEqual(app_name, APP_NAME)
+
+    @defer.inlineCallbacks
+    def test_set_new_password(self):
+        """Test that the set_new_password method fails as expected."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, "PasswordChanged", d.errback)
+        self.patch(self.obj, "PasswordChangeError", lambda *a: d.callback(a))
+        self.obj.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
+
+        app_name, errdict = yield d
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assertEqual(app_name, APP_NAME)
+
+
+class BlockingFunctionTestCase(TestCase):
+    """Tests for the "thread_execute" function."""
+
+    timeout = 5
+
+    @defer.inlineCallbacks
+    def test_thread_execute(self):
+        """Test the normal behaviour."""
+        d = defer.Deferred()
+        expected_result = "expected result"
+
+        def f():
+            """No failure."""
+            return expected_result
+
+        thread_execute(f, APP_NAME, lambda *a: d.callback(a), d.errback)
+
+        app_name, result = yield d
+
+        self.assertEqual(result, expected_result)
+        self.assertEqual(app_name, APP_NAME)
+
+    @defer.inlineCallbacks
+    def test_thread_execute_error(self):
+        """Test the behaviour when an Exception is raised."""
+        d = defer.Deferred()
+        expected_error_message = "expected error message"
+        expected_exc = SampleException(expected_error_message)
+
+        def f():
+            """Failure."""
+            raise expected_exc
+
+        thread_execute(f, APP_NAME, d.errback, lambda *a: d.callback(a))
+
+        app_name, error = yield d
+
+        self.assertEqual(app_name, APP_NAME)
+        self.assertEqual(error, expected_exc)
+
+
+class CredentialsManagementTestCase(BaseTestCase):
+    """Tests for the CredentialsManagement DBus interface."""
+
+    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',
+    }
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(CredentialsManagementTestCase, self).setUp()
+
+        self.factory = FakedCredentialsFactory()
+        self.patch(main, 'Credentials', self.factory.Credentials)
+        self.obj = CredentialsManagement(timeout_func=lambda *a: None,
+                                         shutdown_func=lambda *a: None,
+                                         proxy=self.proxy)
+        self.args = {}
+        self.cred_args = {}
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        main.logger.addHandler(self.memento)
+        self.addCleanup(main.logger.removeHandler, self.memento)
+
+
+class CredentialsManagementRefCountingTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement ref counting."""
+
+    @defer.inlineCallbacks
+    def assert_refcounter_increased(self, method_name, signal_name=None):
+        """Assert that calling 'method_name' increases the ref counter."""
+        if signal_name is not None:
+            d = defer.Deferred()
+            self.patch(self.obj, signal_name, lambda *a: d.callback(a))
+        else:
+            d = defer.succeed(None)
+
+        getattr(self.obj, method_name)(APP_NAME, self.args)
+
+        yield d
+        self.assertEqual(self.obj.ref_count, 1)
+
+    def assert_refcounter_decreased(self, signal_name, *a, **kw):
+        """Assert that calling 'signal_name' decreases the ref counter."""
+        self.obj.ref_count = 3
+
+        getattr(self.obj, signal_name)(*a, **kw)
+
+        self.assertEqual(self.obj.ref_count, 2)
+
+    def assert_refcounter_negative(self, signal_name, *a, **kw):
+        """Assert that calling 'signal_name' decreases the ref counter.
+
+        If decreased value is negative, assert that a warning log was made.
+
+        """
+        self.obj._ref_count = -3  # overwrite internal to force a negative
+
+        getattr(self.obj, signal_name)(*a, **kw)
+
+        self.assertEqual(self.obj.ref_count, 0)
+        msg = 'Attempting to decrease ref_count to a negative value (-4).'
+        self.assertTrue(self.memento.check_warning(msg))
+
+    def test_ref_counting(self):
+        """Ref counting is in place."""
+        self.assertEqual(self.obj.ref_count, 0)
+
+    @defer.inlineCallbacks
     def test_find_credentials(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        args = 'args'
-        self.root.find_credentials(app_name, args, MATCH(callable),
-                                   MATCH(callable))
-        self.mocker.replay()
-        self.cred.find_credentials(app_name, args)
-
+        """Keep proper track of ongoing requests."""
+        yield self.assert_refcounter_increased('find_credentials',
+                                               'CredentialsFound')
+
+    @defer.inlineCallbacks
+    def test_find_credentials_with_success_cb(self):
+        """Keep proper track of ongoing requests."""
+        d = defer.Deferred()
+        counter = []
+
+        def in_the_middle():
+            """Store the ref_count value."""
+            counter.append(self.obj.ref_count)
+            return defer.succeed(TOKEN)
+
+        self.patch(self.factory.credentials, 'find_credentials', in_the_middle)
+        self.obj.find_credentials(APP_NAME, self.args,
+                                  success_cb=d.callback, error_cb=d.errback)
+        yield d
+        self.assertEqual(counter, [1])
+        self.assertEqual(self.obj.ref_count, 0)
+
+    @defer.inlineCallbacks
+    def test_find_credentials_with_error_cb(self):
+        """Keep proper track of ongoing requests."""
+        d = defer.Deferred()
+        counter = []
+
+        def in_the_middle():
+            """Store the ref_count value."""
+            counter.append(self.obj.ref_count)
+            return defer.fail('foo')
+
+        self.patch(self.factory.credentials, 'find_credentials', in_the_middle)
+        self.obj.find_credentials(APP_NAME, self.args,
+                                  success_cb=d.errback, error_cb=d.callback)
+
+        yield d
+        self.assertEqual(counter, [1])
+        self.assertEqual(self.obj.ref_count, 0)
+
+    @defer.inlineCallbacks
     def test_clear_credentials(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        args = 'args'
-        self.root.clear_credentials(app_name, args, MATCH(callable),
-                                    MATCH(callable))
-        self.mocker.replay()
-        self.cred.clear_credentials(app_name, args)
+        """Keep proper track of ongoing requests."""
+        yield self.assert_refcounter_increased('clear_credentials',
+                                               'CredentialsCleared')
 
+    @defer.inlineCallbacks
     def test_store_credentials(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        args = 'args'
-        self.root.store_credentials(app_name, args, MATCH(callable),
-                                    MATCH(callable))
-        self.mocker.replay()
-        self.cred.store_credentials(app_name, args)
-
-    def test_register(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        args = 'args'
-        self.root.register(app_name, args)
-        self.mocker.replay()
-        self.cred.register(app_name, args)
-
-    def test_login(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        args = 'args'
-        self.root.login(app_name, args)
-        self.mocker.replay()
-        self.cred.login(app_name, args)
+        """Keep proper track of ongoing requests."""
+        yield self.assert_refcounter_increased('store_credentials',
+                                               'CredentialsStored')
+
+    def test_register(self):
+        """Keep proper track of ongoing requests."""
+        yield self.assert_refcounter_increased('register')
+
+    def test_login(self):
+        """Keep proper track of ongoing requests."""
+        yield self.assert_refcounter_increased('login')
+
+    def test_several_requests(self):
+        """Requests can be nested."""
+        self.obj.login(APP_NAME, self.args)
+        self.obj.register(APP_NAME, self.args)
+        self.obj.login(APP_NAME, self.args)
+        self.obj.register(APP_NAME, self.args)
+        self.obj.register(APP_NAME, self.args)
+
+        self.assertEqual(self.obj.ref_count, 5)
+
+    def test_credentials_found(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_decreased('CredentialsFound', APP_NAME, TOKEN)
+
+    def test_credentials_not_found(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_decreased('CredentialsNotFound', APP_NAME)
+
+    def test_credentials_cleared(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_decreased('CredentialsCleared', APP_NAME)
+
+    def test_credentials_stored(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_decreased('CredentialsStored', APP_NAME)
+
+    def test_credentials_error(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_decreased('CredentialsError', APP_NAME,
+                                         SampleException('test'))
+
+    def test_authorization_denied(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_decreased('AuthorizationDenied', APP_NAME)
+
+    def test_credentials_found_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_negative('CredentialsFound', APP_NAME, TOKEN)
+
+    def test_credentials_not_found_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_negative('CredentialsNotFound', APP_NAME)
+
+    def test_credentials_cleared_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_negative('CredentialsCleared', APP_NAME)
+
+    def test_credentials_stored_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_negative('CredentialsStored', APP_NAME)
+
+    def test_credentials_error_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_negative('CredentialsError', APP_NAME,
+                                        SampleException('test'))
+
+    def test_autorization_denied_when_ref_count_is_not_positive(self):
+        """Ref counter is decreased when a signal is sent."""
+        self.assert_refcounter_negative('AuthorizationDenied', APP_NAME)
+
+    def test_on_zero_ref_count_shutdown(self):
+        """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), {}))
+
+    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)
+        self.obj.login(APP_NAME, self.args)
+
+        self.assertEqual(self._called, False)
+
+    def test_on_non_zero_ref_count_after_zero_do_not_shutdown(self):
+        """If the shutdown was queued, do not quit if counter is not zero."""
+
+        def fake_timeout_func(interval, func):
+            """Start a new request when the timer is started."""
+            self.obj.register(APP_NAME, self.args)
+            assert self.obj.ref_count > 0
+            func()
+
+        self.patch(self.obj, 'timeout_func', fake_timeout_func)
+        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, False, 'shutdown_func was not called')
+
+    def test_zero_ref_count_after_zero_do_shutdown(self):
+        """If the shutdown was queued, do quit if counter is zero."""
+
+        def fake_timeout_func(interval, func):
+            """Start a new request when the timer is started."""
+            assert self.obj.ref_count == 0
+            func()
+
+        self.patch(self.obj, 'timeout_func', fake_timeout_func)
+        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')
+
+
+class CredentialsManagementClearTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement clear method."""
+
+    method = 'clear_credentials'
+    success_signal = 'CredentialsCleared'
+    success_result = (APP_NAME,)
+    others_should_errback = []
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(CredentialsManagementClearTestCase, self).setUp()
+        self.call_method = getattr(self.obj, self.method)
+
+    def test_backend_called(self):
+        """The credentials backend is properly called."""
+        self.call_method(APP_NAME, self.args)
+        self.assert_recorder_called(self.factory, 'Credentials', APP_NAME)
+
+    @defer.inlineCallbacks
+    def test_does_not_block(self):
+        """Calling 'method' does not block but return thru signals."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, self.success_signal, lambda *a: d.callback(a))
+        self.patch(self.obj, 'CredentialsError',
+                   lambda *a: d.errback(SampleException(a)))
+        for signal in self.others_should_errback:
+            self.patch(self.obj, signal,
+                       lambda *a: d.errback(AssertionError(a)))
+
+        self.call_method(APP_NAME, self.args)
+
+        result = yield d
+        self.assertEqual(result, self.success_result)
+
+    @defer.inlineCallbacks
+    def test_handles_error(self):
+        """If calling the backend fails, CredentialsError is sent."""
+        d = defer.Deferred()
+
+        self.patch(self.obj, self.success_signal, d.errback)
+        self.patch(self.obj, 'CredentialsError', lambda *a: d.callback(a))
+
+        exc = SampleException('baz')
+        self.patch(self.factory.credentials, self.method,
+                   lambda *a: defer.fail(exc))
+        self.call_method(APP_NAME, self.args)
+
+        app_name, error = yield d
+        self.assertEqual(error, exc)
+        self.assertEqual(app_name, APP_NAME)
+
+
+class CredentialsManagementStoreTestCase(CredentialsManagementClearTestCase):
+    """Tests for the CredentialsManagement store method."""
+
+    method = 'store_credentials'
+    success_signal = 'CredentialsStored'
+
+
+class CredentialsManagementFindTestCase(CredentialsManagementClearTestCase):
+    """Tests for the CredentialsManagement find method."""
+
+    method = 'find_credentials'
+    success_signal = 'CredentialsFound'
+    success_result = (APP_NAME, TOKEN)
+    others_should_errback = ['CredentialsNotFound']
+
+    @defer.inlineCallbacks
+    def test_find_credentials_with_success_cb(self):
+        """The credentials are asked and returned in a thread_execute call."""
+        d = defer.Deferred()
+
+        self.obj.find_credentials(APP_NAME, self.args,
+                                  success_cb=d.callback, error_cb=d.errback)
+
+        creds = yield d
+        expected = yield self.factory.credentials.find_credentials()
+        self.assertEqual(creds, expected)
+        self.assert_recorder_called(self.factory, 'Credentials', APP_NAME)
+
+    @defer.inlineCallbacks
+    def test_find_credentials_with_error_cb(self):
+        """If find_credentials fails, error_cb is called."""
+        d = defer.Deferred()
+
+        self.patch(self.factory.credentials, 'find_credentials',
+                   lambda *a: defer.fail(SampleException('baz')))
+        self.obj.find_credentials(APP_NAME, self.args,
+                                  success_cb=d.errback, error_cb=d.callback)
+
+        errdict = yield d
+        self.assertEqual(errdict["errtype"], "SampleException")
+        self.assert_recorder_called(self.factory, 'Credentials', APP_NAME)
+
+
+class CredentialsManagementNotFindTestCase(CredentialsManagementFindTestCase):
+    """Tests for the CredentialsManagement find method."""
+
+    success_signal = 'CredentialsNotFound'
+    success_result = (APP_NAME,)
+    others_should_errback = ['CredentialsFound']
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(CredentialsManagementNotFindTestCase, self).setUp()
+        self.call_method = getattr(self.obj, self.method)
+        self.patch(self.factory.credentials, self.method,
+                   lambda: defer.succeed({}))
+
+
+class CredentialsManagementOpsTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement login/register methods."""
+
+    @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.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."""
+        self.obj.register(APP_NAME, self.args)
+        self.assert_recorder_called(self.factory, 'Credentials',
+                                    APP_NAME, **self.cred_args)
+
+    def test_login(self):
+        """The login is correct."""
+        self.obj.login(APP_NAME, self.args)
+        self.assert_recorder_called(self.factory, 'Credentials',
+                                    APP_NAME, **self.cred_args)
 
     def test_login_email_password(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        args = 'args'
-        self.root.login_email_password(app_name, args)
-        self.mocker.replay()
-        self.cred.login_email_password(app_name, args)
+        """The login_email_password is correct."""
+        self.args['email'] = EMAIL
+        self.args['password'] = PASSWORD
+        self.obj.login_email_password(APP_NAME, self.args)
+        self.assert_recorder_called(self.factory, 'Credentials',
+                                    APP_NAME, **self.cred_args)
+
+
+class CredentialsManagementParamsTestCase(CredentialsManagementOpsTestCase):
+    """Tests for the CredentialsManagement extra parameters handling."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(CredentialsManagementParamsTestCase, self).setUp()
+        self.args['dummy'] = 'nothing useful'
+
+
+class CredentialsManagementSignalsTestCase(CredentialsManagementTestCase):
+    """Tests for the CredentialsManagement DBus signals."""
+
+    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))
+
+        msg = 'credentials must not be logged (found %r in log).'
+        for val in TOKEN.itervalues():
+            self.assertFalse(self.memento.check_info(val), msg % val)
+
+    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))
+
+    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))
+
+    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))
+
+    def test_credentials_error(self):
+        """The CredentialsError signal."""
+        error = {'error_message': 'failed!', 'detailed error': 'yadda yadda'}
+        self.obj.CredentialsError(APP_NAME, error)
+        msgs = (self.obj.__class__.__name__,
+                self.obj.CredentialsError.__name__,
+                APP_NAME, str(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))
+
+
+class UbuntuSSOServiceTestCase(BaseTestCase):
+    """Test suite for the UbuntuSSOService class."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(UbuntuSSOServiceTestCase, self).setUp()
+        self.proxy.sso_login = object()
+        self.proxy.cred_manager = object()
+        self.params = []
+        self.patch(main, 'UbuntuSSOProxy',
+                   lambda _: self.params.append(_) or self.proxy)
+        self.obj = UbuntuSSOService()
+        yield self.obj.start()
+
+    def test_creation(self):
+        """Creation paremeter is properly used."""
+        self.assertEqual(self.params, [self.obj])
+
+    def test_sso_login(self):
+        """Attributes has the expected value."""
+        self.assertIsInstance(self.obj.sso_login, SSOLogin)
+        self.assertTrue(self.obj.sso_login.proxy is self.proxy.sso_login)
+
+    def test_cred_manager(self):
+        """Attributes has the expected value."""
+        self.assertIsInstance(self.obj.cred_manager, CredentialsManagement)
+        self.assertTrue(self.obj.cred_manager.proxy is self.proxy.cred_manager)

=== removed file 'ubuntu_sso/main/tests/test_linux.py'
--- ubuntu_sso/main/tests/test_linux.py	2011-12-19 19:35:06 +0000
+++ ubuntu_sso/main/tests/test_linux.py	1970-01-01 00:00:00 +0000
@@ -1,1275 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# test_main - tests for ubuntu_sso.main
-#
-# Author: Natalia Bidart <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright 2009-2010 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 main SSO client code."""
-
-import logging
-
-from mocker import Mocker, ARGS, KWARGS
-from twisted.internet import defer
-from ubuntuone.devtools.handlers import MementoHandler
-
-import ubuntu_sso.keyring
-import ubuntu_sso.main
-import ubuntu_sso.main.linux
-
-from ubuntu_sso import DBUS_CREDENTIALS_IFACE
-from ubuntu_sso.main import (
-    except_to_errdict,
-    CredentialsManagement,
-    SSOLogin,
-    TIMEOUT_INTERVAL,
-)
-from ubuntu_sso.main.linux import blocking
-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)
-from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
-    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, PING_URL, TOKEN,
-    TOKEN_NAME, WINDOW_ID, TestCase)
-
-
-# Access to a protected member 'yyy' of a client class
-# pylint: disable=W0212
-
-
-class BlockingSampleException(Exception):
-    """The exception that will be thrown by the fake blocking."""
-
-
-def fake_ok_blocking(f, app, cb, eb):
-    """A fake blocking function that succeeds."""
-    cb(app, f())
-
-
-def fake_err_blocking(f, app, cb, eb):
-    """A fake blocking function that fails."""
-    try:
-        f()
-    except Exception, e:  # pylint: disable=W0703
-        eb(app, except_to_errdict(e))
-    else:
-        eb(app, except_to_errdict(BlockingSampleException()))
-
-
-class SsoDbusTestCase(TestCase):
-    """Test the SSOLogin DBus interface."""
-
-    timeout = 2
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Create the mocking bus."""
-        yield super(SsoDbusTestCase, self).setUp()
-        self.mocker = Mocker()
-        self.mockbusname = self.mocker.mock()
-        mockbus = self.mocker.mock()
-        self.mockbusname.get_bus()
-        self.mocker.result(mockbus)
-        mockbus._register_object_path(ARGS)
-        self.mockprocessorclass = None
-
-        def ksc(keyring, k, val):
-            """Assert over token and app_name."""
-            self.assertEqual(k, APP_NAME)
-            self.assertEqual(val, TOKEN)
-            self.keyring_was_set = True
-            self.keyring_values = k, val
-            return defer.succeed(None)
-
-        self.patch(ubuntu_sso.main.Keyring, "set_credentials", ksc)
-        self.keyring_was_set = False
-        self.keyring_values = None
-
-    @defer.inlineCallbacks
-    def tearDown(self):
-        """Verify the mocking bus and shut it down."""
-        self.mocker.verify()
-        self.mocker.restore()
-        yield super(SsoDbusTestCase, self).tearDown()
-
-    def test_creation(self):
-        """Test that the object creation is successful."""
-        self.mocker.replay()
-        SSOLogin(self.mockbusname)
-
-    def create_mock_processor(self):
-        """Create a mock processor from a dummy processor class."""
-        self.mockprocessorclass = self.mocker.mock()
-        mockprocessor = self.mocker.mock()
-        self.mockprocessorclass(ARGS, KWARGS)
-        self.mocker.result(mockprocessor)
-        return mockprocessor
-
-    def test_generate_captcha(self):
-        """Test that the captcha method works ok."""
-        d = defer.Deferred()
-        filename = "sample filename"
-        expected_result = "expected result"
-        self.create_mock_processor().generate_captcha(filename)
-        self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, expected_result)
-            self.assertEqual(app_name, APP_NAME)
-            d.callback(result)
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "CaptchaGenerated", verify)
-        self.patch(client, "CaptchaGenerationError", d.errback)
-        client.generate_captcha(APP_NAME, filename)
-        return d
-
-    def test_generate_captcha_error(self):
-        """Test that the captcha method fails as expected."""
-        d = defer.Deferred()
-        filename = "sample filename"
-        expected_result = "expected result"
-        self.create_mock_processor().generate_captcha(filename)
-        self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "CaptchaGenerated", d.errback)
-        self.patch(client, "CaptchaGenerationError", verify)
-        client.generate_captcha(APP_NAME, filename)
-        return d
-
-    def test_register_user(self):
-        """Test that the register_user method works ok."""
-        d = defer.Deferred()
-        expected_result = "expected result"
-        self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
-            CAPTCHA_ID, CAPTCHA_SOLUTION)
-        self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, expected_result)
-            self.assertEqual(app_name, APP_NAME)
-            d.callback(result)
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "UserRegistered", verify)
-        self.patch(client, "UserRegistrationError", d.errback)
-        client.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
-                             CAPTCHA_SOLUTION)
-        return d
-
-    def test_register_user_error(self):
-        """Test that the register_user method fails as expected."""
-        d = defer.Deferred()
-        expected_result = "expected result"
-        self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
-            CAPTCHA_ID, CAPTCHA_SOLUTION)
-        self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "UserRegistered", d.errback)
-        self.patch(client, "UserRegistrationError", verify)
-        client.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
-                             CAPTCHA_SOLUTION)
-        return d
-
-    def test_login(self):
-        """Test that the login method works ok."""
-        d = defer.Deferred()
-        processor = self.create_mock_processor()
-        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
-        self.mocker.result(TOKEN)
-        processor.is_validated(TOKEN)
-        self.mocker.result(True)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, EMAIL)
-            self.assertEqual(app_name, APP_NAME)
-            self.assertTrue(self.keyring_was_set, "The keyring should be set")
-            d.callback(result)
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "LoggedIn", verify)
-        self.patch(client, "LoginError", d.errback)
-        self.patch(client, "UserNotValidated", d.errback)
-        client.login(APP_NAME, EMAIL, PASSWORD)
-        return d
-
-    def test_login_user_not_validated(self):
-        """Test that the login sends EmailNotValidated signal."""
-        d = defer.Deferred()
-        processor = self.create_mock_processor()
-        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
-        self.mocker.result(TOKEN)
-        processor.is_validated(TOKEN)
-        self.mocker.result(False)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, email):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            self.assertEqual(email, EMAIL)
-            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "LoggedIn", d.errback)
-        self.patch(client, "LoginError", d.errback)
-        self.patch(client, "UserNotValidated", verify)
-        client.login(APP_NAME, EMAIL, PASSWORD)
-        return d
-
-    def test_login_error_get_token_name(self):
-        """The login method fails as expected when get_token_name fails."""
-        d = defer.Deferred()
-        self.create_mock_processor()
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
-
-        def fake_gtn(*args):
-            """A fake get_token_name that fails."""
-            raise BlockingSampleException()
-
-        self.patch(ubuntu_sso.main, "get_token_name", fake_gtn)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "LoggedIn", d.errback)
-        self.patch(client, "LoginError", verify)
-        self.patch(client, "UserNotValidated", d.errback)
-        client.login(APP_NAME, EMAIL, PASSWORD)
-        return d
-
-    def test_login_error_set_credentials(self):
-        """The login method fails as expected when set_credentials fails."""
-        d = defer.Deferred()
-        processor = self.create_mock_processor()
-        processor.login(EMAIL, PASSWORD, TOKEN_NAME)
-        self.mocker.result(TOKEN)
-        processor.is_validated(TOKEN)
-        self.mocker.result(True)
-
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-
-        def fake_set_creds(*args):
-            """A fake Keyring.set_credentials that fails."""
-            return defer.fail(BlockingSampleException())
-
-        self.patch(ubuntu_sso.main.Keyring, "set_credentials", fake_set_creds)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        fail = lambda app, res: d.errback((app, res))
-        self.patch(client, "LoggedIn", fail)
-        self.patch(client, "LoginError", verify)
-        self.patch(client, "UserNotValidated", fail)
-        client.login(APP_NAME, EMAIL, PASSWORD)
-        return d
-
-    def test_validate_email(self):
-        """Test that the validate_email method works ok."""
-        d = defer.Deferred()
-        self.create_mock_processor().validate_email(EMAIL, PASSWORD,
-                                                    EMAIL_TOKEN, TOKEN_NAME)
-        self.mocker.result(TOKEN)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, EMAIL)
-            self.assertEqual(app_name, APP_NAME)
-            self.assertTrue(self.keyring_was_set, "The keyring should be set")
-            d.callback(result)
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "EmailValidated", verify)
-        self.patch(client, "EmailValidationError", d.errback)
-        client.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
-        return d
-
-    def test_validate_email_error(self):
-        """Test that the validate_email method fails as expected."""
-        d = defer.Deferred()
-        self.create_mock_processor()
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
-
-        def fake_gtn(*args):
-            """A fake get_token_name that fails."""
-            raise BlockingSampleException()
-
-        self.patch(ubuntu_sso.main, "get_token_name", fake_gtn)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertFalse(self.keyring_was_set, "Keyring should not be set")
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "EmailValidated", d.errback)
-        self.patch(client, "EmailValidationError", verify)
-        client.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
-        return d
-
-    def test_request_password_reset_token(self):
-        """Test that the request_password_reset_token method works ok."""
-        d = defer.Deferred()
-        processor = self.create_mock_processor()
-        processor.request_password_reset_token(EMAIL)
-        self.patch(ubuntu_sso.main, "thread_execute", fake_ok_blocking)
-        self.mocker.result(EMAIL)
-        self.mocker.replay()
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, EMAIL)
-            self.assertEqual(app_name, APP_NAME)
-            d.callback(result)
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "PasswordResetTokenSent", verify)
-        self.patch(client, "PasswordResetError", d.errback)
-        client.request_password_reset_token(APP_NAME, EMAIL)
-        return d
-
-    def test_request_password_reset_token_error(self):
-        """Test the request_password_reset_token method fails as expected."""
-        d = defer.Deferred()
-
-        self.create_mock_processor().request_password_reset_token(EMAIL)
-        self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "PasswordResetTokenSent", d.errback)
-        self.patch(client, "PasswordResetError", verify)
-        client.request_password_reset_token(APP_NAME, EMAIL)
-        return d
-
-    def test_set_new_password(self):
-        """Test that the set_new_password method works ok."""
-        d = defer.Deferred()
-        self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
-                                                      PASSWORD)
-        self.mocker.result(EMAIL)
-        self.patch(ubuntu_sso.main.linux, "blocking", fake_ok_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, EMAIL)
-            self.assertEqual(app_name, APP_NAME)
-            d.callback(result)
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "PasswordChanged", verify)
-        self.patch(client, "PasswordChangeError", d.errback)
-        client.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
-        return d
-
-    def test_set_new_password_error(self):
-        """Test that the set_new_password method fails as expected."""
-        d = defer.Deferred()
-        expected_result = "expected result"
-
-        self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
-                                                      PASSWORD)
-        self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "thread_execute", fake_err_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "PasswordChanged", d.errback)
-        self.patch(client, "PasswordChangeError", verify)
-        client.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
-        return d
-
-
-class BlockingFunctionTestCase(TestCase):
-    """Tests for the "blocking" function."""
-
-    timeout = 5
-
-    def test_blocking(self):
-        """Test the normal behaviour."""
-        d = defer.Deferred()
-        expected_result = "expected result"
-
-        def f():
-            """No failure."""
-            return expected_result
-
-        def verify(app_name, result):
-            """The actual test."""
-            self.assertEqual(result, expected_result)
-            self.assertEqual(app_name, APP_NAME)
-            d.callback(result)
-
-        blocking(f, APP_NAME, verify, d.errback)
-        return d
-
-    def test_blocking_error(self):
-        """Test the behaviour when an Exception is raised."""
-        d = defer.Deferred()
-        expected_error_message = "expected error message"
-
-        def f():
-            """Failure."""
-            raise BlockingSampleException(expected_error_message)
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(app_name, APP_NAME)
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(errdict["message"], expected_error_message)
-            d.callback("Ok")
-
-        blocking(f, APP_NAME, d.errback, verify)
-        return d
-
-
-class TestExceptToErrdictException(Exception):
-    """A dummy exception for the following testcase."""
-
-
-class ExceptToErrdictTestCase(TestCase):
-    """Tests for the except_to_errdict function."""
-
-    def test_first_arg_is_dict(self):
-        """If the first arg is a dict, use it as the base dict."""
-        sample_dict = {
-            "errorcode1": "error message 1",
-            "errorcode2": "error message 2",
-            "errorcode3": "error message 3",
-        }
-        e = TestExceptToErrdictException(sample_dict)
-        result = except_to_errdict(e)
-
-        self.assertEqual(result["errtype"], e.__class__.__name__)
-        for k in sample_dict.keys():
-            self.assertIn(k, result)
-            self.assertEqual(result[k], sample_dict[k])
-
-    def test_first_arg_is_str(self):
-        """If the first arg is a str, use it as the message."""
-        sample_string = "a sample string"
-        e = TestExceptToErrdictException(sample_string)
-        result = except_to_errdict(e)
-        self.assertEqual(result["errtype"], e.__class__.__name__)
-        self.assertEqual(result["message"], sample_string)
-
-    def test_first_arg_is_unicode(self):
-        """If the first arg is a unicode, use it as the message."""
-        sample_string = u"a sample string"
-        e = TestExceptToErrdictException(sample_string)
-        result = except_to_errdict(e)
-        self.assertEqual(result["errtype"], e.__class__.__name__)
-        self.assertEqual(result["message"], sample_string)
-
-    def test_no_args_at_all(self):
-        """If there are no args, use the class docstring."""
-        e = TestExceptToErrdictException()
-        result = except_to_errdict(e)
-        self.assertEqual(result["errtype"], e.__class__.__name__)
-        self.assertEqual(result["message"], e.__class__.__doc__)
-
-    def test_some_other_thing_as_first_arg(self):
-        """If first arg is not basestring nor dict, then repr all args."""
-        sample_args = (None, u"unicode2\ufffd", "errorcode3")
-        e = TestExceptToErrdictException(*sample_args)
-        result = except_to_errdict(e)
-        self.assertEqual(result["errtype"], e.__class__.__name__)
-
-
-class CredentialsManagementTestCase(TestCase):
-    """Tests for the CredentialsManagement DBus interface."""
-
-    timeout = 2
-    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',
-                }
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsManagementTestCase, self).setUp()
-
-        self.mocker = Mocker()
-        self.client = CredentialsManagement(timeout_func=lambda *a: None,
-                                            shutdown_func=lambda *a: None)
-        self.args = {}
-        self.cred_args = {}
-
-        self.memento = MementoHandler()
-        self.memento.setLevel(logging.DEBUG)
-        ubuntu_sso.main.logger.addHandler(self.memento)
-        self.addCleanup(ubuntu_sso.main.logger.removeHandler, self.memento)
-
-    @defer.inlineCallbacks
-    def tearDown(self):
-        """Verify the mocking stuff and shut it down."""
-        self.mocker.verify()
-        self.mocker.restore()
-        yield super(CredentialsManagementTestCase, self).tearDown()
-
-    def assert_dbus_method_correct(self, method, out_signature=''):
-        """Check that 'method' is a dbus method with proper signatures."""
-        self.assertTrue(method._dbus_is_method)
-        self.assertEqual(method._dbus_interface, DBUS_CREDENTIALS_IFACE)
-        self.assertEqual(method._dbus_in_signature, 'sa{ss}')
-        self.assertEqual(method._dbus_out_signature, out_signature)
-
-    def create_mock_backend(self):
-        """Create a mock backend."""
-        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
-        mock_class(APP_NAME, **self.cred_args)
-        creds_obj = self.mocker.mock()
-        self.mocker.result(creds_obj)
-
-        return creds_obj
-
-    def test_is_dbus_object(self):
-        """CredentialsManagement is a Dbus object."""
-        self.assertIsInstance(self.client,
-                              ubuntu_sso.main.linux.dbus.service.Object)
-
-
-class FakeCredentials(object):
-    """A very dummy Credentials object."""
-
-    def __init__(self, *a, **kw):
-        self.clear_credentials = lambda *a: defer.succeed(None)
-        self.store_credentials = lambda *a: defer.succeed(None)
-        self.login = self.register = lambda *a: None
-
-    def find_credentials(self, *a, **kw):
-        """Retrieve credentials."""
-        return defer.succeed(TOKEN)
-
-
-class CredentialsManagementRefCountingTestCase(CredentialsManagementTestCase):
-    """Tests for the CredentialsManagement ref counting."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsManagementRefCountingTestCase, self).setUp()
-        self.patch(ubuntu_sso.main, 'Credentials', FakeCredentials)
-
-    def test_ref_counting(self):
-        """Ref counting is in place."""
-        self.assertEqual(self.client.root.ref_count, 0)
-
-    def test_find_credentials(self):
-        """Keep proper track of on going requests."""
-        d = defer.Deferred()
-
-        def verify(*args):
-            """Make the check."""
-            self.assertEqual(self.client.root.ref_count, 1)
-            d.callback(True)
-
-        self.patch(self.client, 'CredentialsFound', verify)
-        self.client.find_credentials(APP_NAME, self.args)
-
-        return d
-
-    @defer.inlineCallbacks
-    def test_find_credentials_sync(self):
-        """Keep proper track of on going requests."""
-        d = defer.Deferred()
-
-        def verify(*args):
-            """Make the check."""
-            self.assertEqual(self.client.root.ref_count, 1)
-            d.callback(True)
-
-        self.client.find_credentials_sync(APP_NAME, self.args,
-                                          reply_handler=verify,
-                                          error_handler=d.errback)
-        yield d
-        self.assertEqual(self.client.root.ref_count, 0)
-
-    @defer.inlineCallbacks
-    def test_find_credentials_sync_error(self):
-        """Keep proper track of on going requests."""
-        d = defer.Deferred()
-
-        def verify(*args):
-            """Make the check."""
-            self.assertEqual(self.client.root.ref_count, 1)
-            d.callback(True)
-
-        self.patch(ubuntu_sso.main.Credentials, 'find_credentials',
-                   lambda *a: defer.fail('foo'))
-        self.client.find_credentials_sync(APP_NAME, self.args,
-                                          reply_handler=d.errback,
-                                          error_handler=verify)
-
-        yield d
-        self.assertEqual(self.client.root.ref_count, 0)
-
-    def test_clear_credentials(self):
-        """Keep proper track of on going requests."""
-        d = defer.Deferred()
-
-        def verify(*args):
-            """Make the check."""
-            self.assertEqual(self.client.root.ref_count, 1)
-            d.callback(True)
-
-        self.patch(self.client, 'CredentialsCleared', verify)
-        self.client.clear_credentials(APP_NAME, self.args)
-
-        return d
-
-    def test_store_credentials(self):
-        """Keep proper track of on going requests."""
-        d = defer.Deferred()
-
-        def verify(*args):
-            """Make the check."""
-            self.assertEqual(self.client.root.ref_count, 1)
-            d.callback(True)
-
-        self.patch(self.client, 'CredentialsStored', verify)
-        self.client.store_credentials(APP_NAME, self.args)
-
-        return d
-
-    def test_register(self):
-        """Keep proper track of on going requests."""
-        self.client.register(APP_NAME, self.args)
-
-        self.assertEqual(self.client.root.ref_count, 1)
-
-    def test_login(self):
-        """Keep proper track of on going requests."""
-        self.client.login(APP_NAME, self.args)
-
-        self.assertEqual(self.client.root.ref_count, 1)
-
-    def test_several_requests(self):
-        """Requests can be nested."""
-        self.client.login(APP_NAME, self.args)
-        self.client.register(APP_NAME, self.args)
-        self.client.login(APP_NAME, self.args)
-        self.client.register(APP_NAME, self.args)
-        self.client.register(APP_NAME, self.args)
-
-        self.assertEqual(self.client.root.ref_count, 5)
-
-    def test_credentials_found(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root.ref_count = 3
-        self.client.CredentialsFound(APP_NAME, TOKEN)
-
-        self.assertEqual(self.client.root.ref_count, 2)
-
-    def test_credentials_not_found(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root.ref_count = 3
-        self.client.CredentialsNotFound(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 2)
-
-    def test_credentials_cleared(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root.ref_count = 3
-        self.client.CredentialsCleared(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 2)
-
-    def test_credentials_stored(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root.ref_count = 3
-        self.client.CredentialsStored(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 2)
-
-    def test_credentials_error(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root.ref_count = 3
-        self.client.CredentialsError(APP_NAME, {'error_type': 'test'})
-
-        self.assertEqual(self.client.root.ref_count, 2)
-
-    def test_authorization_denied(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root.ref_count = 3
-        self.client.AuthorizationDenied(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 2)
-
-    def test_credentials_found_when_ref_count_is_not_positive(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root._ref_count = -3
-        self.client.CredentialsFound(APP_NAME, TOKEN)
-
-        self.assertEqual(self.client.root.ref_count, 0)
-        msg = 'Attempting to decrease ref_count to a negative value (-4).'
-        self.assertTrue(self.memento.check_warning(msg))
-
-    def test_credentials_not_found_when_ref_count_is_not_positive(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root._ref_count = -3
-        self.client.CredentialsNotFound(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 0)
-        msg = 'Attempting to decrease ref_count to a negative value (-4).'
-        self.assertTrue(self.memento.check_warning(msg))
-
-    def test_credentials_cleared_when_ref_count_is_not_positive(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root._ref_count = -3
-        self.client.CredentialsCleared(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 0)
-        msg = 'Attempting to decrease ref_count to a negative value (-4).'
-        self.assertTrue(self.memento.check_warning(msg))
-
-    def test_credentials_stored_when_ref_count_is_not_positive(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root._ref_count = -3
-        self.client.CredentialsStored(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 0)
-        msg = 'Attempting to decrease ref_count to a negative value (-4).'
-        self.assertTrue(self.memento.check_warning(msg))
-
-    def test_credentials_error_when_ref_count_is_not_positive(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root._ref_count = -3
-        self.client.CredentialsError(APP_NAME, {'error_type': 'test'})
-
-        self.assertEqual(self.client.root.ref_count, 0)
-        msg = 'Attempting to decrease ref_count to a negative value (-4).'
-        self.assertTrue(self.memento.check_warning(msg))
-
-    def test_autorization_denied_when_ref_count_is_not_positive(self):
-        """Ref counter is decreased when a signal is sent."""
-        self.client.root._ref_count = -3
-        self.client.AuthorizationDenied(APP_NAME)
-
-        self.assertEqual(self.client.root.ref_count, 0)
-        msg = 'Attempting to decrease ref_count to a negative value (-4).'
-        self.assertTrue(self.memento.check_warning(msg))
-
-    def test_on_zero_ref_count_shutdown(self):
-        """When ref count reaches 0, queue shutdown op."""
-        self.patch(self.client.root, 'timeout_func', self._set_called)
-        self.client.login(APP_NAME, self.args)
-        self.client.CredentialsFound(APP_NAME, TOKEN)
-
-        self.assertEqual(self._called,
-                         ((TIMEOUT_INTERVAL, self.client.root.shutdown), {}))
-
-    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.client.root, 'timeout_func', self._set_called)
-        self.client.login(APP_NAME, self.args)
-
-        self.assertEqual(self._called, False)
-
-    def test_on_non_zero_ref_count_after_zero_do_not_shutdown(self):
-        """If the shutdown was queued, do not quit if counter is not zero."""
-
-        def fake_timeout_func(interval, func):
-            """Start a new request when the timer is started."""
-            self.client.register(APP_NAME, self.args)
-            assert self.client.root.ref_count > 0
-            func()
-
-        self.patch(self.client.root, 'timeout_func', fake_timeout_func)
-        self.patch(self.client.root, 'shutdown_func', self._set_called)
-
-        self.client.login(APP_NAME, self.args)
-        self.client.CredentialsFound(APP_NAME, TOKEN)
-        # counter reached 0, timeout_func was called
-
-        self.assertEqual(self._called, False, 'shutdown_func was not called')
-
-    def test_zero_ref_count_after_zero_do_shutdown(self):
-        """If the shutdown was queued, do quit if counter is zero."""
-
-        def fake_timeout_func(interval, func):
-            """Start a new request when the timer is started."""
-            assert self.client.root.ref_count == 0
-            func()
-
-        self.patch(self.client.root, 'timeout_func', fake_timeout_func)
-        self.patch(self.client.root, 'shutdown_func', self._set_called)
-
-        self.client.login(APP_NAME, self.args)
-        self.client.CredentialsFound(APP_NAME, TOKEN)
-        # counter reached 0, timeout_func was called
-
-        self.assertEqual(self._called, ((), {}), 'shutdown_func was called')
-
-
-class CredentialsManagementFindTestCase(CredentialsManagementTestCase):
-    """Tests for the CredentialsManagement find method."""
-
-    def test_find_credentials(self):
-        """The credentials are asked and returned in signals."""
-        self.create_mock_backend().find_credentials()
-        self.mocker.result(defer.succeed(None))
-        self.mocker.replay()
-
-        self.client.find_credentials(APP_NAME, self.args)
-        self.assert_dbus_method_correct(self.client.find_credentials)
-
-    def test_find_credentials_does_not_block_when_found(self):
-        """Calling find_credentials does not block but return thru signals.
-
-        If the creds are found, CredentialsFound is emitted.
-
-        """
-        d = defer.Deferred()
-
-        def verify(app_name, creds):
-            """The actual test."""
-            try:
-                self.assertEqual(app_name, APP_NAME)
-                self.assertEqual(creds, TOKEN)
-            except Exception, e:  # pylint: disable=W0703
-                d.errback(e)
-            else:
-                d.callback(creds)
-
-        self.patch(self.client, 'CredentialsFound', verify)
-        self.patch(self.client, 'CredentialsNotFound', d.errback)
-
-        self.create_mock_backend().find_credentials()
-        self.mocker.result(defer.succeed(TOKEN))
-        self.mocker.replay()
-
-        self.client.find_credentials(APP_NAME, self.args)
-        return d
-
-    def test_find_credentials_does_not_block_when_not_found(self):
-        """Calling find_credentials does not block but return thru signals.
-
-        If the creds are not found, CredentialsNotFound is emitted.
-
-        """
-        d = defer.Deferred()
-
-        def verify(app_name):
-            """The actual test."""
-            try:
-                self.assertEqual(app_name, APP_NAME)
-            except Exception, e:  # pylint: disable=W0703
-                d.errback(e)
-            else:
-                d.callback(app_name)
-
-        self.patch(self.client, 'CredentialsFound',
-                   lambda app, creds: d.errback(app))
-        self.patch(self.client, 'CredentialsNotFound', verify)
-
-        self.create_mock_backend().find_credentials()
-        self.mocker.result(defer.succeed({}))
-        self.mocker.replay()
-
-        self.client.find_credentials(APP_NAME, self.args)
-        return d
-
-    def test_find_credentials_error(self):
-        """If find_credentials fails, CredentialsError is sent."""
-        d = defer.Deferred()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        self.patch(self.client, 'CredentialsFound',
-                   lambda app, creds: d.errback(app))
-        self.patch(self.client, 'CredentialsNotFound', d.errback)
-        self.patch(self.client, 'CredentialsError', verify)
-
-        self.create_mock_backend().find_credentials()
-        self.mocker.result(defer.fail(BlockingSampleException()))
-        self.mocker.replay()
-
-        self.client.find_credentials(APP_NAME, self.args)
-        return d
-
-    def test_find_credentials_sync(self):
-        """The credentials are asked and returned in a blocking call."""
-        d = defer.Deferred()
-
-        def verify(creds):
-            """The actual test."""
-            try:
-                self.assertEqual(creds, TOKEN)
-            except Exception, e:  # pylint: disable=W0703
-                d.errback(e)
-            else:
-                d.callback(creds)
-
-        self.create_mock_backend().find_credentials()
-        self.mocker.result(defer.succeed(TOKEN))
-        self.mocker.replay()
-
-        self.client.find_credentials_sync(APP_NAME, self.args,
-                                          reply_handler=verify,
-                                          error_handler=d.errback)
-        self.assert_dbus_method_correct(self.client.find_credentials_sync,
-                                        out_signature='a{ss}')
-        return d
-
-    def test_find_credentials_sync_error(self):
-        """If find_credentials_sync fails, error_handler is called."""
-        d = defer.Deferred()
-
-        def verify(error):
-            """The actual test."""
-            try:
-                errdict = error.args[0]
-                self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            except Exception, e:  # pylint: disable=W0703
-                d.errback(e)
-            else:
-                d.callback("Ok")
-
-        self.create_mock_backend().find_credentials()
-        self.mocker.result(defer.fail(BlockingSampleException()))
-        self.mocker.replay()
-
-        self.client.find_credentials_sync(APP_NAME, self.args,
-                                          reply_handler=d.errback,
-                                          error_handler=verify)
-        return d
-
-
-class CredentialsManagementClearTestCase(CredentialsManagementTestCase):
-    """Tests for the CredentialsManagement clear method."""
-
-    def test_clear_credentials(self):
-        """The credentials are removed."""
-        self.create_mock_backend().clear_credentials()
-        self.mocker.result(defer.succeed(APP_NAME))
-        self.mocker.replay()
-
-        self.client.clear_credentials(APP_NAME, self.args)
-        self.assert_dbus_method_correct(self.client.clear_credentials)
-
-    def test_clear_credentials_does_not_block(self):
-        """Calling clear_credentials does not block but return thru signals."""
-        d = defer.Deferred()
-
-        def verify(app_name):
-            """The actual test."""
-            try:
-                self.assertEqual(app_name, APP_NAME)
-            except Exception, e:  # pylint: disable=W0703
-                d.errback(e)
-            else:
-                d.callback(app_name)
-
-        self.patch(self.client, 'CredentialsCleared', verify)
-        self.patch(self.client, 'CredentialsError',
-                   lambda app, err: d.errback(app))
-
-        self.create_mock_backend().clear_credentials()
-        self.mocker.result(defer.succeed(APP_NAME))
-        self.mocker.replay()
-
-        self.client.clear_credentials(APP_NAME, self.args)
-        return d
-
-    def test_clear_credentials_error(self):
-        """If clear_credentials fails, CredentialsError is sent."""
-        d = defer.Deferred()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        self.patch(self.client, 'CredentialsCleared', d.errback)
-        self.patch(self.client, 'CredentialsError', verify)
-
-        self.create_mock_backend().clear_credentials()
-        self.mocker.result(defer.fail(BlockingSampleException()))
-        self.mocker.replay()
-
-        self.client.clear_credentials(APP_NAME, self.args)
-        return d
-
-
-class CredentialsManagementStoreTestCase(CredentialsManagementTestCase):
-    """Tests for the CredentialsManagement store method."""
-
-    def test_store_credentials(self):
-        """The credentials are stored and the outcome is a signal."""
-        self.create_mock_backend().store_credentials(TOKEN)
-        self.mocker.result(defer.succeed(APP_NAME))
-        self.mocker.replay()
-
-        self.client.store_credentials(APP_NAME, TOKEN)
-        self.assert_dbus_method_correct(self.client.store_credentials)
-
-    def test_store_credentials_does_not_block(self):
-        """Calling store_credentials does not block but return thru signals.
-
-        If the creds are stored, CredentialsStored is emitted.
-
-        """
-        d = defer.Deferred()
-
-        def verify(app_name):
-            """The actual test."""
-            try:
-                self.assertEqual(app_name, APP_NAME)
-            except Exception, e:  # pylint: disable=W0703
-                d.errback(e)
-            else:
-                d.callback(app_name)
-
-        self.patch(self.client, 'CredentialsStored', verify)
-        self.patch(self.client, 'CredentialsError',
-                   lambda app, err: d.errback(app))
-
-        self.create_mock_backend().store_credentials(TOKEN)
-        self.mocker.result(defer.succeed(APP_NAME))
-        self.mocker.replay()
-
-        self.client.store_credentials(APP_NAME, TOKEN)
-        return d
-
-    def test_store_credentials_error(self):
-        """If store_credentials fails, CredentialsError is sent."""
-        d = defer.Deferred()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        self.patch(self.client, 'CredentialsStored', d.errback)
-        self.patch(self.client, 'CredentialsError', verify)
-
-        self.create_mock_backend().store_credentials(TOKEN)
-        self.mocker.result(defer.fail(BlockingSampleException()))
-        self.mocker.replay()
-
-        self.client.store_credentials(APP_NAME, TOKEN)
-        return d
-
-
-class CredentialsManagementOpsTestCase(CredentialsManagementTestCase):
-    """Tests for the CredentialsManagement login/register methods."""
-
-    @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.cred_args = self.base_args.copy()
-        self.cred_args[SUCCESS_CB_KEY] = self.client.CredentialsFound
-        self.cred_args[ERROR_CB_KEY] = self.client.CredentialsError
-        self.cred_args[DENIAL_CB_KEY] = self.client.AuthorizationDenied
-
-    def test_register(self):
-        """The registration is correct."""
-        self.create_mock_backend().register()
-        self.mocker.replay()
-
-        self.client.register(APP_NAME, self.args)
-        self.assert_dbus_method_correct(self.client.register)
-
-    def test_login(self):
-        """The login is correct."""
-        self.create_mock_backend().login()
-        self.mocker.replay()
-
-        self.client.login(APP_NAME, self.args)
-        self.assert_dbus_method_correct(self.client.login)
-
-    def test_login_email_password(self):
-        """The login_email_password is correct."""
-        self.create_mock_backend().login_email_password(email=EMAIL,
-                                                        password=PASSWORD)
-        self.mocker.replay()
-
-        self.args['email'] = EMAIL
-        self.args['password'] = PASSWORD
-        self.client.login_email_password(APP_NAME, self.args)
-        self.assert_dbus_method_correct(self.client.login_email_password)
-
-
-class CredentialsManagementParamsTestCase(CredentialsManagementOpsTestCase):
-    """Tests for the CredentialsManagement extra parameters handling."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(CredentialsManagementParamsTestCase, self).setUp()
-        self.args['dummy'] = 'nothing useful'
-
-
-class CredentialsManagementSignalsTestCase(TestCase):
-    """Tests for the CredentialsManagement DBus signals."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set up."""
-        yield super(CredentialsManagementSignalsTestCase, self).setUp()
-        self.client = CredentialsManagement(timeout_func=lambda *a: None,
-                                            shutdown_func=lambda *a: None)
-
-        self.memento = MementoHandler()
-        self.memento.setLevel(logging.DEBUG)
-        ubuntu_sso.main.linux.logger.addHandler(self.memento)
-        self.addCleanup(ubuntu_sso.main.linux.logger.removeHandler,
-                        self.memento)
-
-    def assert_dbus_signal_correct(self, signal, signature):
-        """Check that 'signal' is a dbus signal with proper 'signature'."""
-        self.assertTrue(signal._dbus_is_signal)
-        self.assertEqual(signal._dbus_interface, DBUS_CREDENTIALS_IFACE)
-        self.assertEqual(signal._dbus_signature, signature)
-
-    def test_credentials_found(self):
-        """The CredentialsFound signal."""
-        self.client.CredentialsFound(APP_NAME, TOKEN)
-        msgs = (self.client.__class__.__name__,
-                self.client.CredentialsFound.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
-
-        msg = 'credentials must not be logged (found %r in log).'
-        for val in TOKEN.itervalues():
-            self.assertFalse(self.memento.check_info(val), msg % val)
-
-        self.assert_dbus_signal_correct(self.client.CredentialsFound, 'sa{ss}')
-
-    def test_credentials_not_found(self):
-        """The CredentialsNotFound signal."""
-        self.client.CredentialsNotFound(APP_NAME)
-        msgs = (self.client.__class__.__name__,
-                self.client.CredentialsNotFound.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
-        self.assert_dbus_signal_correct(self.client.CredentialsNotFound, 's')
-
-    def test_credentials_cleared(self):
-        """The CredentialsCleared signal."""
-        self.client.CredentialsCleared(APP_NAME)
-        msgs = (self.client.__class__.__name__,
-                self.client.CredentialsCleared.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
-
-        self.assert_dbus_signal_correct(self.client.CredentialsCleared, 's')
-
-    def test_credentials_stored(self):
-        """The CredentialsStored signal."""
-        self.client.CredentialsStored(APP_NAME)
-        msgs = (self.client.__class__.__name__,
-                self.client.CredentialsStored.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
-
-        self.assert_dbus_signal_correct(self.client.CredentialsStored, 's')
-
-    def test_credentials_error(self):
-        """The CredentialsError signal."""
-        error = {'error_message': 'failed!', 'detailed error': 'yadda yadda'}
-        self.client.CredentialsError(APP_NAME, error)
-        msgs = (self.client.__class__.__name__,
-                self.client.CredentialsError.__name__,
-                APP_NAME, str(error))
-        self.assertTrue(self.memento.check_error(*msgs))
-
-        self.assert_dbus_signal_correct(self.client.CredentialsError, 'sa{ss}')
-
-    def test_authorization_denied(self):
-        """The AuthorizationDenied signal."""
-        self.client.AuthorizationDenied(APP_NAME)
-        msgs = (self.client.__class__.__name__,
-                self.client.AuthorizationDenied.__name__, APP_NAME)
-        self.assertTrue(self.memento.check_info(*msgs))
-
-        self.assert_dbus_signal_correct(self.client.AuthorizationDenied, 's')

=== modified file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	2011-12-19 19:35:06 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2012-01-17 16:51:50 +0000
@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-# Authors: Manuel de la Pena <[e-mail]>
-#          Alejandro J. Cura <[e-mail]>
 #
 # Copyright 2011 Canonical Ltd.
 #
@@ -15,932 +13,16 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Windows tests."""
+"""Windows specific tests for the main module."""
 
 # pylint: disable=F0401
 from _winreg import REG_SZ
 
-from mocker import MATCH, Mocker, MockerTestCase
-
-from twisted.internet import defer, reactor
-from twisted.trial.unittest import TestCase
-from twisted.spread.pb import (
-    DeadReferenceError,
-    PBClientFactory,
-    PBServerFactory,
-    Broker,
-)
-from ubuntu_sso import main
 from ubuntu_sso.main import windows
-from ubuntu_sso.main.windows import (
-    signal,
-    CredentialsManagement,
-    CredentialsManagementClient,
-    LOCALHOST,
-    SignalBroadcaster,
-    SSOLogin,
-    SSOLoginClient,
-    UbuntuSSORoot,
-    UbuntuSSOClient,
-    get_sso_pb_port,
-)
-
-# because we are using twisted we have java like names C0103 and
-# the issues that mocker brings with it like W0104
-# pylint: disable=C0103,W0104,E1101,W0201
-
-
-class SaveProtocolServerFactory(PBServerFactory):
-    """A PBServerFactory that saves the latest connected client."""
-
-    protocolInstance = None
-
-    def clientConnectionMade(self, protocol):
-        """Keep track of the given protocol."""
-        self.protocolInstance = protocol
-
-
-class SaveClientFactory(PBClientFactory):
-    """Client Factory that knows when we disconnected."""
-
-    def __init__(self, connected_d, disconnected_d):
-        """Create a new instance."""
-        PBClientFactory.__init__(self)
-        self.connected_d = connected_d
-        self.disconnected_d = disconnected_d
-
-    def clientConnectionMade(self, broker):
-        """Connection made."""
-        PBClientFactory.clientConnectionMade(self, broker)
-        self.connected_d.callback(True)
-
-    def clientConnectionLost(self, connector, reason, reconnecting=0):
-        """Connection lost."""
-        self.disconnected_d.callback(True)
-
-
-class ServerProtocol(Broker):
-    """Server protocol that allows us to clean the tests."""
-
-    def connectionLost(self, *a):
-        self.factory.onConnectionLost.callback(self)
-
-
-class ConnectedTestCase(TestCase):
-    """Base test case with a client and a server."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set up for the tests."""
-        yield super(ConnectedTestCase, self).setUp()
-        self.server_disconnected = defer.Deferred()
-        self.client_disconnected = defer.Deferred()
-        self.listener = None
-        self.connector = None
-        self.server_factory = None
-        self.client_factory = None
-
-    def setup_client_server(self, sso_root):
-        """Set tests."""
-        port = get_sso_pb_port()
-        self.listener = self._listen_server(sso_root, self.server_disconnected,
-                port)
-        connected = defer.Deferred()
-        self.connector = self._connect_client(connected,
-                self.client_disconnected, port)
-        self.addCleanup(self.teardown_client_server)
-        return connected
-
-    def _listen_server(self, sso_root, d, port):
-        """Start listenting."""
-        self.server_factory = SaveProtocolServerFactory(sso_root)
-        self.server_factory.onConnectionLost = d
-        self.server_factory.protocol = ServerProtocol
-        return reactor.listenTCP(port, self.server_factory)
-
-    def _connect_client(self, d1, d2, port):
-        """Connect client."""
-        self.client_factory = SaveClientFactory(d1, d2)
-        return reactor.connectTCP(LOCALHOST, port, self.client_factory)
-
-    def teardown_client_server(self):
-        """Clean resources."""
-        self.connector.disconnect()
-        d = defer.maybeDeferred(self.listener.stopListening)
-        return defer.gatherResults([d, self.client_disconnected,
-            self.server_disconnected])
-
-
-class FakeDecoratedObject(object):
-    """An object that has decorators."""
-
-    def __init__(self):
-        """Create a new instance."""
-        super(FakeDecoratedObject, self).__init__()
-
-    @signal
-    def on_no_args(self):
-        """Get no args passwed."""
-
-    @signal
-    def on_just_args(self, *args):
-        """Just get args."""
-
-    @signal
-    def on_just_kwargs(self, **kwargs):
-        """Just get kwargs."""
-
-    @signal
-    def on_both_args(self, *args, **kwargs):
-        """Both args."""
-
-
-class TestException(Exception):
-    """A test exception."""
-
-    @classmethod
-    def fail(cls, *args):
-        """Raise this exception."""
-        raise cls(*args)
-
-
-# pylint: disable=W0201
-class SignalTestCase(MockerTestCase):
-    """Test the signal decorator."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(SignalTestCase, self).setUp()
-        self.fake_object = FakeDecoratedObject()
-        self.cb = self.mocker.mock()
-
-    def test_no_args(self):
-        """Test when the cb should have no args."""
-        self.fake_object.on_no_args_cb = self.cb
-        self.cb()
-        self.mocker.replay()
-        self.fake_object.on_no_args()
-
-    def test_just_args(self):
-        """Test when the cb just has *args"""
-        first = 'first'
-        second = 'second'
-        self.fake_object.on_just_args_cb = self.cb
-        self.cb(first, second)
-        self.mocker.replay()
-        self.fake_object.on_just_args(first, second)
-
-    def test_just_kwargs(self):
-        """Test when the cb just has kwargs."""
-        first = 'first'
-        second = 'second'
-        self.fake_object.on_just_kwargs_cb = self.cb
-        self.cb(first=first, second=second)
-        self.mocker.replay()
-        self.fake_object.on_just_kwargs(first=first, second=second)
-
-    def test_just_kwargs_empty(self):
-        """Test when the cb just has kwargs."""
-        self.fake_object.on_just_kwargs_cb = self.cb
-        self.cb()
-        self.mocker.replay()
-        self.fake_object.on_just_kwargs()
-
-    def test_both_args(self):
-        """Test with args and kwargs."""
-        first = 'first'
-        second = 'second'
-        self.fake_object.on_both_args_cb = self.cb
-        self.cb(first, second, first=first, second=second)
-        self.mocker.replay()
-        self.fake_object.on_both_args(first, second, first=first,
-                                      second=second)
-
-    def test_both_args_no_kwargs(self):
-        """Test with args and kwargs."""
-        first = 'first'
-        second = 'second'
-        self.fake_object.on_both_args_cb = self.cb
-        self.cb(first, second)
-        self.mocker.replay()
-        self.fake_object.on_both_args(first, second)
-
-    def test_both_args_no_args(self):
-        """Test with args and kwargs."""
-        first = 'first'
-        second = 'second'
-        self.fake_object.on_both_args_cb = self.cb
-        self.cb(first=first, second=second)
-        self.mocker.replay()
-        self.fake_object.on_both_args(first=first, second=second)
-# pylint: enable=W0201
-
-
-class FakeDeadRemoteClient(object):
-    """A fake dead remote client."""
-
-    def callRemote(self, signal_name, *args, **kwargs):
-        """Fails with DeadReferenceError."""
-        raise DeadReferenceError("Calling Stale Broker")
-
-
-class FakeAliveRemoteClient(object):
-    """A fake alive remote client."""
-
-    def __init__(self):
-        self.called = False
-
-    def callRemote(self, signal_name, *args, **kwargs):
-        """Returns a succeed."""
-        self.called = True
-        return defer.succeed(None)
-
-
-class SignalBroadcasterTestCase(TestCase):
-    """Test the SignalBroadcaster class."""
-
-    def test_emit_signal_dead_reference(self):
-        """Test dead reference while emiting the signal."""
-        fake_remote_client = FakeDeadRemoteClient()
-        sb = SignalBroadcaster()
-        sb.remote_register_to_signals(fake_remote_client)
-        self.assertIn(fake_remote_client, sb.clients)
-        sb.emit_signal("sample_signal")
-        self.assertNotIn(fake_remote_client, sb.clients)
-
-    def test_emit_signal_some_dead_some_not(self):
-        """Test a clean reference after a dead one."""
-        fake_dead_remote = FakeDeadRemoteClient()
-        fake_alive_remote = FakeAliveRemoteClient()
-        sb = SignalBroadcaster()
-        sb.remote_register_to_signals(fake_dead_remote)
-        sb.remote_register_to_signals(fake_alive_remote)
-        sb.emit_signal("sample_signal")
-        self.assertTrue(fake_alive_remote.called, "The alive must be called.")
-
-
-class SignalHandlingTestCase(TestCase):
-    """Base for test suites that deal with IPC signal handling."""
-
-    timeout = 3
-    signal_names = []
-    first_signal = None
-
-    def create_handler(self, d):
-        """Create a handler in a new namespace."""
-        return lambda *args: d.callback(args)
-
-    def install_handlers(self, client):
-        """Install the signal handlers."""
-        signal_handlers = []
-
-        for signal_name in self.signal_names:
-            d = defer.Deferred()
-            handler = self.create_handler(d)
-            handler_name = "on_%s_cb" % signal_name
-            setattr(client, handler_name, handler)
-            signal_handlers.append(d)
-        self.first_signal = defer.DeferredList(signal_handlers,
-                                               fireOnOneCallback=True,
-                                               fireOnOneErrback=True)
-
-    @defer.inlineCallbacks
-    def assert_fired(self, name, *args):
-        """Assert that the given signal was fired."""
-        signal_args, signal_index = yield self.first_signal
-        self.assertEqual(args, signal_args[:len(args)])
-        self.assertEqual(name, self.signal_names[signal_index])
-
-
-class SSOLoginTestCase(ConnectedTestCase, SignalHandlingTestCase):
-    """Test the login class."""
-
-    signal_names = [
-        'captcha_generated',
-        'captcha_generation_error',
-        'user_registered',
-        'user_registration_error',
-        'logged_in',
-        'login_error',
-        'user_not_validated',
-        'email_validated',
-        'email_validation_error',
-        'password_reset_token_sent',
-        'password_reset_error',
-        'password_changed',
-        'password_change_error',
-    ]
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Setup tests."""
-        yield super(SSOLoginTestCase, self).setUp()
-        self.mocker = Mocker()
-        self.root = self.mocker.mock()
-        self.login = SSOLogin(None)
-        # start pb
-        self.sso_root = UbuntuSSORoot(sso_login=self.login)
-        # pylint: disable=E1101
-        yield self.setup_client_server(self.sso_root)
-        self.client = yield self._get_client()
-        # pylint: enable=E1101
-
-    @defer.inlineCallbacks
-    def _get_client(self):
-        """Get the client."""
-        # request the remote object and create a client
-        root = yield self.client_factory.getRootObject()
-        remote = yield root.callRemote('get_sso_login')
-        client = SSOLoginClient(remote)
-        yield client.register_to_signals()
-        self.addCleanup(client.unregister_to_signals)
-
-        self.install_handlers(client)
-        defer.returnValue(client)
-
-    @defer.inlineCallbacks
-    def test_emit_captcha_generated(self):
-        """Test that the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_captcha_generated(app_name, result)
-        yield self.assert_fired("captcha_generated", app_name, result)
-
-    @defer.inlineCallbacks
-    def test_emit_captcha_generation_error(self):
-        """Test that the cb was called."""
-        app_name = 'app'
-        filename = 'file'
-
-        self.patch(self.login.root.processor, "generate_captcha",
-                   TestException.fail)
-        self.login.generate_captcha(app_name, filename)
-        yield self.assert_fired("captcha_generation_error", app_name)
-
-    @defer.inlineCallbacks
-    def test_generate_captcha(self):
-        """Test the call from the client."""
-        app_name = 'app'
-        filename = 'file'
-        self.login.root = self.root
-
-        self.root.generate_captcha(app_name, filename,
-                               self.login.emit_captcha_generated,
-                               self.login.emit_captcha_generation_error)
-        self.mocker.replay()
-        yield self.client.generate_captcha(app_name, filename)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_user_registered(self):
-        """Test that the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_user_registered(app_name, result)
-        yield self.assert_fired("user_registered", app_name, result)
-
-    @defer.inlineCallbacks
-    def test_emit_user_registration_error(self):
-        """Test that the cb was called."""
-        app_name = 'app'
-
-        self.patch(self.login.root.processor, "register_user",
-                   TestException.fail)
-        self.login.register_user(app_name, "email", "password", "name",
-                                 "captcha_id", "captcha_solution")
-        yield self.assert_fired("user_registration_error", app_name)
-
-    @defer.inlineCallbacks
-    def test_register_user(self):
-        """Test the call from the client."""
-        app_name = 'app'
-        email = 'email'
-        password = 'password'
-        displayname = 'name'
-        captcha_id = 'captcha_id'
-        captcha_solution = 'captcha_solution'
-        self.login.root = self.root
-
-        self.root.register_user(app_name, email, password, displayname,
-                                captcha_id, captcha_solution,
-                                self.login.emit_user_registered,
-                                self.login.emit_user_registration_error)
-        self.mocker.replay()
-        yield self.client.register_user(app_name, email, password, displayname,
-                                   captcha_id, captcha_solution)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_logged_in(self):
-        """Test that the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_logged_in(app_name, result)
-        yield self.assert_fired("logged_in", app_name)
-
-    @defer.inlineCallbacks
-    def test_emit_login_error(self):
-        """Test that the db was called."""
-        app_name = 'app'
-
-        self.patch(main, "get_token_name", lambda _: None)
-        self.patch(self.login.root.processor, "login",
-                   TestException.fail)
-        self.login.login(app_name, "email", "password")
-        yield self.assert_fired("login_error", app_name)
-
-    @defer.inlineCallbacks
-    def test_emit_user_not_validated(self):
-        """Test that the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_user_not_validated(app_name, result)
-        yield self.assert_fired("user_not_validated", app_name)
-
-    @defer.inlineCallbacks
-    def test_login(self):
-        """Test the call from the client."""
-        app_name = 'app'
-        email = 'email'
-        password = 'password'
-        self.login.root = self.root
-
-        self.root.login(app_name, email, password,
-                        self.login.emit_logged_in,
-                        self.login.emit_login_error,
-                        self.login.emit_user_not_validated)
-        self.mocker.replay()
-        yield self.client.login(app_name, email, password)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_email_validated(self):
-        """Test the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_email_validated(app_name, result)
-        yield self.assert_fired("email_validated", app_name)
-
-    @defer.inlineCallbacks
-    def test_emit_email_validation_error(self):
-        """Test the cb was called."""
-        app_name = 'app'
-
-        self.patch(main, "get_token_name", lambda _: None)
-        self.patch(self.login.root.processor, "validate_email",
-                   TestException.fail)
-        self.login.validate_email(app_name, "email", "password", "token")
-        yield self.assert_fired("email_validation_error", app_name)
-
-    @defer.inlineCallbacks
-    def test_validate_email(self):
-        """Test the client calll."""
-        app_name = 'app'
-        email = 'email'
-        password = 'password'
-        email_token = 'token'
-        self.login.root = self.root
-
-        self.root.validate_email(app_name, email, password, email_token,
-                                 self.login.emit_email_validated,
-                                 self.login.emit_email_validation_error)
-        self.mocker.replay()
-        yield self.client.validate_email(app_name, email, password,
-                                         email_token)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_password_reset_token_sent(self):
-        """Test the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_password_reset_token_sent(app_name, result)
-        yield self.assert_fired("password_reset_token_sent", app_name)
-
-    @defer.inlineCallbacks
-    def test_emit_password_reset_error(self):
-        """Test the cb was called."""
-        app_name = 'app'
-
-        self.patch(self.login.root.processor, "request_password_reset_token",
-                   TestException.fail)
-        self.login.request_password_reset_token(app_name, "email")
-        yield self.assert_fired("password_reset_error", app_name)
-
-    @defer.inlineCallbacks
-    def test_request_password_reset_token(self):
-        """Test the client call."""
-        app_name = 'app'
-        email = 'email'
-        self.login.root = self.root
-
-        self.root.request_password_reset_token(app_name, email,
-                            self.login.emit_password_reset_token_sent,
-                            self.login.emit_password_reset_error)
-        self.mocker.replay()
-        self.client.request_password_reset_token(app_name, email)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_password_changed(self):
-        """Test the cb was called."""
-        app_name = 'app'
-        result = 'result'
-
-        self.login.emit_password_changed(app_name, result)
-        yield self.assert_fired("password_changed", app_name)
-
-    @defer.inlineCallbacks
-    def test_emit_password_change_error(self):
-        """Test the cb was called."""
-        app_name = 'app'
-
-        self.patch(self.login.root.processor, "set_new_password",
-                   TestException.fail)
-        self.login.set_new_password(app_name, "email", "token", "password")
-        yield self.assert_fired("password_change_error", app_name)
-
-    @defer.inlineCallbacks
-    def test_set_new_password(self):
-        """Test the client call."""
-        app_name = 'app'
-        email = 'email'
-        token = 'token'
-        new_password = 'password'
-        self.login.root = self.root
-
-        self.root.set_new_password(app_name, email, token, new_password,
-                               self.login.emit_password_changed,
-                               self.login.emit_password_change_error)
-        self.mocker.replay()
-        yield self.client.set_new_password(app_name, email, token,
-                                           new_password)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-
-class CredentialsManagementTestCase(ConnectedTestCase, TestCase):
-    """Test the management class."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set up tests."""
-        yield super(CredentialsManagementTestCase, self).setUp()
-        self.mocker = Mocker()
-        self.root = self.mocker.mock()
-        self.except_to_errdict = self.mocker.replace(
-                                        'ubuntu_sso.main.except_to_errdict')
-        self.creds = CredentialsManagement(None, None)
-        self.creds.root = self.root
-        # start pb
-        self.sso_root = UbuntuSSORoot(cred_manager=self.creds)
-        # pylint: disable=E1101
-        yield self.setup_client_server(self.sso_root)
-        self.client = yield self._get_client()
-        # pylint: enable=E1101
-
-    @defer.inlineCallbacks
-    def _get_client(self):
-        """Get the client."""
-        # request the remote object and create a client
-        root = yield self.client_factory.getRootObject()
-        remote = yield root.callRemote('get_cred_manager')
-        client = CredentialsManagementClient(remote)
-        yield client.register_to_signals()
-        self.addCleanup(client.unregister_to_signals)
-        # set the cb
-        for signal_name in ['on_authorization_denied_cb',
-                            'on_credentials_found_cb',
-                            'on_credentials_not_found_cb',
-                            'on_credentials_cleared_cb',
-                            'on_credentials_stored_cb',
-                            'on_credentials_error_cb']:
-            setattr(client, signal_name, self.mocker.mock())
-        defer.returnValue(client)
-
-    @defer.inlineCallbacks
-    def test_shutdown(self):
-        """Test that root is called."""
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.shutdown()
-        self.mocker.replay()
-        yield self.client.shutdown()
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_emit_authorization_denied(self):
-        """Test the callback is called."""
-        app_name = 'app'
-
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.ref_count = 0
-        self.client.on_authorization_denied_cb(app_name)
-        self.mocker.replay()
-        self.creds.emit_authorization_denied(app_name)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_found(self):
-        """Test the callback is called."""
-        app_name = 'app'
-        creds = 'creds'
-
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.ref_count = 0
-        self.client.on_credentials_found_cb(app_name, creds)
-        self.mocker.replay()
-        self.creds.emit_credentials_found(app_name, creds)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_not_found(self):
-        """Test the callback is called."""
-        app_name = 'app'
-
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.ref_count = 0
-        self.client.on_credentials_not_found_cb(app_name)
-        self.mocker.replay()
-        self.creds.emit_credentials_not_found(app_name)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_cleared(self):
-        """Test the callback is called."""
-        app_name = 'app'
-
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.ref_count = 0
-        self.client.on_credentials_cleared_cb(app_name)
-        self.mocker.replay()
-        self.creds.emit_credentials_cleared(app_name)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_stored(self):
-        """Test the callback is called."""
-        app_name = 'app'
-
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.ref_count = 0
-        self.client.on_credentials_stored_cb(app_name)
-        self.mocker.replay()
-        self.creds.emit_credentials_stored(app_name)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_error(self):
-        """Test the callback is called."""
-        app_name = 'app'
-        raised_error = 'error'
-
-        # pylint: disable=W0104
-        self.root.ref_count
-        # pylint: enable=W0104
-        self.mocker.result(1)
-        self.root.ref_count = 0
-        self.client.on_credentials_error_cb(app_name, raised_error)
-        self.mocker.replay()
-        self.creds.emit_credentials_error(app_name, raised_error)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_find_credentials(self):
-        """Test that root is called."""
-        app_name = 'app'
-        args = 'args'
-
-        # pylint: disable=W0212
-        self.root.find_credentials(app_name, args, MATCH(callable),
-                                   self.creds._process_failure)
-        # pylint: enable=W0212
-        self.root.shutdown()
-        yield self.client.find_credentials(app_name, args)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_clear_credentials(self):
-        """Test that root is called."""
-        app_name = 'app'
-        args = 'args'
-
-        # pylint: disable=W0212
-        self.root.clear_credentials(app_name, args, MATCH(callable),
-                                    self.creds._process_failure)
-        # pylint: enable=W0212
-        self.mocker.replay()
-        yield self.client.clear_credentials(app_name, args)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_store_credentials(self):
-        """Test that root is called."""
-        app_name = 'app'
-        args = 'args'
-
-        # pylint: disable=W0212
-        self.root.store_credentials(app_name, args, MATCH(callable),
-                           self.creds._process_failure)
-        # pylint: enable=W0212
-        self.mocker.replay()
-        yield self.client.store_credentials(app_name, args)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_register(self):
-        """Test that root is called."""
-        app_name = 'app'
-        args = 'args'
-
-        self.root.register(app_name, args)
-        self.mocker.replay()
-        yield self.client.register(app_name, args)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_login(self):
-        """Test that root is called."""
-        app_name = 'app'
-        args = 'args'
-
-        self.root.login(app_name, args)
-        self.mocker.replay()
-        yield self.client.login(app_name, args)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_login_email_password(self):
-        """Test that root is called."""
-        app_name = 'app'
-        args = 'args'
-
-        self.root.login_email_password(app_name, args)
-        self.mocker.replay()
-        yield self.client.login_email_password(app_name, args)
-        yield self.client.unregister_to_signals()
-
-
-class MockRemoteObject(object):
-    """A mock RemoteObject."""
-
-    def __init__(self):
-        """A place to store MockRemoteObjects created by this."""
-        self.children = []
-
-    def callRemote(self, method_name, *args, **kwargs):
-        """Any call to a remote object returns one of us."""
-        new_child = MockRemoteObject()
-        self.children.append(new_child)
-        return defer.succeed(new_child)
-
-
-class MockPBClientFactory(object):
-    """A mock PBClientFactory."""
-
-    connected = False
-    root_object = None
-
-    def getRootObject(self):
-        """Store that we were called; return a deferred."""
-        assert self.connected == True
-        self.root_object = MockRemoteObject()
-        return defer.succeed(self.root_object)
-
-
-class MockReactorResult(object):
-    """A mock result when calling twisted.reactor.connectTCP."""