Merge lp:~nataliabidart/ubuntuone-control-panel/new-creds into lp:ubuntuone-control-panel

[Natalia Bidart]

- Using CredentialsManagementTool instead of SSO dbus backend (LP: #828805).

[Roberto Alsina (ralsina)]

+1

review: Approve

[John Lenton (chipaca)]

Good.

What does GTK_MODULES break?

review: Approve

=== modified file 'run-tests'
--- run-tests	2011-07-15 17:50:50 +0000
+++ run-tests	2011-08-18 17:23:16 +0000
@@ -37,14 +37,16 @@
 fi
 
 style_check() {
-    u1lint --ignore ubuntuone/controlpanel/gui/qt/ui ubuntuone/
+    u1lint --ignore ubuntuone/controlpanel/gui/qt/ui
     if [ -x `which pep8` ]; then
-        pep8 --exclude '.svn,CVS,.bzr,.hg,.git,*_ui.py,*_rc.py' --repeat bin/ $MODULE
+        pep8 --exclude '.svn,CVS,.bzr,.hg,.git,*_ui.py,*_rc.py' --repeat .
     else
         echo "Please install the 'pep8' package."
     fi
 }
 
+unset GTK_MODULES
+
 ./setup.py build
 echo "Running test suite for ""$MODULE"
 if [ "$USE_QT" -eq 0 ]; then
 
=== modified file 'setup.py'
--- setup.py	2011-08-12 19:09:02 +0000
+++ setup.py	2011-08-18 17:23:16 +0000
@@ -46,6 +46,7 @@
 CLEANFILES = [
     SERVICE_FILE, GUI_SERVICE_FILE, MESSAGE_ENTRY, CONSTANTS, POT_FILE,
     'MANIFEST']
+QT_UI_DIR = os.path.join('ubuntuone', 'controlpanel', 'gui', 'qt', 'ui')
 
 
 def replace_prefix(prefix):
@@ -64,7 +65,7 @@
     def run(self):
         """Do the install.
 
-        Read from *.service.in and generate .service files with reeplacing
+        Read from *.service.in and generate .service files by replacing
         @prefix@ by self.prefix.
 
         """
@@ -75,7 +76,6 @@
 class ControlPanelBuild(build_extra.build_extra):
     """Build PyQt (.ui) files and resources."""
 
-    QT_UI_DIR = os.path.join('ubuntuone', 'controlpanel', 'gui', 'qt', 'ui')
     description = "build PyQt GUIs (.ui) and resources (.qrc)"
 
     def compile_ui(self, ui_file, py_file=None):
@@ -86,7 +86,7 @@
             # python file in the qt moodule
             py_file = os.path.split(ui_file)[1]
             py_file = os.path.splitext(py_file)[0] + '_ui.py'
-            py_file = os.path.join(self.QT_UI_DIR, py_file)
+            py_file = os.path.join(QT_UI_DIR, py_file)
         # we indeed want to catch Exception, is ugly but we need it
         # pylint: disable=W0703
         try:
@@ -112,7 +112,7 @@
         if py_file is None:
             py_file = os.path.split(qrc_file)[1]
             py_file = os.path.splitext(py_file)[0] + '_rc.py'
-            py_file = os.path.join(self.QT_UI_DIR, py_file)
+            py_file = os.path.join(QT_UI_DIR, py_file)
         path = os.getenv('PATH')
         os.putenv('PATH', path + os.path.pathsep + os.path.join(
                   os.path.dirname(PyQt4.__file__), 'bin'))
@@ -218,6 +218,12 @@
             if os.path.exists(built_file):
                 os.unlink(built_file)
 
+        for dirpath, _, filenames in os.walk(os.path.join(QT_UI_DIR)):
+            for current_file in filenames:
+                if current_file.endswith('_ui.py') or\
+                                current_file.endswith('_rc.py'):
+                    os.unlink(os.path.join(dirpath, current_file))
+
         DistUtilsExtra.auto.clean_build_tree.run(self)
 
 
@@ -228,8 +234,8 @@
     author='Natalia Bidart',
     author_email='[e-mail]',
     description='Ubuntu One Control Panel',
-    long_description='Application to manage a Ubuntu One account. Provides a'\
-                     'DBus service to query/modify all the Ubuntu One bits.',
+    long_description='Application to manage a Ubuntu One account. Provides' \
+        ' a DBus service to query/modify all the Ubuntu One bits.',
     url='https://launchpad.net/ubuntuone-control-panel',
     packages=[
         'ubuntuone', 'ubuntuone.controlpanel', 'ubuntuone.controlpanel.gui',
 
=== modified file 'ubuntuone/controlpanel/gui/gtk/gui.py'
--- ubuntuone/controlpanel/gui/gtk/gui.py	2011-06-01 18:10:22 +0000
+++ ubuntuone/controlpanel/gui/gtk/gui.py	2011-08-18 17:23:16 +0000
@@ -28,17 +28,15 @@
 import dbus
 import gtk
 import gobject
-import ubuntu_sso
 
 from dbus.mainloop.glib import DBusGMainLoop
 from ubuntu_sso import networkstate
-from ubuntu_sso.credentials import (TC_URL_KEY, HELP_TEXT_KEY, WINDOW_ID_KEY,
-    PING_URL_KEY)
-# No name 'clientdefs' in module 'ubuntuone'
 # pylint: disable=E0611,F0401
 from gi.repository import GLib
-from ubuntuone.clientdefs import (APP_NAME as U1_APP_NAME, TC_URL as U1_TC_URL,
-    PING_URL as U1_PING_URL, DESCRIPTION as U1_DESCRIPTION)
+from ubuntuone.platform.credentials import (
+    APP_NAME as U1_APP_NAME,
+    CredentialsManagementTool,
+)
 # pylint: enable=E0611,F0401
 
 # Wildcard import ubuntuone.controlpanel.gui
@@ -123,21 +121,6 @@
     gtk.main()
 
 
-def filter_by_app_name(f):
-    """Excecute 'f' filtering by app_name."""
-
-    @wraps(f)
-    def filter_by_app_name_inner(instance, app_name, *args, **kwargs):
-        """Execute 'f' only if 'app_name' matches 'U1_APP_NAME'."""
-        if app_name == U1_APP_NAME:
-            return f(instance, app_name, *args, **kwargs)
-        else:
-            logger.info('%s: ignoring call since received app_name '\
-                        '"%s" (expected "%s")',
-                        f.__name__, app_name, U1_APP_NAME)
-    return filter_by_app_name_inner
-
-
 def on_size_allocate(widget, allocation, label):
     """Resize labels according to who 'widget' is being resized."""
     label.set_size_request(allocation.width - 2, -1)
@@ -272,23 +255,9 @@
 
     def __init__(self, main_window):
         GreyableBin.__init__(self)
-
-        sso_backend = None
-        bus = dbus.SessionBus()
-        try:
-            obj = bus.get_object(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CREDENTIALS_PATH,
-                                 follow_name_owner_changes=True)
-            iface = ubuntu_sso.DBUS_CREDENTIALS_IFACE
-            sso_backend = dbus.Interface(obj, dbus_interface=iface)
-        except dbus.exceptions.DBusException:
-            logger.exception('Can not connect to DBus at %r',
-                             (ubuntu_sso.DBUS_BUS_NAME,
-                              ubuntu_sso.DBUS_CREDENTIALS_PATH))
-            raise
-
+        creds_backend = CredentialsManagementTool()
         ControlPanelMixin.__init__(self, filename='overview.ui',
-                                   backend_instance=sso_backend)
+                                   backend_instance=creds_backend)
         self.add(self.itself)
         self.banner.set_from_file(get_data_file(OVERVIEW_BANNER))
         self.files_icon.set_from_file(get_data_file(FILES_ICON))
@@ -305,15 +274,6 @@
         self._credentials_are_new = False
         self.show()
 
-        self.backend.connect_to_signal('CredentialsFound',
-                                       self.on_credentials_found)
-        self.backend.connect_to_signal('CredentialsNotFound',
-                                       self.on_credentials_not_found)
-        self.backend.connect_to_signal('CredentialsError',
-                                       self.on_credentials_error)
-        self.backend.connect_to_signal('AuthorizationDenied',
-                                       self.on_authorization_denied)
-
         kw = dict(result_cb=self.on_network_state_changed)
         self.network_manager_state = networkstate.NetworkManagerState(**kw)
         self.network_manager_state.find_online_state()
@@ -323,6 +283,14 @@
         ControlPanelMixin._set_warning(self, message,
                                        label=self.warning_label)
 
+    def _window_xid(self):
+        """Return settings for credentials backend."""
+        if self.main_window.window is not None:
+            settings = {'window_id': str(self.main_window.window.xid)}
+        else:
+            settings = {}
+        return settings
+
     def set_property(self, prop_name, new_value):
         """Override 'set_property' to disable buttons if prop is 'greyed'."""
         if prop_name == 'greyed':
@@ -342,21 +310,17 @@
 
     def on_join_now_button_clicked(self, *a, **kw):
         """User wants to join now."""
-        settings = {TC_URL_KEY: U1_TC_URL, HELP_TEXT_KEY: U1_DESCRIPTION,
-                    WINDOW_ID_KEY: str(self.main_window.window.xid),
-                    PING_URL_KEY: U1_PING_URL}
-        self.backend.register(U1_APP_NAME, settings,
-            reply_handler=NO_OP, error_handler=error_handler)
+        d = self.backend.register(**self._window_xid())
+        d.addCallback(self.on_credentials_result)
+        d.addErrback(self.on_credentials_error)
         self.set_property('greyed', True)
         self.warning_label.set_text('')
 
     def on_connect_button_clicked(self, *a, **kw):
         """User wants to connect now."""
-        settings = {TC_URL_KEY: U1_TC_URL, HELP_TEXT_KEY: U1_DESCRIPTION,
-                    WINDOW_ID_KEY: str(self.main_window.window.xid),
-                    PING_URL_KEY: U1_PING_URL}
-        self.backend.login(U1_APP_NAME, settings,
-            reply_handler=NO_OP, error_handler=error_handler)
+        d = self.backend.login(**self._window_xid())
+        d.addCallback(self.on_credentials_result)
+        d.addErrback(self.on_credentials_error)
         self.set_property('greyed', True)
         self.warning_label.set_text('')
 
@@ -364,31 +328,42 @@
         """User wants to learn more."""
         uri_hook(self.learn_more_button, LEARN_MORE_LINK)
 
-    @filter_by_app_name
+    def on_credentials_result(self, result):
+        """Process the credentials response.
+
+        If 'result' is a non empty dict, they were found.
+        If 'result' is an empty dict, they were not found.
+        If 'result' is None, the user cancelled the process.
+
+        """
+        if result is None:
+            self.on_authorization_denied()
+        elif result == {}:
+            self.on_credentials_not_found()
+        else:
+            self.on_credentials_found(result)
+
     @log_call(logger.info, with_args=False)
-    def on_credentials_found(self, app_name, credentials):
-        """SSO backend notifies of credentials found."""
+    def on_credentials_found(self, credentials):
+        """Credentials backend notifies of credentials found."""
         self.set_property('greyed', False)
         self.emit('credentials-found', self._credentials_are_new, credentials)
 
-    @filter_by_app_name
     @log_call(logger.info)
-    def on_credentials_not_found(self, app_name):
-        """SSO backend notifies of credentials not found."""
+    def on_credentials_not_found(self):
+        """Creds backend notifies of credentials not found."""
         self._credentials_are_new = True
         self.set_property('greyed', False)
 
-    @filter_by_app_name
     @log_call(logger.error)
-    def on_credentials_error(self, app_name, error_dict):
-        """SSO backend notifies of an error when fetching credentials."""
+    def on_credentials_error(self, error_dict):
+        """Creds backend notifies of an error when fetching credentials."""
         self.set_property('greyed', False)
         self._set_warning(CREDENTIALS_ERROR)
 
-    @filter_by_app_name
     @log_call(logger.info)
-    def on_authorization_denied(self, app_name):
-        """SSO backend notifies that user refused auth for 'app_name'."""
+    def on_authorization_denied(self):
+        """Creds backend notifies that user refused auth for 'app_name'."""
         self.set_property('greyed', False)
 
     @log_call(logger.info)
@@ -402,8 +377,9 @@
         else:
             self.set_sensitive(True)
             self.warning_label.set_text(msg)
-            self.backend.find_credentials(U1_APP_NAME, {},
-                reply_handler=NO_OP, error_handler=error_handler)
+            d = self.backend.find_credentials()
+            d.addCallback(self.on_credentials_result)
+            d.addErrback(self.on_credentials_error)
 
 
 class DashboardPanel(UbuntuOneBin, ControlPanelMixin):
 
=== modified file 'ubuntuone/controlpanel/gui/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gui/gtk/tests/__init__.py	2011-05-26 22:18:04 +0000
+++ ubuntuone/controlpanel/gui/gtk/tests/__init__.py	2011-08-18 17:23:16 +0000
@@ -22,6 +22,7 @@
 
 from collections import defaultdict
 
+from twisted.internet import defer
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.controlpanel.gui.gtk import gui
@@ -83,14 +84,12 @@
         self._signals[signal].append(handler)
 
 
-class FakedSSOBackend(FakedDBusBackend):
-    """Fake a SSO Backend, act as a dbus.Interface."""
+class FakedCredentialsBackend(FakedObject):
+    """Fake a credentials backend."""
 
-    bus_name = gui.ubuntu_sso.DBUS_BUS_NAME
-    object_path = gui.ubuntu_sso.DBUS_CREDENTIALS_PATH
-    iface = gui.ubuntu_sso.DBUS_CREDENTIALS_IFACE
     exposed_methods = ['find_credentials', 'clear_credentials',
                        'login', 'register']
+    next_result = defer.succeed(None)
 
 
 class FakedControlPanelBackend(FakedDBusBackend):
@@ -135,8 +134,6 @@
         if dbus_interface == gui.DBUS_PREFERENCES_IFACE:
             return FakedControlPanelBackend(obj, dbus_interface,
                                             *args, **kwargs)
-        if dbus_interface == gui.ubuntu_sso.DBUS_CREDENTIALS_IFACE:
-            return FakedSSOBackend(obj, dbus_interface, *args, **kwargs)
         if dbus_interface == gui.DBUS_IFACE_GUI:
             return FakeControlPanelBackend(
                 obj, dbus_interface, *args, **kwargs)
@@ -188,9 +185,11 @@
     # pylint: disable=E1102
     klass = None
     kwargs = {}
+    backend_is_dbus = True
 
     def setUp(self):
         super(BaseTestCase, self).setUp()
+        self.patch(gui, 'CredentialsManagementTool', FakedCredentialsBackend)
         self.patch(gui.os.path, 'expanduser',
                    lambda path: path.replace('~', USER_HOME))
         self.patch(gui.gtk, 'main', lambda: None)
@@ -221,14 +220,13 @@
         pb = gui.gtk.gdk.pixbuf_new_from_file(gui.get_data_file(filename))
         self.assertEqual(image.get_pixbuf().get_pixels(), pb.get_pixels())
 
-    def assert_backend_called(self, method_name, args, backend=None):
+    def assert_backend_called(self, method_name, *args, **kwargs):
         """Check that the control panel backend 'method_name' was called."""
-        if backend is None:
-            backend = self.ui.backend
-        self.assertIn(method_name, backend._called)
-        kwargs = {'reply_handler': gui.NO_OP,
-                  'error_handler': gui.error_handler}
-        self.assertEqual(backend._called[method_name], (args, kwargs))
+        if self.backend_is_dbus:
+            kwargs = {'reply_handler': gui.NO_OP,
+                      'error_handler': gui.error_handler}
+        self.assertIn(method_name, self.ui.backend._called)
+        self.assertEqual(self.ui.backend._called[method_name], (args, kwargs))
 
     def assert_warning_correct(self, warning, text):
         """Check that 'warning' is visible, showing 'text'."""
 
=== modified file 'ubuntuone/controlpanel/gui/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gui/gtk/tests/test_gui.py	2011-06-01 21:18:46 +0000
+++ ubuntuone/controlpanel/gui/gtk/tests/test_gui.py	2011-08-18 17:23:16 +0000
@@ -159,7 +159,7 @@
         self.ui.backend._called.pop('volumes_info', None)
         self.ui.load()
 
-        self.assert_backend_called('volumes_info', ())
+        self.assert_backend_called('volumes_info')
 
     def test_is_processing_after_load(self):
         """The ui is processing when contents are load."""
@@ -440,7 +440,7 @@
                 subscribed = gui.bool_str(not bool(volume['subscribed']))
                 # backend was called
                 self.assert_backend_called('change_volume_settings',
-                                           (fid, {'subscribed': subscribed}))
+                                           fid, {'subscribed': subscribed})
                 # store was updated
                 it = self.ui.volumes_store.get_iter(path)
                 value = self.ui.volumes_store.get_value(it, 1)
