Merge lp:~nataliabidart/ubuntu-sso-client/unify-signal-broadcaster into lp:ubuntu-sso-client

[Natalia Bidart]

- Remove duplications and unify code for IPC using Twisted's Perspective Broker between ubuntu-sso-client and ubuntuone-client (LP: #834730).

In order to run syncdaemon with this branch, you need to use this branch:

https://code.launchpad.net/~nataliabidart/ubuntuone-client/make-it-work/+merge/87767

[Alejandro J. Cura (alecu)]

== Python Lint Notices ==

ubuntu_sso/main/linux.py:
    29: [W0611] Unused import sys

ubuntu_sso/main/tests/test_windows.py:
    21: [W0611] Unused import defer
    23: [W0611] Unused import UbuntuSSOService

review: Needs Fixing

[lp:~nataliabidart/ubuntu-sso-client/unify-signal-broadcaster]

842. By Natalia Bidart on 2012-01-10

Merged trunk in.

[Alejandro J. Cura (alecu)]

Why do we have an Elf here?

            def __init__(elf):
                elf.LoggedIn = lambda app_name, result: d.callback(result)
                elf.LoginError = lambda app_name, error: d.errback(error)
                elf.UserNotValidated = lambda app_name, email: d.callback(None)

I think __init__ should be deleted, and each of those lambda methods could be written as:
           def LoggedIn(self, app_name, result):
               d.callback(result)
---

"Provides an utility" -> "Provides a utility"

---

I find that the refcounting code in CredentialsManagement is confusing.
Perhaps we should open a bug to fix this so it's not spread in so many functions, and also we should make so that when the refcount increases above zero any pending timeout should be cancelled.
I don't consider this to be a "needs-fixing" since it's code that was already present in this branch.

[Manuel de la Peña (mandel)]

Major branch!!! here are some things I'v noticed:

* We do the following several times:
'SSOLogin: emitting CaptchaGenerated with app_name "%s" and result %r', app_name, result
'SSOLogin: emitting CaptchaGenerationError with app_name "%s" and error %r', app_name, error

is it possible to be smarter regarding the logging of the DBusSignals? an idea would be to use a decorator that way we know the function name and the args. I think it will remove some noise form the code.

* I'm confused, why do we have the following?:

1218 + d.addCallback(lambda a: reply_handler(*a))

If a is not a sequence we are going to have a runtime error..

* There are several tests of the type:

2869 + def test_credentials_cleared(self):
2870 + """The CredentialsCleared signal."""
2871 + self.obj.CredentialsCleared(APP_NAME)
2872 + msgs = (self.obj.__class__.__name__,
2873 + self.obj.CredentialsCleared.__name__, APP_NAME)
2874 + self.assertTrue(self.memento.check_info(*msgs))

Where we call a signal, build the msg and assert, can those be merged?

There seems to be some repetitive code here:

2583 + def test_credentials_found_when_ref_count_is_not_positive(self):
2584 + """Ref counter is decreased when a signal is sent."""
2585 + self.obj._ref_count = -3
2586 + self.obj.CredentialsFound(APP_NAME, TOKEN)
2587 +
2588 + self.assertEqual(self.obj.ref_count, 0)
2589 + msg = 'Attempting to decrease ref_count to a negative value (-4).'
2590 + self.assertTrue(self.memento.check_warning(msg))
2591 +
2592 + def test_credentials_not_found_when_ref_count_is_not_positive(self):
2593 + """Ref counter is decreased when a signal is sent."""
2594 + self.obj._ref_count = -3
2595 + self.obj.CredentialsNotFound(APP_NAME)
2596 +
2597 + self.assertEqual(self.obj.ref_count, 0)
2598 + msg = 'Attempting to decrease ref_count to a negative value (-4).'
2599 + self.assertTrue(self.memento.check_warning(msg))
2600 +
2601 + def test_credentials_cleared_when_ref_count_is_not_positive(self):
2602 + """Ref counter is decreased when a signal is sent."""
2603 + self.obj._ref_count = -3
2604 + self.obj.CredentialsCleared(APP_NAME)
2605 +
2606 + self.assertEqual(self.obj.ref_count, 0)
2607 + msg = 'Attempting to decrease ref_count to a negative value (-4).'
2608 + self.assertTrue(self.memento.check_warning(msg))
2609 +
2610 + def test_credentials_stored_when_ref_count_is_not_positive(self):
2611 + """Ref counter is decreased when a signal is sent."""
2612 + self.obj._ref_count = -3
2613 + self.obj.CredentialsStored(APP_NAME)
2614 +
2615 + self.assertEqual(self.obj.ref_count, 0)
2616 + msg = 'Attempting to decrease ref_count to a negative value (-4).'
2617 + self.assertTrue(self.memento.check_warning(msg))
2618 +
2619 + def test_credentials_error_when_ref_count_is_not_positive(self):
2620 + """Ref counter is decreased when a signal is sent."""
2621 + self.obj._ref_count = -3
2622 + self.obj.CredentialsError(APP_NAME, SampleException('test'))
2623 ...

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

> Why do we have an Elf here?

Fixed.

