Merge lp:~nataliabidart/ubuntuone-control-panel/applications-woohoo into lp:ubuntuone-control-panel

[Natalia Bidart]

* renamed Account to Dashboard
* renamed Applications to Services
* added enable_files/disable_files to backend + dbus service
* added a new dbus signal FileSyncStatusChanged
* desktopcouch replication exclusion layer is acceded directly on the GUI. We should later move that to the backend.
* a new module package_manager was added to the gtk package, since we need to do some deeper work to abstract that manager from the toolkit (since it uses a gtk progress bar)(LP: #673673).
* a new widget InstallPackage that provides package installation.
* widgets FilesService and DesktopcouchService that can be re used as needed.
* ServicesPanel checks for depenencies and creates widget as necessary (LP: #673672).

This is an epic branch, I know, please don't hate me. Think on the good things, we have a full featured control panel!

This branch implements all bits needed to list the services offered and install package dependencies if needed.

What was done:

(see commit message for the full list)

All this is tested with code and was tested IRL.

To run the tests, do:

./run-tests

To test IRL:

* uninstall desktopcouch, xul-ext-bindwood, evolution-couchdb
* on terminal 1: DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-backend
* on terminal 2: DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-gtk

Got to the Services tab, and install desktopcouch using the same UI, and then install (if you want) the bindwood and evocouch packages.

[Natalia Bidart (nataliabidart)]

Need to handle the case where the pairing record is not present:

  File "/home/ralsina/canonical/ubuntuone/woo/ubuntuone/controlpanel/logger.py", line 75, in inner
    res = f(*args, **kwargs)
  File "/home/ralsina/canonical/ubuntuone/woo/ubuntuone/controlpanel/gtk/gui.py", line 992, in load_replications
    self.replication_service = self.replication_exclusion_class()
  File "/usr/lib/pymodules/python2.7/desktopcouch/application/replication_services/ubuntuone.py", line 140, in __init__
    raise ValueError("No pairing record for ubuntuone.")
ValueError: No pairing record for ubuntuone.

[Natalia Bidart (nataliabidart)]

Code to properly handle ValueError is now in place. The lack of a pairing record with Ubuntu One should be handled in the pairing_ubuntuone plugin of desktopcouch, see bug #694495.

[Natalia Bidart (nataliabidart)]

Just filled bug #696782 to make the DC service starts on the backend.

[lp:~nataliabidart/ubuntuone-control-panel/applications-woohoo]

53. By Natalia Bidart on 2011-01-03

aptdaemon.defer on natty is just defer.

54. By Natalia Bidart on 2011-01-03

Proper namespace for defer.

55. By Natalia Bidart on 2011-01-03

Avoiding lint warnings.

[John Lenton (chipaca)]

review: Approve

[Roberto Alsina (ralsina)]

Approved.

review: Approve

=== renamed file 'data/account.ui' => 'data/dashboard.ui'
=== added file 'data/install.ui'
--- data/install.ui	1970-01-01 00:00:00 +0000
+++ data/install.ui	2011-01-03 14:24:42 +0000
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk+" version="2.16"/>
+  <!-- interface-naming-policy project-wide -->
+  <object class="GtkVBox" id="itself">
+    <property name="visible">True</property>
+    <property name="border_width">10</property>
+    <property name="spacing">10</property>
+    <child>
+      <object class="GtkLabel" id="install_label">
+        <property name="visible">True</property>
+        <property name="xalign">0</property>
+        <property name="label">label</property>
+        <property name="wrap">True</property>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkHButtonBox" id="install_button_box">
+        <property name="visible">True</property>
+        <child>
+          <object class="GtkButton" id="install_button">
+            <property name="label">gtk-ok</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <property name="use_stock">True</property>
+            <signal name="clicked" handler="on_install_button_clicked"/>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+</interface>

=== modified file 'data/management.ui'
--- data/management.ui	2010-12-20 20:23:57 +0000
+++ data/management.ui	2011-01-03 14:24:42 +0000
@@ -64,8 +64,8 @@
                         <property name="visible">True</property>
                         <property name="layout_style">center</property>
                         <child>
-                          <object class="GtkRadioButton" id="account_button">
-                            <property name="label" translatable="yes">Account</property>
+                          <object class="GtkRadioButton" id="dashboard_button">
+                            <property name="label" translatable="yes">Dashboard</property>
                             <property name="visible">True</property>
                             <property name="can_focus">True</property>
                             <property name="receives_default">False</property>
@@ -85,7 +85,7 @@
                             <property name="can_focus">True</property>
                             <property name="receives_default">False</property>
                             <property name="draw_indicator">False</property>
-                            <property name="group">account_button</property>
+                            <property name="group">dashboard_button</property>
                           </object>
                           <packing>
                             <property name="expand">False</property>
@@ -100,7 +100,7 @@
                             <property name="can_focus">True</property>
                             <property name="receives_default">False</property>
                             <property name="draw_indicator">False</property>
-                            <property name="group">account_button</property>
+                            <property name="group">dashboard_button</property>
                           </object>
                           <packing>
                             <property name="expand">False</property>
@@ -109,13 +109,13 @@
                           </packing>
                         </child>
                         <child>
-                          <object class="GtkRadioButton" id="applications_button">
-                            <property name="label" translatable="yes">Applications</property>
+                          <object class="GtkRadioButton" id="services_button">
+                            <property name="label" translatable="yes">Services</property>
                             <property name="visible">True</property>
                             <property name="can_focus">True</property>
                             <property name="receives_default">False</property>
                             <property name="draw_indicator">False</property>
-                            <property name="group">account_button</property>
+                            <property name="group">dashboard_button</property>
                           </object>
                           <packing>
                             <property name="expand">False</property>

=== renamed file 'data/applications.ui' => 'data/services.ui'
--- data/applications.ui	2010-10-21 21:14:24 +0000
+++ data/services.ui	2011-01-03 14:24:42 +0000
@@ -7,7 +7,63 @@
     <property name="border_width">10</property>
     <property name="spacing">10</property>
     <child>
-      <placeholder/>
+      <object class="GtkScrolledWindow" id="scrolledwindow1">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="hscrollbar_policy">automatic</property>
+        <property name="vscrollbar_policy">automatic</property>
+        <child>
+          <object class="GtkViewport" id="viewport1">
+            <property name="visible">True</property>
+            <property name="resize_mode">queue</property>
+            <property name="shadow_type">none</property>
+            <child>
+              <object class="GtkVBox" id="vbox1">
+                <property name="visible">True</property>
+                <child>
+                  <object class="GtkAlignment" id="alignment1">
+                    <property name="visible">True</property>
+                    <child>
+                      <object class="GtkVBox" id="replications">
+                        <property name="visible">True</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <placeholder/>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkAlignment" id="alignment2">
+                    <property name="visible">True</property>
+                    <child>
+                      <object class="GtkVBox" id="files">
+                        <property name="visible">True</property>
+                        <property name="spacing">5</property>
+                        <child>
+                          <placeholder/>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
     </child>
   </object>
 </interface>

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2010-12-22 13:20:20 +0000
+++ po/POTFILES.in	2011-01-03 14:24:42 +0000
@@ -1,6 +1,7 @@
 ubuntuone/controlpanel/gtk/gui.py
-[type: gettext/glade] data/account.ui
-[type: gettext/glade] data/applications.ui
+[type: gettext/glade] data/dashboard.ui
+[type: gettext/glade] data/services.ui
+[type: gettext/glade] data/device.ui
 [type: gettext/glade] data/devices.ui
 [type: gettext/glade] data/management.ui
 [type: gettext/glade] data/overview.ui

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2010-12-18 20:16:18 +0000
+++ ubuntuone/controlpanel/backend.py	2011-01-03 14:24:42 +0000
@@ -273,6 +273,18 @@
 
     @log_call(logger.debug)
     @inlineCallbacks
+    def enable_files(self):
+        """Enable the files service."""
+        yield dbus_client.set_files_sync_enabled(True)
+
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def disable_files(self):
+        """Enable the files service."""
+        yield dbus_client.set_files_sync_enabled(False)
+
+    @log_call(logger.debug)
+    @inlineCallbacks
     def volumes_info(self):
         """Get the volumes info."""
         result = yield dbus_client.get_folders()

=== modified file 'ubuntuone/controlpanel/dbus_service.py'
--- ubuntuone/controlpanel/dbus_service.py	2010-12-16 21:09:46 +0000
+++ ubuntuone/controlpanel/dbus_service.py	2011-01-03 14:24:42 +0000
@@ -209,6 +209,8 @@
         else:
             self.FileSyncStatusError(error_handler(status_dict))
 
+        self.FileSyncStatusChanged(status)
+
     @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def file_sync_status(self):
@@ -242,6 +244,11 @@
     def FileSyncStatusIdle(self, msg):
         """The file sync service is idle."""
 
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusChanged(self, msg):
+        """The file sync service status changed."""
+
     @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def FileSyncStatusError(self, error):
@@ -251,6 +258,46 @@
 
     @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def enable_files(self):
+        """Enable the files service."""
+        d = self.backend.enable_files()
+        d.addCallback(lambda _: self.FilesEnabled())
+        d.addErrback(transform_failure(self.FilesEnableError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesEnabled(self):
+        """The files service is enabled."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesEnableError(self, error):
+        """Problem enabling the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
+    def disable_files(self):
+        """Disable the files service."""
+        d = self.backend.disable_files()
+        d.addCallback(lambda _: self.FilesDisabled())
+        d.addErrback(transform_failure(self.FilesDisableError))
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE)
+    def FilesDisabled(self):
+        """The files service is disabled."""
+
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
+    def FilesDisableError(self, error):
+        """Problem disabling the files service."""
+
+    #---
+
+    @log_call(logger.debug)
+    @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def volumes_info(self):
         """Find out the volumes info for the logged in user."""
         d = self.backend.volumes_info()

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2010-12-20 21:55:49 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2011-01-03 14:24:42 +0000
@@ -46,12 +46,13 @@
 from ubuntuone.controlpanel.gtk.widgets import GreyableBin
 
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
-    DBUS_PREFERENCES_IFACE)
+    DBUS_PREFERENCES_IFACE, backend)
 from ubuntuone.controlpanel.backend import (DEVICE_TYPE_PHONE,
     DEVICE_TYPE_COMPUTER, bool_str)
 from ubuntuone.controlpanel.logger import setup_logging, log_call
 from ubuntuone.controlpanel.utils import get_data_file
 
+from ubuntuone.controlpanel.gtk import package_manager
 
 logger = setup_logging('gtk.gui')
 _ = gettext.gettext
@@ -149,7 +150,7 @@
 class ControlPanelWindow(gtk.Window):
     """The main window for the Ubuntu One control panel."""
 
-    TITLE = _('My %(app_name)s Account')
+    TITLE = _('My %(app_name)s Dashboard')
 
     def __init__(self):
         super(ControlPanelWindow, self).__init__()
@@ -410,8 +411,8 @@
             self.sso_backend.find_credentials(U1_APP_NAME, {})
 
 
-class AccountPanel(UbuntuOneBin, ControlPanelMixin):
-    """The account panel. The user can manage the subscription."""
+class DashboardPanel(UbuntuOneBin, ControlPanelMixin):
+    """The dashboard panel. The user can manage the subscription."""
 
     TITLE = _('Welcome to Ubuntu One!')
     NAME = _('Name')
@@ -420,7 +421,7 @@
 
     def __init__(self):
         UbuntuOneBin.__init__(self)
-        ControlPanelMixin.__init__(self, filename='account.ui')
+        ControlPanelMixin.__init__(self, filename='dashboard.ui')
         self.add(self.itself)
         self.show()
 
@@ -750,26 +751,276 @@
         self.message.start()
 
 
-class ApplicationsPanel(UbuntuOneBin, ControlPanelMixin):
-    """The applications panel."""
+class InstallPackage(gtk.VBox, ControlPanelMixin):
+    """A widget to process the install of a package."""
+
+    INSTALL_PACKAGE = _('You need to install the package <i>%(package_name)s'
+                        '</i> in order to enable replication.')
+    INSTALLING = _('The package <i>%(package_name)s</i> is being installed, '
+                   'please wait...')
+    FAILED_INSTALL = _('The installation of <i>%(package_name)s</i> failed.')
+    SUCCESS_INSTALL = _('The installation of <i>%(package_name)s</i> '
+                        'was successful.')
+
+    def __init__(self, package_name):
+        gtk.VBox.__init__(self)
+        ControlPanelMixin.__init__(self, filename='install.ui')
+        self.add(self.itself)
+
+        self.package_name = package_name
+        self.package_manager = package_manager.PackageManager()
+        self.args = {'package_name': self.package_name}
+        self.transaction = None
+
+        self.progress_bar = None
+        self.install_label.set_markup(self.INSTALL_PACKAGE % self.args)
+
+        self.show()
+
+    @package_manager.inline_callbacks
+    def on_install_button_clicked(self, button):
+        """The install button was clicked."""
+        try:
+            # create the install transaction
+            self.transaction = yield self.package_manager.install(
+                                    self.package_name)
+
+            # create the progress bar and pack it to the box
+            self.progress_bar = package_manager.PackageManagerProgressBar(
+                                    self.transaction)
+            self.progress_bar.show()
+
+            self.itself.remove(self.install_button_box)
+            self.itself.pack_start(self.progress_bar)
+
+            self.transaction.connect('finished', self.on_install_finished)
+            self.install_label.set_markup(self.INSTALLING % self.args)
+            yield self.transaction.run()
+        except:  # pylint: disable=W0702
+            self._set_warning(self.FAILED_INSTALL % self.args,
+                              self.install_label)
+
+    @log_call(logger.info)
+    def on_install_finished(self, transaction, exit_code):
+        """The installation finished."""
+        self.progress_bar.set_sensitive(False)
+
+        if exit_code != package_manager.aptdaemon.enums.EXIT_SUCCESS:
+            if hasattr(transaction, 'error'):
+                logger.error('transaction failed: %r', transaction.error)
+            self._set_warning(self.FAILED_INSTALL % self.args,
+                              self.install_label)
+        else:
+            self.install_label.set_markup(self.SUCCESS_INSTALL % self.args)
+            self.emit('finished')
+
+
+class Service(gtk.VBox, ControlPanelMixin):
+    """A service."""
+
+    def __init__(self, name, localized_name, *args, **kwargs):
+        gtk.VBox.__init__(self)
+        ControlPanelMixin.__init__(self)
+        self.service_name = name
+
+        self.button = gtk.CheckButton(label=localized_name)
+        self.pack_start(self.button, expand=False)
+
+        self.show_all()
+
+
+class FilesService(Service):
+    """The file sync service."""
+
+    FILES_SERVICE_NAME = _('Files')
+
+    def __init__(self):
+        Service.__init__(self, name='files',
+                         localized_name=self.FILES_SERVICE_NAME)
+
+        self.set_sensitive(False)
+        self.backend.connect_to_signal('FileSyncStatusChanged',
+                                       self.on_file_sync_status_changed)
+        self.backend.connect_to_signal('FilesEnabled', self.on_files_enabled)
+        self.backend.connect_to_signal('FilesDisabled', self.on_files_disabled)
+        self.backend.file_sync_status()
+
+    @log_call(logger.debug)
+    def on_file_sync_status_changed(self, status):
+        """File sync status changed."""
+        enabled = status != backend.FILE_SYNC_DISABLED
+        self.button.set_active(enabled)
+
+        if not self.is_sensitive():
+            # first time we're getting this event
+            self.button.connect('toggled', self.on_button_toggled)
+            self.set_sensitive(True)
+
+    def on_files_enabled(self):
+        """Files service was enabled."""
+        self.on_file_sync_status_changed('enabled!')
+
+    def on_files_disabled(self):
+        """Files service was disabled."""
+        self.on_file_sync_status_changed(backend.FILE_SYNC_DISABLED)
+
+    @log_call(logger.debug)
+    def on_button_toggled(self, button):
+        """Button was toggled, exclude/replicate the service properly."""
+        logger.info('File sync enabled? %r', self.button.get_active())
+        if self.button.get_active():
+            self.backend.enable_files()
+        else:
+            self.backend.disable_files()
+
+
+class DesktopcouchService(Service):
+    """A desktopcouch service."""
+
+    def __init__(self, name, localized_name,
+                 replication_service, dependency=None):
+        Service.__init__(self, name, localized_name)
+        self.replication_service = replication_service
+        enabled = name not in self.replication_service.all_exclusions()
+        self.button.set_active(enabled)
+
+        self.dependency = None
+        if dependency is not None:
+            self.dependency = InstallPackage(dependency)
+            self.dependency.connect('finished', self.on_depedency_finished)
+            self.pack_start(self.dependency, expand=False)
+            self.button.set_sensitive(False)
+
+        self.button.connect('toggled', self.on_button_toggled)
+
+    def on_depedency_finished(self, widget):
+        """The dependency was installed."""
+        self.button.set_sensitive(True)
+        self.remove(self.dependency)
+        self.dependency = None
+
+    @log_call(logger.debug)
+    def on_button_toggled(self, button):
+        """Button was toggled, exclude/replicate the service properly."""
+        logger.info('Starting replication for %r? %r',
+                    self.service_name, self.button.get_active())
+        if self.button.get_active():
+            self.replication_service.replicate(self.service_name)
+        else:
+            self.replication_service.exclude(self.service_name)
+
+
+class ServicesPanel(UbuntuOneBin, ControlPanelMixin):
+    """The services panel."""
 
     TITLE = _('Ubuntu One services including data sync are enabled for the '
-              'data types and applications listed below:')
+              'data types and services listed below.')
+    CHOOSE_SERVICES = _('Choose services to synchronize with this computer:')
+    DESKTOPCOUCH_PKG = 'desktopcouch'
+    BINDWOOD_PKG = 'xul-ext-bindwood'
+    EVOCOUCH_PKG = 'evolution-couchdb'
+    BOOKMARKS = _('Bookmarks (Firefox)')
+    CONTACTS = _('Contacts (Evolution)')
+    NO_PAIRING_RECORD = _('There is no Ubuntu One pairing record.')
 
