Merge lp:~nataliabidart/ubuntuone-control-panel/remove-devices into lp:ubuntuone-control-panel

[Natalia Bidart]

* Devices can now be removed (LP: #691295).

To run the tests, do:

./run-tests

To test IRL, open 2 terminals pointing to this branch, and run:

terminal 1: DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-backend
terminal 2: DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-gtk

and play with the 3rd tab. The 'Remove' button is fully functional so be careful.

Among the suggested tests if removing the local device (ie the computer you're testing on). You should be taken to the overview panel after that to re-add your account.

[Roberto Alsina (ralsina)]

It works.

review: Approve (fieldtest)

[Manuel de la Peña (mandel)]

+1

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~nataliabidart/ubuntuone-control-panel/remove-devices into lp:ubuntuone-control-panel failed. Below is the output from the failed tests.

Running test suite for ubuntuone/controlpanel/tests
ubuntuone.controlpanel.tests.test_backend
  BackendAccountTestCase
    test_account_info ... [OK]
    test_account_info_fails ... [OK]
    test_backend_creation ... [OK]
    test_device_is_local ... [OK]
    test_get_token ... [OK]
  BackendBasicTestCase
    test_backend_creation ... [OK]
    test_device_is_local ... [OK]
    test_get_token ... [OK]
  BackendDevicesTestCase
    test_backend_creation ... [OK]
    test_change_download_speed_limit ... [OK]
    test_change_limit_bandwidth ... [OK]
    test_change_upload_speed_limit ... [OK]
    test_changing_settings_for_wrong_id_has_no_effect ... [OK]
    test_device_is_local ... [OK]
    test_devices_info ... [OK]
    test_devices_info_fails ... [OK]
    test_get_token ... [OK]
    test_remove_device ... [OK]
    test_remove_device_clear_credentials_if_local_device ... [OK]
    test_remove_device_fails ... [OK]
  BackendSyncStatusTestCase
    test_backend_creation ... [OK]
    test_device_is_local ... [OK]
    test_disabled ... [OK]
    test_disconnected ... [OK]
    test_error ... [OK]
    test_get_token ... [OK]
    test_idle ... [OK]
    test_starting_when_init_not_user ... [OK]
    test_starting_when_init_with_user ... [OK]
    test_starting_when_local_rescan_not_user ... [OK]
    test_starting_when_local_rescan_with_user ... [OK]
    test_starting_when_ready_with_user ... [OK]
    test_status_changed ... [OK]
    test_syncing_even_if_not_online ... [OK]
    test_syncing_if_online ... [OK]
    test_unknown ... ...

=== modified file 'data/device.ui'
--- data/device.ui	2010-12-16 20:56:57 +0000
+++ data/device.ui	2010-12-18 17:42:12 +0000
@@ -2,6 +2,14 @@
 <interface>
   <requires lib="gtk+" version="2.16"/>
   <!-- interface-naming-policy project-wide -->
+  <object class="GtkAdjustment" id="adjustment2">
+    <property name="upper">10000</property>
+    <property name="step_increment">1</property>
+  </object>
+  <object class="GtkAdjustment" id="adjustment1">
+    <property name="upper">10000</property>
+    <property name="step_increment">1</property>
+  </object>
   <object class="GtkVBox" id="itself">
     <property name="visible">True</property>
     <property name="spacing">5</property>
@@ -74,7 +82,7 @@
                     <property name="can_focus">True</property>
                     <property name="receives_default">False</property>
                     <property name="draw_indicator">True</property>
-                    <signal name="toggled" handler="on_limit_bandwidth_toggled"/>
+                    <signal name="toggled" handler="on_limit_bandwidth_toggled" swapped="no"/>
                   </object>
                 </child>
                 <child>
@@ -108,7 +116,7 @@
                     <property name="invisible_char">•</property>
                     <property name="activates_default">True</property>
                     <property name="adjustment">adjustment1</property>
-                    <signal name="value_changed" handler="on_max_upload_speed_value_changed"/>
+                    <signal name="value-changed" handler="on_max_upload_speed_value_changed" swapped="no"/>
                   </object>
                   <packing>
                     <property name="left_attach">1</property>
@@ -126,7 +134,7 @@
                     <property name="invisible_char">•</property>
                     <property name="activates_default">True</property>
                     <property name="adjustment">adjustment2</property>
-                    <signal name="value_changed" handler="on_max_download_speed_value_changed"/>
+                    <signal name="value-changed" handler="on_max_download_speed_value_changed" swapped="no"/>
                   </object>
                   <packing>
                     <property name="left_attach">1</property>
@@ -161,6 +169,8 @@
                 <property name="can_focus">True</property>
                 <property name="receives_default">True</property>
                 <property name="use_stock">True</property>
+                <signal name="activate" handler="on_remove_clicked" swapped="no"/>
+                <signal name="clicked" handler="on_remove_clicked" swapped="no"/>
               </object>
               <packing>
                 <property name="expand">False</property>
@@ -190,12 +200,4 @@
       </packing>
     </child>
   </object>
-  <object class="GtkAdjustment" id="adjustment1">
-    <property name="upper">10000</property>
-    <property name="step_increment">1</property>
-  </object>
-  <object class="GtkAdjustment" id="adjustment2">
-    <property name="upper">10000</property>
-    <property name="step_increment">1</property>
-  </object>
 </interface>

=== modified file 'ubuntuone/controlpanel/__init__.py'
--- ubuntuone/controlpanel/__init__.py	2010-10-08 01:31:34 +0000
+++ ubuntuone/controlpanel/__init__.py	2010-12-18 17:42:12 +0000
@@ -29,4 +29,4 @@
 DBUS_PREFERENCES_PATH = "/preferences"
 DBUS_PREFERENCES_IFACE = "com.ubuntuone.controlpanel.Preferences"
 
-WEBSERVICE_BASE_URL = "https://one.ubuntu.com/api/"
+WEBSERVICE_BASE_URL = u"https://one.ubuntu.com/api/"

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2010-12-18 17:42:11 +0000
+++ ubuntuone/controlpanel/backend.py	2010-12-18 17:42:12 +0000
@@ -49,6 +49,11 @@
 STATUS_KEY = 'status'
 
 
+def bool_str(value):
+    """Return the string representation of a bool (dbus-compatible)."""
+    return 'True' if value else ''
+
+
 class ControlBackend(object):
     """The control panel backend."""
 
@@ -124,6 +129,15 @@
         credentials = yield dbus_client.get_credentials()
         returnValue(credentials["token"])
 
+    @inlineCallbacks
+    def device_is_local(self, device_id):
+        """Return whether 'device_id' is the local devicew or not."""
+        dtype, did = self.type_n_id(device_id)
+        local_token = yield self.get_token()
+        is_local = (dtype == DEVICE_TYPE_COMPUTER and did == local_token)
+        logger.info('device_is_local: result %r, ', is_local)
+        returnValue(is_local)
+
     @log_call(logger.debug)
     @inlineCallbacks
     def account_info(self):
@@ -146,7 +160,6 @@
     def devices_info(self):
         """Get the user devices info."""
         result = []
-        this_token = yield self.get_token()
         limit_bw = yield dbus_client.bandwidth_throttling_enabled()
         limits = yield dbus_client.get_throttling_limits()
 
@@ -159,16 +172,22 @@
             di["configurable"] = ''
             if di["type"] == DEVICE_TYPE_COMPUTER:
                 di["device_id"] = di["type"] + d["token"]
-                if d["token"] == this_token:
-                    di["configurable"] = 'True'
-                    di["limit_bandwidth"] = 'True' if limit_bw else ''
-                    upload = limits["upload"]
-                    download = limits["download"]
-                    di[UPLOAD_KEY] = str(upload)
-                    di[DOWNLOAD_KEY] = str(download)
             if di["type"] == DEVICE_TYPE_PHONE:
                 di["device_id"] = di["type"] + str(d["id"])
 
+            is_local = yield self.device_is_local(di["device_id"])
+            di["is_local"] = bool_str(is_local)
+            # currently, only local devices are configurable.
+            # eventually, more the devices will be configurable.
+            di["configurable"] = bool_str(is_local)
+
+            if bool(di["configurable"]):
+                di["limit_bandwidth"] = bool_str(limit_bw)
+                upload = limits["upload"]
+                download = limits["download"]
+                di[UPLOAD_KEY] = str(upload)
+                di[DOWNLOAD_KEY] = str(download)
+
             # date_added is not in the webservice yet (LP: #673668)
             # di["date_added"] = ""
 
@@ -190,9 +209,7 @@
     @inlineCallbacks
     def change_device_settings(self, device_id, settings):
         """Change the settings for the given device."""
-        dtype, did = self.type_n_id(device_id)
-        local_token = yield self.get_token()
-        is_local = (dtype == DEVICE_TYPE_COMPUTER and did == local_token)
+        is_local = yield self.device_is_local(device_id)
 
         if is_local and "limit_bandwidth" in settings:
             limit_bw = bool(settings["limit_bandwidth"])
@@ -222,8 +239,16 @@
     def remove_device(self, device_id):
         """Remove a device's tokens from the sso server."""
         dtype, did = self.type_n_id(device_id)
-        api = DEVICE_REMOVE_API % (dtype, did)
+        is_local = yield self.device_is_local(device_id)
+
+        api = DEVICE_REMOVE_API % (dtype.lower(), did)
         yield self.wc.call_api(api)
+
+        if is_local:
+            logger.warning('remove_device: device is local, id %r, '
+                           'clearing credentials.', device_id)
+            yield dbus_client.clear_credentials()
+
         returnValue(device_id)
 
     @log_call(logger.debug)

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2010-12-17 17:25:10 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2010-12-18 17:42:12 +0000
@@ -48,7 +48,7 @@
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
     DBUS_PREFERENCES_IFACE)
 from ubuntuone.controlpanel.backend import (DEVICE_TYPE_PHONE,
-    DEVICE_TYPE_COMPUTER)
+    DEVICE_TYPE_COMPUTER, bool_str)
 from ubuntuone.controlpanel.logger import setup_logging, log_call
 from ubuntuone.controlpanel.utils import get_data_file
 