> I think __init__ should be deleted, and each of those lambda methods could be
> written as:
> def LoggedIn(self, app_name, result):
> d.callback(result)

Fixed.

> "Provides an utility" -> "Provides a utility"

Fixed.

> I find that the refcounting code in CredentialsManagement is confusing.
> Perhaps we should open a bug to fix this so it's not spread in so many
> functions, and also we should make so that when the refcount increases above
> zero any pending timeout should be cancelled.

I agree. Filled bug #914381.

[lp:~nataliabidart/ubuntu-sso-client/unify-signal-broadcaster]

843. By Natalia Bidart on 2012-01-10

- Fixes from alecu's review.

844. By Natalia Bidart on 2012-01-10

Adding a log_call decorator to remove logging code duplication.

[Alejandro J. Cura (alecu)]

This is a great branch: a lot of redundancy removed, a lot of needed cleanup on the part of our code that has always managed to make grown men cry.

Here are few more comments:
----

"about which signal send when" ->
"about when to send which signal"

----
This line seems that should be gone:
            #return defer.fail(AlreadyStartedError())

----
        """Disconnect from the process."""
        # do something?
        ->
        """No need to disconnect DBus proxy objects."""
----

"The self.patchable_backend will be patch with" ->
"The self.patchable_backend will be patched with"

----

test_clients.py is magnificent. I'm shedding tears because of how concise and beautiful it is.

----

"on going" -> "ongoing" (it's repeated a few times)

----
what's a namaner?

    def test_cred_namaner(self):

----

In ubuntu_sso/main/windows.py:

    service_cmdlie = UbuntuSSOProxy.cmdline

(lie instead of line)
----
Authentication or Authorization?

    client.cred_manager.connect_to_signal('AuthenrizationDenied', found)

(this is present twice)
----
"Kepp track of calls" -> "Keep track of calls"
----
test_service_url_as_paremeter -> test_service_url_as_parameter
"If the paremeter service url" -> "If the parameter service url"
----
"exeucte" - > "execute
----

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

> "about which signal send when" ->
> "about when to send which signal"

Fixed.

> This line seems that should be gone:
> #return defer.fail(AlreadyStartedError())

Yes, thanks for catching that. Removed!

> """Disconnect from the process."""
> # do something?
> ->
> """No need to disconnect DBus proxy objects."""

Changed.

> "The self.patchable_backend will be patch with" ->
> "The self.patchable_backend will be patched with"

Fixed.

> test_clients.py is magnificent. I'm shedding tears because of how concise and
> beautiful it is.

Thanks. If it wasn't for you, I would not have been able to complete it.

> "on going" -> "ongoing" (it's repeated a few times)

All fixed.

> what's a namaner?

A manager written by a gal really tired :-)

> In ubuntu_sso/main/windows.py:
>
> service_cmdlie = UbuntuSSOProxy.cmdline
>
> (lie instead of line)

Good catch!

> Authentication or Authorization?
>
> client.cred_manager.connect_to_signal('AuthenrizationDenied', found)

Twice fixed.

> "Kepp track of calls" -> "Keep track of calls"
> ----
> test_service_url_as_paremeter -> test_service_url_as_parameter
> "If the paremeter service url" -> "If the parameter service url"
> ----
> "exeuexeuctecte" - > "execute

All fixed!
Thanks!!!

[lp:~nataliabidart/ubuntu-sso-client/unify-signal-broadcaster]

845. By Natalia Bidart on 2012-01-10

Tons of grammar errors and typos fixed.

846. By Natalia Bidart on 2012-01-10

Fixed failing tests.

[Natalia Bidart (nataliabidart)]

> * We do the following several times:
> 'SSOLogin: emitting CaptchaGenerated with app_name "%s" and result %r',
> app_name, result
> 'SSOLogin: emitting CaptchaGenerationError with app_name "%s" and error %r',
> app_name, error
>
> is it possible to be smarter regarding the logging of the DBusSignals? an idea
> would be to use a decorator that way we know the function name and the args. I
> think it will remove some noise form the code.

Yes, I added a lg_call function to the logger module to facilitate this.

> * I'm confused, why do we have the following?:
>
> 1218 + d.addCallback(lambda a: reply_handler(*a))
>
> If a is not a sequence we are going to have a runtime error..

There will be no runtime error because of the following. That code is inside the implementation of "call_method", which makes an async call thru dbus.

So, as you can see here:

    390 self.bus.call_async(
    391 bus_name=self.bus_name, object_path=self.path,
    392 dbus_interface=self.interface, method=method_name,
    393 signature=None, args=args,
    394 reply_handler=lambda *a: d.callback(a),
    395 error_handler=d.errback)

the dbus async called will call d.callback(a) when the call is finished, and because of the lamda *a, 'a' will always be a tuple (perhaps the empty one).

This method also has to call reply_handler if it was passed as named parameter, so that's why we add this code:

    382 reply_handler = kwargs.get('reply_handler', None)
    383 if reply_handler is not None:
    384 d.addCallback(lambda a: reply_handler(*a))

Since d is callback'd with a tuple, we "desrefence" that tuple for reply_handler, which expects separated arguments.

> * There are several tests of the type:
>
> 2869 + def test_credentials_cleared(self):
> 2870 + """The CredentialsCleared signal."""
> 2871 + self.obj.CredentialsCleared(APP_NAME)
> 2872 + msgs = (self.obj.__class__.__name__,
> 2873 + self.obj.CredentialsCleared.__name__, APP_NAME)
> 2874 + self.assertTrue(self.memento.check_info(*msgs))
>
> Where we call a signal, build the msg and assert, can those be merged?

Yes, I added a method called assert_refcounter_increased which unifies them all.

> There seems to be some repetitive code here:
>
> 2583 + def test_credentials_found_when_ref_count_is_not_positive(self):
...

Yes, also unified all tests you listed using assert_refcounter_decreased and assert_refcounter_negative.

Thanks for the great review!

[lp:~nataliabidart/ubuntu-sso-client/unify-signal-broadcaster]

847. By Natalia Bidart on 2012-01-10

Avoid code duplication in main/test_common.py.

848. By Natalia Bidart on 2012-01-10

Fixed broken tests.

849. By Natalia Bidart on 2012-01-10

Merged trunk in.

850. By Natalia Bidart on 2012-01-10

- Make cmdline use it's classes' name instead of it's instance.

851. By Natalia Bidart on 2012-01-11

- Fixed copyright year.

[Manuel de la Peña (mandel)]

Looks great to me, things are cleaner an unified. Superb!

review: Approve

[Alejandro J. Cura (alecu)]

And the "Fowler lifetime achievement" goes to.... nessita!
Keep those huge refactorings coming, but let's hope we can do them in smaller branches :-)

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-11 13:22:26 +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	2011-12-30 18:57:23 +0000
+++ ubuntu_sso/credentials.py	2012-01-11 13:22:26 +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-11 13:22:26 +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-13 16:20:46 +0000
+++ ubuntu_sso/main/__init__.py	2012-01-11 13:22:26 +0000
@@ -13,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,
@@ -31,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__,
     }