-    def __init__(self):
+    def __init__(self, replication_exclusion_class=None):
         UbuntuOneBin.__init__(self)
-        ControlPanelMixin.__init__(self, filename='applications.ui')
+        ControlPanelMixin.__init__(self, filename='services.ui')
         self.add(self.itself)
+
+        self.replication_exclusion_class = replication_exclusion_class
+        self.replication_service = None
+        self.has_desktopcouch = False
+        self.has_bindwood = False
+        self.has_evocouch = False
+        self.package_manager = package_manager.PackageManager()
+        self.install_box = None
+        self.bookmarks = None
+        self.contacts = None
+
+        self.files.pack_start(FilesService(), expand=False)
+
         self.show()
 
+    @log_call(logger.debug)
+    def load(self):
+        """Load info."""
+        if self.install_box is not None:
+            self.itself.remove(self.install_box)
+            self.install_box = None
+
+        self.has_desktopcouch = \
+            self.package_manager.is_installed(self.DESKTOPCOUCH_PKG)
+        self.has_bindwood = \
+            self.package_manager.is_installed(self.BINDWOOD_PKG)
+        self.has_evocouch = \
+            self.package_manager.is_installed(self.EVOCOUCH_PKG)
+
+        logger.info('load: has_desktopcouch? %r has_bindwood? %s '
+                    'has_evocouch? %s', self.has_desktopcouch,
+                    self.has_bindwood, self.has_evocouch)
+        if not self.has_desktopcouch:
+            self.message.set_text('')
+            self.replications.hide()
+
+            self.install_box = InstallPackage(self.DESKTOPCOUCH_PKG)
+            self.install_box.connect('finished', self.load_replications)
+            self.itself.pack_start(self.install_box, expand=False)
+            self.itself.reorder_child(self.install_box, 0)
+        else:
+            self.load_replications()
+
         self.message.stop()
