Merge lp:~nataliabidart/ubuntuone-control-panel/preferences into lp:ubuntuone-control-panel

[Natalia Bidart]

- Implemented the "Preferences" tab (LP: #797294).

To test this branch, please run the tests for both widget sets:

./run-tests
./run-tests -qt

To test IRL, please run from within this branch:

DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-qt

then go to the preferences tab and play with the settings (please note that initial settings are fake). When clicking apply, you should see in the terminal something like:

2011-06-16 15:23:58,688 - ubuntuone.controlpanel.backend - INFO - change_file_sync_settings: args (<ubuntuone.controlpanel.backend.ControlBackend object at 0x29ef950>, {'autoconnect': False, 'max_download_speed': 102400, 'share_autosubscribe': True, 'max_upload_speed': 10240, 'show_all_notifications': False, 'udf_autosubscribe': True}), kwargs {}.

When restoring to defaults, you should get autoconnect and show notifications enabled, autosubscribe disabled x 2 and no limit for throttling.

[John Lenton (chipaca)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

Attempt to merge into lp:ubuntuone-control-panel failed due to conflicts:

text conflict in ubuntuone/controlpanel/gui/qt/folders.py

[lp:~nataliabidart/ubuntuone-control-panel/preferences]

169. By Natalia Bidart on 2011-06-17

Merged trunk in.

=== modified file 'data/qt/preferences.ui'
--- data/qt/preferences.ui	2011-05-23 21:24:08 +0000
+++ data/qt/preferences.ui	2011-06-17 14:51:05 +0000
@@ -15,64 +15,90 @@
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
-    <widget class="QLabel" name="tab_header_label">
-     <property name="text">
-      <string>(empty)</string>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox">
-     <property name="title">
-      <string>Bandwidth settings</string>
-     </property>
-     <layout class="QGridLayout" name="gridLayout">
-      <item row="0" column="0">
-       <widget class="QCheckBox" name="limit_uploads_checkbox">
-        <property name="text">
-         <string>Limit upload speed to</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="1">
-       <widget class="QSpinBox" name="upload_speed_spinbox"/>
-      </item>
-      <item row="0" column="2">
-       <widget class="QLabel" name="kbps_label_1">
-        <property name="text">
-         <string>Kilobits per second</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QCheckBox" name="limit_downloads_checkbox">
-        <property name="text">
-         <string>Limit download speed to</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="1">
-       <widget class="QSpinBox" name="download_speed_spinbox"/>
-      </item>
-      <item row="1" column="2">
-       <widget class="QLabel" name="kbps_label_2">
-        <property name="text">
-         <string>Kilobits per second</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="3">
-       <spacer name="horizontalSpacer_2">
-        <property name="orientation">
-         <enum>Qt::Horizontal</enum>
-        </property>
-        <property name="sizeHint" stdset="0">
-         <size>
-          <width>40</width>
-          <height>20</height>
-         </size>
-        </property>
-       </spacer>
+    <widget class="QGroupBox" name="verticalGroupBox">
+     <layout class="QVBoxLayout" name="verticalLayout_4">
+      <item>
+       <widget class="QGroupBox" name="groupBox">
+        <property name="title">
+         <string>Bandwidth settings</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout">
+         <item row="0" column="0">
+          <widget class="QCheckBox" name="limit_uploads_checkbox">
+           <property name="text">
+            <string>Limit upload speed to</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QSpinBox" name="upload_speed_spinbox">
+           <property name="minimum">
+            <number>-1</number>
+           </property>
+           <property name="maximum">
+            <number>999999999</number>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="2">
+          <widget class="QLabel" name="kbps_label_1">
+           <property name="text">
+            <string>Kilobits per second</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QCheckBox" name="limit_downloads_checkbox">
+           <property name="text">
+            <string>Limit download speed to</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="1">
+          <widget class="QSpinBox" name="download_speed_spinbox">
+           <property name="minimum">
+            <number>-1</number>
+           </property>
+           <property name="maximum">
+            <number>999999999</number>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="2">
+          <widget class="QLabel" name="kbps_label_2">
+           <property name="text">
+            <string>Kilobits per second</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="3">
+          <spacer name="horizontalSpacer_2">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item row="3" column="0" colspan="3">
+          <widget class="QLabel" name="label_2">
+           <property name="text">
+            <string>Please note that your files will not sync if you set bandwidth to 0</string>
+           </property>
+           <property name="scaledContents">
+            <bool>false</bool>
+           </property>
+           <property name="wordWrap">
+            <bool>false</bool>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
       </item>
      </layout>
     </widget>
@@ -80,32 +106,32 @@
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
-      <string>Application Settings</string>
+      <string>File Sync Settings</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
-       <widget class="QCheckBox" name="auto_connect_checkbox">
+       <widget class="QCheckBox" name="autoconnect_checkbox">
         <property name="text">
          <string>Connect automatically when computer starts</string>
         </property>
        </widget>
       </item>
       <item>
-       <widget class="QCheckBox" name="auto_sync_local_folders_checkbox">
+       <widget class="QCheckBox" name="udf_autosubscribe_checkbox">
         <property name="text">
          <string>Automatically sync all selected folders on this computer to the cloud</string>
         </property>
        </widget>
       </item>
       <item>
-       <widget class="QCheckBox" name="auto_sync_shares_to_me_checkbox">
+       <widget class="QCheckBox" name="share_autosubscribe_checkbox">
         <property name="text">
          <string>Automatically sync all folders shared with me by other to this computer</string>
         </property>
        </widget>
       </item>
       <item>
-       <widget class="QCheckBox" name="show_notifications_checkbox">
+       <widget class="QCheckBox" name="show_all_notifications_checkbox">
         <property name="text">
          <string>Allow all notifications to this device</string>
         </property>
 
=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2011-06-02 03:58:53 +0000
+++ ubuntuone/controlpanel/backend.py	2011-06-17 14:51:05 +0000
@@ -42,6 +42,10 @@
 DEVICE_REMOVE_API = "1.0/devices/remove/%s/%s"
 DEVICE_TYPE_PHONE = "Phone"
 DEVICE_TYPE_COMPUTER = "Computer"
+AUTOCONNECT_KEY = 'autoconnect'
+SHOW_ALL_NOTIFICATIONS_KEY = 'show_all_notifications'
+SHARE_AUTOSUBSCRIBE_KEY = 'share_autosubscribe'
+UDF_AUTOSUBSCRIBE_KEY = 'udf_autosubscribe'
 UPLOAD_KEY = "max_upload_speed"
 DOWNLOAD_KEY = "max_download_speed"
 
@@ -99,6 +103,14 @@
     NAME_NOT_SET = u'ENAMENOTSET'
     FREE_BYTES_NOT_AVAILABLE = u'EFREEBYTESNOTAVAILABLE'
     STATUS_DISABLED = {MSG_KEY: '', STATUS_KEY: FILE_SYNC_DISABLED}
+    DEFAULT_FILE_SYNC_SETTINGS = {
+        AUTOCONNECT_KEY: True,
+        SHOW_ALL_NOTIFICATIONS_KEY: True,
+        SHARE_AUTOSUBSCRIBE_KEY: False,
+        UDF_AUTOSUBSCRIBE_KEY: False,
+        DOWNLOAD_KEY: -1,  # no limit
+        UPLOAD_KEY: -1,  # no limit
+    }
 
     def __init__(self, shutdown_func=None):
         """Initialize the web_client."""
@@ -180,7 +192,8 @@
 
     @inlineCallbacks
     def _process_device_web_info(self, devices, enabled, limit_bw, limits,
-                                 show_notifs):
+                                 autoconnect, show_notifs,
+                                 share_autosubscribe, udf_autosubscribe):
         """Return a lis of processed devices."""
         result = []
         for d in devices:
@@ -202,7 +215,10 @@
 
             if di["configurable"]:
                 di["limit_bandwidth"] = limit_bw
-                di["show_all_notifications"] = show_notifs
+                di[AUTOCONNECT_KEY] = autoconnect
+                di[SHOW_ALL_NOTIFICATIONS_KEY] = show_notifs
+                di[SHARE_AUTOSUBSCRIBE_KEY] = share_autosubscribe
+                di[UDF_AUTOSUBSCRIBE_KEY] = udf_autosubscribe
                 di[UPLOAD_KEY] = limits["upload"]
                 di[DOWNLOAD_KEY] = limits["download"]
 
@@ -273,19 +289,35 @@
     @inlineCallbacks
     def devices_info(self):
         """Get the user devices info."""
-        result = limit_bw = limits = show_notifs = None
+        result = limit_bw = limits = None
+        autoconnect = show_notifs = None
+        share_autosubscribe = udf_autosubscribe = None
+
         enabled = yield sd_client.files_sync_enabled()
         enabled = bool(enabled)
         if enabled:
-            limit_bw = yield sd_client.bandwidth_throttling_enabled()
-            limit_bw = bool(limit_bw)
-            show_notifs = yield sd_client.show_all_notifications_enabled()
-            show_notifs = bool(show_notifs)
+            sd_res = yield sd_client.autoconnect_enabled()
+            autoconnect = bool(sd_res)
+
+            sd_res = yield sd_client.show_all_notifications_enabled()
+            show_notifs = bool(sd_res)
+
+            sd_res = yield sd_client.share_autosubscribe_enabled()
+            share_autosubscribe = bool(sd_res)
+
+            sd_res = yield sd_client.udf_autosubscribe_enabled()
+            udf_autosubscribe = bool(sd_res)
+
+            sd_res = yield sd_client.bandwidth_throttling_enabled()
+            limit_bw = bool(sd_res)
+
             limits = yield sd_client.get_throttling_limits()
 
         logger.debug('devices_info: file sync enabled? %s limit_bw %s, limits '
-                     '%s, show_notifs %s',
-                     enabled, limit_bw, limits, show_notifs)
+                     '%s, autoconnect %s, show_notifs %s, '
+                     'share_autosubscribe %s, udf_autosubscribe %s',
+                     enabled, limit_bw, limits, autoconnect, show_notifs,
+                     share_autosubscribe, udf_autosubscribe)
 
         try:
             devices = yield self.wc.call_api(DEVICES_API)