@@ -54,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."""
@@ -99,22 +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:
-                error_dict = {
-                    'errtype': 'UserNotValidated',
-                    'message': email,
-                }
-                not_validated_cb(app_name, error_dict)
-        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-11-16 12:14:00 +0000
+++ ubuntu_sso/main/linux.py	2012-01-11 13:22:26 +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-11 13:22:26 +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-11 13:22:26 +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-12-12 13:50:12 +0000
+++ ubuntu_sso/main/tests/test_common.py	2012-01-11 13:22:26 +0000
@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# test_main - tests for ubuntu_sso.main
-#
-# 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
@@ -15,227 +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 twisted.trial.unittest import TestCase
-from twisted.internet.defer import inlineCallbacks
-
-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,
-    SSOLoginRoot,
+    thread_execute,
+    TIMEOUT_INTERVAL,
+    UbuntuSSOService,
 )
-
-
-class FakeCallbacks(object):
-
-    """Fake callbacks class."""
-
-    def __init__(self):
-        self.args = None
-
-    def result_cb(self, *args):
-        """Fake result callbacks function."""
-        self.args = args
-
-    def error_cb(self, *args):
-        """Fake error callbacks function."""
-        self.args = args
-
-
-class FakeProcessor(object):
-
-    """Fake Processor."""
-
-    def __init__(self, *args, **kwargs):
-        self.args = args
-        self.kwargs = kwargs
-        self.validated = True
-
-    def is_validated(self, credentials):
-        """Fake is validated function for Account Processor."""
-        return self.validated
-
-
-def execute_fake_success_callback(function, app_name, success_cb, error_cb):
-    """Fake execute callback function."""
-    success_cb(app_name, object())
-
-
-class SSOLoginRootTestCase(TestCase):
-
-    """Test for SSOLoginRoot."""
-
-    @inlineCallbacks
-    def setUp(self):
-        yield super(SSOLoginRootTestCase, self).setUp()
-        self.root = SSOLoginRoot(FakeProcessor)
-        self.patch(main, "thread_execute", execute_fake_success_callback)
-
-    def test_login_not_validated_email(self):
-        """Test Login function with an email not validated."""
-        fake_callback = FakeCallbacks()
-        self.patch(self.root.processor, "validated", False)
-        app_name = 'app_name'
-        email = '[e-mail]'
-        password = 'password'
-        self.root.login(app_name, email, password,
-            fake_callback.result_cb, fake_callback.error_cb,
-            fake_callback.error_cb)
-        self.assertEqual(fake_callback.args[0], 'app_name')
-        self.assertEqual(fake_callback.args[1]['errtype'],
-            'UserNotValidated')
-        self.assertEqual(fake_callback.args[1]['message'],
-            email)
-
-
-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."""
-
-    @inlineCallbacks
-    def setUp(self):
-        """Setup tests."""
-        yield 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-01 17:44:58 +0000
+++ ubuntu_sso/main/tests/test_linux.py	1970-01-01 00:00:00 +0000
@@ -1,1249 +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_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' (properties changed: +x to -x)
--- ubuntu_sso/main/tests/test_windows.py	2011-11-24 15:02:24 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2012-01-11 13:22:26 +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):