-        self.message.set_text('Under construction')
+
+    @log_call(logger.debug)
+    def load_replications(self, *args):
+        """Load replications info."""
+        self.replications.show()
+
+        if self.install_box is not None:
+            self.itself.remove(self.install_box)
+            self.install_box = None
+
+        self.message.set_text(self.CHOOSE_SERVICES)
+        for child in self.replications.get_children():
+            self.replications.remove(child)
+
+        # Unable to import 'desktopcouch.application.replication_services'
+        # pylint: disable=F0401
+        if self.replication_exclusion_class is None:
+            from desktopcouch.application.replication_services import \
+                ubuntuone as u1rep
+            self.replication_exclusion_class = u1rep.ReplicationExclusion
+
+        if self.replication_service is None:
+            try:
+                self.replication_service = self.replication_exclusion_class()
+            except ValueError:
+                logger.exception('Can not load replications:')
+                self._set_warning(self.NO_PAIRING_RECORD, self.message)
+                return
+
+        pkg = None
+        if not self.has_bindwood:
+            pkg = self.BINDWOOD_PKG
+        self.bookmarks = DesktopcouchService('bookmarks', self.BOOKMARKS,
+                                             self.replication_service,
+                                             dependency=pkg)
+        self.replications.pack_start(self.bookmarks, expand=False)
+
+        pkg = None
+        if not self.has_evocouch:
+            pkg = self.EVOCOUCH_PKG
+        self.contacts = DesktopcouchService('contacts', self.CONTACTS,
+                                            self.replication_service,
+                                            dependency=pkg)
+        self.replications.pack_start(self.contacts, expand=False)
 
 
 class ManagementPanel(gtk.VBox, ControlPanelMixin):
     """The management panel.
 
-    The user can manage account, folders, devices and applications.
+    The user can manage dashboard, folders, devices and services.
 
     """
 
@@ -817,13 +1068,13 @@
         self.status_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
         self.status_box.pack_end(self.status_label, expand=False)
 
-        self.account = AccountPanel()
+        self.dashboard = DashboardPanel()
         self.folders = FoldersPanel()
         self.devices = DevicesPanel()
-        self.applications = ApplicationsPanel()
+        self.services = ServicesPanel()
 
         cb = lambda button, page_num: self.notebook.set_current_page(page_num)
-        self.tabs = (u'account', u'folders', u'devices', u'applications')
+        self.tabs = (u'dashboard', u'folders', u'devices', u'services')
         for page_num, tab in enumerate(self.tabs):
             setattr(self, ('%s_page' % tab).upper(), page_num)
             button = getattr(self, '%s_button' % tab)
@@ -835,6 +1086,7 @@
 
         self.folders_button.connect('clicked', lambda b: self.folders.load())
         self.devices_button.connect('clicked', lambda b: self.devices.load())
+        self.services_button.connect('clicked', lambda b: self.services.load())
         self.devices.connect('local-device-removed',
                              lambda widget: self.emit('local-device-removed'))
 
@@ -857,7 +1109,7 @@
         """Load the account info and file sync status list."""
         self.backend.account_info()
         self.backend.file_sync_status()
-        self.account_button.clicked()
+        self.dashboard_button.clicked()
 
     @log_call(logger.debug)
     def on_account_info_ready(self, info):