@@ -74,11 +74,6 @@
 KILOBYTES = 1024
 
 
-def bool_str(value):
-    """Return the string representation of a bool (dbus-compatible)."""
-    return 'True' if value else ''
-
-
 def filter_by_app_name(f):
     """Excecute 'f' filtering by app_name."""
 
@@ -187,15 +182,23 @@
         self._window_id = window_id
 
         self.management = None
-        self.overview = OverviewPanel(window_id=window_id)
+        self.overview = None
+        self.on_show_overview_panel()
+        self.show()
+
+    def on_show_overview_panel(self, widget=None):
+        """Show the overview panel."""
+        for child in self.get_children():
+            self.remove(child)
+
+        self.overview = OverviewPanel(window_id=self._window_id)
         self.overview.connect('credentials-found',
                               self.on_show_management_panel)
         self.add(self.overview)
-        self.show()
 
     def on_show_management_panel(self, widget=None,
                                  credentials_are_new=False, token=None):
-        """Show the netbook (main panel)."""
+        """Show the notebook (main panel)."""
         if self.overview in self.get_children():
             self.remove(self.overview)
 
@@ -206,6 +209,9 @@
 
             self.add(self.management)
 
+            self.management.connect('local-device-removed',
+                                    self.on_show_overview_panel)
+
 
 class UbuntuOneBin(gtk.VBox):
     """A Ubuntu One bin."""