@@ -572,7 +572,7 @@
         """Changing throttling settings updates the backend properly."""
         expected = self.ui.__dict__
         self.assert_backend_called('change_device_settings',
-                                   (self.ui.id, expected))
+                                   self.ui.id, expected)
         self.assertEqual(self.ui.warning_label.get_text(), '')
 
         limit_enabled = self.ui.throttling_limits.get_sensitive()
@@ -806,7 +806,7 @@
         self.ui.is_local = False
         self.ui.remove.clicked()
 
-        self.assert_backend_called('remove_device', (self.ui.id,))
+        self.assert_backend_called('remove_device', self.ui.id)
         self.assertFalse(self.ui.get_sensitive(),
                          'Must be disabled while removing.')
 
@@ -936,7 +936,7 @@
         self.ui.backend._called.pop('devices_info', None)
         self.ui.load()
 
-        self.assert_backend_called('devices_info', ())
+        self.assert_backend_called('devices_info')
 
     def test_is_processing_after_load(self):
         """The ui is processing when contents are load."""
@@ -1246,7 +1246,7 @@
 
     def test_file_sync_status_is_requested(self):
         """The file sync status is requested to the backend."""
-        self.assert_backend_called('file_sync_status', ())
+        self.assert_backend_called('file_sync_status')
 
     def test_is_disabled(self):
         """Until file sync status is given, the widget is disabled."""