@@ -910,3 +1162,6 @@
 
 gobject.signal_new('local-device-removed', DevicesPanel,
                     gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
+
+gobject.signal_new('finished', InstallPackage,
+                    gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())

=== added file 'ubuntuone/controlpanel/gtk/package_manager.py'
--- ubuntuone/controlpanel/gtk/package_manager.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gtk/package_manager.py	2011-01-03 14:24:42 +0000
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Client to manage packages."""
+
+import apt
+import aptdaemon.client
+import aptdaemon.enums
+
+try:
+    # Unable to import 'defer', pylint: disable=F0401,E0611
+    from aptdaemon.defer import inline_callbacks, return_value
+except ImportError:
+    # Unable to import 'defer', pylint: disable=F0401,E0611
+    from defer import inline_callbacks, return_value
+from aptdaemon.gtkwidgets import AptProgressBar
+
+from ubuntuone.controlpanel.logger import setup_logging
+
+
+logger = setup_logging('package_manager')
+
+
+class PackageManagerProgressBar(AptProgressBar):
+    """A progress bar for a transaction."""
+
+
+class PackageManager(object):
+    """Manage packages (check if is installed, install)."""
+
+    def is_installed(self, package_name):
+        """Return whether 'package_name' is installed in this system."""
+        cache = apt.Cache()
+        result = package_name in cache and cache[package_name].is_installed
+        return result
+
+    @inline_callbacks
+    def install(self, package_name):
+        """Install 'package_name' if is not installed in this system."""
+        if self.is_installed(package_name):
+            return_value(aptdaemon.enums.EXIT_SUCCESS)
+
+        client = aptdaemon.client.AptClient()
+        transaction = yield client.install_packages([package_name])
+        return_value(transaction)

=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2011-01-03 14:24:42 +0000
@@ -17,3 +17,153 @@
 # 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 collections import defaultdict
+
+from ubuntuone.controlpanel.gtk import gui
+from ubuntuone.controlpanel.gtk.tests.test_package_manager import (
+    FakedTransaction)
+
+
+FAKE_ACCOUNT_INFO = {'type': 'Payed', 'name': 'Test me',
+    'email': 'test.com', 'quota_total': '12345', 'quota_used': '9999'}
+
+FAKE_VOLUMES_INFO = [
+    {'volume_id': '0', 'suggested_path': '~/foo', 'subscribed': ''},
+    {'volume_id': '1', 'suggested_path': '~/bar', 'subscribed': 'True'},
+    {'volume_id': '2', 'suggested_path': '~/baz', 'subscribed': 'True'},
+]
+
+FAKE_DEVICE_INFO = {
+    'device_id': '1258-6854', 'device_name': 'Baz', 'device_type': 'Computer',
+    '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',
+     'is_local': '', 'configurable': ''},
+    {'device_id': '1', 'name': 'Bar', 'type': 'Phone',
+     'is_local': '', 'configurable': ''},
+    {'device_id': '2', 'name': 'Z', 'type': 'Computer',
+     'is_local': '', 'configurable': 'True', 'limit_bandwidth': '',
+     'max_upload_speed': '0', 'max_download_speed': '0'},
+    {'device_id': '1258-6854', 'name': 'Baz', 'type': 'Computer',
+     'is_local': 'True', 'configurable': 'True', 'limit_bandwidth': 'True',
+     'max_upload_speed': '1000', 'max_download_speed': '72548'},  # local
+]
+
+
+class FakedObject(object):
+    """Fake an object, record every call."""
+
+    exposed_methods = []
+
+    def __init__(self, *args, **kwargs):
+        self._args = args
+        self._kwargs = kwargs
+        self._called = {}
+        for i in self.exposed_methods:
+            setattr(self, i, self._record_call(i))
+
+    def _record_call(self, func_name):
+        """Store values when calling 'func_name'."""
+
+        def inner(*args, **kwargs):
+            """Fake 'func_name'."""
+            self._called[func_name] = (args, kwargs)
+
+        return inner
+
+
+class FakedNMState(FakedObject):
+    """Fake a NetworkManagerState."""
+
+    exposed_methods = ['find_online_state']
+
+
+class FakedDBusBackend(FakedObject):
+    """Fake a DBus Backend."""
+
+    bus_name = None
+    object_path = None
+    iface = None
+
+    def __init__(self, obj, dbus_interface, *args, **kwargs):
+        if dbus_interface != self.iface:
+            raise TypeError()
+        self._signals = defaultdict(list)
+        super(FakedDBusBackend, self).__init__(*args, **kwargs)
+
+    def connect_to_signal(self, signal, handler):
+        """Bind 'handler' to be callback'd when 'signal' is fired."""
+        self._signals[signal].append(handler)
+
+
+class FakedSSOBackend(FakedDBusBackend):
+    """Fake a SSO Backend, act as a dbus.Interface."""
+
+    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']
+
+
+class FakedControlPanelBackend(FakedDBusBackend):
+    """Fake a Control Panel Backend, act as a dbus.Interface."""
+
+    bus_name = gui.DBUS_BUS_NAME
+    object_path = gui.DBUS_PREFERENCES_PATH
+    iface = gui.DBUS_PREFERENCES_IFACE
+    exposed_methods = [
+        'account_info', 'devices_info', 'change_device_settings',
+        'volumes_info', 'change_volume_settings', 'file_sync_status',
+        'remove_device', 'enable_files', 'disable_files',
+    ]
+
+
+class FakedSessionBus(object):
+    """Fake a session bus."""
+
+    def get_object(self, bus_name, object_path, introspect=True,
+                   follow_name_owner_changes=False, **kwargs):
+        """Return a faked proxy for the given remote object."""
+        return None
+
+
+class FakedInterface(object):
+    """Fake a dbus interface."""
+
+    def __new__(cls, obj, dbus_interface, *args, **kwargs):
+        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)
+
+
+class FakedPackageManager(object):
+    """Faked a package manager."""
+
+    def __init__(self):
+        self._installed = {}
+        self.is_installed = lambda package_name: \
+            self._installed.setdefault(package_name, False)
+
+    @gui.package_manager.inline_callbacks
+    def install(self, package_name):
+        """Install 'package_name' if is not installed in this system."""
+        yield
+        self._installed[package_name] = True
+        gui.package_manager.return_value(FakedTransaction([package_name]))
+
+
+class FakedReplication(object):
+    """Faked a DC replication exclusion."""
+
+    def __init__(self):
+        self._exclusions = set()
+        self.all_exclusions = lambda: self._exclusions
+        self.replicate = self._exclusions.remove
+        self.exclude = self._exclusions.add

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-20 20:58:39 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-01-03 14:24:42 +0000
@@ -22,136 +22,21 @@
 
 import logging
 
-from collections import defaultdict
-
 from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.controlpanel.gtk import gui
+from ubuntuone.controlpanel.gtk.tests import (FAKE_ACCOUNT_INFO,
+    FAKE_VOLUMES_INFO, FAKE_DEVICE_INFO, FAKE_DEVICES_INFO,
+    FakedNMState, FakedSSOBackend, FakedSessionBus, FakedInterface,
+    FakedPackageManager, FakedReplication,
+)
 from ubuntuone.controlpanel.tests import TOKEN, TestCase
-
-# Attribute 'yyy' defined outside __init__
-# pylint: disable=W0201
-
-# Access to a protected member 'yyy' of a client class
-# pylint: disable=W0212
-
-
-FAKE_ACCOUNT_INFO = {'type': 'Payed', 'name': 'Test me',
-    'email': 'test.com', 'quota_total': '12345', 'quota_used': '9999'}
-
-FAKE_VOLUMES_INFO = [
-    {'volume_id': '0', 'suggested_path': '~/foo', 'subscribed': ''},
-    {'volume_id': '1', 'suggested_path': '~/bar', 'subscribed': 'True'},
-    {'volume_id': '2', 'suggested_path': '~/baz', 'subscribed': 'True'},
-]
-
-FAKE_DEVICE_INFO = {
-    'device_id': '1258-6854', 'device_name': 'Baz', 'device_type': 'Computer',
-    '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',
-     'is_local': '', 'configurable': ''},
-    {'device_id': '1', 'name': 'Bar', 'type': 'Phone',
-     'is_local': '', 'configurable': ''},
-    {'device_id': '2', 'name': 'Z', 'type': 'Computer',
-     'is_local': '', 'configurable': 'True', 'limit_bandwidth': '',
-     'max_upload_speed': '0', 'max_download_speed': '0'},
-    {'device_id': '1258-6854', 'name': 'Baz', 'type': 'Computer',
-     'is_local': 'True', 'configurable': 'True', 'limit_bandwidth': 'True',
-     'max_upload_speed': '1000', 'max_download_speed': '72548'},  # local
-]
-
-
-class FakedObject(object):
-    """Fake an object, record every call."""
-
-    exposed_methods = []
-
-    def __init__(self, *args, **kwargs):
-        self._args = args
-        self._kwargs = kwargs
-        self._called = {}
-        for i in self.exposed_methods:
-            setattr(self, i, self._record_call(i))
-
-    def _record_call(self, func_name):
-        """Store values when calling 'func_name'."""
-
-        def inner(*args, **kwargs):
-            """Fake 'func_name'."""
-            self._called[func_name] = (args, kwargs)
-
-        return inner
-
-
-class FakedNMState(FakedObject):
-    """Fake a NetworkManagerState."""
-
-    exposed_methods = ['find_online_state']
-
-
-class FakedDBusBackend(FakedObject):
-    """Fake a DBus Backend."""
-
-    bus_name = None
-    object_path = None
-    iface = None
-
-    def __init__(self, obj, dbus_interface, *args, **kwargs):
-        if dbus_interface != self.iface:
-            raise TypeError()
-        self._signals = defaultdict(list)
-        super(FakedDBusBackend, self).__init__(*args, **kwargs)
-
-    def connect_to_signal(self, signal, handler):
-        """Bind 'handler' to be callback'd when 'signal' is fired."""
-        self._signals[signal].append(handler)
-
-
-class FakedSSOBackend(FakedDBusBackend):
-    """Fake a SSO Backend, act as a dbus.Interface."""
-
-    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']
-
-
-class FakedControlPanelBackend(FakedDBusBackend):
-    """Fake a Control Panel Backend, act as a dbus.Interface."""
-
-    bus_name = gui.DBUS_BUS_NAME
-    object_path = gui.DBUS_PREFERENCES_PATH
-    iface = gui.DBUS_PREFERENCES_IFACE
-    exposed_methods = [
-        'account_info', 'devices_info', 'change_device_settings',
-        'volumes_info', 'change_volume_settings', 'file_sync_status',
-        'remove_device',
-    ]
-
-
-class FakedSessionBus(object):
-    """Fake a session bus."""
-
-    def get_object(self, bus_name, object_path, introspect=True,
-                   follow_name_owner_changes=False, **kwargs):
-        """Return a faked proxy for the given remote object."""
-        return None
-
-
-class FakedInterface(object):
-    """Fake a dbus interface."""
-
-    def __new__(cls, obj, dbus_interface, *args, **kwargs):
-        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)
+from ubuntuone.controlpanel.gtk.tests.test_package_manager import (
+    SUCCESS, FAILURE)
+
+
+# Attribute 'yyy' defined outside __init__, access to a protected member
+# pylint: disable=W0201, W0212
 
 
 class BaseTestCase(TestCase):