@@ -505,10 +511,11 @@
 
 
 class Device(gtk.VBox, ControlPanelMixin):
-    """The devices panel."""
+    """The device widget."""
 
     DEVICE_CHANGE_ERROR = _('The settings could not be changed,\n'
                             'previous values were restored.')
+    DEVICE_REMOVAL_ERROR = _('The device could not be removed.')
 
     def __init__(self):
         gtk.VBox.__init__(self)
@@ -516,19 +523,25 @@
 
         self._updating = False
         self._last_settings = {}
+        self.id = None
+        self.is_local = False
         self.configurable = False
 
-        self.update(device_id='', device_name='', limit_bandwidth=False,
+        self.update(device_id=None, device_name='',
+                    is_local=False, configurable=False, limit_bandwidth=False,
                     max_upload_speed=0, max_download_speed=0)
 
         self.add(self.itself)
-        self.device_id.hide()
         self.show()
 
         self.backend.connect_to_signal('DeviceSettingsChanged',
                                        self.on_device_settings_changed)
         self.backend.connect_to_signal('DeviceSettingsChangeError',
                                        self.on_device_settings_change_error)
+        self.backend.connect_to_signal('DeviceRemoved',
+                                       self.on_device_removed)
+        self.backend.connect_to_signal('DeviceRemovalError',
+                                       self.on_device_removal_error)
 
     def _change_device_settings(self, *args):
         """Update backend settings for this device."""
@@ -538,8 +551,7 @@
         # Not disabling the GUI to avoid annyong twitchings
         #self.set_sensitive(False)
         self.warning_label.set_text('')
-        self.backend.change_device_settings(self.device_id.get_text(),
-                                            self.__dict__)
+        self.backend.change_device_settings(self.id, self.__dict__)
 
     def _block_signals(f):
         """Execute 'f' while having the _updating flag set."""
@@ -563,6 +575,11 @@
     on_max_upload_speed_value_changed = _change_device_settings
     on_max_download_speed_value_changed = _change_device_settings
 
+    def on_remove_clicked(self, widget):
+        """Remove button was clicked or activated."""
+        self.backend.remove_device(self.id)
+        self.set_sensitive(False)
+
     @_block_signals
     def update(self, **kwargs):
         """Update according to named parameters.
@@ -571,6 +588,7 @@
             * device_id (string, not shown to the user)
             * device_name (string)
             * type (either DEVICE_TYPE_PHONE or DEVICE_TYPE_COMPUTER)
+            * is_local (True/False)
             * configurable (True/False)
             * if configurable, the following can be set:
                 * limit_bandwidth (True/False)
@@ -579,7 +597,7 @@
 
         """
         if 'device_id' in kwargs:
-            self.device_id.set_text(kwargs['device_id'])
+            self.id = kwargs['device_id']
 
         if 'device_name' in kwargs:
             self.device_name.set_markup('<b>%s</b>' % kwargs['device_name'])
@@ -590,6 +608,9 @@
                 self.device_type.set_from_icon_name(dtype.lower(),
                                                     gtk.ICON_SIZE_BUTTON)
 
+        if 'is_local' in kwargs:
+            self.is_local = bool(kwargs['is_local'])
+
         if 'configurable' in kwargs:
             self.configurable = bool(kwargs['configurable'])
             self.throttling.set_visible(self.configurable)
@@ -607,9 +628,10 @@
     @property
     def __dict__(self):
         result = {
-            'device_id': self.device_id.get_text(),
+            'device_id': self.id,
             'device_name': self.device_name.get_text(),
             'device_type': self.device_type.get_icon_name()[0].capitalize(),
+            'is_local': bool_str(self.is_local),
             'configurable': bool_str(self.configurable),
             'limit_bandwidth': bool_str(self.limit_bandwidth.get_active()),
             'max_upload_speed': \
@@ -622,7 +644,7 @@
     @log_call(logger.info)
     def on_device_settings_changed(self, device_id):
         """The change of this device settings succeded."""
-        if device_id != self.device_id.get_text():
+        if device_id != self.id:
             return
         self.set_sensitive(True)
         self.warning_label.set_text('')
@@ -631,12 +653,27 @@
     @log_call(logger.error)
     def on_device_settings_change_error(self, device_id, error_dict=None):
         """The change of this device settings failed."""
-        if device_id != self.device_id.get_text():
+        if device_id != self.id:
             return
         self.update(**self._last_settings)
         self._set_warning(self.DEVICE_CHANGE_ERROR, self.warning_label)
         self.set_sensitive(True)
 
+    @log_call(logger.warning)
+    def on_device_removed(self, device_id):
+        """The removal of this device succeded."""
+        if device_id != self.id:
+            return
+        self.hide()
+
+    @log_call(logger.error)
+    def on_device_removal_error(self, device_id, error_dict=None):
+        """The removal of this device failed."""
+        if device_id != self.id:
+            return
+        self._set_warning(self.DEVICE_REMOVAL_ERROR, self.warning_label)
+        self.set_sensitive(True)
+
 
 class DevicesPanel(UbuntuOneBin, ControlPanelMixin):
     """The devices panel."""
@@ -650,10 +687,14 @@
         self.add(self.itself)
         self.show()
 
+        self._devices = {}
+
         self.backend.connect_to_signal('DevicesInfoReady',
                                        self.on_devices_info_ready)
         self.backend.connect_to_signal('DevicesInfoError',
                                        self.on_devices_info_error)
+        self.backend.connect_to_signal('DeviceRemoved',
+                                       self.on_device_removed)
         self.backend.devices_info()
 
     def on_devices_info_ready(self, info):
@@ -665,11 +706,22 @@
                                                          DEVICE_TYPE_COMPUTER)
             device.update(**device_info)
             self.devices.pack_start(device)
+            self._devices[device.id] = device
 
     @log_call(logger.error)
     def on_devices_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching volumes info."""
 
+    @log_call(logger.warning)
+    def on_device_removed(self, device_id):
+        """The removal of a device succeded."""
+        if device_id in self._devices:
+            child = self._devices.pop(device_id)
+            self.devices.remove(child)
+
+            if child.is_local:
+                self.emit('local-device-removed')
+
 
 class ApplicationsPanel(UbuntuOneBin, ControlPanelMixin):
     """The applications panel."""
@@ -750,6 +802,8 @@
             self.notebook.insert_page(getattr(self, tab), position=page_num)
 
         self.folders_button.connect('clicked', lambda b: self.folders.load())
+        sig = 'local-device-removed'
+        self.devices.connect(sig, lambda widget: self.emit(sig))
 
         self.backend.account_info()
         self.backend.file_sync_status()
@@ -818,3 +872,6 @@
 gobject.signal_new('credentials-found', OverviewPanel,
                     gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                    (gobject.TYPE_BOOLEAN, gobject.TYPE_PYOBJECT))
+
+gobject.signal_new('local-device-removed', DevicesPanel,
+                    gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-17 17:25:10 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-18 17:42:12 +0000
@@ -47,19 +47,21 @@
 
 FAKE_DEVICE_INFO = {
     'device_id': '1258-6854', 'device_name': 'Baz', 'device_type': 'Computer',
-    'configurable': 'True', 'limit_bandwidth': 'True',
+    'is_local': 'True', 'configurable': 'True', 'limit_bandwidth': 'True',
     'max_upload_speed': '1000', 'max_download_speed': '72548',
 }
 
 FAKE_DEVICES_INFO = [
-    {'device_id': '0', 'name': 'Foo', 'type': 'Computer', 'configurable': ''},
-    {'device_id': '1', 'name': 'Bar', 'type': 'Phone', 'configurable': ''},
+    {'device_id': '0', 'name': 'Foo', 'type': 'Computer',
+     'is_local': '', 'configurable': ''},
+    {'device_id': '1', 'name': 'Bar', 'type': 'Phone',
+     'is_local': '', 'configurable': ''},
     {'device_id': '2', 'name': 'Z', 'type': 'Computer',
-     'configurable': 'True', 'limit_bandwidth': '',
+     'is_local': '', 'configurable': 'True', 'limit_bandwidth': '',
      'max_upload_speed': '0', 'max_download_speed': '0'},
     {'device_id': '1258-6854', 'name': 'Baz', 'type': 'Computer',
-     'configurable': 'True', 'limit_bandwidth': 'True',
-     'max_upload_speed': '1000', 'max_download_speed': '72548'},
+     'is_local': 'True', 'configurable': 'True', 'limit_bandwidth': 'True',
+     'max_upload_speed': '1000', 'max_download_speed': '72548'},  # local
 ]
 
 
@@ -128,6 +130,7 @@
     exposed_methods = [
         'account_info', 'devices_info', 'change_device_settings',
         'volumes_info', 'change_volume_settings', 'file_sync_status',
+        'remove_device',
     ]
 
 
@@ -356,6 +359,15 @@
         self.assertEqual(self.ui.management.notebook.get_current_page(),
                          self.ui.management.FOLDERS_PAGE)
 
+    def test_local_device_removed_shows_overview_panel(self):
+        """On 'local-device-removed' signal, the overview panel is shown."""
+        self.ui.overview.emit('credentials-found', True, object())
+        self.ui.management.emit('local-device-removed')
+
+        children = self.ui.get_children()
+        self.assertEqual(1, len(children))
+        self.assertTrue(children[0] is self.ui.overview)
+
 
 class UbuntuOneBinTestCase(BaseTestCase):
     """The test suite for a Ubuntu One panel."""
@@ -907,12 +919,14 @@
 
     def assert_device_equal(self, device, expected):
         """Assert that the device has the values from expected."""
-        self.assertEqual(device.device_id.get_text(),
+        self.assertEqual(device.id,
                          expected['device_id'])
         self.assertEqual(device.device_name.get_text(),
                          expected['device_name'])
         self.assertEqual(device.device_type.get_icon_name()[0],
                          expected['device_type'].lower())
+        self.assertEqual(device.is_local,
+                         bool(expected['is_local']))
         self.assertEqual(device.configurable,
                          bool(expected['configurable']))
         self.assertEqual(device.limit_bandwidth.get_active(),
@@ -927,7 +941,7 @@
         """Changing throttling settings updates the backend properly."""
         expected = self.ui.__dict__
         self.assert_backend_called('change_device_settings',
-                                   (self.ui.device_id.get_text(), expected))
+                                   (self.ui.id, expected))
         self.assertEqual(self.ui.warning_label.get_text(), '')
 
     def modify_settings(self):
@@ -961,16 +975,13 @@
         """The warning label is cleared."""
         self.assertEqual(self.ui.warning_label.get_text(), '')
 
-    def test_device_id_is_hidden(self):
-        """The device id label is hidden."""
-        self.assertFalse(self.ui.device_id.get_visible())
-
     def test_default_values(self):
         """Default values are correct."""
-        self.assertEqual(self.ui.device_id.get_text(), '')
+        self.assertEqual(self.ui.id, None)
         self.assertEqual(self.ui.device_name.get_text(), '')
         self.assertEqual(self.ui.device_type.get_icon_name()[0],
                          gui.DEVICE_TYPE_COMPUTER.lower())
+        self.assertEqual(self.ui.is_local, False)
         self.assertEqual(self.ui.configurable, False)
         self.assertEqual(self.ui.limit_bandwidth.get_active(), False)
         self.assertEqual(self.ui.max_upload_speed.get_value_as_int(), 0)
@@ -980,12 +991,6 @@
         """When updating, the backend is not called."""
         self.assertEqual(self.ui.backend._called, {})
 
-    def test_update_device_id(self):
-        """A device can be updated from a dict."""
-        value = '741-822-963'
-        self.ui.update(device_id=value)
-        self.assertEqual(value, self.ui.device_id.get_text())
-
     def test_update_device_name(self):
         """A device can be updated from a dict."""
         value = 'The death star'
@@ -1012,13 +1017,23 @@
         self.assertEqual((dtype.lower(), gui.gtk.ICON_SIZE_BUTTON),
                          self.ui.device_type.get_icon_name())
 
-    def test_update_configurable(self):
+    def test_update_is_not_local(self):
+        """A device can be updated from a dict."""
+        self.ui.update(is_local='')
+        self.assertFalse(self.ui.is_local)
+
+    def test_update_is_local(self):
+        """A device can be updated from a dict."""
+        self.ui.update(is_local='True')
+        self.assertTrue(self.ui.is_local)
+
+    def test_update_non_configurable(self):
         """A device can be updated from a dict."""
         self.ui.update(configurable='')
         self.assertFalse(self.ui.configurable)
         self.assertFalse(self.ui.throttling.get_visible())
 
-    def test_update_non_configurable(self):
+    def test_update_configurable(self):
         """A device can be updated from a dict."""
         self.ui.update(configurable='True')
         self.assertTrue(self.ui.configurable)
@@ -1073,12 +1088,15 @@
                          [self.ui.on_device_settings_changed])
         self.assertEqual(self.ui.backend._signals['DeviceSettingsChangeError'],
                          [self.ui.on_device_settings_change_error])
+        self.assertEqual(self.ui.backend._signals['DeviceRemoved'],
+                         [self.ui.on_device_removed])
+        self.assertEqual(self.ui.backend._signals['DeviceRemovalError'],
+                         [self.ui.on_device_removal_error])
 
     def test_on_device_settings_changed(self):
         """When settings were changed for this device, enable it."""
         self.modify_settings()
-        did = self.ui.device_id.get_text()
-        self.ui.on_device_settings_changed(device_id=did)
+        self.ui.on_device_settings_changed(device_id=self.ui.id)
 
         self.assertTrue(self.ui.get_sensitive())
         self.assertEqual(self.ui.warning_label.get_text(), '')
@@ -1087,8 +1105,7 @@
     def test_on_device_settings_change_after_error(self):
         """Change success after error."""
         self.modify_settings()
-        did = self.ui.device_id.get_text()
-        self.ui.on_device_settings_change_error(device_id=did)  # change failed
+        self.ui.on_device_settings_change_error(device_id=self.ui.id)  # error
 
         self.test_on_device_settings_changed()
 
@@ -1109,8 +1126,7 @@
 
         self.modify_settings()
 
-        did = self.ui.device_id.get_text()
-        self.ui.on_device_settings_change_error(device_id=did)  # change failed
+        self.ui.on_device_settings_change_error(device_id=self.ui.id)  # error
 
         self.assertTrue(self.ui.get_sensitive())
         self.assert_warning_correct(self.ui.warning_label,
@@ -1120,8 +1136,7 @@
     def test_on_device_settings_change_error_after_success(self):
         """Change error after success."""
         self.modify_settings()
-        did = self.ui.device_id.get_text()
-        self.ui.on_device_settings_changed(device_id=did)
+        self.ui.on_device_settings_changed(device_id=self.ui.id)
 
         self.test_on_device_settings_change_error()
 
@@ -1131,6 +1146,49 @@
         self.ui.on_device_settings_change_error(device_id='yudo')
         self.assertEqual(self.ui.warning_label.get_text(), '')
 
+    def test_remove(self):
+        """Clicking on remove calls the backend properly."""
+        self.ui.is_local = False
+        self.ui.remove.clicked()
+
+        self.assert_backend_called('remove_device', (self.ui.id,))
+        self.assertFalse(self.ui.get_sensitive(),
+                         'Must be disabled while removing.')
+
+    def test_on_device_removed(self):
+        """On this device removed, hide and destroy."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removed(device_id=self.ui.id)
+
+        self.assertFalse(self.ui.get_visible(),
+                         'Must not be visible after removed.')
+
+    def test_on_device_removed_other_id(self):
+        """On other device removed, do nothing."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removed(device_id='foo')
+
+        self.assertTrue(self.ui.get_visible(),
+                        'Must be visible after other device was removed.')
+
+    def test_on_device_removal_error(self):
+        """On this device removal error, re-enable and show error."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removal_error(device_id=self.ui.id)
+
+        self.assertTrue(self.ui.get_sensitive(),
+                        'Must be enabled after removal error.')
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.DEVICE_REMOVAL_ERROR)
+
+    def test_on_device_removal_error_other_id(self):
+        """On other device removal error, do nothing."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removal_error(device_id='foo')
+
+        self.assertFalse(self.ui.get_sensitive(),
+                         'Must be disabled after other device removal error.')
+
 
 class DevicesTestCase(ControlPanelMixinTestCase):
     """The test suite for the devices panel."""
@@ -1156,6 +1214,8 @@
                          [self.ui.on_devices_info_ready])
         self.assertEqual(self.ui.backend._signals['DevicesInfoError'],
                          [self.ui.on_devices_info_error])
+        self.assertEqual(self.ui.backend._signals['DeviceRemoved'],
+                         [self.ui.on_device_removed])
 
     def test_devices_info_is_requested(self):
         """The devices info is requested to the backend."""
@@ -1171,12 +1231,13 @@
         for child, device in zip(children, FAKE_DEVICES_INFO):
             self.assertIsInstance(child, gui.Device)
 
-            self.assertEqual(device['device_id'],
-                             child.device_id.get_text())
+            self.assertEqual(device['device_id'], child.id)
             self.assertEqual(device['device_name'],
                              child.device_name.get_text())
             self.assertEqual(device['device_type'].lower(),
                              child.device_type.get_icon_name()[0])
+            self.assertEqual(bool(device['is_local']),
+                             child.is_local)
             self.assertEqual(bool(device['configurable']),
                              child.configurable)
 
@@ -1190,9 +1251,51 @@
                 self.assertEqual(value,
                                  child.max_download_speed.get_value_as_int())
 
+    def test_on_devices_info_ready_have_devices_cached(self):
+        """The devices are cached for further removal."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+
+        for child in self.ui.devices.get_children():
+            self.assertTrue(self.ui._devices[child.id] is child)
+
     def test_on_devices_info_error(self):
         """The devices info couldn't be retrieved."""
         self.ui.on_devices_info_error()
