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

[Natalia Bidart]

* Migrated dbus_client to use non-deprectaed SSO D-Bus API.
* Added clear_credentials to dbus_client module.

To run tests:

./run-tests

[Roberto Alsina (ralsina)]

Looks good to me.

review: Approve

[Manuel de la Peña (mandel)]

+1

review: Approve

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2010-12-16 21:09:46 +0000
+++ ubuntuone/controlpanel/backend.py	2010-12-18 17:36:06 +0000
@@ -120,7 +120,7 @@
 
     @inlineCallbacks
     def get_token(self):
-        """Return the token from the credentials"""
+        """Return the token from the credentials."""
         credentials = yield dbus_client.get_credentials()
         returnValue(credentials["token"])
 

=== modified file 'ubuntuone/controlpanel/dbus_client.py'
--- ubuntuone/controlpanel/dbus_client.py	2010-12-13 22:13:05 +0000
+++ ubuntuone/controlpanel/dbus_client.py	2010-12-18 17:36:06 +0000
@@ -46,36 +46,88 @@
     """Do nothing"""
 
 
+def get_sso_proxy():
+    """Get a DBus proxy for credentials management."""
+    bus = dbus.SessionBus()
+    obj = bus.get_object(bus_name=ubuntu_sso.DBUS_BUS_NAME,
+                         object_path=ubuntu_sso.DBUS_CREDENTIALS_PATH,
+                         follow_name_owner_changes=True)
+    proxy = dbus.Interface(object=obj,
+                           dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+    return proxy
+
+
 def get_credentials():
     """Get the credentials from the ubuntu-sso-client."""
     d = defer.Deferred()
-    bus = dbus.SessionBus()
-    obj = bus.get_object(bus_name=ubuntu_sso.DBUS_BUS_NAME,
-                         object_path=ubuntu_sso.DBUS_CRED_PATH,
-                         follow_name_owner_changes=True)
-    proxy = dbus.Interface(object=obj,
-                           dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME)
+    proxy = get_sso_proxy()
 
     def found_credentials(app_name, creds):
         """Credentials have been found."""
+        logger.debug('credentials were found for app_name %r.', app_name)
         if app_name == APP_NAME:
+            logger.info('credentials were found! (%r).', APP_NAME)
             d.callback(creds)
 
-    def credentials_error(app_name, error_message, detailed_error):
+    def credentials_error(app_name, error_dict=None):
         """No credentials could be retrieved."""
         if app_name == APP_NAME:
-            error = CredentialsError(app_name, error_message, detailed_error)
+            if error_dict is None:
+                error_dict = {'error_message': 'Credentials were not found.',
+                              'detailed_error': ''}
+
+            logger.error('credentials error (%r, %r).', app_name, error_dict)
+            error = CredentialsError(app_name, error_dict)
             d.errback(error)
 
     foundsig = proxy.connect_to_signal("CredentialsFound", found_credentials)
+    notfoundsig = proxy.connect_to_signal("CredentialsNotFound",
+                                          credentials_error)
     errorsig = proxy.connect_to_signal("CredentialsError", credentials_error)
-    proxy.login_or_register_to_get_credentials(APP_NAME, "tcurl", "help", 0,
-                                               reply_handler=no_op,
-                                               error_handler=d.errback)
+    logger.debug('calling get_credentials.')
+    proxy.find_credentials(APP_NAME, {'': ''},
+                           reply_handler=no_op, error_handler=d.errback)
 
     def cleanup_signals(result):
         """Remove signals after use."""
         foundsig.remove()
+        notfoundsig.remove()
+        errorsig.remove()
+        return result
+
+    d.addBoth(cleanup_signals)
+    return d
+
+
+def clear_credentials():
+    """Clear the credentials using the ubuntu-sso-client."""
+    d = defer.Deferred()
+    proxy = get_sso_proxy()
+
+    def credentials_cleared(app_name):
+        """Credentials have been cleared."""
+        logger.debug('credentials were cleared for app_name %r.', app_name)
+        if app_name == APP_NAME:
+            logger.info('credentials were cleared! (%r).', APP_NAME)
+            d.callback(app_name)
+
+    def credentials_error(app_name, error_dict=None):
+        """No credentials could be retrieved."""
+        if app_name == APP_NAME:
+            logger.error('credentials error (%r, %r).', app_name, error_dict)
+            error = CredentialsError(app_name, error_dict)
+            d.errback(error)
+
+    clearedsig = proxy.connect_to_signal("CredentialsCleared",
+                                         credentials_cleared)
+    errorsig = proxy.connect_to_signal("CredentialsError", credentials_error)
+    logger.warning('calling clear_credentials.')
+    proxy.clear_credentials(APP_NAME, {'': ''},
+                            reply_handler=no_op, error_handler=d.errback)
+
+    def cleanup_signals(result):
+        """Remove signals after use."""
+        clearedsig.remove()
         errorsig.remove()
         return result
 

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py	2010-12-18 17:36:06 +0000
@@ -23,8 +23,9 @@
 # DBus signals have CamelCased names
 
 import dbus
-import ubuntu_sso
 
+from ubuntu_sso import (DBUS_BUS_NAME,
+    DBUS_CREDENTIALS_PATH, DBUS_CREDENTIALS_IFACE)
 from twisted.internet.defer import inlineCallbacks
 
 from ubuntuone.controlpanel import dbus_client
@@ -36,6 +37,8 @@
     "token": "ABCDEF12345678",
     "access_token": "DEADCAFE2010",
 }