@@ -295,8 +327,8 @@
             logger.exception('devices_info: web client failure:')
         else:
             result = yield self._process_device_web_info(devices, enabled,
-                                                         limit_bw, limits,
-                                                         show_notifs)
+                        limit_bw, limits, autoconnect, show_notifs,
+                        share_autosubscribe, udf_autosubscribe)
         if result is None:
             logger.info('devices_info: result is None after calling '
                         'devices/ API, building the local device.')
@@ -310,12 +342,15 @@
             local_device["configurable"] = enabled
             if local_device["configurable"]:
                 local_device["limit_bandwidth"] = limit_bw
-                show_notifs = show_notifs
-                local_device["show_all_notifications"] = show_notifs
+                local_device[AUTOCONNECT_KEY] = autoconnect
+                local_device[SHOW_ALL_NOTIFICATIONS_KEY] = show_notifs
+                local_device[SHARE_AUTOSUBSCRIBE_KEY] = share_autosubscribe
+                local_device[UDF_AUTOSUBSCRIBE_KEY] = udf_autosubscribe
                 upload = limits["upload"]
                 download = limits["download"]
                 local_device[UPLOAD_KEY] = upload
                 local_device[DOWNLOAD_KEY] = download
+            logger.debug('devices_info: local device built: %r.', local_device)
             result = [local_device]
         else:
             logger.info('devices_info: result is not None after calling '
@@ -338,8 +373,8 @@
         """Change the settings for the given device."""
         is_local = yield self.device_is_local(device_id)
 
-        if is_local and "show_all_notifications" in settings:
-            if not settings["show_all_notifications"]:
+        if is_local and SHOW_ALL_NOTIFICATIONS_KEY in settings:
+            if not settings[SHOW_ALL_NOTIFICATIONS_KEY]:
                 yield sd_client.disable_show_all_notifications()
             else:
                 yield sd_client.enable_show_all_notifications()
@@ -597,6 +632,65 @@
         # still pending (LP: #673673)
         returnValue(None)
 
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def file_sync_settings_info(self):
+        """Get the file sync settings info."""
+        result = {}
+
+        for name in (AUTOCONNECT_KEY, SHOW_ALL_NOTIFICATIONS_KEY,
+                     SHARE_AUTOSUBSCRIBE_KEY, UDF_AUTOSUBSCRIBE_KEY):
+            sd_method = getattr(sd_client, '%s_enabled' % name)
+            value = yield sd_method()
+            result[name] = bool(value)
+
+        limits = yield sd_client.get_throttling_limits()
+        result[DOWNLOAD_KEY] = limits['download']
+        result[UPLOAD_KEY] = limits['upload']
+
+        returnValue(result)
+
+    @inlineCallbacks
+    def _change_boolean_file_sync_setting(self, setting_name, settings):
+        """Change the value for 'setting_name' to be 'new_value'."""
+        if setting_name in settings:
+            new_value = settings[setting_name]
+            sd_method_name = 'enable_%s' if new_value else 'disable_%s'
+            sd_method = getattr(sd_client, sd_method_name % setting_name)
+            yield sd_method()
+
+    @log_call(logger.info)
+    @inlineCallbacks
+    def change_file_sync_settings(self, settings):
+        """Change the file sync settings."""
+        for name in (AUTOCONNECT_KEY, SHOW_ALL_NOTIFICATIONS_KEY,
+                     SHARE_AUTOSUBSCRIBE_KEY, UDF_AUTOSUBSCRIBE_KEY):
+            yield self._change_boolean_file_sync_setting(name, settings)
+
+        if DOWNLOAD_KEY in settings or UPLOAD_KEY in settings:
+            current_limits = yield sd_client.get_throttling_limits()
+            limits = {
+                "download": current_limits["download"],
+                "upload": current_limits["upload"],
+            }
+            if UPLOAD_KEY in settings:
+                limits["upload"] = settings[UPLOAD_KEY]
+            if DOWNLOAD_KEY in settings:
+                limits["download"] = settings[DOWNLOAD_KEY]
+            yield sd_client.set_throttling_limits(limits)
+
+            throttling_disabled = sum(limits.itervalues()) == -2
+            if throttling_disabled:
+                yield sd_client.disable_bandwidth_throttling()
+            else:
+                yield sd_client.enable_bandwidth_throttling()
+
+    @log_call(logger.info)
+    @inlineCallbacks
+    def restore_file_sync_settings(self):
+        """Restore the file sync settings."""
+        yield self.change_file_sync_settings(self.DEFAULT_FILE_SYNC_SETTINGS)
+
     @log_call(logger.info)
     def shutdown(self):
         """Stop this service."""
 
=== modified file 'ubuntuone/controlpanel/gui/qt/folders.py'
--- ubuntuone/controlpanel/gui/qt/folders.py	2011-06-16 20:33:39 +0000
+++ ubuntuone/controlpanel/gui/qt/folders.py	2011-06-17 14:51:05 +0000
@@ -34,6 +34,7 @@
     FILE_URI_PREFIX,
     FOLDER_ICON_NAME,
     FOLDERS_CONFIRM_MERGE,
+    KILOBYTES,
     MANAGE_FILES_LINK,
     MUSIC_ICON_NAME,
     MUSIC_DISPLAY_NAME,
@@ -102,8 +103,8 @@
         units = {0: 'bytes', 1: 'KiB', 2: 'MiB', 3: 'GiB', 4: 'TiB',
                  5: 'PiB', 6: 'Eib', 7: 'ZiB', 8: 'YiB'}
         unit = 0
-        while int_bytes >= 1024:
-            int_bytes = int_bytes / 1024
+        while int_bytes >= KILOBYTES:
+            int_bytes = int_bytes / KILOBYTES
             unit += 1
         return '%.1f %s' % (int_bytes, units[unit])
 
 
=== modified file 'ubuntuone/controlpanel/gui/qt/main/linux.py'
--- ubuntuone/controlpanel/gui/qt/main/linux.py	2011-06-14 11:41:11 +0000
+++ ubuntuone/controlpanel/gui/qt/main/linux.py	2011-06-17 14:51:05 +0000
@@ -55,6 +55,14 @@
     class SDTool(FakedSyncDaemonTool):
         """A custom SDTool."""
 
+        settings = {
+            'autoconnect': True,
+            'show_all_notifications': True,
+            'share_autosubscribe': False,
+            'udf_autosubscribe': False,
+            'throttling_enabled': True,
+            'limits': {'download': 100000, 'upload': 1000},
+        }
         shares = [
             {u'accepted': u'True',
              u'access_level': u'Modify',
 
=== modified file 'ubuntuone/controlpanel/gui/qt/preferences.py'
--- ubuntuone/controlpanel/gui/qt/preferences.py	2011-05-24 14:20:18 +0000
+++ ubuntuone/controlpanel/gui/qt/preferences.py	2011-06-17 14:51:05 +0000
@@ -18,10 +18,24 @@
 
 """The user interface for the control panel for Ubuntu One."""
 
-from PyQt4 import QtGui
+from PyQt4 import QtGui, QtCore
+from twisted.internet import defer
 
+from ubuntuone.controlpanel import backend
+from ubuntuone.controlpanel.logger import setup_logging, log_call
+from ubuntuone.controlpanel.gui import KILOBYTES
 from ubuntuone.controlpanel.gui.qt.ui import preferences_ui
 
+logger = setup_logging('qt.preferences')
+
+CHECKED = QtCore.Qt.Checked
+UNCHECKED = QtCore.Qt.Unchecked
+
+
+def check_state(checked):
+    """Return the QCheckBox check state according the value of 'checked'."""
+    return CHECKED if checked else UNCHECKED
+
 
 class PreferencesPanel(QtGui.QWidget):
     """The Preferences Tab Panel widget"""
@@ -31,3 +45,95 @@
         QtGui.QWidget.__init__(self, *args)
         self.ui = preferences_ui.Ui_Form()
         self.ui.setupUi(self)
+
+        self.backend = backend.ControlBackend()
+        logger.debug('%s: started.', self.__class__.__name__)
+
+    # Invalid name "showEvent"
+    # pylint: disable=C0103
+
+    def showEvent(self, event):
+        """Load info."""
+        d = defer.maybeDeferred(self.backend.file_sync_settings_info)
+        d.addCallback(self.process_settings)
+        event.accept()
+
+    @log_call(logger.debug)
+    def process_settings(self, info):
+        """Load settings info into the view."""
+        if not info:
+            return
+
+        autoconnect = check_state(info[backend.AUTOCONNECT_KEY])
+        show_all_notifs = \
+            check_state(info[backend.SHOW_ALL_NOTIFICATIONS_KEY])
+        share_autosubscribe = \
+            check_state(info[backend.SHARE_AUTOSUBSCRIBE_KEY])
+        udf_autosubscribe = \
+            check_state(info[backend.UDF_AUTOSUBSCRIBE_KEY])
+        download_speed = info[backend.DOWNLOAD_KEY] // KILOBYTES
+        upload_speed = info[backend.UPLOAD_KEY] // KILOBYTES
+
+        self.ui.autoconnect_checkbox.setCheckState(autoconnect)
+        self.ui.show_all_notifications_checkbox.setCheckState(show_all_notifs)
+        self.ui.share_autosubscribe_checkbox.setCheckState(share_autosubscribe)
+        self.ui.udf_autosubscribe_checkbox.setCheckState(udf_autosubscribe)
+        self.ui.download_speed_spinbox.setValue(download_speed)
+        self.ui.upload_speed_spinbox.setValue(upload_speed)
+
+    def process_speed_settings(self, new_value, checkbox):
+        """A new speed limit was set."""
+        if new_value < 0:
+            checkbox.setCheckState(UNCHECKED)
+        else:
+            checkbox.setCheckState(CHECKED)
+
+    @QtCore.pyqtSlot(int)
+    def on_download_speed_spinbox_valueChanged(self, new_value):
+        """A new download speed was set."""
+        self.process_speed_settings(new_value,
+                                    self.ui.limit_downloads_checkbox)
+
+    @QtCore.pyqtSlot(int)
+    def on_upload_speed_spinbox_valueChanged(self, new_value):
+        """A new upload speed was set."""
+        self.process_speed_settings(new_value,
+                                    self.ui.limit_uploads_checkbox)
+
+    @QtCore.pyqtSlot()
+    @defer.inlineCallbacks
+    def on_apply_changes_button_clicked(self):
+        """The apply changes button was clicked."""
+        autoconnect = self.ui.autoconnect_checkbox.checkState()
+        notifications = self.ui.show_all_notifications_checkbox.checkState()
+        share_autosubscribe = self.ui.share_autosubscribe_checkbox.checkState()
+        udf_autosubscribe = self.ui.udf_autosubscribe_checkbox.checkState()
+        download_speed = self.ui.download_speed_spinbox.value() * KILOBYTES
+        upload_speed = self.ui.upload_speed_spinbox.value() * KILOBYTES
+
+        settings = {
+            backend.AUTOCONNECT_KEY: autoconnect == CHECKED,
+            backend.SHOW_ALL_NOTIFICATIONS_KEY: notifications == CHECKED,
+            backend.SHARE_AUTOSUBSCRIBE_KEY: share_autosubscribe == CHECKED,
+            backend.UDF_AUTOSUBSCRIBE_KEY: udf_autosubscribe == CHECKED,
+            backend.DOWNLOAD_KEY: download_speed,
+            backend.UPLOAD_KEY: upload_speed,
+        }
+
+        # set is_processing
+        # TODO: handle errors
+        yield self.backend.change_file_sync_settings(settings)
+        # unset is_processing
+
+    @QtCore.pyqtSlot()
+    @defer.inlineCallbacks
+    def on_restore_defaults_button_clicked(self):
+        """The restore defaults button was clicked."""
+        # set is_processing
+        # TODO: handle errors
+        yield self.backend.restore_file_sync_settings()
+        settings = yield self.backend.file_sync_settings_info()
+
+        self.process_settings(settings)
+
+        # unset is_processing
 
=== modified file 'ubuntuone/controlpanel/gui/qt/tests/__init__.py'
--- ubuntuone/controlpanel/gui/qt/tests/__init__.py	2011-06-16 20:31:27 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/__init__.py	2011-06-17 14:51:05 +0000
@@ -93,6 +93,14 @@
     SHARE_TYPE = u'SHARE'
     NAME_NOT_SET = u'ENAMENOTSET'
     FREE_BYTES_NOT_AVAILABLE = u'EFREEBYTESNOTAVAILABLE'
+    DEFAULT_FILE_SYNC_SETTINGS = {
+        backend.AUTOCONNECT_KEY: True,
+        backend.SHOW_ALL_NOTIFICATIONS_KEY: True,
+        backend.SHARE_AUTOSUBSCRIBE_KEY: False,
+        backend.UDF_AUTOSUBSCRIBE_KEY: False,
+        backend.DOWNLOAD_KEY: -1,  # no limit
+        backend.UPLOAD_KEY: -1,  # no limit
+    }
 
     exposed_methods = [
         'account_info',  # account
@@ -101,7 +109,11 @@
         'replications_info', 'change_replication_settings',  # replications
         'file_sync_status', 'enable_files', 'disable_files',  # files
         'connect_files', 'disconnect_files',
-        'restart_files', 'start_files', 'stop_files', 'shutdown',
+        'restart_files', 'start_files', 'stop_files',
+        'file_sync_settings_info',
+        'change_file_sync_settings',
+        'restore_file_sync_settings',
+        'shutdown',
     ]
 
 
@@ -140,13 +152,8 @@
 
         self.ui.show()
 
-    def assert_backend_called(self, method_name, args=None, kwargs=None):
+    def assert_backend_called(self, method_name, *args, **kwargs):
         """Check that the control panel backend 'method_name' was called."""
-        if args is None:
-            args = ()
-        if kwargs is None:
-            kwargs = {}
-
         self.assertIn(method_name, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[method_name], (args, kwargs))
 
 
=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_filesyncstatus.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_filesyncstatus.py	2011-06-01 18:10:22 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_filesyncstatus.py	2011-06-17 14:51:05 +0000
@@ -87,7 +87,7 @@
 
     def test_file_sync_status_is_requested_on_show(self):
         """The file sync status is requested to the backend."""
-        self.assert_backend_called('file_sync_status', ())
+        self.assert_backend_called('file_sync_status')
 
     def test_process_status_disabled(self):
         """File sync status disabled update the label."""
 
=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_folders.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_folders.py	2011-06-16 20:33:39 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_folders.py	2011-06-17 14:51:05 +0000
@@ -77,7 +77,7 @@
 
     def test_volumes_info_is_requested_on_show(self):
         """The volumes info is requested to the backend."""
-        self.assert_backend_called('volumes_info', ())
+        self.assert_backend_called('volumes_info')
 
     def test_process_folders(self):
         """The volumes info is processed when ready."""
@@ -333,7 +333,7 @@
 
         # backend was called
         self.assert_backend_called('change_volume_settings',
-                                   (fid, {'subscribed': subscribed}))
+                                   fid, {'subscribed': subscribed})
 
         value = self.item.checkState(gui.SUBSCRIPTION_COL) == gui.CHECKED
         self.assertEqual(value, bool(subscribed))
 
=== added file 'ubuntuone/controlpanel/gui/qt/tests/test_preferences.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_preferences.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_preferences.py	2011-06-17 14:51:05 +0000
@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Natalia B Bidart <[e-mail]>
+#
+# Copyright 2011 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 Control Panel."""
+
+from __future__ import division
+
+from ubuntuone.controlpanel.gui.qt import preferences as gui
+from ubuntuone.controlpanel.gui.qt.tests import BaseTestCase
+
+# Access to a protected member
+# pylint: disable=W0212
+
+
+class PreferencesPanelTestCase(BaseTestCase):
+    """Test the qt cloud preferences tab."""
+
+    innerclass_ui = gui.preferences_ui
+    innerclass_name = "Ui_Form"
+    class_ui = gui.PreferencesPanel
+
+    def test_backend(self):
+        """Backend is created."""
+        self.assertIsInstance(self.ui.backend,
+                              gui.backend.ControlBackend)
+
+    def test_file_sync_settings_info_is_requested(self):
+        """The file_sync_settings info is requested to the backend."""
+        self.assert_backend_called('file_sync_settings_info')
+
+    def _test_update_ui_from_settings_info(self, settings):
+        """The ui is correctly updated when the backend info is received."""
+        autoconnect = self.ui.ui.autoconnect_checkbox.checkState()
+        self.assertEqual(autoconnect == gui.CHECKED,
+                         settings[gui.backend.AUTOCONNECT_KEY])
+
+        show_all_notifications = \
+            self.ui.ui.show_all_notifications_checkbox.checkState()
+        self.assertEqual(show_all_notifications == gui.CHECKED,
+                         settings[gui.backend.SHOW_ALL_NOTIFICATIONS_KEY])
+
+        share_autosubscribe = \
+            self.ui.ui.share_autosubscribe_checkbox.checkState()
+        self.assertEqual(share_autosubscribe == gui.CHECKED,
+                         settings[gui.backend.SHARE_AUTOSUBSCRIBE_KEY])
+
+        udf_autosubscribe = self.ui.ui.udf_autosubscribe_checkbox.checkState()
+        self.assertEqual(udf_autosubscribe == gui.CHECKED,
+                         settings[gui.backend.UDF_AUTOSUBSCRIBE_KEY])
+
+        download_speed = self.ui.ui.download_speed_spinbox.value()
+        self.assertEqual(download_speed,
+                         settings[gui.backend.DOWNLOAD_KEY] // gui.KILOBYTES)
+
+        upload_speed = self.ui.ui.upload_speed_spinbox.value()
+        self.assertEqual(upload_speed,
+                         settings[gui.backend.UPLOAD_KEY] // gui.KILOBYTES)
+
+    def test_update_ui_from_backed_info(self):
+        """The ui is correctly updated when the backend info is received."""
+        settings = {
+            gui.backend.AUTOCONNECT_KEY: True,
+            gui.backend.SHOW_ALL_NOTIFICATIONS_KEY: True,
+            gui.backend.SHARE_AUTOSUBSCRIBE_KEY: True,
+            gui.backend.UDF_AUTOSUBSCRIBE_KEY: True,
+            gui.backend.DOWNLOAD_KEY: 20480,
+            gui.backend.UPLOAD_KEY: 2048,
+        }
+        self.ui.process_settings(settings)
+        self._test_update_ui_from_settings_info(settings)
+
+    def _test_speed_checkbox_value_changed_to_positive(self, speed_spinbox,
+                                                       limit_checkbox):
+        """When the speed is set to a positive value, enable the checkbox."""
+        limit_checkbox.setCheckState(gui.UNCHECKED)
+        speed_spinbox.setValue(33)
+
+        self.assertEqual(gui.CHECKED, limit_checkbox.checkState())
+
+    def _test_speed_checkbox_value_changed_to_negative(self, speed_spinbox,
+                                                       limit_checkbox):
+        """When the speed is set to a negative value, disable the checkbox."""
+        limit_checkbox.setCheckState(gui.UNCHECKED)
+        speed_spinbox.setValue(-1)
+
+        self.assertEqual(gui.UNCHECKED, limit_checkbox.checkState())
+
+    def test_download_speed_checkbox_value_changed_to_positive(self):
+        """When the download speed is set, enable the checkbox."""
+        self._test_speed_checkbox_value_changed_to_positive(
+            self.ui.ui.download_speed_spinbox,
+            self.ui.ui.limit_downloads_checkbox)
+
+    def test_download_speed_checkbox_value_changed_to_negative(self):
+        """When the download speed is set, enable the checkbox."""
+        self._test_speed_checkbox_value_changed_to_negative(
+            self.ui.ui.download_speed_spinbox,
+            self.ui.ui.limit_downloads_checkbox)
+
+    def test_upload_speed_checkbox_value_changed_to_positive(self):
+        """When the upload speed is set, enable the checkbox."""
+        self._test_speed_checkbox_value_changed_to_positive(
+            self.ui.ui.upload_speed_spinbox,
+            self.ui.ui.limit_uploads_checkbox)
+
+    def test_upload_speed_checkbox_value_changed_to_negative(self):
+        """When the upload speed is set, enable the checkbox."""
+        self._test_speed_checkbox_value_changed_to_negative(
+            self.ui.ui.upload_speed_spinbox,
+            self.ui.ui.limit_uploads_checkbox)
+
+    def test_apply_changes_button_clicked(self):
+        """When the apply button is clicked, the backend is called."""
+        self.ui.ui.autoconnect_checkbox.setCheckState(gui.CHECKED)
+        self.ui.ui.show_all_notifications_checkbox.setCheckState(gui.CHECKED)
+        self.ui.ui.share_autosubscribe_checkbox.setCheckState(gui.CHECKED)
+        self.ui.ui.udf_autosubscribe_checkbox.setCheckState(gui.CHECKED)
+        self.ui.ui.download_speed_spinbox.setValue(20)
+        self.ui.ui.upload_speed_spinbox.setValue(2)
+
+        self.ui.ui.apply_changes_button.click()
+
+        expected_dict = {
+            gui.backend.AUTOCONNECT_KEY: True,
+            gui.backend.SHOW_ALL_NOTIFICATIONS_KEY: True,
+            gui.backend.SHARE_AUTOSUBSCRIBE_KEY: True,
+            gui.backend.UDF_AUTOSUBSCRIBE_KEY: True,
+            gui.backend.DOWNLOAD_KEY: 20 * gui.KILOBYTES,
+            gui.backend.UPLOAD_KEY: 2 * gui.KILOBYTES,
+        }
+        self.assert_backend_called('change_file_sync_settings', expected_dict)
+
+    def test_restore_defaults_button_clicked(self):
+        """When the restore button is clicked, the backend is called."""
+        settings = gui.backend.ControlBackend.DEFAULT_FILE_SYNC_SETTINGS
+        self.patch(self.ui.backend, 'file_sync_settings_info',
+                   lambda: settings)
+        # modify the state a bit to ensure defaults are applied
+        self.ui.ui.autoconnect_checkbox.setCheckState(gui.UNCHECKED)
+        self.ui.ui.show_all_notifications_checkbox.setCheckState(gui.UNCHECKED)
+        self.ui.ui.share_autosubscribe_checkbox.setCheckState(gui.CHECKED)
+        self.ui.ui.udf_autosubscribe_checkbox.setCheckState(gui.CHECKED)
+        self.ui.ui.download_speed_spinbox.setValue(20)
+        self.ui.ui.upload_speed_spinbox.setValue(2)
+
+        self.ui.ui.restore_defaults_button.click()
+
+        self.assert_backend_called('restore_file_sync_settings')
+
+        self._test_update_ui_from_settings_info(settings)
 
=== modified file 'ubuntuone/controlpanel/integrationtests/test_sd_client/test_linux.py'
--- ubuntuone/controlpanel/integrationtests/test_sd_client/test_linux.py	2011-06-02 17:19:37 +0000
+++ ubuntuone/controlpanel/integrationtests/test_sd_client/test_linux.py	2011-06-17 14:51:05 +0000
@@ -51,7 +51,10 @@
     """Fake the SyncDaemonTool."""
 
     settings = {
+        'autoconnect': True,
         'show_all_notifications': True,
+        'share_autosubscribe': True,
+        'udf_autosubscribe': True,
         'file_sync_enabled': True,
         'throttling_enabled': False,
         'limits': {'download': -1, 'upload': -1},
@@ -264,6 +267,14 @@
         """Enable/disable file sync."""
         self.settings['file_sync_enabled'] = enabled
 
+    def is_autoconnect_enabled(self):
+        """Check if autoconnect is enabled."""
+        return self.settings['autoconnect']
+
+    def enable_autoconnect(self, enabled):
+        """Enable/disable autoconnect."""
+        self.settings['autoconnect'] = enabled
+
     def is_show_all_notifications_enabled(self):
         """Check if show_all_notifications is enabled."""
         return self.settings['show_all_notifications']
@@ -272,6 +283,22 @@
         """Enable/disable show_all_notifications."""
         self.settings['show_all_notifications'] = enabled
 
+    def is_share_autosubscribe_enabled(self):
+        """Check if share_autosubscribe is enabled."""
+        return self.settings['share_autosubscribe']
+
+    def enable_share_autosubscribe(self, enabled):
+        """Enable/disable share_autosubscribe."""
+        self.settings['share_autosubscribe'] = enabled
+
+    def is_udf_autosubscribe_enabled(self):
+        """Check if udf_autosubscribe is enabled."""
+        return self.settings['udf_autosubscribe']
+
+    def enable_udf_autosubscribe(self, enabled):
+        """Enable/disable udf_autosubscribe."""
+        self.settings['udf_autosubscribe'] = enabled
+
     def refresh_volumes(self):
         """Request the volumes list to the server."""
         self.called['refresh_volumes'] = None
@@ -393,54 +420,86 @@
 class NotificationsTestCase(BaseTestCase):
     """Test for the show_all_notifications syncdaemon client methods."""
 
+    # No value passed for parameter '_' in function call
+    # pylint: disable=E1120
+
+    name = 'show_all_notifications'
+    getter = lambda _: sd_client.show_all_notifications_enabled()
+    enabler = lambda _: sd_client.enable_show_all_notifications()
+    disabler = lambda _: sd_client.disable_show_all_notifications()
+
     @inlineCallbacks
-    def test_notifications_get(self):
+    def test_get_value(self):
         """Getting the show_all_notifications state."""
-        FakedSyncDaemonTool.settings['show_all_notifications'] = False
-        state = yield sd_client.show_all_notifications_enabled()
+        FakedSyncDaemonTool.settings[self.name] = False
+        state = yield self.getter()
         self.assertEqual(state, False)
-        FakedSyncDaemonTool.settings['show_all_notifications'] = True
-        state = yield sd_client.show_all_notifications_enabled()
+        FakedSyncDaemonTool.settings[self.name] = True
+        state = yield self.getter()
         self.assertEqual(state, True)
 
     @inlineCallbacks
-    def test_notifications_get_throws_an_error(self):
+    def test_get_value_throws_an_error(self):
         """Handle error when getting the show_all_notifications state."""
-        self.patch(FakedSyncDaemonTool, 'is_show_all_notifications_enabled',
+        self.patch(FakedSyncDaemonTool, 'is_%s_enabled' % self.name,
                    self.fake_fail)
-        yield self.assertFailure(sd_client.show_all_notifications_enabled(),
-                                 CustomError)
+        yield self.assertFailure(self.getter(), CustomError)
 
     @inlineCallbacks
-    def test_notifications_enable(self):
+    def test_enable(self):
         """Enabling show_all_notifications."""
-        FakedSyncDaemonTool.settings['show_all_notifications'] = False
-        yield sd_client.enable_show_all_notifications()
-        self.assertTrue(FakedSyncDaemonTool.settings['show_all_notifications'])
+        FakedSyncDaemonTool.settings[self.name] = False
+        yield self.enabler()
+        self.assertTrue(FakedSyncDaemonTool.settings[self.name])
 
     @inlineCallbacks
-    def test_notifications_enable_throws_an_error(self):
+    def test_enable_throws_an_error(self):
         """Handle error when enabling show_all_notifications."""
-        self.patch(FakedSyncDaemonTool, 'enable_show_all_notifications',
+        self.patch(FakedSyncDaemonTool, 'enable_%s' % self.name,
                    self.fake_fail)
-        yield self.assertFailure(sd_client.enable_show_all_notifications(),
-                                 CustomError)
+        yield self.assertFailure(self.enabler(), CustomError)
 
     @inlineCallbacks
-    def test_notifications_disable(self):
+    def test_disable(self):
         """Disabling show_all_notifications."""
-        FakedSyncDaemonTool.settings['show_all_notifications'] = True
-        yield sd_client.disable_show_all_notifications()
-        value = FakedSyncDaemonTool.settings['show_all_notifications']
+        FakedSyncDaemonTool.settings[self.name] = True
+        yield self.disabler()
+        value = FakedSyncDaemonTool.settings[self.name]
         self.assertFalse(value)
 
     @inlineCallbacks
-    def test_notifications_disable_throws_an_error(self):
+    def test_disable_throws_an_error(self):
         """Handle error when disabling show_all_notifications."""
-        self.patch(FakedSyncDaemonTool, 'enable_show_all_notifications',
+        self.patch(FakedSyncDaemonTool, 'enable_%s' % self.name,
                    self.fake_fail)
-        yield self.assertFailure(sd_client.disable_show_all_notifications(),
-                                 CustomError)
+        yield self.assertFailure(self.disabler(), CustomError)
+
+
+class AutoconnectTestCase(NotificationsTestCase):
+    """Test for the autoconnect syncdaemon client methods."""
+
+    name = 'autoconnect'
+    getter = lambda _: sd_client.autoconnect_enabled()
+    enabler = lambda _: sd_client.enable_autoconnect()
+    disabler = lambda _: sd_client.disable_autoconnect()
+
+
+class ShareAutosubscribeTestCase(NotificationsTestCase):
+    """Test for the share_autosubscribe syncdaemon client methods."""
+
+    name = 'share_autosubscribe'
+    getter = lambda _: sd_client.share_autosubscribe_enabled()
+    enabler = lambda _: sd_client.enable_share_autosubscribe()
+    disabler = lambda _: sd_client.disable_share_autosubscribe()
+
+
+class UDFAutosubscribeTestCase(NotificationsTestCase):
+    """Test for the udf_autosubscribe syncdaemon client methods."""
+
+    name = 'udf_autosubscribe'
+    getter = lambda _: sd_client.udf_autosubscribe_enabled()
+    enabler = lambda _: sd_client.enable_udf_autosubscribe()
+    disabler = lambda _: sd_client.disable_udf_autosubscribe()
 
 
 class FoldersTestCase(BaseTestCase):
 
=== modified file 'ubuntuone/controlpanel/sd_client/linux.py'
--- ubuntuone/controlpanel/sd_client/linux.py	2011-05-26 22:08:32 +0000
+++ ubuntuone/controlpanel/sd_client/linux.py	2011-06-17 14:51:05 +0000
@@ -77,6 +77,21 @@
     return get_syncdaemon_tool().enable_throttling(False)
 
 
+def autoconnect_enabled():
+    """Get the state of autoconnect in the syncdaemon."""
+    return get_syncdaemon_tool().is_autoconnect_enabled()
+
+
+def enable_autoconnect():
+    """Enable autoconnect in the syncdaemon."""
+    return get_syncdaemon_tool().enable_autoconnect(True)
+
+
+def disable_autoconnect():
+    """Disable autoconnect in the syncdaemon."""
+    return get_syncdaemon_tool().enable_autoconnect(False)
+
+
 def show_all_notifications_enabled():
     """Get the state of show_all_notifications in the syncdaemon."""
     return get_syncdaemon_tool().is_show_all_notifications_enabled()
@@ -92,6 +107,36 @@
     return get_syncdaemon_tool().enable_show_all_notifications(False)
 
 
+def share_autosubscribe_enabled():
+    """Get the state of share_autosubscribe in the syncdaemon."""
+    return get_syncdaemon_tool().is_share_autosubscribe_enabled()
+
+
+def enable_share_autosubscribe():
+    """Enable share_autosubscribe in the syncdaemon."""
+    return get_syncdaemon_tool().enable_share_autosubscribe(True)
+
+
+def disable_share_autosubscribe():
+    """Disable share_autosubscribe in the syncdaemon."""
+    return get_syncdaemon_tool().enable_share_autosubscribe(False)
+
+
+def udf_autosubscribe_enabled():
+    """Get the state of udf_autosubscribe in the syncdaemon."""
+    return get_syncdaemon_tool().is_udf_autosubscribe_enabled()
+
+
+def enable_udf_autosubscribe():
+    """Enable udf_autosubscribe in the syncdaemon."""
+    return get_syncdaemon_tool().enable_udf_autosubscribe(True)
+
+
+def disable_udf_autosubscribe():
+    """Disable udf_autosubscribe in the syncdaemon."""
+    return get_syncdaemon_tool().enable_udf_autosubscribe(False)
+
+
 def get_root_dir():
     """Retrieve the root information from syncdaemon."""
     return get_syncdaemon_tool().get_root_dir()
 
=== modified file 'ubuntuone/controlpanel/tests/__init__.py'
--- ubuntuone/controlpanel/tests/__init__.py	2011-05-19 17:57:56 +0000
+++ ubuntuone/controlpanel/tests/__init__.py	2011-06-17 14:51:05 +0000
@@ -125,7 +125,10 @@
     'configurable': True,
     'device_id': 'ComputerABCDEF01234-localtoken',
     'limit_bandwidth': False,
+    'autoconnect': True,
     'show_all_notifications': True,
+    'share_autosubscribe': False,
+    'udf_autosubscribe': False,
     'max_download_speed': -1,
     'max_upload_speed': -1,
     'name': 'Ubuntu One @ localhost',
 
=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2011-06-02 03:58:53 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2011-06-17 14:51:05 +0000
@@ -63,6 +63,9 @@
 )
 
 
+# pylint: disable=E1101
+
+
 class MockWebClient(object):
     """A mock webclient."""
 
@@ -104,6 +107,9 @@
 
     throttling = False
     show_all_notifications = True
+    autoconnect = True
+    udf_autosubscribe = False
+    share_autosubscribe = False
     limits = {"download": -1, "upload": -1}
     file_sync = True
     status = {
@@ -151,6 +157,42 @@
         """Disable show_all_notifications."""
         self.show_all_notifications = False
 
+    def autoconnect_enabled(self):
+        """Return the state of autoconnect."""
+        return self.autoconnect
+
+    def enable_autoconnect(self):
+        """Enable autoconnect."""
+        self.autoconnect = True
+
+    def disable_autoconnect(self):
+        """Disable autoconnect."""
+        self.autoconnect = False
+
+    def udf_autosubscribe_enabled(self):
+        """Return the state of udf_autosubscribe."""
+        return self.udf_autosubscribe
+
+    def enable_udf_autosubscribe(self):
+        """Enable udf_autosubscribe."""
+        self.udf_autosubscribe = True
+
+    def disable_udf_autosubscribe(self):
+        """Disable udf_autosubscribe."""
+        self.udf_autosubscribe = False
+
+    def share_autosubscribe_enabled(self):
+        """Return the state of share_autosubscribe."""
+        return self.share_autosubscribe
+
+    def enable_share_autosubscribe(self):
+        """Enable share_autosubscribe."""
+        self.share_autosubscribe = True
+
+    def disable_share_autosubscribe(self):
+        """Disable share_autosubscribe."""
+        self.share_autosubscribe = False
+
     def files_sync_enabled(self):
         """Get if file sync service is enabled."""
         return MockSDClient.file_sync
@@ -319,7 +361,6 @@
     @inlineCallbacks
     def test_account_info(self):
         """The account_info method exercises its callback."""
-        # pylint: disable=E1101
         self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_NO_CURRENT_PLAN
         self.be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
         result = yield self.be.account_info()
@@ -328,7 +369,6 @@
     @inlineCallbacks
     def test_account_info_with_current_plan(self):
         """The account_info method exercises its callback."""
-        # pylint: disable=E1101
         self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_WITH_CURRENT_PLAN
         self.be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
         result = yield self.be.account_info()
@@ -359,7 +399,6 @@
     @inlineCallbacks
     def test_devices_info(self):
         """The devices_info method exercises its callback."""
-        # pylint: disable=E1101
         self.be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
         result = yield self.be.devices_info()
         self.assertEqual(result, EXPECTED_DEVICES_INFO)
@@ -402,23 +441,24 @@
         status = yield self.be.file_sync_status()
         assert status['status'] == backend.FILE_SYNC_DISABLED, status
 
-        # pylint: disable=E1101
         self.be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
         result = yield self.be.devices_info()
 
         expected = EXPECTED_DEVICES_INFO[:]
         for device in expected:
             device.pop('limit_bandwidth', None)
-            device.pop('max_download_speed', None)
-            device.pop('max_upload_speed', None)
-            device.pop('show_all_notifications', None)
+            device.pop(backend.DOWNLOAD_KEY, None)
+            device.pop(backend.UPLOAD_KEY, None)
+            device.pop(backend.AUTOCONNECT_KEY, None)
+            device.pop(backend.SHOW_ALL_NOTIFICATIONS_KEY, None)
+            device.pop(backend.SHARE_AUTOSUBSCRIBE_KEY, None)
+            device.pop(backend.UDF_AUTOSUBSCRIBE_KEY, None)
             device['configurable'] = False
         self.assertEqual(result, expected)
 
     @inlineCallbacks
     def test_devices_info_when_token_name_is_empty(self):
         """The devices_info can handle empty token names."""
-        # pylint: disable=E1101
         self.be.wc.results[DEVICES_API] = EMPTY_DESCRIPTION_JSON
         result = yield self.be.devices_info()
         expected = {'configurable': False,
@@ -430,7 +470,6 @@
     @inlineCallbacks
     def test_devices_info_does_not_log_device_id(self):
         """The devices_info does not log the device_id."""
-        # pylint: disable=E1101
         self.be.wc.results[DEVICES_API] = SAMPLE_DEVICES_JSON
         yield self.be.devices_info()
 
@@ -446,7 +485,6 @@
         dtype, did = DEVICE_TYPE_COMPUTER, "SAMPLE-TOKEN"
         device_id = 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)
@@ -457,7 +495,6 @@
     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', TOKEN['token'])
-        # pylint: disable=E1101
         self.be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
         yield self.be.remove_device(self.local_token)
         # credentials were cleared
@@ -496,10 +533,10 @@
         """The device settings are updated."""
         backend.sd_client.show_all_notifications = False
         yield self.be.change_device_settings(self.local_token,
-                                        {"show_all_notifications": True})
+                                    {backend.SHOW_ALL_NOTIFICATIONS_KEY: True})
         self.assertEqual(backend.sd_client.show_all_notifications, True)
         yield self.be.change_device_settings(self.local_token,
-                                        {"show_all_notifications": False})
+                                   {backend.SHOW_ALL_NOTIFICATIONS_KEY: False})
         self.assertEqual(backend.sd_client.show_all_notifications, False)
 
     @inlineCallbacks
@@ -566,7 +603,6 @@
     def setUp(self):
         super(BackendVolumesTestCase, self).setUp()
         # fake quota info and calculate free bytes
-        # pylint: disable=E1101
         self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_NO_CURRENT_PLAN
         self.be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
 
@@ -1009,7 +1045,6 @@
         self.be.status_changed_handler = self._set_called
         status = {'name': 'foo', 'description': 'bar', 'is_error': '',
                   'is_connected': '', 'is_online': '', 'queues': ''}
-        # pylint: disable=E1101
         backend.sd_client.status_changed_handler(status)
 
         # pylint: disable=W0212
@@ -1158,3 +1193,162 @@
         yield self.be.change_replication_settings(rid, {})
 
         self.assertEqual(MockReplicationClient.exclusions, prior)
+
+
+class BackendFileSyncSettingsTestCase(BackendBasicTestCase):
+    """File Sync Settings tests for the backend."""
+
+    default_settings = backend.ControlBackend.DEFAULT_FILE_SYNC_SETTINGS
+
+    @inlineCallbacks
+    def setUp(self):
+        yield super(BackendFileSyncSettingsTestCase, self).setUp()
+        # restore default settings
+        yield self.be.change_file_sync_settings(self.default_settings)
+
+    @inlineCallbacks
+    def assert_boolean_setting_is_correct(self, setting_name):
+        """The 'setting_name' can be successfully changed."""
+        new_value = not self.default_settings[setting_name]
+        yield self.be.change_file_sync_settings({setting_name: new_value})
+
+        self.assertEqual(getattr(backend.sd_client, setting_name), new_value)
+
+        actual = yield self.be.file_sync_settings_info()
+        expected = self.default_settings.copy()
+        expected[setting_name] = new_value
+        self.assertEqual(expected, actual)
+
+    @inlineCallbacks
+    def test_file_sync_settings_info(self):
+        """The settings_info method exercises its callback."""
+        backend.sd_client.limits = {"download": 1000, "upload": 100}
+        expected = {
+            backend.AUTOCONNECT_KEY: backend.sd_client.autoconnect,
+            backend.SHOW_ALL_NOTIFICATIONS_KEY:
+                backend.sd_client.show_all_notifications,
+            backend.SHARE_AUTOSUBSCRIBE_KEY:
+                backend.sd_client.share_autosubscribe,
+            backend.UDF_AUTOSUBSCRIBE_KEY:
+                backend.sd_client.udf_autosubscribe,
+            backend.DOWNLOAD_KEY: backend.sd_client.limits['download'],
+            backend.UPLOAD_KEY: backend.sd_client.limits['upload'],
+        }
+        result = yield self.be.file_sync_settings_info()
+        self.assertEqual(expected, result)
+
+    @inlineCallbacks
+    def test_change_file_sync_setting_autoconnect(self):
+        """The settings can be changed for autoconnect."""
+        yield self.assert_boolean_setting_is_correct(backend.AUTOCONNECT_KEY)
+
+    @inlineCallbacks
+    def test_change_file_sync_setting_show_all_notifications(self):
+        """The settings can be changed for show_all_notifications."""
+        yield self.assert_boolean_setting_is_correct(
+            backend.SHOW_ALL_NOTIFICATIONS_KEY)
+
+    @inlineCallbacks
+    def test_change_file_sync_setting_share_autosubscribe(self):
+        """The settings can be changed for share_autosubscribe."""
+        yield self.assert_boolean_setting_is_correct(
+            backend.SHARE_AUTOSUBSCRIBE_KEY)
+
+    @inlineCallbacks
+    def test_change_file_sync_setting_udf_autosubscribe(self):
+        """The settings can be changed for udf_autosubscribe."""
+        yield self.assert_boolean_setting_is_correct(
+            backend.UDF_AUTOSUBSCRIBE_KEY)
+
+    @inlineCallbacks
+    def test_change_file_sync_setting_download_bandwidth_limit(self):
+        """The settings can be changed for download_bandwidth_limit."""
+        new_value = 834
+        setting_name = backend.DOWNLOAD_KEY
+        yield self.be.change_file_sync_settings({setting_name: new_value})
+
+        self.assertEqual(backend.sd_client.throttling, True)
+        self.assertEqual(backend.sd_client.limits,
+                         {'download': new_value, 'upload': -1})
+
+    @inlineCallbacks
+    def test_change_file_sync_setting_upload_bandwidth_limit(self):
+        """The settings can be changed for upload_bandwidth_limit."""
+        new_value = 932
+        setting_name = backend.UPLOAD_KEY
+        yield self.be.change_file_sync_settings({setting_name: new_value})
+
+        self.assertEqual(backend.sd_client.throttling, True)
+        self.assertEqual(backend.sd_client.limits,
+                         {'download': -1, 'upload': new_value})
+
+    @inlineCallbacks
+    def test_no_download_limit_and_upload_change_to_no_limit(self):
+        """The settings can be changed for download_bandwidth_limit.
+
+        If the download limit was not set and the upload was set, when
+        unsetting the upload limit the bandwidth_throttling_enabled is False.
+
+        """
+        only_one_limit_set = {
+            backend.DOWNLOAD_KEY: -1,
+            backend.UPLOAD_KEY: 52,
+        }
+        yield self.be.change_file_sync_settings(only_one_limit_set)
+
+        # unset upload_bandwidth_limit
+        setting_name = backend.UPLOAD_KEY
+        yield self.be.change_file_sync_settings({setting_name: -1})
+
+        self.assertEqual(backend.sd_client.throttling, False)
+        self.assertEqual(backend.sd_client.limits,
+                         {'download': -1, 'upload': -1})
+
+    @inlineCallbacks
+    def test_no_upload_limit_and_download_change_to_no_limit(self):
+        """The settings can be changed for upload_bandwidth_limit.
+
+        If the upload limit was not set and the download was set, when
+        unsetting the download limit the bandwidth_throttling_enabled is False.
+
+        """
+        only_one_limit_set = {
+            backend.DOWNLOAD_KEY: 33,
+            backend.UPLOAD_KEY: -1,
+        }
+        yield self.be.change_file_sync_settings(only_one_limit_set)
+
+        # unset download_bandwidth_limit
+        setting_name = backend.DOWNLOAD_KEY
+        yield self.be.change_file_sync_settings({setting_name: -1})
+
+        self.assertEqual(backend.sd_client.throttling, False)
+        self.assertEqual(backend.sd_client.limits,
+                         {'download': -1, 'upload': -1})
+
+    @inlineCallbacks
+    def test_restore_defaults(self):
+        """The defaults can be restored."""
+        not_defaults = {
+            backend.AUTOCONNECT_KEY: False,
+            backend.SHOW_ALL_NOTIFICATIONS_KEY: False,
+            backend.SHARE_AUTOSUBSCRIBE_KEY: True,
+            backend.UDF_AUTOSUBSCRIBE_KEY: True,
+            backend.DOWNLOAD_KEY: 204800,
+            backend.UPLOAD_KEY: 2048,
+        }
+        yield self.be.change_file_sync_settings(not_defaults)
+
+        # the call we want to test
+        yield self.be.restore_file_sync_settings()
+
+        self.assertEqual(backend.sd_client.autoconnect, True)
+        self.assertEqual(backend.sd_client.show_all_notifications, True)
+        self.assertEqual(backend.sd_client.share_autosubscribe, False)
+        self.assertEqual(backend.sd_client.udf_autosubscribe, False)
+        self.assertEqual(backend.sd_client.throttling, False)
+        self.assertEqual(backend.sd_client.limits,
+                         {'download': -1, 'upload': -1})
+
+        result = yield self.be.file_sync_settings_info()
+        self.assertEqual(self.default_settings, result)