Merge lp:~nataliabidart/ubuntuone-control-panel/handle-sd-timeout into lp:ubuntuone-control-panel

[Natalia Bidart]

Handling properly any failure between dbus calls and errbacking deferreds (LP: #683760).

When passing DBus error signals to deferred's errback, we need to transform the twisted Failures into string-string dicts. Otherwise, we get traces like:

Unhandled error in Deferred:
Traceback (most recent call last):
  File "/usr/lib/python2.6/dist-packages/twisted/internet/defer.py", line 949, in gotResult
    _inlineCallbacks(r, g, deferred)
  File "/usr/lib/python2.6/dist-packages/twisted/internet/defer.py", line 939, in _inlineCallbacks
    deferred.errback()
  File "/usr/lib/python2.6/dist-packages/twisted/internet/defer.py", line 345, in errback
    self._startRunCallbacks(fail)
  File "/usr/lib/python2.6/dist-packages/twisted/internet/defer.py", line 424, in _startRunCallbacks
    self._runCallbacks()
--- <exception caught here> ---
  File "/usr/lib/python2.6/dist-packages/twisted/internet/defer.py", line 441, in _runCallbacks
    self.result = callback(self.result, *args, **kw)
  File "/usr/lib/pymodules/python2.6/dbus/decorators.py", line 309, in emit_signal
    message.append(signature=signature, *args)
exceptions.TypeError: iteration over non-sequence

To reproduce:

* Temporally make syncdaemon dbus service unavailable (edit /usr/share/dbus-1/services/com.ubuntuone.SyncDaemon.service and modify the Name= field so the dbus name doesn't exist)

* from trunk, run:

in terminal 1) PYTHONPATH=. ./bin/ubuntuone-control-panel-backend
in terminal 2) PYTHONPATH=. ./bin/ubuntuone-control-panel-gtk

* you'll see the trace I pasted above on terminal 1.

From this branch, reproduce the test case and this time you'll get, on terminal 1:

ERROR:ubuntuone.controlpanel.dbus_service:VolumesInfoError: args (<ubuntuone.controlpanel.dbus_service.ControlPanelBackend at /preferences at 0x343e550>, {'error_type': 'DBusException', 'error_msg': u'org.freedesktop.DBus.Error.ServiceUnknown: The name com.ubuntuone.SyncDaemon was not provided by any .service files'}), kwargs {}.

[John Lenton (chipaca)]

As advertised.

review: Approve

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2010-11-17 21:28:55 +0000
+++ ubuntuone/controlpanel/backend.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #

=== modified file 'ubuntuone/controlpanel/dbus_client.py'
--- ubuntuone/controlpanel/dbus_client.py	2010-11-17 21:28:55 +0000
+++ ubuntuone/controlpanel/dbus_client.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -26,6 +27,11 @@
 from ubuntuone.clientdefs import APP_NAME
 from ubuntuone.syncdaemon import dbus_interface as sd_dbus_iface
 
+from ubuntuone.controlpanel.logger import setup_logging
+
+
+logger = setup_logging('dbus_client')
+
 
 class CredentialsError(Exception):
     """No credentials could be retrieved."""
@@ -78,6 +84,8 @@
 
 def get_syncdaemon_proxy(object_path, dbus_interface):
     """Get a DBus proxy for syncdaemon at 'object_path':'dbus_interface'."""
+    logger.debug('get_syncdaemon_proxy: object_path %r, dbus_interface %r',
+                 object_path, dbus_interface)
     bus = dbus.SessionBus()
     obj = bus.get_object(bus_name=sd_dbus_iface.DBUS_IFACE_NAME,
                          object_path=object_path,

=== modified file 'ubuntuone/controlpanel/dbus_service.py'
--- ubuntuone/controlpanel/dbus_service.py	2010-11-15 21:05:30 +0000
+++ ubuntuone/controlpanel/dbus_service.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -24,9 +25,61 @@
 from dbus.mainloop.glib import DBusGMainLoop
 from dbus.service import method, signal
 
+from twisted.python.failure import Failure
+
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
-                                    DBUS_PREFERENCES_IFACE)
+    DBUS_PREFERENCES_IFACE, utils)
 from ubuntuone.controlpanel.backend import ControlBackend