+        # add test!
+
+    def test_on_device_removed(self):
+        """When a child device was removed, remove and destroy."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        did = FAKE_DEVICES_INFO[0]['device_id']
+        device = self.ui._devices[did]
+        self.ui.on_device_removed(device_id=did)
+
+        self.assertTrue(device not in self.ui.devices.get_children())
+        self.assertTrue(did not in self.ui._devices)
+
+    def test_on_local_device_removed(self):
+        """Removing the local device emits local-device-removed."""
+        self.ui.connect('local-device-removed', self._set_called)
+
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        local_device = FAKE_DEVICES_INFO[-1]
+        assert bool(local_device['is_local'])
+        local_device_id = local_device['device_id']
+        assert self.ui._devices[local_device_id].is_local
+
+        self.ui.on_device_removed(device_id=local_device_id)
+
+        self.assertEqual(self._called, ((self.ui,), {}))
+
+    def test_on_device_removed_for_no_child_device(self):
+        """On other device removed, do nothing."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        old_devices = self.ui.devices.get_children()
+
+        self.ui.on_device_removed(device_id='foo')
+
+        new_devices = self.ui.devices.get_children()
+        self.assertEqual(new_devices, old_devices)
 
 
 class ApplicationsTestCase(ControlPanelMixinTestCase):