+OTHER_CREDS = {"token": "other!"}
+SAMPLE_ERROR = {"error message": "test", "detailed_error": "error details"}
 
 # pylint: disable=C0322
 # pylint, you have to go to decorator's school
@@ -44,116 +47,161 @@
 class MockDBusSSOService(dbus.service.Object):
     """A mock object that mimicks ussoc."""
 
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Get creds from the keyring, login/register if needed."""
-        self.CredentialsFound(app_name, SAMPLE_CREDS)
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Credentials were finally found."""
-
-
-class MockDBusSSOServiceOther(dbus.service.Object):
-    """A mock object that mimicks ussoc."""
-
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Get creds from the keyring, login/register if needed."""
-        self.CredentialsFound("wrong app name", {})
-        self.CredentialsFound(app_name, SAMPLE_CREDS)
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Credentials were finally found."""
-
-
-class MockDBusSSOClientOtherFailing(dbus.service.Object):
-    """A mock object that mimicks ussoc."""
-
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Get creds from the keyring, login/register if needed."""
-        self.CredentialsError("wrong app", "error message", "error details")
-        self.CredentialsFound(app_name, SAMPLE_CREDS)
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Credentials were finally found."""
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sss")
-    def CredentialsError(self, app_name, error_message, detailed_error):
-        """Some error happened and credentials were not found."""
-
-
-class MockDBusSSOClientFailing(dbus.service.Object):
-    """A mock object that mimicks ussoc but fails."""
-
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Fail while trying to get creds from the keyring."""
-        self.CredentialsError(app_name, "error message", "error details")
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sss")
-    def CredentialsError(self, app_name, error_message, detailed_error):
-        """Some error happened and credentials were not found."""
+    found = True
+    wrong_app = None
+    error = None
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def find_credentials(self, app_name, args):
+        """Get creds from the keyring, login/register if needed."""
+        if self.wrong_app is None and self.error is None:
+            if self.found:
+                self.CredentialsFound(app_name, SAMPLE_CREDS)
+            else:
+                self.CredentialsNotFound(app_name)
+        elif self.wrong_app is not None and self.error is None:
+            self.CredentialsFound(self.wrong_app, OTHER_CREDS)
+        elif self.wrong_app is None and self.error is not None:
+            self.CredentialsError(app_name, self.error)
+        else:
+            self.CredentialsError(self.wrong_app, self.error)
+
+        self.CredentialsFound(app_name, SAMPLE_CREDS)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def clear_credentials(self, app_name, args):
+        """Clear the credentials for an application."""
+        self.found = False
+
+        if self.wrong_app is None and self.error is None:
+            self.CredentialsCleared(app_name)
+        elif self.wrong_app is not None and self.error is None:
+            self.CredentialsCleared(self.wrong_app)
+        elif self.wrong_app is None and self.error is not None:
+            self.CredentialsError(app_name, self.error)
+        else:
+            self.CredentialsError(self.wrong_app, self.error)
+
+        self.CredentialsCleared(app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsFound(self, app_name, credentials):
+        """Signal thrown when the credentials are found."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsNotFound(self, app_name):
+        """Signal thrown when the credentials are not found."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsCleared(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsStored(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+
+    @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."""
 
 
 class SSOClientTestCase(DBusClientTestCase):
     """Test for the SSO dbus client."""
 