@@ -1273,10 +1273,10 @@
         assert self.ui.button.get_active()
 
         self.ui.button.set_active(not self.ui.button.get_active())
-        self.assert_backend_called('disable_files', ())
+        self.assert_backend_called('disable_files')
 
         self.ui.button.set_active(not self.ui.button.get_active())
-        self.assert_backend_called('enable_files', ())
+        self.assert_backend_called('enable_files')
 
     def test_on_file_sync_enabled(self):
         """When file sync is enabled, the button is active."""
@@ -1330,7 +1330,7 @@
 
         args = (self.service_id,
                 {'enabled': gui.bool_str(self.ui.button.get_active())})
-        self.assert_backend_called('change_replication_settings', args)
+        self.assert_backend_called('change_replication_settings', *args)
 
     def test_dependency(self):
         """The dependency box is None."""
@@ -1543,7 +1543,7 @@
         self.ui.load_replications()
 
         self.assertTrue(self.ui.message.active)
-        self.assert_backend_called('replications_info', ())
+        self.assert_backend_called('replications_info')
 
 
 class ServicesWithDesktopcouchTestCase(ServicesTestCase):
@@ -1750,7 +1750,7 @@
     def test_file_sync_status_is_requested_on_load(self):
         """The file sync status is requested to the backend."""
         self.ui.load()