@@ -168,6 +53,7 @@
         self.patch(gui.dbus, 'SessionBus', FakedSessionBus)
         self.patch(gui.dbus, 'Interface', FakedInterface)
         self.patch(gui.networkstate, 'NetworkManagerState', FakedNMState)
+        self.patch(gui.package_manager, 'PackageManager', FakedPackageManager)
 
         if self.klass is not None:
             self.ui = self.klass(**self.kwargs)
@@ -339,10 +225,10 @@
 
         self.assert_current_tab_correct(self.ui.management)
 
-    def test_credentials_found_shows_account_management_panel(self):
+    def test_credentials_found_shows_dashboard_management_panel(self):
         """On 'credentials-found' signal, the management panel is shown.
 
-        If first signal parameter is False, visible tab should be account.
+        If first signal parameter is False, visible tab should be dashboard.
 
         """
         self.patch(self.ui.management, 'load', self._set_called)
@@ -350,7 +236,7 @@
 
         self.assert_current_tab_correct(self.ui.management)
         self.assertEqual(self.ui.management.notebook.get_current_page(),
-                         self.ui.management.ACCOUNT_PAGE)
+                         self.ui.management.DASHBOARD_PAGE)
         self.assertEqual(self._called, ((), {}))
 
     def test_credentials_found_shows_folders_management_panel(self):
@@ -736,11 +622,11 @@
     messages = ['<small>Test me</small>', 'A <b>little</b> bit more']
 
 
-class AccountTestCase(ControlPanelMixinTestCase):
-    """The test suite for the account panel."""
+class DashboardTestCase(ControlPanelMixinTestCase):
+    """The test suite for the dashboard panel."""
 
-    klass = gui.AccountPanel
-    ui_filename = 'account.ui'
+    klass = gui.DashboardPanel
+    ui_filename = 'dashboard.ui'
 
     def assert_account_info_correct(self, info):
         """Check that the displayed account info matches 'info'."""
@@ -1087,7 +973,8 @@
 
     def test_on_limit_bandwidth_toggled(self):
         """When toggling limit_bandwidth, backend is updated."""
-        self.ui.limit_bandwidth.toggled()
+        value = not self.ui.limit_bandwidth.get_active()
+        self.ui.limit_bandwidth.set_active(value)
         self.assert_device_settings_changed()
 
     def test_on_max_upload_speed_value_changed(self):
@@ -1365,11 +1252,294 @@
         self.assertEqual(new_devices, old_devices)
 
 
-class ApplicationsTestCase(ControlPanelMixinTestCase):
-    """The test suite for the applications panel."""
-
-    klass = gui.ApplicationsPanel
-    ui_filename = 'applications.ui'
+class InstallPackageTestCase(ControlPanelMixinTestCase):
+    """The test suite for the install widget."""
+
+    klass = gui.InstallPackage
+    ui_filename = 'install.ui'
+    kwargs = {'package_name': 'a test package'}
+
+    def test_is_an_box(self):
+        """Inherits from gtk.VBox."""
+        self.assertIsInstance(self.ui, gui.gtk.VBox)
+
+    def test_inner_widget_is_packed(self):
+        """The 'itself' vbox is packed into the widget."""
+        self.assertIn(self.ui.itself, self.ui.get_children())
+
+    def test_is_visible(self):
+        """Is visible."""
+        self.assertTrue(self.ui.get_visible())
+
+    def test_package_name(self):
+        """The package_name is stored."""
+        self.assertEqual(self.ui.package_name, self.kwargs['package_name'])
+
+    def test_children(self):
+        """The children is correct."""
+        children = self.ui.itself.get_children()
+        self.assertEqual(len(children), 2)
+        self.assertEqual(self.ui.install_label, children[0])
+        self.assertIn(self.ui.install_button, children[1].get_children())
+
+    def test_install_label(self):
+        """The install label is correct."""
+        msg = self.ui.INSTALL_PACKAGE % self.kwargs
+        self.assertEqual(self.ui.install_label.get_label(), msg)
+
+    @gui.package_manager.inline_callbacks
+    def test_install_button_clicked_shows_progress(self):
+        """The install button is correct."""
+        yield self.ui.install_button.clicked()
+
+        children = self.ui.itself.get_children()
+        self.assertEqual(len(children), 2)
+        self.assertEqual(self.ui.progress_bar, children[1])
+        self.assertTrue(self.ui.progress_bar.get_visible())
+        self.assertIsInstance(self.ui.progress_bar,
+                              gui.package_manager.PackageManagerProgressBar)
+
+    def test_install_button_clicked_install_label(self):
+        """The install label is correct."""
+        yield self.ui.install_button.clicked()
+
+        children = self.ui.itself.get_children()
+        self.assertEqual(len(children), 2)
+        self.assertEqual(self.ui.install_label, children[0])
+        msg = self.ui.INSTALLING % self.kwargs
+        self.assertEqual(self.ui.install_label.get_label(), msg)
+
+    @gui.package_manager.inline_callbacks
+    def test_install_button_clicked_transaction(self):
+        """The install button transaction is correct."""
+        yield self.ui.install_button.clicked()
+
+        transaction = self.ui.transaction
+        self.assertTrue(transaction.packages, [self.ui.package_name])
+        self.assertIn(self.ui.on_install_finished,
+                      transaction._signals['finished'])
+        self.assertTrue(transaction.was_run)
+
+    @gui.package_manager.inline_callbacks
+    def test_install_button_clicked_fails(self):
+        """The install button transaction is correct."""
+
+        def fail(*args):
+            """Simulate an error."""
+            raise Exception(args)
+
+        self.patch(self.ui.package_manager, 'install', fail)
+        yield self.ui.install_button.clicked()
+
+        msg = self.ui.FAILED_INSTALL % self.kwargs
+        self.assert_warning_correct(self.ui.install_label, msg)
+
+    @gui.package_manager.inline_callbacks
+    def test_on_install_finished_success(self):
+        """The install finished."""
+        self.ui.connect('finished', self._set_called)
+        yield self.ui.install_button.clicked()
+        self.ui.on_install_finished(object(), SUCCESS)
+
+        self.assertFalse(self.ui.progress_bar.get_sensitive())
+        msg = self.ui.SUCCESS_INSTALL % self.kwargs
+        self.assertEqual(self.ui.install_label.get_label(), msg)
+        self.assertEqual(self._called, ((self.ui,), {}))
+
+    @gui.package_manager.inline_callbacks
+    def test_on_install_finished_failed(self):
+        """The install finished."""
+        yield self.ui.install_button.clicked()
+        self.ui.on_install_finished(object(), FAILURE)
+
+        self.assertFalse(self.ui.progress_bar.get_sensitive())
+        msg = self.ui.FAILED_INSTALL % self.kwargs
+        self.assert_warning_correct(self.ui.install_label, msg)
+
+
+class ServiceTestCase(ControlPanelMixinTestCase):
+    """The test suite for a service."""
+
+    klass = gui.Service
+    name = 'dc_test'
+    localized_name = u'Qué lindo test!'
+    kwargs = {'name': 'dc_test', 'localized_name': u'Qué lindo test!'}
+
+    def test_is_an_box(self):
+        """Inherits from gtk.VBox."""
+        self.assertIsInstance(self.ui, gui.gtk.VBox)
+
+    def test_is_visible(self):
+        """Is visible."""
+        self.assertTrue(self.ui.get_visible())
+
+    def test_check_button_packed(self):
+        """A check button is packed as only child."""
+        self.assertIn(self.ui.button, self.ui.get_children())
+
+    def test_label(self):
+        """The label is set."""
+        self.assertEqual(self.localized_name, self.ui.button.get_label())
+
+    def test_service_name(self):
+        """The service_name is set."""
+        self.assertEqual(self.name, self.ui.service_name)
+
+
+class FilesServiceTestCase(ServiceTestCase):
+    """The test suite for the file sync service."""
+
+    klass = gui.FilesService
+    kwargs = {}
+
+    def setUp(self):
+        self.name = 'files'
+        self.localized_name = gui.FilesService.FILES_SERVICE_NAME
+        super(FilesServiceTestCase, self).setUp()
+
+    def test_backend_account_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.backend._signals['FileSyncStatusChanged'],
+                         [self.ui.on_file_sync_status_changed])
+        self.assertEqual(self.ui.backend._signals['FilesEnabled'],
+                         [self.ui.on_files_enabled])
+        self.assertEqual(self.ui.backend._signals['FilesDisabled'],
+                         [self.ui.on_files_disabled])
+
+    def test_file_sync_status_is_requested(self):
+        """The file sync status is requested to the backend."""
+        self.assert_backend_called('file_sync_status', ())
+
+    def test_is_disabled(self):
+        """Until file sync status is given, the widget is disabled."""
+        self.assertFalse(self.ui.get_sensitive())
+
+    def test_is_enabled_on_file_sync_status_changed(self):
+        """When the file sync status is given, the widget is enabled."""
+        self.ui.on_file_sync_status_changed('something')
+        self.assertTrue(self.ui.get_sensitive())
+
+    def test_active(self):
+        """Is active when file status is anything but 'file-sync-disabled'."""
+        self.ui.on_file_sync_status_changed('something not disabled')
+        self.assertTrue(self.ui.button.get_active())
+
+    def test_not_active(self):
+        """Is not active when status is exactly but 'file-sync-disabled'."""
+        self.ui.on_file_sync_status_changed(gui.backend.FILE_SYNC_DISABLED)
+        self.assertFalse(self.ui.button.get_active())
+
+    def test_on_button_toggled(self):
+        """When toggling the button, the file sync service is updated."""
+        self.ui.on_file_sync_status_changed('something not disabled')
+        assert self.ui.button.get_active()
+
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.assert_backend_called('disable_files', ())
+
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.assert_backend_called('enable_files', ())
+
+    def test_on_file_sync_enabled(self):
+        """When file sync is enabled, the button is active."""
+        self.ui.on_files_disabled()
+        assert not self.ui.button.get_active()
+
+        self.ui.on_files_enabled()
+        self.assertTrue(self.ui.button.get_active())
+
+    def test_on_file_sync_disabled(self):
+        """When file sync is disabled, the button is not active."""
+        self.ui.on_files_enabled()
+        assert self.ui.button.get_active()
+
+        self.ui.on_files_disabled()
+        self.assertFalse(self.ui.button.get_active())
+
+
+class DesktopcouchServiceTestCase(ServiceTestCase):
+    """The test suite for a desktopcouch service."""
+
+    klass = gui.DesktopcouchService
+
+    def setUp(self):
+        self.replication = FakedReplication()
+        self.name = self.kwargs['name']
+        self.kwargs['replication_service'] = self.replication
+        super(DesktopcouchServiceTestCase, self).setUp()
+
+    def test_active(self):
+        """Is active since replication has an empty database."""
+        self.assertTrue(self.ui.button.get_active())
+
+    def test_not_active(self):
+        """Is not active since 'name' is excluded on replication database."""
+        self.replication.exclude(self.name)
+        self.ui = self.klass(**self.kwargs)
+        self.assertFalse(self.ui.button.get_active())
+
+    def test_on_button_toggled(self):
+        """When toggling the button, the DC exclude list is updated."""
+        assert self.ui.button.get_active()
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.assertEqual(set([self.name]), self.replication.all_exclusions())
+
+    def test_on_button_toggled_twice(self):
+        """When toggling the button twice, the DC exclude list is updated."""
+        assert self.ui.button.get_active()
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.ui.button.set_active(not self.ui.button.get_active())
+        self.assertEqual(set(), self.replication.all_exclusions())
+
+    def test_dependency(self):
+        """The dependency box is None."""
+        self.assertTrue(self.ui.dependency is None)
+
+    def test_button_sensitiveness(self):
+        """The check button is sensitive."""
+        self.assertTrue(self.ui.button.get_sensitive())
+
+
+class DesktopcouchServiceWithDependencyTestCase(DesktopcouchServiceTestCase):
+    """The test suite for a desktopcouch service when it needs a dependency."""
+
+    def setUp(self):
+        self.kwargs['dependency'] = 'a package'
+        super(DesktopcouchServiceWithDependencyTestCase, self).setUp()
+
+    def test_dependency(self):
+        """The dependency bos is not hidden."""
+        self.assertIsInstance(self.ui.dependency, gui.InstallPackage)
+        self.assertEqual(self.ui.dependency.package_name,
+                         self.kwargs['dependency'])
+
+    def test_dependency_is_packed(self):
+        """The dependency is packed in the ui."""
+        self.assertIn(self.ui.dependency, self.ui.get_children())
+
+    def test_button_sensitiveness(self):
+        """The check button is not sensitive until depedency installed."""
+        self.assertFalse(self.ui.button.get_sensitive())
+
+    def test_button_is_enabled_on_dependency_installed(self):
+        """The check button is sensitive when depedency is installed."""
+        self.ui.dependency.emit('finished')
+
+        self.assertTrue(self.ui.button.get_sensitive())
+
+    def test_install_widget_is_removed_on_dependency_installed(self):
+        """The install button is removed when depedency is installed."""
+        self.ui.dependency.emit('finished')
+
+        self.assertTrue(self.ui.dependency is None)
+        self.assertEqual(self.ui.get_children(), [self.ui.button])
+
+
+class ServicesTestCase(ControlPanelMixinTestCase):
+    """The test suite for the services panel."""
+
+    klass = gui.ServicesPanel
+    ui_filename = 'services.ui'
 
     def test_is_an_ubuntuone_bin(self):
         """Inherits from UbuntuOneBin."""