+    def setUp(self):
+        super(SSOClientTestCase, self).setUp()
+        self.register_mockserver(DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
+                                 MockDBusSSOService)
+        MockDBusSSOService.wrong_app = None
+        MockDBusSSOService.error = None
+        MockDBusSSOService.found = True
+
+    # get_credentials
+
     @inlineCallbacks
     def test_get_credentials_ok(self):
         """Test the success case for get_credentials."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH, MockDBusSSOService)
         creds = yield dbus_client.get_credentials()
         self.assertEqual(creds, SAMPLE_CREDS)
 
     @inlineCallbacks
+    def test_get_credentials_not_found(self):
+        """Credentials were not found."""
+        yield dbus_client.clear_credentials()  # not found will be sent
+        yield self.assertFailure(dbus_client.get_credentials(),
+                                 dbus_client.CredentialsError)
+
+    @inlineCallbacks
     def test_get_credentials_other(self):
         """Creds for other apps are ignored."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusSSOServiceOther)
+        MockDBusSSOService.wrong_app = 'other app!'
         creds = yield dbus_client.get_credentials()
         self.assertEqual(creds, SAMPLE_CREDS)
 
     @inlineCallbacks
     def test_get_credentials_error(self):
         """Test what happens when the creds can't be retrieved."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusSSOClientFailing)
-
+        MockDBusSSOService.error = SAMPLE_ERROR
         yield self.assertFailure(dbus_client.get_credentials(),
                                  dbus_client.CredentialsError)
 
     @inlineCallbacks
     def test_get_credentials_other_error(self):
         """Other creds err before ours are retrieved."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusSSOClientOtherFailing)
-
+        MockDBusSSOService.wrong_app = 'other app!'
+        MockDBusSSOService.error = SAMPLE_ERROR
         creds = yield dbus_client.get_credentials()
         self.assertEqual(creds, SAMPLE_CREDS)
 
+    # clear_credentials
+
+    @inlineCallbacks
+    def test_clear_credentials_ok(self):
+        """Test the success case for clear_credentials."""
+        result = yield dbus_client.clear_credentials()
+        self.assertEqual(result, dbus_client.APP_NAME)
+
+    @inlineCallbacks
+    def test_clear_credentials_other(self):
+        """Creds for other apps are ignored."""
+        MockDBusSSOService.wrong_app = 'other app!'
+        result = yield dbus_client.clear_credentials()
+        self.assertEqual(result, dbus_client.APP_NAME)
+
+    @inlineCallbacks
+    def test_clear_credentials_error(self):
+        """Test what happens when the creds can't be retrieved."""
+        MockDBusSSOService.error = SAMPLE_ERROR
+        yield self.assertFailure(dbus_client.clear_credentials(),
+                                 dbus_client.CredentialsError)
+
+    @inlineCallbacks
+    def test_clear_credentials_other_error(self):
+        """Other creds err before ours are retrieved."""
+        MockDBusSSOService.wrong_app = 'other app!'
+        MockDBusSSOService.error = SAMPLE_ERROR
+        result = yield dbus_client.clear_credentials()
+        self.assertEqual(result, dbus_client.APP_NAME)
+
+
+class NoMethodsSSOClientTestCase(DBusClientTestCase):
+    """Test for the SSO dbus client when the service provides no methods."""
+
+    def setUp(self):
+        super(NoMethodsSSOClientTestCase, self).setUp()
+        self.register_mockserver(DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
+                                 MockDBusNoMethods)
+
     @inlineCallbacks
     def test_get_credentials_dbus_error(self):
         """Test what happens when there's a DBus error."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusNoMethods)
+        yield self.assertFailure(dbus_client.get_credentials(),
+                                 dbus.DBusException)
 
-        yield self.assertFailure(dbus_client.get_credentials(),
+    @inlineCallbacks
+    def test_clear_credentials_dbus_error(self):
+        """Test what happens when there's a DBus error."""
+        yield self.assertFailure(dbus_client.clear_credentials(),
                                  dbus.DBusException)

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2010-12-16 21:01:43 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2010-12-18 17:36:06 +0000
@@ -211,6 +211,11 @@
         """Return the mock credentials."""
         return defer.succeed(self.creds)
 
+    def clear_credentials(self):
+        """Clear the mock credentials."""
+        MockDBusClient.creds = None
+        return defer.succeed(None)
+
     def get_throttling_limits(self):
         """Return the sample speed limits."""
         return self.limits
@@ -284,6 +289,8 @@
         self.memento = MementoHandler()
         backend.logger.addHandler(self.memento)
 
+        MockDBusClient.creds = SAMPLE_CREDENTIALS
+
     def test_backend_creation(self):
         """The backend instance is successfully created."""
         self.assertEqual(self.be.wc.__class__, MockWebClient)