-        self.assert_backend_called('file_sync_status', ())
+        self.assert_backend_called('file_sync_status')
 
     def test_on_file_sync_status_disabled(self):
         """The file sync is disabled.
@@ -1862,43 +1862,43 @@
         self.ui.backend._called.clear()
         self.ui.on_files_start_error({'error_msg': 'error msg'})
 
-        self.assert_backend_called('file_sync_status', ())
+        self.assert_backend_called('file_sync_status')
 
     def test_on_connect_clicked(self):
         """User requested connection."""
         self.ui.on_connect_clicked(self.ui.button)
 
-        self.assert_backend_called('connect_files', ())
+        self.assert_backend_called('connect_files')
 
     def test_on_disconnect_clicked(self):
         """User requested disconnection."""
         self.ui.on_disconnect_clicked(self.ui.button)
 
-        self.assert_backend_called('disconnect_files', ())
+        self.assert_backend_called('disconnect_files')
 
     def test_on_enable_clicked(self):
         """User requested enable the service."""
         self.ui.on_enable_clicked(self.ui.button)
 
-        self.assert_backend_called('enable_files', ())
+        self.assert_backend_called('enable_files')
 
     def test_on_restart_clicked(self):
         """User requested restart the service."""
         self.ui.on_restart_clicked(self.ui.button)
 
-        self.assert_backend_called('restart_files', ())
+        self.assert_backend_called('restart_files')
 
     def test_on_start_clicked(self):
         """User requested start the service."""
         self.ui.on_start_clicked(self.ui.button)
 
-        self.assert_backend_called('start_files', ())
+        self.assert_backend_called('start_files')
 
     def test_on_stop_clicked(self):
         """User requested stop the service."""
         self.ui.on_stop_clicked(self.ui.button)
 
-        self.assert_backend_called('stop_files', ())
+        self.assert_backend_called('stop_files')
 
 
 class ManagementPanelTestCase(ControlPanelMixinTestCase):
@@ -1992,7 +1992,7 @@
     def test_account_info_is_requested_on_load(self):
         """The account info is requested to the backend."""
         self.ui.load()
-        self.assert_backend_called('account_info', ())
+        self.assert_backend_called('account_info')
 
     def test_file_sync_status_info_is_requested_on_load(self):
         """The file sync status info is requested to the backend."""
 
=== modified file 'ubuntuone/controlpanel/gui/gtk/tests/test_gui_basic.py'
--- ubuntuone/controlpanel/gui/gtk/tests/test_gui_basic.py	2011-05-24 16:05:30 +0000
+++ ubuntuone/controlpanel/gui/gtk/tests/test_gui_basic.py	2011-08-18 17:23:16 +0000
@@ -20,9 +20,14 @@
 
 from __future__ import division
 
+from twisted.internet import defer
+from twisted.python.failure import Failure
 
 from ubuntuone.controlpanel.gui.gtk import gui
-from ubuntuone.controlpanel.gui.gtk.tests import BaseTestCase, FakedSSOBackend
+from ubuntuone.controlpanel.gui.gtk.tests import (
+    BaseTestCase,
+    FakedCredentialsBackend,
+)
 from ubuntuone.controlpanel.tests import TOKEN
 
 from ubuntuone.devtools.testcase import skipIf
@@ -287,7 +292,7 @@
         """On 'credentials-found' signal, ask syncdaemon to connect."""
         # credentials are new
         self.ui.overview.emit('credentials-found', True, object())
-        self.assert_backend_called('connect_files', ())
+        self.assert_backend_called('connect_files')
 
     def test_local_device_removed_shows_overview_panel(self):
         """On 'local-device-removed' signal, the overview panel is shown."""
@@ -306,7 +311,7 @@
     def test_backend_is_shutdown_on_close(self):
         """When the control panel is closed, the backend is shutdown."""
         self.ui.emit('destroy')
-        self.assert_backend_called('shutdown', ())
+        self.assert_backend_called('shutdown')
 
 
 class UbuntuOneBinTestCase(BaseTestCase):
@@ -437,6 +442,11 @@
     klass = gui.OverviewPanel
     kwargs = {'main_window': gui.gtk.Window()}
     ui_filename = 'overview.ui'
+    backend_is_dbus = False
+
+    def setUp(self):
+        super(OverwiewPanelTestCase, self).setUp()
+        gui.gtk.link_button_set_uri_hook(lambda *a: None)
 
     def test_is_a_greyable_bin(self):
         """Inherits from GreyableBin."""
@@ -450,20 +460,102 @@
         """The 'join_now' button is the default widget."""
         self.assertTrue(self.ui.join_now_button.get_property('can-default'))
 
-    def test_sso_backend(self):
-        """Has a correct SSO backend."""
-        self.assertIsInstance(self.ui.backend, FakedSSOBackend)
-
-    def test_sso_backend_signals(self):
-        """The proper signals are connected to the backend."""
-        self.assertEqual(self.ui.backend._signals['CredentialsFound'],
-                         [self.ui.on_credentials_found])
-        self.assertEqual(self.ui.backend._signals['CredentialsNotFound'],
-                         [self.ui.on_credentials_not_found])
-        self.assertEqual(self.ui.backend._signals['CredentialsError'],
-                         [self.ui.on_credentials_error])
-        self.assertEqual(self.ui.backend._signals['AuthorizationDenied'],
-                         [self.ui.on_authorization_denied])
+    def test_backend(self):
+        """Has a correct backend."""
+        self.assertIsInstance(self.ui.backend, FakedCredentialsBackend)
+
+
+class OverwiewPanelBackendCallbacksTestCase(OverwiewPanelTestCase):
+    """Proper callbacks are chained to the credentials backend methods."""
+
+    failure = Exception()
+
+    def test_find_credentials_fired_with_credentials(self):
+        """Test that on_credentials_found is called."""
+        self.ui.backend.next_result = defer.succeed(TOKEN)
+        self.patch(self.ui, 'on_credentials_found', self._set_called)
+
+        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
+
+        self.assertEqual(self._called, ((TOKEN,), {}))
+
+    def test_find_credentials_fired_without_credentials(self):
+        """Test that on_credentials_not_found is called."""
+        self.ui.backend.next_result = defer.succeed({})
+        self.patch(self.ui, 'on_credentials_not_found', self._set_called)
+
+        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_find_credentials_errback(self):
+        """Test that on_credentials_error is called."""
+        self.ui.backend.next_result = defer.fail(self.failure)
+        self.patch(self.ui, 'on_credentials_error', self._set_called)
+
+        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
+
+        failure = self._called[0][0]
+        self.assertIsInstance(failure, Failure)
+        self.assertEqual(failure.value, self.failure)
+
+    def test_register_fired_with_credentials(self):
+        """Test that on_credentials_found is called."""
+        self.ui.backend.next_result = defer.succeed(TOKEN)
+        self.patch(self.ui, 'on_credentials_found', self._set_called)
+
+        self.ui.join_now_button.clicked()
+
+        self.assertEqual(self._called, ((TOKEN,), {}))
+
+    def test_register_fired_with_credentials_none(self):
+        """Test that on_authorization_denied is called."""
+        self.ui.backend.next_result = defer.succeed(None)
+        self.patch(self.ui, 'on_authorization_denied', self._set_called)
+
+        self.ui.join_now_button.clicked()
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_register_errback(self):
+        """Test that on_credentials_error is called."""
+        self.ui.backend.next_result = defer.fail(self.failure)
+        self.patch(self.ui, 'on_credentials_error', self._set_called)
+
+        self.ui.join_now_button.clicked()
+
+        failure = self._called[0][0]
+        self.assertIsInstance(failure, Failure)
+        self.assertEqual(failure.value, self.failure)
+
+    def test_login_fired_with_credentials(self):
+        """Test that on_credentials_found is called."""
+        self.ui.backend.next_result = defer.succeed(TOKEN)
+        self.patch(self.ui, 'on_credentials_found', self._set_called)
+
+        self.ui.connect_button.clicked()
+
+        self.assertEqual(self._called, ((TOKEN,), {}))
+
+    def test_login_fired_with_credentials_none(self):
+        """Test that on_authorization_denied is called."""
+        self.ui.backend.next_result = defer.succeed(None)
+        self.patch(self.ui, 'on_authorization_denied', self._set_called)
+
+        self.ui.connect_button.clicked()
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_login_errback(self):
+        """Test that on_credentials_error is called."""
+        self.ui.backend.next_result = defer.fail(self.failure)
+        self.patch(self.ui, 'on_credentials_error', self._set_called)
+
+        self.ui.connect_button.clicked()
+
+        failure = self._called[0][0]
+        self.assertIsInstance(failure, Failure)
+        self.assertEqual(failure.value, self.failure)
 
 
 class OverwiewNetworkStatePanelTestCase(OverwiewPanelTestCase):
@@ -514,13 +606,13 @@
     def test_find_credentials_is_called(self):
         """Credentials are asked to SSO backend."""
         self.assertFalse(self.ui._credentials_are_new)
-        self.assert_backend_called('find_credentials', (gui.U1_APP_NAME, {}))
+        self.assert_backend_called('find_credentials')
 
     def test_on_credentials_found(self):
         """Callback 'on_credentials_found' is correct."""
         self.ui.connect('credentials-found', self._set_called)
 
-        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
+        self.ui.on_credentials_found(TOKEN)
 
         self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
         # assume credentials were in local keyring
@@ -531,9 +623,9 @@
         self.ui.connect('credentials-found', self._set_called)
 
         # credentials weren't in the system
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        self.ui.on_credentials_not_found()
         # now they are!
-        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
+        self.ui.on_credentials_found(TOKEN)
 
         self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
         # assume credentials were not in local keyring
@@ -541,70 +633,31 @@
 
     def test_on_credentials_not_found(self):
         """Callback 'on_credentials_not_found' is correct."""
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        self.ui.on_credentials_not_found()
         self.assertTrue(self.ui.get_visible())
         self.assertTrue(self.ui._credentials_are_new)
 
     def test_on_credentials_error(self):
         """Callback 'on_credentials_error' is correct."""
-        self.ui.on_credentials_error(gui.U1_APP_NAME, {})
+        self.ui.on_credentials_error({})
         self.assertTrue(self.ui.get_visible())
         self.assert_warning_correct(self.ui.warning_label,
                                     gui.CREDENTIALS_ERROR)
 
     def test_on_authorization_denied(self):
         """Callback 'on_authorization_denied' is correct."""
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)
+        self.ui.on_authorization_denied()
         self.assertTrue(self.ui.get_visible())
         self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
         self.assertEqual(self.ui.warning_label.get_text(), '')
 
 
-class OverwiewPanelAppNameMismatchTestCase(OverwiewPanelTestCase):
-    """The test suite for the overview panel when the app_name won't match."""
-
-    NOT_U1_APP = 'Not ' + gui.U1_APP_NAME
-
-    def test_filter_by_app_name(self):
-        """The filter_by_app_name decorator is correct."""
-        f = gui.filter_by_app_name(self._set_called)
-        f(self.ui, self.NOT_U1_APP)
-        self.assertFalse(self._called)
-        self.assertTrue(self.memento.check_info('ignoring', self.NOT_U1_APP))
-
-        args = ('test', object())
-        kwargs = {'really': 'AWESOME'}
-        f(self.ui, gui.U1_APP_NAME, *args, **kwargs)
-        self.assertEqual(self._called,
-                         ((self.ui, gui.U1_APP_NAME,) + args, kwargs))
-
-    def test_on_credentials_found(self):
-        """Callback 'on_credentials_found' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_credentials_found)
-
-    def test_on_credentials_not_found(self):
-        """Callback 'on_credentials_not_found' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_credentials_not_found)
-
-    def test_on_credentials_error(self):
-        """Callback 'on_credentials_error' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_credentials_error)
-
-    def test_on_authorization_denied(self):
-        """Callback 'on_authorization_denied' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_authorization_denied)
-
-
 class OverwiewPanelNoCredsTestCase(OverwiewPanelTestCase):
     """The test suite for the overview panel when no credentials are found."""
 
     def setUp(self):
         super(OverwiewPanelNoCredsTestCase, self).setUp()
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        self.ui.on_credentials_not_found()
 
     def test_startup_visibility(self):
         """The widget is visible at startup."""