@@ -1413,3 +1516,11 @@
         self.assert_warning_correct(self.ui.status_label,
                                     self.ui.FILE_SYNC_ERROR)
         self.assertFalse(self.ui.status_label.active)
+
+    def test_local_device_removed_is_emitted(self):
+        """Signal local-device-removed is sent when DevicesPanel emits it."""
+        self.ui.connect('local-device-removed', self._set_called)
+
+        self.ui.devices.emit('local-device-removed')
+
+        self.assertEqual(self._called, ((self.ui,), {}))

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2010-12-18 17:42:11 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2010-12-18 17:42:12 +0000
@@ -114,9 +114,11 @@
         "device_id": "ComputerABCDEF01234token",
         "name": "Ubuntu One @ darkstar",
         "type": "Computer",
+        "is_local": '',
         "configurable": '',
     },
     {
+        'is_local': 'True',
         'configurable': 'True',
         'device_id': 'ComputerABC1234DEF',
         'limit_bandwidth': '',
@@ -130,6 +132,7 @@
         "name": "Nokia E65",
         "type": "Phone",
         "configurable": '',
+        "is_local": '',
     },
 ]
 
@@ -301,6 +304,16 @@
         token = yield self.be.get_token()
         self.assertEqual(token, SAMPLE_CREDENTIALS["token"])
 