+from ubuntuone.controlpanel.logger import setup_logging
+
+
+logger = setup_logging('dbus_service')
+
+
+def make_unicode(anything):
+    """Transform 'anything' on an unicode."""
+    if not isinstance(anything, unicode):
+        anything = str(anything).decode('utf8', 'replace')
+
+    return anything
+
+
+def error_handler(error):
+    """Handle 'error' properly to be able to call a dbus error signal.
+     If 'error' is a Failure, then transform the exception in it to a error
+    dict. If 'error' is a regular Exception, transform it.
+
+    If 'error' is already a string-string dict, just pass it along. Build a
+    generic error dict in any other case.
+
+    """
+    result = {}
+    if isinstance(error, Failure):
+        result = utils.failure_to_error_dict(error)
+    elif isinstance(error, Exception):
+        result = utils.exception_to_error_dict(error)
+    elif isinstance(error, dict):
+        # ensure that both keys and values are unicodes
+        result = dict(map(make_unicode, i) for i in error.iteritems())
+    else:
+        msg = 'Got unexpected error argument %r' % error
+        result = {utils.ERROR_TYPE: 'UnknownError', utils.ERROR_MESSAGE: msg}
+
+    return result
+
+
+def transform_failure(f):
+    """Decorator to apply to DBus error signals.
+
+    With this call, a Failure is transformed into a string-string dict.
+
+    """
+    def inner(error, *a):
+        """Do the Failure transformation."""
+        error_dict = error_handler(error)
+        return f(error_dict)
+
+    return inner
 
 
 class ControlPanelBackend(dbus.service.Object):
@@ -36,6 +89,7 @@
         """Create this instance of the backend."""
         super(ControlPanelBackend, self).__init__(*args, **kwargs)
         self.backend = backend
+        logger.debug('ControlPanelBackend created with %r, %r', args, kwargs)
 
     # pylint: disable=C0103
 
@@ -44,7 +98,7 @@
         """Find out the account info for the current logged in user."""
         d = self.backend.account_info()
         d.addCallback(self.AccountInfoReady)