@@ -631,12 +684,8 @@
         self.ui.join_now_button.clicked()
 
         window_id = self.kwargs['main_window'].window.xid
-        args = (gui.U1_APP_NAME,
-                {gui.TC_URL_KEY: gui.U1_TC_URL,
-                 gui.HELP_TEXT_KEY: gui.U1_DESCRIPTION,
-                 gui.WINDOW_ID_KEY: str(window_id),
-                 gui.PING_URL_KEY: gui.U1_PING_URL})
-        self.assert_backend_called('register', args)
+        kwargs = {'window_id': str(window_id)}
+        self.assert_backend_called('register', **kwargs)
 
     def test_connect_button_clicked(self):
         """Test the 'join now' button callback."""
@@ -646,12 +695,8 @@
         self.ui.connect_button.clicked()
 
         window_id = self.kwargs['main_window'].window.xid
-        args = (gui.U1_APP_NAME,
-                {gui.TC_URL_KEY: gui.U1_TC_URL,
-                 gui.HELP_TEXT_KEY: gui.U1_DESCRIPTION,
-                 gui.WINDOW_ID_KEY: str(window_id),
-                 gui.PING_URL_KEY: gui.U1_PING_URL})
-        self.assert_backend_called('login', args)
+        kwargs = {'window_id': str(window_id)}
+        self.assert_backend_called('login', **kwargs)
 
     def test_join_now_button_clicked_set_greyed(self):
         """Clicking on 'join_now' self is greyed."""