+    @inlineCallbacks
+    def test_device_is_local(self):
+        """The device_is_local returns the right result."""
+        result = yield self.be.device_is_local(self.local_token)
+        self.assertTrue(result)
+
+        did = EXPECTED_DEVICES_INFO[0]['device_id']
+        result = yield self.be.device_is_local(did)
+        self.assertFalse(result)
+
 
 class BackendAccountTestCase(BackendBasicTestCase):
     """Account tests for the backend."""
@@ -345,11 +358,23 @@
         """The remove_device method calls the right api."""
         dtype, did = "Computer", "SAMPLE-TOKEN"
         device_id = dtype + did
-        apiurl = DEVICE_REMOVE_API % (dtype, did)
+        apiurl = DEVICE_REMOVE_API % (dtype.lower(), did)
         # pylint: disable=E1101
         self.be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
         result = yield self.be.remove_device(device_id)
         self.assertEqual(result, device_id)
+        # credentials were not cleared
+        self.assertEqual(MockDBusClient.creds, SAMPLE_CREDENTIALS)
+
+    @inlineCallbacks
+    def test_remove_device_clear_credentials_if_local_device(self):
+        """The remove_device method clears the credentials if is local."""
+        apiurl = DEVICE_REMOVE_API % ('computer', SAMPLE_CREDENTIALS['token'])
+        # pylint: disable=E1101
+        self.be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
+        yield self.be.remove_device(self.local_token)
+        # credentials were cleared
+        self.assertEqual(MockDBusClient.creds, None)
 
     @inlineCallbacks
     def test_remove_device_fails(self):