@@ -1383,6 +1553,200 @@
         """Is visible."""
         self.assertTrue(self.ui.get_visible())
 
+    def test_package_manager(self):
+        """Has a package manager."""
+        self.assertIsInstance(self.ui.package_manager,
+                              gui.package_manager.PackageManager)
+
+    def test_install_box(self):
+        """The install box is None."""
+        self.assertTrue(self.ui.install_box is None)
+
+
+class ServicesFilesTestCase(ServicesTestCase):
+    """The test suite for the services panel (files section)."""
+
+    def test_files_is_visible(self):
+        """Files section is visible."""
+        self.assertTrue(self.ui.files.get_visible())
+
+    def test_files_is_a_file_sync_service(self):
+        """Files contains a FilesService."""
+        child, = self.ui.files.get_children()
+        self.assertIsInstance(child, gui.FilesService)
+
+
+class ServicesWithoutDesktopcouchTestCase(ServicesTestCase):
+    """The test suite for the services panel when DC is not installed."""
+
+    def setUp(self):
+        super(ServicesWithoutDesktopcouchTestCase, self).setUp()
+        self.patch(self.ui.package_manager, 'is_installed', lambda *a: False)
+        self.ui.load()
+
+    def test_message(self):
+        """Global load message is stopped and cleared."""
+        self.assertFalse(self.ui.message.active)
+        self.assertEqual(self.ui.message.get_text(), '')
+
+    def test_replication_service(self):
+        """Has a replication service."""
+        self.assertEqual(self.ui.replication_service, None)
+
+    def test_has_desktopcouch(self):
+        """Has desktopcouch installed?"""
+        self.assertFalse(self.ui.has_desktopcouch)
+
+    def test_has_bindwood(self):
+        """Has bindwood installed?"""
+        self.assertFalse(self.ui.has_bindwood)
+
+    def test_has_evocouch(self):
+        """Has evocouch installed?"""
+        self.assertFalse(self.ui.has_evocouch)
+
+    def test_install_box_is_hidden(self):
+        """The install box is not hidden."""
+        self.assertTrue(self.ui.install_box.get_visible())
+
+    def test_replications_is_hidden(self):
+        """The replications section is disabled."""
+        self.assertFalse(self.ui.replications.get_visible())
+
+    def test_install_box(self):
+        """The install box is enabled."""
+        self.assertTrue(self.ui.install_box.get_visible())
+        self.assertIn(self.ui.install_box, self.ui.itself.get_children())
+        self.assertEqual(self.ui.install_box.package_name,
+                         self.ui.DESKTOPCOUCH_PKG)
+
+    def test_install_box_finished_connected(self):
+        """The install box 'finished' signal is connected."""
+        self.patch(self.ui, 'load_replications', self._set_called)
+        self.ui.load()  # ensure signal connection uses the new method
+
+        self.ui.install_box.emit('finished')
+
+        self.assertEqual(self._called, ((self.ui.install_box,), {}))
+
+
+class ServicesWithDesktopcouchTestCase(ServicesTestCase):
+    """The test suite for the services panel."""
+
+    kwargs = {'replication_exclusion_class': FakedReplication}
+
+    def setUp(self):
+        super(ServicesWithDesktopcouchTestCase, self).setUp()
+        self.ui.package_manager._installed[self.ui.DESKTOPCOUCH_PKG] = True
+        self.ui.load()
+
+    def test_message(self):
+        """Global load message is stopped and proper test is shown."""
+        self.assertFalse(self.ui.message.active)
+        self.assertEqual(self.ui.message.get_text(), self.ui.CHOOSE_SERVICES)
+
+    def test_replication_service(self):
+        """Has a replication service."""
+        self.assertIsInstance(self.ui.replication_service, FakedReplication)
+
+    def test_no_pairing_record(self):
+        """The pairing record is not in place."""
+
+        def no_pairing_record(*a):
+            """Fake a ReplicationExclusion with no pairing record."""
+            raise ValueError("No pairing record for ubuntuone.")
+
+        self.ui.replication_exclusion_class = no_pairing_record
+        self.ui.replication_service = None
+        self.ui.load()
+
+        self.assertEqual(self.ui.replications.get_children(), [])
+        self.assertFalse(self.ui.message.active)
+        self.assert_warning_correct(self.ui.message, self.ui.NO_PAIRING_RECORD)
+
+    def test_has_desktopcouch(self):
+        """Has desktopcouch installed?"""
+        self.assertTrue(self.ui.has_desktopcouch)
+
+    def test_replications(self):
+        """Has proper child for each desktopcouch replication available."""
+        self.assertTrue(self.ui.replications.get_visible())
+
+        children = self.ui.replications.get_children()
+        self.assertEqual(len(children), 2)
+        for child in children:
+            self.assertIsInstance(child, gui.DesktopcouchService)
+
+        self.assertTrue(self.ui.bookmarks is children[0])
+        self.assertTrue(self.ui.contacts is children[1])
+
+    def test_replications_after_loading_twice(self):
+        """Has proper child after loading twice."""
+        self.ui.load()
+        self.test_replications()
+
+    def test_bookmarks(self):
+        """The bookmarks is correct."""
+        self.assertEqual(self.ui.bookmarks.service_name, 'bookmarks')
+        self.assertEqual(self.ui.bookmarks.button.get_label(),
+                         self.ui.BOOKMARKS)
+        self.assertTrue(self.ui.bookmarks.replication_service is
+                        self.ui.replication_service)
+
+    def test_bookmarks_dependency(self):
+        """The bookmarks dependency is correct."""
+        self.assertTrue(self.ui.bookmarks.dependency is not None)
+        self.assertEqual(self.ui.bookmarks.dependency.package_name,
+                         self.ui.BINDWOOD_PKG)
+
+    def test_contacts(self):
+        """The contacts is correct."""
+        self.assertEqual(self.ui.contacts.service_name, 'contacts')
+        self.assertEqual(self.ui.contacts.button.get_label(),
+                         self.ui.CONTACTS)
+        self.assertTrue(self.ui.contacts.replication_service is
+                        self.ui.replication_service)
+
+    def test_contacts_dependency(self):
+        """The contacts dependency is correct."""
+        self.assertTrue(self.ui.contacts.dependency is not None)
+        self.assertEqual(self.ui.contacts.dependency.package_name,
+                         self.ui.EVOCOUCH_PKG)
+
+
+class ServicesWithDCAndBindwoodTestCase(ServicesWithDesktopcouchTestCase):
+    """The test suite for the services panel."""
+
+    def setUp(self):
+        super(ServicesWithDCAndBindwoodTestCase, self).setUp()
+        self.ui.package_manager._installed[self.ui.BINDWOOD_PKG] = True
+        self.ui.load()
+
+    def test_has_bindwood(self):
+        """Has bindwood installed?"""
+        self.assertTrue(self.ui.has_bindwood)
+
+    def test_bookmarks_dependency(self):
+        """The bookmarks dependency is correct."""
+        self.assertTrue(self.ui.bookmarks.dependency is None)
+
+
+class ServicesWithDCAndEvocouchTestCase(ServicesWithDesktopcouchTestCase):
+    """The test suite for the services panel."""
+
+    def setUp(self):
+        super(ServicesWithDCAndEvocouchTestCase, self).setUp()
+        self.ui.package_manager._installed[self.ui.EVOCOUCH_PKG] = True
+        self.ui.load()
+
+    def test_has_evocouch(self):
+        """Has evocoucg installed?"""
+        self.assertTrue(self.ui.has_evocouch)
+
+    def test_contacts_dependency(self):
+        """The bookmarks dependency is correct."""
+        self.assertTrue(self.ui.contacts.dependency is None)
+
 
 class ManagementPanelTestCase(ControlPanelMixinTestCase):
     """The test suite for the management panel."""