@@ -660,7 +705,7 @@
 
     def test_join_now_button_clicked_removes_warning(self):
         """Clicking on 'join_now' the warnings are removed."""
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)  # show warning
+        self.ui.on_authorization_denied()  # show warning
         self.ui.join_now_button.clicked()
 
         self.assertEqual(self.ui.warning_label.get_text(), '')
@@ -672,7 +717,7 @@
 
     def test_connect_button_clicked_removes_warning(self):
         """Clicking on 'connect' the warnings are removed."""
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)  # show warning
+        self.ui.on_authorization_denied()  # show warning
         self.ui.connect_button.clicked()
 
         self.assertEqual(self.ui.warning_label.get_text(), '')
@@ -688,21 +733,21 @@
     def test_on_credentials_not_found_unset_greyed(self):
         """Callback 'on_credentials_not_found' unsets the 'greyed' prop."""
         self.ui.connect_button.clicked()
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        self.ui.on_credentials_not_found()
 
         self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
 
     def test_on_credentials_error_unset_greyed(self):
         """Callback 'on_credentials_error' unsets the 'greyed' prop."""
         self.ui.connect_button.clicked()
-        self.ui.on_credentials_error(gui.U1_APP_NAME, {})
+        self.ui.on_credentials_error({})
 
         self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
 
     def test_on_authorization_denied_unset_greyed(self):
         """Callback 'on_authorization_denied' unsets the 'greyed' prop."""
         self.ui.connect_button.clicked()
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)
+        self.ui.on_authorization_denied()
 
         self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
 
 