-        d.addErrback(self.AccountInfoError)
+        d.addErrback(transform_failure(self.AccountInfoError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def AccountInfoReady(self, info):
@@ -61,7 +115,7 @@
         """Find out the devices info for the logged in user."""
         d = self.backend.devices_info()
         d.addCallback(self.DevicesInfoReady)
-        d.addErrback(self.DevicesInfoError)
+        d.addErrback(transform_failure(self.DevicesInfoError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
     def DevicesInfoReady(self, info):
@@ -78,7 +132,7 @@
         """Configure a given device."""
         d = self.backend.change_device_settings(token, settings)
         d.addCallback(self.DeviceSettingsChanged)
-        d.addErrback(self.DeviceSettingsChangeError)
+        d.addErrback(transform_failure(self.DeviceSettingsChangeError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
     def DeviceSettingsChanged(self, token):
@@ -95,7 +149,7 @@
         """Remove a given device."""
         d = self.backend.remove_device(token)
         d.addCallback(self.DeviceRemoved)
-        d.addErrback(self.DeviceRemovalError)
+        d.addErrback(transform_failure(self.DeviceRemovalError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
     def DeviceRemoved(self, token):
@@ -112,7 +166,7 @@
         """Get the status of the file sync service."""
         d = self.backend.file_sync_status()
         d.addCallback(lambda args: self.FileSyncStatusReady(*args))
-        d.addErrback(self.FileSyncStatusError)
+        d.addErrback(transform_failure(self.FileSyncStatusError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="bs")
     def FileSyncStatusReady(self, enabled, status):
@@ -129,12 +183,14 @@
         """Find out the volumes info for the logged in user."""
         d = self.backend.volumes_info()
         d.addCallback(self.VolumesInfoReady)
-        d.addErrback(self.VolumesInfoError)
+        d.addErrback(transform_failure(self.VolumesInfoError))
 
+    @utils.log_call(logger.info)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
     def VolumesInfoReady(self, info):
         """The info for the volumes is available right now."""
 
+    @utils.log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def VolumesInfoError(self, error):
         """The info for the volumes is currently unavailable."""
@@ -146,7 +202,7 @@
         """Configure a given volume."""
         d = self.backend.change_volume_settings(volume_id, settings)
         d.addCallback(self.VolumeSettingsChanged)
-        d.addErrback(self.VolumeSettingsChangeError)
+        d.addErrback(transform_failure(self.VolumeSettingsChangeError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
     def VolumeSettingsChanged(self, token):
@@ -163,7 +219,7 @@
         """Check if the extension to sync bookmarks is installed."""
         d = self.backend.query_bookmark_extension()
         d.addCallback(self.QueryBookmarksResult)
-        d.addErrback(self.QueryBookmarksError)
+        d.addErrback(transform_failure(self.QueryBookmarksError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="b")
     def QueryBookmarksResult(self, enabled):
@@ -180,7 +236,7 @@
         """Install the extension to sync bookmarks."""
         d = self.backend.install_bookmarks_extension()
         d.addCallback(lambda _: self.InstallBookmarksSuccess())
-        d.addErrback(self.InstallBookmarksError)
+        d.addErrback(transform_failure(self.InstallBookmarksError))
 
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="")
     def InstallBookmarksSuccess(self):

=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2010-11-30 19:51:01 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2010-12-02 20:41:22 +0000
@@ -17,19 +17,3 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """The test suite for the GTK UI for the control panel for Ubuntu One."""
-
-from twisted.trial.unittest import TestCase
-
-
-class BaseTestCase(TestCase):
-    """Basics for testing."""
-
-    def setUp(self):
-        self._called = False
-
-    def tearDown(self):
-        self._called = False
-
-    def _set_called(self, *args, **kwargs):
-        """Store 'args' and 'kwargs' for test assertions."""
-        self._called = (args, kwargs)

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-11-30 20:13:10 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-02 20:41:22 +0000
@@ -27,8 +27,7 @@
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.controlpanel.gtk import gui
-from ubuntuone.controlpanel.tests import TOKEN
-from ubuntuone.controlpanel.gtk import tests
+from ubuntuone.controlpanel.tests import TOKEN, TestCase
 
 # Attribute 'yyy' defined outside __init__
 # pylint: disable=W0201
@@ -133,7 +132,7 @@
             return FakedSSOBackend(obj, dbus_interface, *args, **kwargs)
 
 
-class BaseTestCase(tests.BaseTestCase):
+class BaseTestCase(TestCase):
     """Basics for testing."""
 
     # self.klass is not callable

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_widgets.py'
--- ubuntuone/controlpanel/gtk/tests/test_widgets.py	2010-11-30 20:36:38 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_widgets.py	2010-12-02 20:41:22 +0000
@@ -18,10 +18,11 @@
 
 """The test suite for the extra widgets."""
 
-from ubuntuone.controlpanel.gtk import widgets, tests
-
-
-class LoadingTestCase(tests.BaseTestCase):
+from ubuntuone.controlpanel.tests import TestCase
+from ubuntuone.controlpanel.gtk import widgets
+
+
+class LoadingTestCase(TestCase):
     """Test suite for the Loading widget (a spinner plus a label)."""
 
     def setUp(self):
@@ -59,7 +60,7 @@
                          widgets.gtk.gdk.Color(expected))
 
 
-class LabelLoadingTestCase(tests.BaseTestCase):
+class LabelLoadingTestCase(TestCase):
     """Test suite for the LabelLoading widget.
 
     (a label that shows a Loading until the text is set).
@@ -155,7 +156,7 @@
         self.assertEqual(actual, widgets.gtk.gdk.Color(expected))
 
 
-class PanelTitleTestCase(tests.BaseTestCase):
+class PanelTitleTestCase(TestCase):
     """Tets case for a special title for each management panel."""
 
     TITLE = '<b>Foo Bar</b>'

=== modified file 'ubuntuone/controlpanel/gtk/widgets.py'
--- ubuntuone/controlpanel/gtk/widgets.py	2010-11-30 20:36:38 +0000
+++ ubuntuone/controlpanel/gtk/widgets.py	2010-12-02 20:41:22 +0000
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+# Authors: Natalia B. Bidart <[e-mail]>
 # Authors: Evan Dandrea <[e-mail]>
 #
 # Copyright 2009-2010 Canonical Ltd.

=== modified file 'ubuntuone/controlpanel/integrationtests/__init__.py'
--- ubuntuone/controlpanel/integrationtests/__init__.py	2010-11-17 21:28:55 +0000
+++ ubuntuone/controlpanel/integrationtests/__init__.py	2010-12-02 20:41:22 +0000
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+# Authors: Natalia B. Bidart <[e-mail]>
 # Authors: Alejandro J. Cura <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py	2010-11-15 16:00:23 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_service.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-11-17 22:05:32 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -23,11 +24,11 @@
 
 from twisted.internet import defer
 from twisted.python.failure import Failure
-from ubuntuone.devtools.testcase import DBusTestCase as TestCase
 
 from ubuntuone.controlpanel import dbus_service
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
                                     DBUS_PREFERENCES_IFACE)
+from ubuntuone.controlpanel.integrationtests import TestCase
 
 
 SAMPLE_ACCOUNT_INFO = {
@@ -120,7 +121,7 @@
         """Process the request with the given result."""
         if self.exception:
             # pylint: disable=E1102
-            return defer.fail(self.exception())
+            return defer.fail(self.exception(result))
         return defer.succeed(result)
 
     def account_info(self):
@@ -189,12 +190,63 @@
         busname = dbus_service.get_busname()
         self.assertEqual(busname.get_name(), DBUS_BUS_NAME)
 
-
-class OperationsTestCase(DBusServiceTestCase):
+    def test_error_handler_with_failure(self):
+        """Ensure to build a string-string dict to pass to error signals."""
+        error = dbus_service.Failure(TypeError('oh no!'))
+        expected = dbus_service.utils.failure_to_error_dict(error)
+
+        result = dbus_service.error_handler(error)
+
+        self.assertEqual(expected, result)
+
+    def test_error_handler_with_exception(self):
+        """Ensure to build a string-string dict to pass to error signals."""
+        error = TypeError('oh no, no again!')
+        expected = dbus_service.utils.exception_to_error_dict(error)
+
+        result = dbus_service.error_handler(error)
+
+        self.assertEqual(expected, result)
+
+    def test_error_handler_with_string_dict(self):
+        """Ensure to build a string-string dict to pass to error signals."""
+        expected = {'test': 'me'}
+
+        result = dbus_service.error_handler(expected)
+
+        self.assertEqual(expected, result)
+
+    def test_error_handler_with_non_string_dict(self):
+        """Ensure to build a string-string dict to pass to error signals."""
+        expected = {'test': 0, 'qué?': None,
+                    10: 'foo\xffbar', True: u'ñoño'}
+
+        result = dbus_service.error_handler(expected)
+        expected = dict(map(lambda x: x if isinstance(x, unicode) else
+                                      str(x).decode('utf8', 'replace'), i)
+                        for i in expected.iteritems())
+
+        self.assertEqual(expected, result)
+
+    def test_error_handler_default(self):
+        """Ensure to build a string-string dict to pass to error signals."""
+        msg = 'Got unexpected error argument %r' % None
+        expected = {dbus_service.utils.ERROR_TYPE: 'UnknownError',
+                    dbus_service.utils.ERROR_MESSAGE: msg}
+
+        result = dbus_service.error_handler(None)
+
+        self.assertEqual(expected, result)
+
+
+class OperationsTestCase(TestCase):
     """Test for the DBus service operations."""
 
+    timeout = 3
+
     def setUp(self):
         super(OperationsTestCase, self).setUp()
+        dbus_service.init_mainloop()
         be = dbus_service.publish_backend(MockBackend())
         self.addCleanup(be.remove_from_connection)
         bus = dbus.SessionBus()
@@ -381,3 +433,29 @@
         args = ("InstallBookmarksSuccess", "InstallBookmarksError", got_signal,
                 self.backend.install_bookmarks_extension)
         return self.assert_correct_method_call(*args)
+
+
+class OperationsErrorTestCase(OperationsTestCase):
+    """Test for the DBus service operations when there is an error."""
+
+    def setUp(self):
+        super(OperationsErrorTestCase, self).setUp()
+        self.patch(MockBackend, 'exception', AssertionError)
+
+    def assert_correct_method_call(self, success_sig, error_sig, success_cb,
+                                   method, *args):
+        """Call parent instance swapping success_sig with error_sig.
+
+        This is because we want to succeed the test when the error signal was
+        received.
+
+        """
+
+        def got_error_signal(error_dict):
+            """The error signal was received."""
+            self.assertEqual(error_dict[dbus_service.utils.ERROR_TYPE],
+                             'AssertionError')
+            self.deferred.callback("success")
+
+        return super(OperationsErrorTestCase, self).assert_correct_method_call(
+            error_sig, success_sig, got_error_signal, method, *args)

=== modified file 'ubuntuone/controlpanel/integrationtests/test_webclient.py'
--- ubuntuone/controlpanel/integrationtests/test_webclient.py	2010-11-10 15:54:29 +0000
+++ ubuntuone/controlpanel/integrationtests/test_webclient.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -22,9 +23,9 @@
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks
 from twisted.web import server, resource
-from ubuntuone.devtools.testcase import DBusTestCase as TestCase
 
 from ubuntuone.controlpanel import webclient
+from ubuntuone.controlpanel.integrationtests import TestCase
 
 
 SAMPLE_KEY = "result"

=== modified file 'ubuntuone/controlpanel/tests/__init__.py'
--- ubuntuone/controlpanel/tests/__init__.py	2010-10-07 20:13:07 +0000
+++ ubuntuone/controlpanel/tests/__init__.py	2010-12-02 20:41:22 +0000
@@ -18,8 +18,25 @@
 
 """The test suite for the control panel for Ubuntu One."""
 
+from twisted.trial import unittest
+
+
 TOKEN = {u'consumer_key': u'xQ7xDAz',
          u'consumer_secret': u'KzCJWCTNbbntwfyCKKjomJDzlgqxLy',
          u'token_name': u'test',
          u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
          u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
+
+
+class TestCase(unittest.TestCase):
+    """Basics for testing."""
+
+    def setUp(self):
+        self._called = False
+
+    def tearDown(self):
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Store 'args' and 'kwargs' for test assertions."""
+        self._called = (args, kwargs)

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2010-11-17 21:28:55 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2010-12-02 20:41:22 +0000
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -22,11 +23,11 @@
 
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks
-from twisted.trial.unittest import TestCase
 
 from ubuntuone.controlpanel import backend
 from ubuntuone.controlpanel.backend import (ACCOUNT_API, QUOTA_API,
                                             DEVICES_API, DEVICE_REMOVE_API)
+from ubuntuone.controlpanel.tests import TestCase
 from ubuntuone.controlpanel.webclient import WebClientError
 
 SAMPLE_CREDENTIALS = {"token": "ABC1234DEF"}
@@ -191,17 +192,16 @@
         self.patch(backend, "WebClient", MockWebClient)
         self.patch(backend, "dbus_client", MockDBusClient())
         self.local_token = "Computer" + SAMPLE_CREDENTIALS["token"]
+        self.be = backend.ControlBackend()
 
     def test_backend_creation(self):
         """The backend instance is successfully created."""
-        be = backend.ControlBackend()
-        self.assertEqual(be.wc.__class__, MockWebClient)
+        self.assertEqual(self.be.wc.__class__, MockWebClient)
 
     @inlineCallbacks
     def test_get_token(self):
         """The get_token method returns the right token."""
-        be = backend.ControlBackend()
-        token = yield be.get_token()
+        token = yield self.be.get_token()
         self.assertEqual(token, SAMPLE_CREDENTIALS["token"])
 
 
@@ -211,20 +211,18 @@
     @inlineCallbacks
     def test_account_info(self):
         """The account_info method exercises its callback."""
-        be = backend.ControlBackend()
         # pylint: disable=E1101
-        be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_JSON
-        be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
-        result = yield be.account_info()
+        self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_JSON
+        self.be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
+        result = yield self.be.account_info()
         self.assertEqual(result, EXPECTED_ACCOUNT_INFO)
 
     @inlineCallbacks
     def test_account_info_fails(self):
         """The account_info method exercises its errback."""
-        be = backend.ControlBackend()
         # pylint: disable=E1101
-        be.wc.failure = 404
-        yield self.assertFailure(be.account_info(), WebClientError)
+        self.be.wc.failure = 404
+        yield self.assertFailure(self.be.account_info(), WebClientError)
 
 
 class BackendDevicesTestCase(BackendBasicTestCase):
@@ -233,58 +231,52 @@
     @inlineCallbacks
     def test_devices_info(self):
         """The devices_info method exercises its callback."""
-        be = backend.ControlBackend()
         # pylint: disable=E1101
-        be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
-        result = yield be.devices_info()
+        self.be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
+        result = yield self.be.devices_info()
         self.assertEqual(result, EXPECTED_DEVICES_INFO)
 
     @inlineCallbacks
     def test_devices_info_fails(self):
         """The devices_info method exercises its errback."""
-        be = backend.ControlBackend()
         # pylint: disable=E1101
-        be.wc.failure = 404
-        yield self.assertFailure(be.devices_info(), WebClientError)
+        self.be.wc.failure = 404
+        yield self.assertFailure(self.be.devices_info(), WebClientError)
 
     @inlineCallbacks
     def test_remove_device(self):
         """The remove_device method calls the right api."""
-        be = backend.ControlBackend()
         dtype, did = "Computer", "SAMPLE-TOKEN"
         device_id = dtype + did
         apiurl = DEVICE_REMOVE_API % (dtype, did)
         # pylint: disable=E1101
-        be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
-        result = yield be.remove_device(device_id)
+        self.be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
+        result = yield self.be.remove_device(device_id)
         self.assertEqual(result, device_id)
 
     @inlineCallbacks
     def test_remove_device_fails(self):
         """The remove_device method fails as expected."""
-        be = backend.ControlBackend()
         # pylint: disable=E1101
-        be.wc.failure = 404
-        yield self.assertFailure(be.devices_info(), WebClientError)
+        self.be.wc.failure = 404
+        yield self.assertFailure(self.be.devices_info(), WebClientError)
 
     @inlineCallbacks
     def test_change_limit_bandwidth(self):
         """The device settings are updated."""
-        be = backend.ControlBackend()
         backend.dbus_client.throttling = False
-        yield be.change_device_settings(self.local_token,
+        yield self.be.change_device_settings(self.local_token,
                                         {"limit_bandwidth": "1"})
         self.assertEqual(backend.dbus_client.throttling, True)
-        yield be.change_device_settings(self.local_token,
+        yield self.be.change_device_settings(self.local_token,
                                         {"limit_bandwidth": "0"})
         self.assertEqual(backend.dbus_client.throttling, False)
 
     @inlineCallbacks
     def test_change_upload_speed_limit(self):
         """The device settings are updated."""
-        be = backend.ControlBackend()
         backend.dbus_client.limits = {"download": -1, "upload": -1}
-        yield be.change_device_settings(self.local_token,
+        yield self.be.change_device_settings(self.local_token,
                                         {"max_upload_speed": "1111"})
         self.assertEqual(backend.dbus_client.limits["upload"], 1111)
         self.assertEqual(backend.dbus_client.limits["download"], -1)
@@ -292,9 +284,8 @@
     @inlineCallbacks
     def test_change_download_speed_limit(self):
         """The device settings are updated."""
-        be = backend.ControlBackend()
         backend.dbus_client.limits = {"download": -1, "upload": -1}
-        yield be.change_device_settings(self.local_token,
+        yield self.be.change_device_settings(self.local_token,
                                         {"max_download_speed": "99"})
         self.assertEqual(backend.dbus_client.limits["upload"], -1)
         self.assertEqual(backend.dbus_client.limits["download"], 99)
@@ -302,7 +293,6 @@
     @inlineCallbacks
     def test_changing_settings_for_wrong_id_has_no_effect(self):
         """If the id is wrong, no settings are changed."""
-        be = backend.ControlBackend()
         backend.dbus_client.throttling = False
         backend.dbus_client.limits = {"download": -1, "upload": -1}
         new_settings = {
@@ -310,7 +300,7 @@
             "max_upload_speed": "99",
             "limit_bandwidth": "1",
         }
-        yield be.change_device_settings("wrong token!", new_settings)
+        yield self.be.change_device_settings("wrong token!", new_settings)
         self.assertEqual(backend.dbus_client.throttling, False)
         self.assertEqual(backend.dbus_client.limits["upload"], -1)
         self.assertEqual(backend.dbus_client.limits["download"], -1)
@@ -322,6 +312,5 @@
     @inlineCallbacks
     def test_volumes_info(self):
         """The volumes_info method exercises its callback."""
-        be = backend.ControlBackend()
-        result = yield be.volumes_info()
+        result = yield self.be.volumes_info()
         self.assertEqual(result, SAMPLE_VOLUMES)

=== modified file 'ubuntuone/controlpanel/tests/test_utils.py'
--- ubuntuone/controlpanel/tests/test_utils.py	2010-11-10 19:50:29 +0000
+++ ubuntuone/controlpanel/tests/test_utils.py	2010-12-02 20:41:22 +0000
@@ -21,10 +21,10 @@
 import logging
 import sys
 
-from twisted.trial.unittest import TestCase
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.controlpanel import utils
+from ubuntuone.controlpanel.tests import TestCase
 
 
 CONSTANTS_MODULE = 'ubuntuone.controlpanel.constants'
@@ -32,11 +32,18 @@
 
 
 class FakedConstantsModule(object):
-    """FAke the 'ubuntuone.controlpanel.constants' module."""
+    """Fake the 'ubuntuone.controlpanel.constants' module."""
 
     PROJECT_DIR = '/tmp/foo/bar'
 
 
+class FakedFailure(object):
+    """Fake a twisted Failure."""
+
+    def __init__(self, value):
+        self.value = value
+
+
 class GetProjectDirTestCase(TestCase):
     """Test case for get_project_dir when constants module is not defined."""
 
@@ -106,3 +113,56 @@
         result = utils.get_data_file(dummy_file)
         expected = utils.os.path.join(dummy_dir, dummy_file)
         self.assertEqual(expected, result)
+
+
+class ExceptionHandligTestCase(TestCase):
+    """Test cases for exception handling."""
+
+    def test_is_dbus_no_reply(self):
+        """The failure is a dbus no_reply error."""
+        exc = utils.dbus.exceptions.DBusException()
+        exc._dbus_error_name = utils.DBUS_NO_REPLY
+
+        result = utils.is_dbus_no_reply(FakedFailure(value=exc))
+
+        self.assertTrue(result)
+
+    def test_other_dbus_error_is_not_dbus_no_reply(self):
+        """Another dbus exception is not a dbus no_reply error."""
+        exc = utils.dbus.exceptions.DBusException()
+        exc._dbus_error_name = utils.DBUS_SERVICE_UNKNOWN
+
+        result = utils.is_dbus_no_reply(FakedFailure(value=exc))
+
+        self.assertFalse(result)
+
+    def test_no_dbus_exception_is_not_dbus_no_reply(self):
+        """A non dbus exception is not a dbus no_reply error."""
+        exc = AssertionError(utils.DBUS_NO_REPLY)
+
+        result = utils.is_dbus_no_reply(FakedFailure(value=exc))
+
+        self.assertFalse(result)
+
+    def test_exception_to_error_dict(self):
+        """Transform a regular Exception into a string-string dictionary."""
+        msg = 'Something went wrong.'
+        exc = AssertionError(msg)
+
+        result = utils.exception_to_error_dict(exc)
+        expected = {utils.ERROR_TYPE: exc.__class__.__name__,
+                    utils.ERROR_MESSAGE: unicode(exc)}
+
+        self.assertEqual(expected, result)
+
+    def test_failure_to_error_dict(self):
+        """Transform a Failure into a string-string dictionary."""
+        msg = 'Something went wrong.'
+        exc = AssertionError(msg)
+        failure = FakedFailure(value=exc)
+
+        result = utils.failure_to_error_dict(failure)
+        expected = {utils.ERROR_TYPE: exc.__class__.__name__,
+                    utils.ERROR_MESSAGE: unicode(exc)}
+
+        self.assertEqual(expected, result)

=== removed file 'ubuntuone/controlpanel/tests/testcase.py'
--- ubuntuone/controlpanel/tests/testcase.py	2010-09-20 17:17:06 +0000
+++ ubuntuone/controlpanel/tests/testcase.py	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-# Author: Guillermo Gonzalez <[e-mail]>
-#
-# Copyright 2009-2010 Canonical Ltd.
-#
-# This program is free software: you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 3, as published
-# by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranties of
-# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-# PURPOSE.  See the GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Test utilities."""
-
-import logging
-
-
-class MementoHandler(logging.Handler):
-    """ A handler class which store logging records in a list """
-
-    def __init__(self, *args, **kwargs):
-        """ Create the instance, and add a records attribute. """
-        logging.Handler.__init__(self, *args, **kwargs)
-        self.records = []
-
-    def emit(self, record):
-        """ Just add the record to self.records. """
-        self.records.append(record)
-
-    def check(self, level, *msgs):
-        """Verifies that the msgs are logged in the specified level."""
-        for rec in self.records:
-            if rec.levelno == level and all(m in rec.message for m in msgs):
-                return True
-        return False
-
-    def check_debug(self, *msgs):
-        """Shortcut for checking in DEBUG."""
-        return self.check(logging.DEBUG, *msgs)
-
-    def check_info(self, *msgs):
-        """Shortcut for checking in INFO."""
-        return self.check(logging.INFO, *msgs)
-
-    def check_warning(self, *msgs):
-        """Shortcut for checking in WARNING."""
-        return self.check(logging.WARNING, *msgs)
-
-    def check_error(self, *msgs):
-        """Shortcut for checking in ERROR."""
-        return self.check(logging.ERROR, *msgs)

=== modified file 'ubuntuone/controlpanel/utils.py'
--- ubuntuone/controlpanel/utils.py	2010-11-10 19:50:29 +0000
+++ ubuntuone/controlpanel/utils.py	2010-12-02 20:41:22 +0000
@@ -22,12 +22,21 @@
 
 from functools import wraps
 
+import dbus
+
 from ubuntuone.controlpanel.logger import setup_logging
 
 
 logger = setup_logging('utils')
+
 DATA_SUFFIX = 'data'
 
+DBUS_NO_REPLY = 'org.freedesktop.DBus.Error.NoReply'
+DBUS_SERVICE_UNKNOWN = 'org.freedesktop.DBus.Error.ServiceUnknown'
+
+ERROR_TYPE = 'error_type'
+ERROR_MESSAGE = 'error_msg'
+
 
 def get_project_dir():
     """Return the absolute path to this project's data/ dir.
@@ -75,3 +84,23 @@
         return inner
 
     return middle
+
+
+def is_dbus_no_reply(failure):
+    """Decide if 'failure' is a DBus NoReply Error."""
+    exc = failure.value
+    res = (isinstance(exc, dbus.exceptions.DBusException) and
+           exc.get_dbus_name() == DBUS_NO_REPLY)
+    return res
+
+
+def exception_to_error_dict(exc):
+    """Transform a regular Exception into a dictionary."""
+    result = {ERROR_TYPE: exc.__class__.__name__, ERROR_MESSAGE: unicode(exc)}
+
+    return result
+
+
+def failure_to_error_dict(failure):
+    """Transform a twisted Failure into a dictionary."""
+    return exception_to_error_dict(failure.value)

=== modified file 'ubuntuone/controlpanel/webclient.py'
--- ubuntuone/controlpanel/webclient.py	2010-10-08 17:38:57 +0000
+++ ubuntuone/controlpanel/webclient.py	2010-12-02 20:41:22 +0000
@@ -1,4 +1,7 @@
+# -*- coding: utf-8 -*-
+
 # Authors: Alejandro J. Cura <[e-mail]>
+# Authors: Natalia B. Bidart <[e-mail]>
 #
 # Copyright 2010 Canonical Ltd.
 #
@@ -45,7 +48,7 @@
 
     def _handler(self, session, msg, d):
         """Handle the result of an http message."""
-        logger.debug("got http response: %d", msg.status_code)
+        logger.debug("WebClient: got http response: %d", msg.status_code)
         if msg.status_code == 200:
             result = simplejson.loads(msg.response_body.data)
             d.callback(result)
@@ -55,20 +58,18 @@
 
     def _call_api_with_creds(self, credentials, api_name):
         """Get a given url from the webservice with credentials."""
-        logger.debug("got credentials")
         url = self.base_url + api_name
         method = "GET"
         msg = Soup.Message.new(method, url)
         add_oauth_headers(msg.request_headers.append, method, url, credentials)
         d = defer.Deferred()
-        logger.debug("getting url: %s", url)
+        logger.debug("WebClient: getting url: %s", url)
         self.session.queue_message(msg, self._handler, d)
         return d
 
     def call_api(self, api_name):
         """Get a given url from the webservice."""
-        logger.debug("calling api: %s", api_name)
-        logger.debug("getting credentials")
+        logger.debug("WebClient: calling api: %s", api_name)
         d = self.get_credentials()
         d.addCallback(self._call_api_with_creds, api_name)
         return d