Merge lp:~nataliabidart/ubuntuone-client/auth into lp:ubuntuone-client

[Natalia Bidart]

D-Bus service to provide Ubuntu One specific login capabilities (LP: #697211).

A new D-Bus service was added to provide Ubuntu One specific login capabilities.

The API is identical to the SSO client D-Bus service, except that no params has to be passed since this layer abstracts the caller from all the specific details.

To test, run from this branch:

DEBUG=True PYTHONPATH=. ./bin/ubuntuone-login

and play with the methods using d-feet, accessing the com.ubuntuone.Credentials service in the Session bus, /credentials object path, com.ubuntuone.CredentialsManagement interface.

[lp:~nataliabidart/ubuntuone-client/auth]

780. By Natalia Bidart on 2011-01-04

Adding installation specific bits.

[dobey (dobey)]

The translation bits are wrong here. The correct way is already done in clientdefs.py.in. You should never set the textdomain on import of a module, like is done here. I would put most of the code in the credentials module into the script itself; as there is no reason for any other application to provide the service, or do most of what is being done in the credentials module.

The tests in ubuntuone-client are also under the toplevel tests/ directory. So your tests aren't being run by 'make test' here.

And if you intend for the SSO defines in clientdefs.py to be deprecated, I would suggest changing them to lambdas that emit a DeprecationWarning, and return the correctly imported values instead.

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

> The translation bits are wrong here. The correct way is already done in
> clientdefs.py.in. You should never set the textdomain on import of a module,
> like is done here. I would put most of the code in the credentials module into
> the script itself; as there is no reason for any other application to provide
> the service, or do most of what is being done in the credentials module.

Putting the code inside the ubuntuone-login script makes testing almost impossible, so I should decline on doing that.

The textdomain thing is now removed and the Q_ function from clientdefs was copied and used.

> The tests in ubuntuone-client are also under the toplevel tests/ directory. So
> your tests aren't being run by 'make test' here.

Tests moved to tests/.

> And if you intend for the SSO defines in clientdefs.py to be deprecated, I
> would suggest changing them to lambdas that emit a DeprecationWarning, and
> return the correctly imported values instead.

I thought about this, but adding a lambda will make the constants be a function call, not a constant. So what I did was adding a module deprecation warning stating that "Constants APP_NAME, TC_URL, PING_URL and DESCRIPTION are deprecated."

Thanks for noticing this!

[lp:~nataliabidart/ubuntuone-client/auth]

781. By Natalia Bidart on 2011-01-04

Credentials tests moved to tests/ folder.

782. By Natalia Bidart on 2011-01-04

Fixing review comments.

[Guillermo Gonzalez (verterok)]

looks good.

review: Approve

[lp:~nataliabidart/ubuntuone-client/auth]

783. By Natalia Bidart on 2011-01-05

Auth constants are imported from ubuntuone.credentials.

Deprecation warning was removed to avoid having that when importing other
useful values.

784. By Natalia Bidart on 2011-01-05

Reverting changed to clientdefs to avoid circular import deps.

[dobey (dobey)]

I still strongly believe that the logging pieces and the CredentialsManagement class should be in the script itself, and only the constants themselves really need to be in the ubuntuone.credentials package. :-/

review: Approve

=== modified file 'Makefile.am'
--- Makefile.am	2010-12-09 18:46:50 +0000
+++ Makefile.am	2011-01-05 15:54:10 +0000
@@ -9,6 +9,7 @@
 # Python packages we want to install
 pypackages =				\
 	ubuntuone/api			\
+	ubuntuone/credentials		\
 	ubuntuone/eventlog		\
 	ubuntuone/platform		\
 	ubuntuone/platform/linux	\
@@ -26,7 +27,8 @@
 	bin/u1sync
 
 libexec_SCRIPTS = 			\
-	bin/ubuntuone-syncdaemon
+	bin/ubuntuone-syncdaemon	\
+	bin/ubuntuone-login
 
 clientdefsdir = $(pythondir)/ubuntuone
 clientdefs_in_files = ubuntuone/clientdefs.py.in

=== added file 'bin/ubuntuone-login'
--- bin/ubuntuone-login	1970-01-01 00:00:00 +0000
+++ bin/ubuntuone-login	2011-01-05 15:54:10 +0000
@@ -0,0 +1,51 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 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/>.
+
+"""The script tu ron the Ubuntu One Login D-Bus service."""
+
+# Invalid name "ubuntuone-login"
+# pylint: disable=C0103
+
+import sys
+
+import dbus.mainloop.glib
+import dbus.service
+import glib
+
+from ubuntuone.credentials import (DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
+    CredentialsManagement, logger)
+
+dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+
+if __name__ == "__main__":
+    # Register DBus service for making sure we run only one instance
+    bus = dbus.SessionBus()
+    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 One login manager already running, quitting.")
+        sys.exit(0)
+
+    logger.info("Starting Ubuntu One login manager for bus %r.", DBUS_BUS_NAME)
+    bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
+    CredentialsManagement(bus_name, object_path=DBUS_CREDENTIALS_PATH)
+
+    mainloop = glib.MainLoop()
+    mainloop.run()

=== modified file 'data/Makefile.am'
--- data/Makefile.am	2010-06-16 21:55:54 +0000
+++ data/Makefile.am	2011-01-05 15:54:10 +0000
@@ -42,7 +42,8 @@
 
 servicedir = $(DBUS_SERVICES_DIR)
 service_in_files = \
-	com.ubuntuone.SyncDaemon.service.in
+	com.ubuntuone.SyncDaemon.service.in	\
+	com.ubuntuone.Credentials.service.in
 service_DATA = $(service_in_files:.service.in=.service)
 
 %.service: %.service.in

=== added file 'data/com.ubuntuone.Credentials.service.in'
--- data/com.ubuntuone.Credentials.service.in	1970-01-01 00:00:00 +0000
+++ data/com.ubuntuone.Credentials.service.in	2011-01-05 15:54:10 +0000
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=com.ubuntuone.Credentials
+Exec=@libexecdir@/ubuntuone-login
+

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2010-10-06 07:42:51 +0000
+++ po/POTFILES.in	2011-01-05 15:54:10 +0000
@@ -1,5 +1,6 @@
 bin/ubuntuone-preferences
 ubuntuone/clientdefs.py.in
+ubuntuone/credentials/__init__.py
 data/emblem-ubuntuone-downloading.icon.in
 data/emblem-ubuntuone-unsynchronized.icon.in
 data/emblem-ubuntuone-uploading.icon.in

=== added directory 'tests/credentials'
=== added file 'tests/credentials/__init__.py'
--- tests/credentials/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/credentials/__init__.py	2011-01-05 15:54:10 +0000
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 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 Ubuntu One credentials management dbus service."""

=== added file 'tests/credentials/test_credentials.py'
--- tests/credentials/test_credentials.py	1970-01-01 00:00:00 +0000
+++ tests/credentials/test_credentials.py	2011-01-05 15:54:10 +0000
@@ -0,0 +1,580 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 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 Ubuntu One credentials management dbus service."""
+
+from functools import wraps
+
+from twisted.internet.defer import Deferred, inlineCallbacks
+from ubuntuone.devtools.testcase import DBusTestCase as TestCase
+from ubuntuone.devtools.handlers import MementoHandler
+
+from ubuntuone.credentials import (dbus, logger, logging, ubuntu_sso,
+    CredentialsManagement,
+    DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH, DBUS_CREDENTIALS_IFACE,
+    APP_NAME, HELP_TEXT_KEY, DESCRIPTION, TC_URL_KEY, TC_URL,
+    PING_URL_KEY, PING_URL, WINDOW_ID_KEY,
+)
+
+FAKED_CREDENTIALS = {
+    'consumer_key': 'faked_consumer_key',
+    'consumer_secret': 'faked_consumer_secret',
+    'token': 'faked_token',
+    'token_secret': 'faked_token_secret',
+    'token_name': 'Woohoo test',
+}
+
+
+class FakedSSOService(dbus.service.Object):
+    """Faked DBus object that manages credentials."""
+
+    error_dict = None
+    app_name = None
+
+    def __init__(self, *args, **kwargs):
+        super(FakedSSOService, self).__init__(*args, **kwargs)
+        self._credentials = {}
+        self._args = None
+        self._kwargs = None
+
+    def maybe_emit_error(f):
+        """Decorator to fake a CredentialsError signal."""
+
+        @wraps(f)
+        def inner(self, *args, **kwargs):
+            """Fake a CredentialsError signal."""
+            if FakedSSOService.error_dict is not None:
+                self.CredentialsError(FakedSSOService.app_name,
+                                      FakedSSOService.error_dict)
+            else:
+                return f(self, *args, **kwargs)
+
+        return inner
+
+    def store_args(f):
+        """Decorator to store arguments to check correct calls."""
+
+        @wraps(f)
+        def inner(self, app_name, args):
+            """Store arguments to check correct calls."""
+            self._app_name = app_name
+            self._args = args
+            return f(self, app_name, args)
+
+        return inner
+
+    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
+    def AuthorizationDenied(self, app_name):
+        """Signal thrown when the user denies the authorization."""
+
+    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsFound(self, app_name, credentials):
+        """Signal thrown when the credentials are found."""
+
+    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsNotFound(self, app_name):
+        """Signal thrown when the credentials are not found."""
+
+    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsCleared(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+
+    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsStored(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+
+    @dbus.service.signal(ubuntu_sso.DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsError(self, app_name, error_dict):
+        """Signal thrown when there is a problem getting the credentials."""
+
+    @store_args
+    @maybe_emit_error
+    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def find_credentials(self, app_name, args):
+        """Look for the credentials for an application."""
+        creds = self._credentials.get(FakedSSOService.app_name, None)
+        if creds is not None:
+            self.CredentialsFound(FakedSSOService.app_name, creds)
+        else:
+            self.CredentialsNotFound(FakedSSOService.app_name)
+
+    @store_args
+    @maybe_emit_error
+    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def clear_credentials(self, app_name, args):
+        """Clear the credentials for an application."""
+        self._credentials.pop(FakedSSOService.app_name, None)
+        self.CredentialsCleared(FakedSSOService.app_name)
+
+    @store_args
+    @maybe_emit_error
+    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def store_credentials(self, app_name, args):
+        """Store the token for an application."""
+        self._credentials[FakedSSOService.app_name] = args
+        self.CredentialsStored(FakedSSOService.app_name)
+
+    @store_args
+    @maybe_emit_error
+    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def register(self, app_name, args):
+        """Get credentials if found else prompt GUI to register."""
+        creds = self._credentials.get(FakedSSOService.app_name, None)
+        if creds is not None and len(creds) > 0:
+            self.CredentialsFound(FakedSSOService.app_name, creds)
+        elif creds == {}:
+            # fake an AuthorizationDenied
+            self.AuthorizationDenied(FakedSSOService.app_name)
+        elif creds is None:
+            # fake the adding of the credentials, in reality this will bring
+            # a GUI that the user will interact with.
+            self._credentials[FakedSSOService.app_name] = FAKED_CREDENTIALS
+            self.CredentialsFound(FakedSSOService.app_name, FAKED_CREDENTIALS)
+
+    @store_args
+    @maybe_emit_error
+    @dbus.service.method(dbus_interface=ubuntu_sso.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.register(app_name, args)
+
+
+class CredentialsManagementTestCase(TestCase):
+    """Test case for the DBus object that manages Ubuntu One credentials."""
+
+    timeout = 2
+    app_name = APP_NAME
+    error_dict = None
+    signals = ('CredentialsFound', 'CredentialsNotFound', 'CredentialsCleared',
+               'CredentialsStored', 'CredentialsError', 'AuthorizationDenied')
+
+    def setUp(self):
+        super(CredentialsManagementTestCase, self).setUp()
+        FakedSSOService.app_name = self.app_name
+        FakedSSOService.error_dict = self.error_dict
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        logger.addHandler(self.memento)
+
+        self.bus = dbus.SessionBus()
+        self.sso_server = self.register_server(ubuntu_sso.DBUS_BUS_NAME,
+                                ubuntu_sso.DBUS_CREDENTIALS_PATH,
+                                FakedSSOService)  # faked SSO server
+        self.creds_server = self.register_server(DBUS_BUS_NAME,
+                                DBUS_CREDENTIALS_PATH,
+                                CredentialsManagement)  # real service
+
+        self.deferred = Deferred()
+        self.proxy = self.get_creds_proxy()
+
+    def register_server(self, bus_name, object_path, service_class):
+        """Register a service on the session bus."""
+        name = self.bus.request_name(bus_name, dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
+        self.assertNotEqual(name, dbus.bus.REQUEST_NAME_REPLY_EXISTS,
+                            'Service %s should not be running.' % bus_name)
+        mock = service_class(object_path=object_path, conn=self.bus)
+        self.addCleanup(mock.remove_from_connection)
+
+        return mock
+
+    def get_proxy(self, bus_name, object_path, dbus_interface):
+        obj = self.bus.get_object(bus_name=bus_name, object_path=object_path,
+                                  follow_name_owner_changes=True)
+        proxy = dbus.Interface(object=obj, dbus_interface=dbus_interface)
+        return proxy
+
+    def get_sso_proxy(self):
+        return self.get_proxy(bus_name=ubuntu_sso.DBUS_BUS_NAME,
+                              object_path=ubuntu_sso.DBUS_CREDENTIALS_PATH,
+                              dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+
+    def get_creds_proxy(self):
+        return self.get_proxy(bus_name=DBUS_BUS_NAME,
+                              object_path=DBUS_CREDENTIALS_PATH,
+                              dbus_interface=DBUS_CREDENTIALS_IFACE)
+
+    def connect_signals(self, callback=None):
+        """Connect every signal accordingly to fire self.deferred.
+
+        If 'callback' is not None, it will be used as a tuple (sig_name,
+        function) and 'sig_name' will be connected to 'function', which should
+        fire self.deferred properly.
+
+        """
+        success_sig_name, success_function = None, None
+        if callback is not None:
+            success_sig_name, success_function = callback
+
+        def fail(sig_name):
+            """Decorator to fire self.deferred."""
+            def inner(*args, **kwargs):
+                """Fire self.deferred."""
+                msg = 'Received an unexpected signal (%r).' % sig_name
+                self.deferred.errback(TypeError(msg))
+            return inner
+
+        for sig_name in self.signals:
+            if sig_name == success_sig_name:
+                sig = self.proxy.connect_to_signal(sig_name, success_function)
+            else:
+                sig = self.proxy.connect_to_signal(sig_name, fail(sig_name))
+            self.addCleanup(sig.remove)
+
+    @inlineCallbacks
+    def add_credentials(self, creds=FAKED_CREDENTIALS):
+        """Add some fake credentials for 'self.app_name'."""
+        d = Deferred()
+        sso_proxy = self.get_sso_proxy()
+        sso_proxy.store_credentials(self.app_name, creds,
+                                    reply_handler=lambda: d.callback(None),
+                                    error_handler=d.errback)
+        yield d
+
+    @inlineCallbacks
+    def do_test(self):
+        """Perform the test itself."""
+        yield self.deferred
+
+    def test_get_sso_proxy(self):
+        """The SSO dbus proxy is properly retrieved."""
+        sso_proxy = CredentialsManagement().sso_proxy
+        self.assertEqual(sso_proxy.bus_name, ubuntu_sso.DBUS_BUS_NAME)
+        self.assertEqual(sso_proxy.object_path,
+                         ubuntu_sso.DBUS_CREDENTIALS_PATH)
+        self.assertEqual(sso_proxy.dbus_interface,
+                         ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+
+    @inlineCallbacks
+    def test_shutdown(self):
+        """On shutdown, SSO backend signals are disconnected."""
+        d = Deferred()
+
+        self.proxy.shutdown(reply_handler=lambda: d.callback(None),
+                            error_handler=d.errback)
+        yield d
+
+        # TODO: assert over params passed to remove_signal_receiver
+
+
+class ArgsTestCase(CredentialsManagementTestCase):
+    """Test case to check that proper arguments are passed to SSO backend."""
+
+    @inlineCallbacks
+    def test_find_credentials(self):
+        """The find_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+        self.proxy.find_credentials(reply_handler=lambda: d.callback(None),
+                                    error_handler=d.errback)
+        yield d
+
+        self.assertEqual(self.sso_server._app_name, APP_NAME)
+        self.assertEqual(self.sso_server._args, {})
+
+    @inlineCallbacks
+    def test_clear_credentials(self):
+        """The clear_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+        self.proxy.clear_credentials(reply_handler=lambda: d.callback(None),
+                                     error_handler=d.errback)
+        yield d
+
+        self.assertEqual(self.sso_server._app_name, APP_NAME)
+        self.assertEqual(self.sso_server._args, {})
+
+    @inlineCallbacks
+    def test_store_credentials(self):
+        """The store_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+        self.proxy.store_credentials(FAKED_CREDENTIALS,
+                                     reply_handler=lambda: d.callback(None),
+                                     error_handler=d.errback)
+        yield d
+
+        self.assertEqual(self.sso_server._app_name, APP_NAME)
+        self.assertEqual(self.sso_server._args, FAKED_CREDENTIALS)
+
+    @inlineCallbacks
+    def test_register(self):
+        """The register method calls ubuntu_sso's method."""
+        d = Deferred()
+        self.proxy.register(reply_handler=lambda: d.callback(None),
+                            error_handler=d.errback)
+        yield d
+
+        self.assertEqual(self.sso_server._app_name, APP_NAME)
+        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
+                  PING_URL_KEY: PING_URL, WINDOW_ID_KEY: '0'}
+        self.assertEqual(self.sso_server._args, params)
+
+    @inlineCallbacks
+    def test_login(self):
+        """The login method calls ubuntu_sso's method."""
+        d = Deferred()
+        self.proxy.login(reply_handler=lambda: d.callback(None),
+                         error_handler=d.errback)
+        yield d
+
+        self.assertEqual(self.sso_server._app_name, APP_NAME)
+        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
+                  PING_URL_KEY: PING_URL, WINDOW_ID_KEY: '0'}
+        self.assertEqual(self.sso_server._args, params)
+
+
+class SameAppNoErrorTestCase(CredentialsManagementTestCase):
+    """Test case when the app_name matches APP_NAME and there was no error."""
+
+    @inlineCallbacks
+    def test_find_credentials(self):
+        """The find_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+        yield self.add_credentials()
+
+        def verify(credentials):
+            """Do the check."""
+            self.assertEqual(credentials, FAKED_CREDENTIALS)
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsFound', verify))
+
+        self.proxy.find_credentials(reply_handler=lambda: d.callback(None),
+                                    error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_find_credentials_without_credentials(self):
+        """The find_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+
+        def verify():
+            """Do the check."""
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsNotFound', verify))
+
+        self.proxy.find_credentials(reply_handler=lambda: d.callback(None),
+                                    error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_clear_credentials(self):
+        """The clear_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+        yield self.add_credentials()
+
+        def verify():
+            """Do the check."""
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsCleared', verify))
+
+        self.proxy.clear_credentials(reply_handler=lambda: d.callback(None),
+                                     error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_clear_credentials_without_credentials(self):
+        """The clear_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+
+        def verify():
+            """Do the check."""
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsCleared', verify))
+
+        self.proxy.clear_credentials(reply_handler=lambda: d.callback(None),
+                                     error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_store_credentials(self):
+        """The store_credentials method calls ubuntu_sso's method."""
+        d = Deferred()
+
+        def verify():
+            """Do the check."""
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsStored', verify))
+
+        self.proxy.store_credentials(FAKED_CREDENTIALS,
+                                     reply_handler=lambda: d.callback(None),
+                                     error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_register_with_credentials(self):
+        """The register method calls ubuntu_sso's method."""
+        d = Deferred()
+        yield self.add_credentials()
+
+        def verify(credentials):
+            """Do the check."""
+            self.assertEqual(credentials, FAKED_CREDENTIALS)
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsFound', verify))
+
+        self.proxy.register(reply_handler=lambda: d.callback(None),
+                            error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_register_without_credentials(self):
+        """The register method calls ubuntu_sso's method."""
+        d = Deferred()
+
+        def verify(credentials):
+            """Do the check."""
+            self.assertEqual(credentials, FAKED_CREDENTIALS)
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsFound', verify))
+
+        self.proxy.register(reply_handler=lambda: d.callback(None),
+                            error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_register_authorization_denied(self):
+        """The register method calls ubuntu_sso's method."""
+        d = Deferred()
+        yield self.add_credentials(creds={})
+
+        def verify():
+            """Do the check."""
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('AuthorizationDenied', verify))
+
+        self.proxy.register(reply_handler=lambda: d.callback(None),
+                            error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_login_with_credentials(self):
+        """The login method calls ubuntu_sso's method."""
+        d = Deferred()
+        yield self.add_credentials()
+
+        def verify(credentials):
+            """Do the check."""
+            self.assertEqual(credentials, FAKED_CREDENTIALS)
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsFound', verify))
+
+        self.proxy.login(reply_handler=lambda: d.callback(None),
+                         error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_login_without_credentials(self):
+        """The login method calls ubuntu_sso's method."""
+        d = Deferred()
+
+        def verify(credentials):
+            """Do the check."""
+            self.assertEqual(credentials, FAKED_CREDENTIALS)
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('CredentialsFound', verify))
+
+        self.proxy.login(reply_handler=lambda: d.callback(None),
+                         error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+    @inlineCallbacks
+    def test_login_authorization_denied(self):
+        """The login method calls ubuntu_sso's method."""
+        d = Deferred()
+        yield self.add_credentials(creds={})
+
+        def verify():
+            """Do the check."""
+            self.deferred.callback(None)
+
+        self.connect_signals(callback=('AuthorizationDenied', verify))
+
+        self.proxy.login(reply_handler=lambda: d.callback(None),
+                         error_handler=d.errback)
+        yield d
+        yield self.do_test()
+
+
+class SameAppWithErrorTestCase(SameAppNoErrorTestCase):
+    """Test case when the app_name matches APP_NAME and there was an error."""
+
+    error_dict = {'error_type': 'Test'}
+
+    def connect_signals(self, callback=None):
+        """CredentialsError is the success signals in this suite."""
+
+        def verify(error_dict):
+            """Do the check."""
+            self.assertEqual(error_dict, self.error_dict)
+            self.deferred.callback(error_dict)
+
+        args = ('CredentialsError', verify)
+        super(SameAppWithErrorTestCase, self).connect_signals(callback=args)
+
+
+class OtherAppNoErrorTestCase(SameAppNoErrorTestCase):
+    """Test case when the app_name is not APP_NAME and there was no error."""
+
+    app_name = APP_NAME * 2
+
+    def connect_signals(self, callback=None):
+        """No signal should be received in this suite."""
+        # ignore all success connection, self.deferred should always errback
+        super(OtherAppNoErrorTestCase, self).connect_signals(callback=None)
+
+    @inlineCallbacks
+    def do_test(self):
+        """Perform the test itself."""
+        if not self.deferred.called:
+            msg = 'does not match %r, exiting.' % APP_NAME
+            if self.memento.check_info(self.app_name, msg):
+                self.deferred.callback(None)
+            else:
+                self.deferred.errback('Log should be present.')
+
+        yield self.deferred
+
+
+class OtherAppWithErrorTestCase(OtherAppNoErrorTestCase):
+    """Test case when the app_name is not APP_NAME and there was an error."""
+
+    app_name = APP_NAME * 2
+    error_dict = {'error_type': 'Test'}

=== modified file 'ubuntuone/clientdefs.py.in'
--- ubuntuone/clientdefs.py.in	2010-12-07 18:01:03 +0000
+++ ubuntuone/clientdefs.py.in	2011-01-05 15:54:10 +0000
@@ -32,6 +32,7 @@
 LIBEXECDIR = "@libexecdir@"
 GETTEXT_PACKAGE = "@GETTEXT_PACKAGE@"
 
+# these variables are Deprecated, use those defined in ubuntuone.credentials
 APP_NAME = "@SSO_APP_NAME@"
 TC_URL = "@SSO_TC_URL@"
 PING_URL = "@SSO_PING_URL@"

=== added directory 'ubuntuone/credentials'
=== added file 'ubuntuone/credentials/__init__.py'
--- ubuntuone/credentials/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/credentials/__init__.py	2011-01-05 15:54:10 +0000
@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+#
+# Author: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 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/>.
+
+"""Ubuntu One credentials management dbus service."""
+
+import os
+import sys
+
+import dbus.service
+import gettext
+import ubuntu_sso
+
+from ubuntu_sso.credentials import (HELP_TEXT_KEY, PING_URL_KEY, TC_URL_KEY,
+    WINDOW_ID_KEY)
+
+from ubuntuone.logger import (basic_formatter, logging,
+    CustomRotatingFileHandler, LOGFOLDER)
+from ubuntuone.clientdefs import GETTEXT_PACKAGE
+
+
+Q_ = lambda string: gettext.dgettext(GETTEXT_PACKAGE, string)
+NO_OP = lambda *args, **kwargs: None
+
+LOG_LEVEL = logging.DEBUG
+path = os.path.join(LOGFOLDER, 'credentials.log')
+MAIN_HANDLER = CustomRotatingFileHandler(path)
+MAIN_HANDLER.setFormatter(basic_formatter)
+MAIN_HANDLER.setLevel(LOG_LEVEL)
+
+logger = logging.getLogger("ubuntuone.credentials")
+logger.setLevel(LOG_LEVEL)
+logger.addHandler(MAIN_HANDLER)
+
+if os.environ.get('DEBUG'):
+    debug_handler = logging.StreamHandler(sys.stderr)
+    debug_handler.setFormatter(basic_formatter)
+    debug_handler.setLevel(LOG_LEVEL)
+    logger.addHandler(debug_handler)
+
+# constants
+DBUS_BUS_NAME = "com.ubuntuone.Credentials"
+DBUS_CREDENTIALS_PATH = "/credentials"
+DBUS_CREDENTIALS_IFACE = "com.ubuntuone.CredentialsManagement"
+
+APP_NAME = "Ubuntu One"
+TC_URL = "https://one.ubuntu.com/terms/"
+PING_URL = "https://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
+DESCRIPTION = Q_('Ubuntu One requires an Ubuntu Single Sign On (SSO) account. '
+                 'This process will allow you to create a new account, '
+                 'if you do not yet have one.')
+
+
+class CredentialsManagement(dbus.service.Object):
+    """DBus object that manages Ubuntu One credentials."""
+
+    def __init__(self, *args, **kwargs):
+        super(CredentialsManagement, self).__init__(*args, **kwargs)
+        self.sso_match = None
+        self.sso_proxy = self._get_sso_proxy()
+
+    def _signal_handler(self, *args, **kwargs):
+        """Generic signal handler."""
+        member = kwargs.get('member', None)
+        app_name = args[0] if len(args) > 0 else None
+        logger.debug('Handling DBus signal for member: %r, app_name: %r.',
+                     member, app_name)
+
+        if app_name != APP_NAME:
+            logger.info('Received %r but app_name %r does not match %r, ' \
+                        'exiting.', member, app_name, APP_NAME)
+            return
+
+        sig = getattr(self, member)
+
+        if member in ('CredentialsFound', 'CredentialsError'):
+            # this are the only signals that will forward the parameter
+            logger.info('%r', member)
+            arg = args[1]
+            sig(arg)
+        else:
+            sig()
+
+    def _get_sso_proxy(self):
+        """Get the SSO dbus proxy."""
+        bus = dbus.SessionBus()
+        # register signal handlers for each kind of error
+        self.sso_match = bus.add_signal_receiver(self._signal_handler,
+                            member_keyword='member',
+                            dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+        try:
+            obj = bus.get_object(ubuntu_sso.DBUS_BUS_NAME,
+                                 ubuntu_sso.DBUS_CREDENTIALS_PATH,
+                                 follow_name_owner_changes=True)
+            proxy = dbus.Interface(obj, ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+        except:
+            logger.exception('get_sso_proxy:')
+            raise
+
+        return proxy
+
+    # Operator not preceded by a space (fails with dbus decorators)
+    # pylint: disable=C0322
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
+    def AuthorizationDenied(self):
+        """Signal thrown when the user denies the authorization."""
+        logger.info('%s: emitting AuthorizationDenied.',
+                    self.__class__.__name__)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='a{ss}')
+    def CredentialsFound(self, credentials):
+        """Signal thrown when the credentials are found."""
+        logger.info('%s: emitting CredentialsFound.',
+                    self.__class__.__name__)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
+    def CredentialsNotFound(self):
+        """Signal thrown when the credentials are not found."""
+        logger.info('%s: emitting CredentialsNotFound.',
+                    self.__class__.__name__)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
+    def CredentialsCleared(self):
+        """Signal thrown when the credentials were cleared."""
+        logger.info('%s: emitting CredentialsCleared.',
+                    self.__class__.__name__)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE)
+    def CredentialsStored(self):
+        """Signal thrown when the credentials were cleared."""
+        logger.info('%s: emitting CredentialsStored.',
+                    self.__class__.__name__)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='a{ss}')
+    def CredentialsError(self, error_dict):
+        """Signal thrown when there is a problem getting the credentials."""
+        logger.error('%s: emitting CredentialsError with error_dict %r.',
+                     self.__class__.__name__, error_dict)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         async_callbacks=("reply_handler", "error_handler"))
+    def find_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Ask the Ubuntu One credentials."""
+        self.sso_proxy.find_credentials(APP_NAME, {},
+            reply_handler=reply_handler, error_handler=error_handler)
+
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         async_callbacks=("reply_handler", "error_handler"))
+    def clear_credentials(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Clear the Ubuntu One credentials."""
+        self.sso_proxy.clear_credentials(APP_NAME, {},
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='a{ss}',
+                         async_callbacks=("reply_handler", "error_handler"))
+    def store_credentials(self, credentials,
+                          reply_handler=NO_OP, error_handler=NO_OP):
+        """Store the token for Ubuntu One application."""
+        self.sso_proxy.store_credentials(APP_NAME, credentials,
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         async_callbacks=("reply_handler", "error_handler"))
+    def register(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Get credentials if found else prompt to register to Ubuntu One."""
+        params = {HELP_TEXT_KEY: DESCRIPTION, TC_URL_KEY: TC_URL,
+                  PING_URL_KEY: PING_URL, WINDOW_ID_KEY: '0'}
+        self.sso_proxy.register(APP_NAME, params,
+            reply_handler=reply_handler, error_handler=error_handler)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         async_callbacks=("reply_handler", "error_handler"))
+    def login(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Get credentials if found else prompt to login to Ubuntu One."""
+        self.register(reply_handler, error_handler)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         async_callbacks=("reply_handler", "error_handler"))
+    def shutdown(self, reply_handler=NO_OP, error_handler=NO_OP):
+        """Disconnect signals from SSO backend."""
+        bus = dbus.SessionBus()
+        try:
+            bus.remove_signal_receiver(self.sso_match, member_keyword='member',
+                dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+        except Exception, e:
+            error_handler(e)
+        else:
+            reply_handler()