=== modified file 'ubuntuone/controlpanel/login_client.py'
--- ubuntuone/controlpanel/login_client.py	2011-06-17 15:56:54 +0000
+++ ubuntuone/controlpanel/login_client.py	2011-08-18 17:23:16 +0000
@@ -18,14 +18,15 @@
 
 """Client to access Ubuntu One credentials."""
 
+# pylint: disable=E0611, F0401
+from ubuntuone.platform.credentials import CredentialsManagementTool
+# pylint: enable=E0611, F0401
+
 
 def get_sso_proxy():
     """Return a login client."""
-    # No name 'credentials' in module 'ubuntuone.platform'
-    # Reimport 'credentials' (imported line 22)
-    # pylint: disable=E0611,W0404
-    from ubuntuone.platform import credentials
-    return credentials.CredentialsManagementTool()
+    result = CredentialsManagementTool()
+    return result
 
 
 def get_credentials():
@@ -38,3 +39,15 @@
     """Clear the credentials for Ubuntu One."""
     proxy = get_sso_proxy()
     return proxy.clear_credentials()
+
+
+def login(*args, **kwargs):
+    """Get the credentials for Ubuntu One offering the user to login."""
+    proxy = get_sso_proxy()
+    return proxy.login(*args, **kwargs)
+
+
+def register(*args, **kwargs):
+    """Get the credentials for Ubuntu One offering the user to register."""
+    proxy = get_sso_proxy()
+    return proxy.register(*args, **kwargs)
 