@@ -1420,11 +1784,11 @@
         """Tabs are not shown."""
         self.assertFalse(self.ui.notebook.get_show_tabs())
 
-    def test_default_page_is_account(self):
-        """The default page is Account."""
+    def test_default_page_is_dashboard(self):
+        """The default page is Dashboard."""
         self.assertEqual(self.ui.notebook.get_current_page(),
-                         self.ui.ACCOUNT_PAGE)
-        self.assertTrue(self.ui.account_button.get_active())
+                         self.ui.DASHBOARD_PAGE)
+        self.assertTrue(self.ui.dashboard_button.get_active())
 
     def test_buttons_set_notebook_pages(self):
         """The notebook pages are set when clicking buttons."""
@@ -1449,10 +1813,6 @@
                 active = getattr(self.ui, '%s_button' % other).get_active()
                 self.assertFalse(active, msg % (button, other))
 
-
-class ManagementPanelAccountTestCase(ManagementPanelTestCase):
-    """The test suite for the management panel (account tab)."""
-
     def test_backend_account_signals(self):
         """The proper signals are connected to the backend."""
         self.assertEqual(self.ui.backend._signals['AccountInfoReady'],
@@ -1465,11 +1825,11 @@
         self.ui.load()
         self.assert_backend_called('account_info', ())
 
-    def test_account_panel_is_packed(self):
-        """The account panel is packed."""
-        self.assertIsInstance(self.ui.account, gui.AccountPanel)
-        actual = self.ui.notebook.get_nth_page(self.ui.ACCOUNT_PAGE)
-        self.assertTrue(self.ui.account is actual)
+    def test_dashboard_panel_is_packed(self):
+        """The dashboard panel is packed."""
+        self.assertIsInstance(self.ui.dashboard, gui.DashboardPanel)
+        actual = self.ui.notebook.get_nth_page(self.ui.DASHBOARD_PAGE)
+        self.assertTrue(self.ui.dashboard is actual)
 
     def test_folders_panel_is_packed(self):
         """The folders panel is packed."""
@@ -1483,11 +1843,11 @@
         actual = self.ui.notebook.get_nth_page(self.ui.DEVICES_PAGE)
         self.assertTrue(self.ui.devices is actual)
 
-    def test_applications_panel_is_packed(self):
-        """The applications panel is packed."""
-        self.assertIsInstance(self.ui.applications, gui.ApplicationsPanel)
-        actual = self.ui.notebook.get_nth_page(self.ui.APPLICATIONS_PAGE)
-        self.assertTrue(self.ui.applications is actual)
+    def test_services_panel_is_packed(self):
+        """The services panel is packed."""
+        self.assertIsInstance(self.ui.services, gui.ServicesPanel)
+        actual = self.ui.notebook.get_nth_page(self.ui.SERVICES_PAGE)
+        self.assertTrue(self.ui.services is actual)
 
     def test_entering_folders_tab_loads_content(self):
         """The volumes info is loaded when entering the Folders tab."""
@@ -1505,6 +1865,14 @@
 
         self.assertEqual(self._called, ((), {}))
 
+    def test_entering_services_tab_loads_content(self):
+        """The services info is loaded when entering the Devices tab."""
+        self.patch(self.ui.services, 'load', self._set_called)
+        # clean backend calls
+        self.ui.services_button.clicked()
+
+        self.assertEqual(self._called, ((), {}))
+
     def test_quota_placeholder_is_loading(self):
         """Placeholders for quota label is a Loading widget."""
         self.assertIsInstance(self.ui.quota_label, gui.LabelLoading)

=== added file 'ubuntuone/controlpanel/gtk/tests/test_package_manager.py'
--- ubuntuone/controlpanel/gtk/tests/test_package_manager.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_package_manager.py	2011-01-03 14:24:42 +0000
@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Natalia B. Bidart <[e-mail]>
+#
+# Copyright 2010 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the package manager service."""
+
+import collections
+
+try:
+    # Unable to import 'defer', pylint: disable=F0401,E0611
+    from aptdaemon import defer
+except ImportError:
+    # Unable to import 'defer', pylint: disable=F0401,E0611
+    import defer
+
+from ubuntuone.controlpanel.gtk import package_manager
+from ubuntuone.controlpanel.tests import TestCase
+
+
+FAKED_CACHE = {}
+SUCCESS = package_manager.aptdaemon.enums.EXIT_SUCCESS
+FAILURE = package_manager.aptdaemon.enums.EXIT_FAILED
+
+
+class FakedPackage(object):
+    """Fake a package."""
+
+    def __init__(self, name=None, is_installed=False):
+        self.name = name
+        self.is_installed = is_installed
+
+
+class FakedTransaction(object):
+    """Fake a transaction."""
+
+    failure = None
+
+    def __init__(self, packages, cache=None):
+        self._signals = collections.defaultdict(list)
+        self._cache = cache
+        self.was_run = False
+        self.packages = packages
+        self.connect = lambda sig, f: self._signals[sig].append(f)
+
+    def run(self):
+        """Run!"""
+        self.was_run = True
+
+        if self._cache is not None:
+            for package in self.packages:
+                FAKED_CACHE[package].is_installed = True
+
+        if self.failure is None:
+            code = SUCCESS
+        else:
+            code = FAILURE
+
+        for listener in self._signals['finished']:
+            listener(self, code)
+
+        d = defer.Deferred()
+        d.callback(code)
+        return d
+
+
+class FakedClient(object):
+    """Fake an apt client."""
+
+    def install_packages(self, packages_names, **kwargs):
+        """Install packages listed in 'package_names'.
+
+        package_names - a list of package names
+        wait - if True run the transaction immediately and return its exit
+            state instead of the transaction itself.
+        reply_handler - callback function. If specified in combination with
+            error_handler the method will be called asynchrounsouly.
+        error_handler - in case of an error the given callback gets the
+            corresponding DBus exception instance
+
+        """
+        if kwargs.get('wait', False):
+            return package_manager.aptdaemon.enums.EXIT_FAILED
+        d = defer.Deferred()
+        d.callback(FakedTransaction(packages_names, cache=FAKED_CACHE))
+        return d
+
+
+class PackageManagerTestCase(TestCase):
+    """Test for the package manager."""
+
+    timeout = 2
+
+    def setUp(self):
+        FAKED_CACHE.clear()  # clean cache
+        self.patch(package_manager.apt, 'Cache', lambda: FAKED_CACHE)
+        self.patch(package_manager.aptdaemon.client, 'AptClient', FakedClient)
+        self.obj = package_manager.PackageManager()
+
+    def test_is_installed(self):
+        """Check that a package is installed."""
+        name = 'test'
+        FAKED_CACHE[name] = FakedPackage(name, is_installed=True)
+
+        result = self.obj.is_installed(name)
+
+        self.assertTrue(result, 'must be installed')
+
+    def test_is_not_installed(self):
+        """Check if a package is installed."""
+        name = 'test'
+        FAKED_CACHE[name] = FakedPackage(name)  # not installed by default
+
+        result = self.obj.is_installed(name)
+
+        self.assertFalse(result, 'must not be installed')
+
+    def test_is_not_installed_if_key_error(self):
+        """Check if a package is installed when cache raises KeyError."""
+        name = 'test'  # is not in the cache
+        result = self.obj.is_installed(name)
+
+        self.assertFalse(result, 'must not be installed')
+
+    def test_progress_bar(self):
+        """The progress bar class is correct."""
+        self.assertIsInstance(package_manager.PackageManagerProgressBar(),
+                              package_manager.AptProgressBar)
+
+    @package_manager.inline_callbacks
+    def test_install(self):
+        """Install is correct."""
+        name = 'test'
+        FAKED_CACHE[name] = FakedPackage(name)  # not installed by default
+
+        result = yield self.obj.install(name)
+
+        self.assertIsInstance(result, FakedTransaction)
+        self.assertFalse(result.was_run, 'transaction must not be run')
+
+    @package_manager.inline_callbacks
+    def test_transaction_install(self):
+        """Install is correct."""
+        name = 'test'
+        FAKED_CACHE[name] = FakedPackage(name)  # not installed by default
+
+        trans = yield self.obj.install(name)
+
+        trans.connect('finished', self._set_called)
+        trans.run()
+
+        self.assertEqual(self._called, ((trans, SUCCESS), {}))
+        self.assertTrue(trans.was_run, 'transaction must be run')
+        self.assertTrue(self.obj.is_installed(name))
+
+    @package_manager.inline_callbacks
+    def test_install_if_installed(self):
+        """Install does nothing is package is already installed."""
+        name = 'test'
+        FAKED_CACHE[name] = FakedPackage(name, is_installed=True)
+
+        result = yield self.obj.install(name)
+
+        self.assertEqual(result, SUCCESS)

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_service.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-12-16 21:09:46 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2011-01-03 14:24:42 +0000
@@ -150,6 +150,14 @@
         """Return the status of the file sync service."""
         return self._process(self.sample_status)
 
+    def enable_files(self):
+        """Enable files service."""
+        return self._process(None)
+
+    def disable_files(self):
+        """Disable files service."""
+        return self._process(None)
+
     def volumes_info(self):
         """Get the user volumes info."""
         return self._process(SAMPLE_VOLUMES_INFO)
@@ -383,6 +391,28 @@
                 self.backend.remove_device, sample_token)
         return self.assert_correct_method_call(*args)
 