=== modified file 'ubuntuone/controlpanel/webclient.py'
--- ubuntuone/controlpanel/webclient.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/webclient.py	2010-12-18 17:42:12 +0000
@@ -48,22 +48,24 @@
 
     def _handler(self, session, msg, d):
         """Handle the result of an http message."""
-        logger.debug("WebClient: got http response: %d", msg.status_code)
+        logger.debug("WebClient: got http response %d for uri %r",
+                     msg.status_code, msg.get_uri().to_string(False))
+        data = msg.response_body.data
         if msg.status_code == 200:
-            result = simplejson.loads(msg.response_body.data)
+            result = simplejson.loads(data)
             d.callback(result)
         else:
-            e = WebClientError(msg.status_code, msg)
+            e = WebClientError(msg.status_code, data)
             d.errback(e)
 
     def _call_api_with_creds(self, credentials, api_name):
         """Get a given url from the webservice with credentials."""
-        url = self.base_url + api_name
+        url = (self.base_url + api_name).encode('utf-8')
         method = "GET"
+        logger.debug("WebClient: getting url: %s, %s", method, url)
         msg = Soup.Message.new(method, url)
         add_oauth_headers(msg.request_headers.append, method, url, credentials)
         d = defer.Deferred()
-        logger.debug("WebClient: getting url: %s", url)
         self.session.queue_message(msg, self._handler, d)
         return d