=== modified file 'ubuntuone/controlpanel/tests/test_login_client.py'
--- ubuntuone/controlpanel/tests/test_login_client.py	2011-06-17 15:56:54 +0000
+++ ubuntuone/controlpanel/tests/test_login_client.py	2011-08-18 17:23:16 +0000
@@ -19,10 +19,6 @@
 """Tests for the service when accessing the login client."""
 
 from twisted.internet import defer
-# No name 'credentials' in module 'ubuntuone.platform'
-# pylint: disable=E0611
-from ubuntuone.platform import credentials
-# pylint: enable=E0611
 
 from ubuntuone.controlpanel import login_client
 from ubuntuone.controlpanel.tests import TestCase, TOKEN
@@ -49,13 +45,23 @@
         FakedCredentialsManagementTool.credentials = None
         yield
 
+    @defer.inlineCallbacks
+    def login(self):
+        """Create credentials for Ubuntu One by logging in."""
+        yield defer.succeed(FakedCredentialsManagementTool.credentials)
+
+    @defer.inlineCallbacks
+    def register(self):
+        """Create credentials for Ubuntu One by registering."""
+        yield defer.succeed(FakedCredentialsManagementTool.credentials)
+
 
 class BaseTestCase(TestCase):
     """Base TestCase for the login client methods."""
 
     def setUp(self):
         super(BaseTestCase, self).setUp()
-        self.patch(credentials, 'CredentialsManagementTool',
+        self.patch(login_client, 'CredentialsManagementTool',
                    FakedCredentialsManagementTool)
         FakedCredentialsManagementTool.credentials = TOKEN
 
@@ -87,7 +93,7 @@
 
     @defer.inlineCallbacks
     def test_clear_credentials(self):
-        """The credentials are properly retrieved."""
+        """The credentials are properly cleared."""
         yield login_client.clear_credentials()
         self.assertEqual(None, FakedCredentialsManagementTool.credentials)
 
@@ -98,3 +104,39 @@
                    self.fake_fail)
         yield self.assertFailure(login_client.clear_credentials(),
                                  CustomError)
+
+
+class LoginTestCase(BaseTestCase):
+    """Test for the login method."""
+
+    @defer.inlineCallbacks
+    def test_login(self):
+        """The credentials are properly retrieved."""
+        yield login_client.login()
+        self.assertEqual(TOKEN, FakedCredentialsManagementTool.credentials)
+
+    @defer.inlineCallbacks
+    def test_login_throws_an_error(self):
+        """If login fails, the error is propagated."""
+        self.patch(FakedCredentialsManagementTool, 'login',
+                   self.fake_fail)
+        yield self.assertFailure(login_client.login(),
+                                 CustomError)
+
+
+class RegisterTestCase(BaseTestCase):
+    """Test for the register method."""
+
+    @defer.inlineCallbacks
+    def test_register(self):
+        """The credentials are properly retrieved."""
+        yield login_client.register()
+        self.assertEqual(TOKEN, FakedCredentialsManagementTool.credentials)
+
+    @defer.inlineCallbacks
+    def test_register_throws_an_error(self):
+        """If register fails, the error is propagated."""
+        self.patch(FakedCredentialsManagementTool, 'register',
+                   self.fake_fail)
+        yield self.assertFailure(login_client.register(),
+                                 CustomError)