+    def test_enable_files(self):
+        """Enable files service."""
+
+        def got_signal(*args):
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesEnabled", "FilesEnableError", got_signal,
+                self.backend.enable_files)
+        return self.assert_correct_method_call(*args)
+
+    def test_disable_files(self):
+        """Disable files service."""
+
+        def got_signal():
+            """The correct signal was received."""
+            self.deferred.callback("success")
+
+        args = ("FilesDisabled", "FilesDisableError", got_signal,
+                self.backend.disable_files)
+        return self.assert_correct_method_call(*args)
+
     def test_volumes_info(self):
         """The volumes info is reported."""
 
@@ -527,6 +557,20 @@
         args = (dbus_service.FILE_SYNC_IDLE, "FileSyncStatusIdle")
         return self.assert_correct_status_signal(*args)
 
+    def test_file_sync_status_changed(self):
+        """The file sync status is reported every time status changed."""
+        status = (
+            dbus_service.FILE_SYNC_DISABLED,
+            dbus_service.FILE_SYNC_DISCONNECTED,
+            dbus_service.FILE_SYNC_ERROR,
+            dbus_service.FILE_SYNC_IDLE,
+            dbus_service.FILE_SYNC_STARTING,
+            dbus_service.FILE_SYNC_SYNCING,
+        )
+        for arg in status:
+            args = (arg, "FileSyncStatusChanged")
+            return self.assert_correct_status_signal(*args, expected_msg=arg)
+
     def test_status_changed_handler(self):
         """The status changed handler is properly set."""
         be = MockBackend()

=== modified file 'ubuntuone/controlpanel/logger.py'
--- ubuntuone/controlpanel/logger.py	2010-12-08 22:25:24 +0000
+++ ubuntuone/controlpanel/logger.py	2011-01-03 14:24:42 +0000
@@ -33,7 +33,7 @@
     LOG_LEVEL = logging.DEBUG
 else:
     # Only log this level and above
-    LOG_LEVEL = logging.INFO
+    LOG_LEVEL = logging.DEBUG  # before final release, switch to INFO
 
 MAIN_HANDLER = RotatingFileHandler(os.path.join(LOGFOLDER, 'controlpanel.log'),
                                    maxBytes=1048576,

=== modified file 'ubuntuone/controlpanel/tests/__init__.py'
--- ubuntuone/controlpanel/tests/__init__.py	2010-12-02 16:23:03 +0000
+++ ubuntuone/controlpanel/tests/__init__.py	2011-01-03 14:24:42 +0000
@@ -18,7 +18,7 @@
 
 """The test suite for the control panel for Ubuntu One."""
 
-from twisted.trial import unittest
+from ubuntuone.devtools.testcase import TestCase as BaseTestCase
 
 
 TOKEN = {u'consumer_key': u'xQ7xDAz',
@@ -28,7 +28,7 @@
          u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
 
 
-class TestCase(unittest.TestCase):
+class TestCase(BaseTestCase):
     """Basics for testing."""
 
     def setUp(self):

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2010-12-18 20:16:18 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2011-01-03 14:24:42 +0000
@@ -257,11 +257,11 @@
 
     def files_sync_enabled(self):
         """Get if file sync service is enabled."""
-        return self.file_sync
+        return MockDBusClient.file_sync
 
     def set_files_sync_enabled(self, enabled):
         """Set the file sync service to be 'enabled'."""
-        self.file_sync = enabled
+        MockDBusClient.file_sync = enabled
 
     def get_folders(self):
         """Grab list of folders."""
@@ -653,3 +653,21 @@
         # Access to a protected member _process_file_sync_status
         expected_status = self.be._process_file_sync_status(status)
         self.assertEqual(self._called, ((expected_status,), {}))
+
+
+class BackendSyncEnabledTestCase(BackendBasicTestCase):
+    """Syncdaemon enable/disable for the backend."""
+
+    def test_enable_files(self):
+        """Files service is enabled."""
+        self.be.disable_files()
+
+        self.be.enable_files()
+        self.assertTrue(MockDBusClient.file_sync)
+
+    def test_disable_files(self):
+        """Files service is disabled."""
+        self.be.enable_files()
+
+        self.be.disable_files()
+        self.assertFalse(MockDBusClient.file_sync)