Merge lp:~nataliabidart/ubuntuone-control-panel/stable-3-0-update-2.99.92 into lp:ubuntuone-control-panel/stable-3-0

[Natalia Bidart]

- Updating from trunk up to revno 308:

[ Brian Curtin <email address hidden> ]
  - Match test behavior with updated functionality.

[ Diego Sarmentero <email address hidden> ]
  - Removing encoding to return unicode (LP: #966513).
  - Using limit_bandwidth attribute to properly process the info dict
    for preferences (LP: #944256).

[ Natalia B. Bidart <email address hidden> ]
  - When user rejects the License, also uninstall the application
    when in Windows (LP: #968327).
  - Remove custom path validation and use the one provided by syncdaemon
    (LP: #824252).
  - Make use of the new feature from syncdaemon where 'refresh_volumes'
    returns a deferred that gets fired when the server info is ready
    (LP: #851810).
  - Ensured that Folders' tree view has proper texts in the columns to
    have proper column widths (LP: #965175).

[ Roberto Alsina <email address hidden> ]
   - Fixed the combination of --minimized --with-icon options
    (LP: #968369).

[lp:~nataliabidart/ubuntuone-control-panel/stable-3-0-update-2.99.92]

258. By Natalia Bidart on 2012-04-03

Attaching bug numbers.

[Alejandro J. Cura (alecu)]

Approving

review: Approve

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2012-03-01 22:05:51 +0000
+++ ubuntuone/controlpanel/backend.py	2012-04-03 13:15:23 +0000
@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
-
-# Authors: Alejandro J. Cura <[e-mail]>
-# Authors: Natalia B. Bidart <[e-mail]>
 #
-# Copyright 2010 Canonical Ltd.
+# Copyright 2010-2012 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
@@ -26,11 +23,7 @@
 from functools import wraps
 
 from twisted.internet.defer import inlineCallbacks, returnValue
-# No name 'is_link' in module 'ubuntuone.platform'
-# pylint: disable=E0611, F0401
-from ubuntuone.platform import is_link
 from ubuntuone.platform.credentials import CredentialsManagementTool
-# pylint: enable=E0611, F0401
 
 from ubuntuone.controlpanel import sd_client, replication_client
 from ubuntuone.controlpanel.logger import setup_logging, log_call
@@ -599,7 +592,7 @@
 
     @log_call(logger.debug)
     @inlineCallbacks
-    def volumes_info(self, with_storage_info=True):
+    def volumes_info(self, with_storage_info=True, refresh=False):
         """Get the volumes info."""
         self._volumes = {}
 
@@ -612,6 +605,9 @@
             else:
                 free_bytes = account['quota_total'] - account['quota_used']
 
+        if refresh:
+            yield self.sd_client.refresh_volumes()
+
         root_dir = yield self.sd_client.get_root_dir()
         shares_dir = yield self.sd_client.get_shares_dir()
         shares_dir_link = yield self.sd_client.get_shares_dir_link()
@@ -717,28 +713,9 @@
         yield self.sd_client.create_folder(path=folder_path)
 
     @log_call(logger.debug)
-    @inlineCallbacks
     def validate_path_for_folder(self, folder_path):
         """Validate 'folder_path' for folder creation."""
-        user_home = yield self.get_home_dir()
-        folder_path = append_path_sep(folder_path)
-
-        # handle folder_path not within '~' or links
-        # XXX is_link expects bytes, see bug #824252
-        if not folder_path.startswith(user_home) or is_link(
-            folder_path.encode('utf-8')):
-            returnValue(False)
-
-        # handle folder_path nested with a existing cloud folder
-        volumes = yield self.volumes_info(with_storage_info=False)
-        for _, _, data in volumes:
-            for volume in data:
-                cloud_folder = append_path_sep(volume['path'])
-                if (folder_path.startswith(cloud_folder) or
-                    cloud_folder.startswith(folder_path)):
-                    returnValue(False)
-
-        returnValue(True)
+        return self.sd_client.validate_path(folder_path)
 
     @log_call(logger.debug)
     @inlineCallbacks
@@ -787,8 +764,13 @@
             result[name] = bool(value)
 
         limits = yield self.sd_client.get_throttling_limits()
-        result[DOWNLOAD_KEY] = limits['download']
-        result[UPLOAD_KEY] = limits['upload']
+        limits_enabled = yield self.sd_client.bandwidth_throttling_enabled()
+        if limits_enabled:
+            result[DOWNLOAD_KEY] = limits['download']
+            result[UPLOAD_KEY] = limits['upload']
+        else:
+            result[DOWNLOAD_KEY] = -1
+            result[UPLOAD_KEY] = -1
 
         returnValue(result)
 

=== removed file 'ubuntuone/controlpanel/dbustests/test_sd_client/test_linux.py'
--- ubuntuone/controlpanel/dbustests/test_sd_client/test_linux.py	2011-10-24 21:48:27 +0000
+++ ubuntuone/controlpanel/dbustests/test_sd_client/test_linux.py	1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Authors: Alejandro J. Cura <[e-mail]>
-# 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 DBus service when accessing SyncDaemon."""
-
-import dbus
-
-from twisted.internet import defer
-
-from ubuntuone.platform.linux import dbus_interface as sd_dbus_iface
-
-from ubuntuone.controlpanel import sd_client
-from ubuntuone.controlpanel.dbustests import DBusClientTestCase
-
-
-SD_DBUS_IFACE_NAME = sd_dbus_iface.DBUS_IFACE_NAME
-SD_DBUS_IFACE_STATUS_NAME = sd_dbus_iface.DBUS_IFACE_STATUS_NAME
-
-# pylint, you have to go to decorator's school
-# pylint: disable=C0322
-
-# Access to a protected member of a client class
-# pylint: disable=W0212
-
-
-class StatusMockDBusSyncDaemon(dbus.service.Object):
-    """A mock object that mimicks syncdaemon regarding the Status iface."""
-
-    state_dict = {
-        'name': 'TEST',
-        'description': 'Some test state, nothing else.',
-        'is_error': '',
-        'is_connected': 'True',
-        'is_online': '',
-        'queues': 'GORGEOUS',
-        'connection': '',
-    }
-
-    def _get_current_state(self):
-        """Get the current status of the system."""
-        return self.state_dict
-
-    @dbus.service.method(SD_DBUS_IFACE_STATUS_NAME,
-                         in_signature='', out_signature='a{ss}')
-    def current_status(self):
-        """Return the current faked status of the system."""
-        return self._get_current_state()
-
-    # pylint: disable=C0103
-    # Invalid name "StatusChanged"
-
-    @dbus.service.signal(SD_DBUS_IFACE_STATUS_NAME)
-    def StatusChanged(self, status):
-        """Fire a signal to notify that the status of the system changed."""
-
-    def emit_status_changed(self, state=None):
-        """Emit StatusChanged."""
-        self.StatusChanged(self._get_current_state())
-
-
-class StatusTestCase(DBusClientTestCase):
-    """Test for the status dbus client methods."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(StatusTestCase, self).setUp()
-        self.register_mockserver(SD_DBUS_IFACE_NAME,
-                                 "/status", StatusMockDBusSyncDaemon)
-
-    def test_set_status_changed_handler(self):
-        """A proper callback can be connected to StatusChanged signal."""
-        client = sd_client.SyncDaemonClient()
-        _, sig = client.set_status_changed_handler(self._set_called)
-
-        self.assertEqual(sig._handler, self._set_called)
-        self.assertEqual(sig._member, 'StatusChanged')
-        self.assertEqual(sig._path, '/status')
-        self.assertEqual(sig._interface, SD_DBUS_IFACE_STATUS_NAME)

=== modified file 'ubuntuone/controlpanel/gui/__init__.py'
--- ubuntuone/controlpanel/gui/__init__.py	2012-03-20 15:11:56 +0000
+++ ubuntuone/controlpanel/gui/__init__.py	2012-04-03 13:15:23 +0000
@@ -204,7 +204,7 @@
 MAIN_PREFERENCES_TAB = _('Settings')
 MAIN_WINDOW_TITLE = _('%(app_name)s Control Panel')
 MUSIC_DISPLAY_NAME = _('Purchased Music')
-MUSIC_REAL_PATH = '.ubuntuone/Purchased from Ubuntu One'
+MUSIC_REAL_PATH = u'.ubuntuone/Purchased from Ubuntu One'
 MY_FOLDERS = _('My folders')
 NAME_NOT_SET = _('[unknown user name]')
 NETWORK_OFFLINE = _('An internet connection is required to join or sign '

=== modified file 'ubuntuone/controlpanel/gui/qt/controlpanel.py'
--- ubuntuone/controlpanel/gui/qt/controlpanel.py	2012-03-21 19:17:21 +0000
+++ ubuntuone/controlpanel/gui/qt/controlpanel.py	2012-04-03 13:15:23 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-
+#
 # Copyright 2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -174,7 +174,6 @@
     @log_call(logger.info)
     def start_from_license(self):
         """Use the license page as first page."""
-        # license
-        self.ui.wizard.setStartId(self.ui.wizard.pages[
-            self.ui.wizard.license_page])
+        license_id = self.ui.wizard.pages[self.ui.wizard.license_page]
+        self.ui.wizard.setStartId(license_id)
         self.ui.wizard.restart()

=== modified file 'ubuntuone/controlpanel/gui/qt/folders.py'
--- ubuntuone/controlpanel/gui/qt/folders.py	2012-03-20 13:05:20 +0000
+++ ubuntuone/controlpanel/gui/qt/folders.py	2012-04-03 13:15:23 +0000
@@ -123,7 +123,7 @@
         self.ui.folders.headerItem().setText(FOLDER_NAME_COL,
                                              FOLDERS_COLUMN_NAME)
         self.ui.folders.headerItem().setText(SUBSCRIPTION_COL,
-                                             FOLDERS_COLUMN_SYNC_LOCALLY)
+                                             ALWAYS_SUBSCRIBED)
         self.ui.folders.headerItem().setText(EXPLORE_COL,
                                              FOLDERS_COLUMN_EXPLORE)
         headers = self.ui.folders.header()
@@ -153,7 +153,8 @@
     def load(self):
         """Load specific tab info."""
         self.is_processing = True
-        info = yield self.backend.volumes_info(with_storage_info=False)
+        info = yield self.backend.volumes_info(with_storage_info=False,
+                                               refresh=self.remote_folders)
         self.process_info(info)
 
     @handle_errors(logger=logger)

=== modified file 'ubuntuone/controlpanel/gui/qt/gui.py'
--- ubuntuone/controlpanel/gui/qt/gui.py	2012-03-26 13:23:57 +0000
+++ ubuntuone/controlpanel/gui/qt/gui.py	2012-04-03 13:15:23 +0000
@@ -43,8 +43,7 @@
         self.ui.setupUi(self)
         self.close_callback = close_callback
         self._setup()
-        self.quit_action = QtGui.QAction(self,
-            triggered=self.close)
+        self.quit_action = QtGui.QAction(self, triggered=self.close)
         self.quit_action.setShortcuts(["Ctrl+q", "Ctrl+w"])
         self.addAction(self.quit_action)
         self.installer = installer

=== modified file 'ubuntuone/controlpanel/gui/qt/main/__init__.py'
--- ubuntuone/controlpanel/gui/qt/main/__init__.py	2012-03-27 13:41:19 +0000
+++ ubuntuone/controlpanel/gui/qt/main/__init__.py	2012-04-03 13:15:23 +0000
@@ -98,7 +98,8 @@
     icon, window = start(lambda: source.main_quit(app),
                          minimized=minimized, with_icon=with_icon,
                          installer=installer)
-    window.switch_to(switch_to)
+    if window:
+        window.switch_to(switch_to)
     # pylint: enable=W0612
     if icon:
         app.new_instance.connect(icon.restore_window)

=== modified file 'ubuntuone/controlpanel/gui/qt/main/tests/test_main.py'
--- ubuntuone/controlpanel/gui/qt/main/tests/test_main.py	2012-03-27 13:49:49 +0000
+++ ubuntuone/controlpanel/gui/qt/main/tests/test_main.py	2012-04-03 13:15:23 +0000
@@ -96,8 +96,11 @@
         self.window = None
 
     def __call__(self, *args, **kwargs):
+        if kwargs.get('minimized', False):
+            self.window = None
+        else:
+            self.window = FakeMainWindow()
         self.args = (args, kwargs)
-        self.window = FakeMainWindow()
         return None, self.window
 
 
@@ -166,6 +169,12 @@
         self.assertEqual(self.start.args[1],
             {'minimized': False, 'with_icon': False, 'installer': True})
 
+    def test_minimized_with_icon_options(self):
+        """Ensure you can be minimized and with icon at the same time."""
+        main.main([sys.argv[0], "--minimized", "--with-icon"])
+        self.assertEqual(self.start.args[1],
+            {'minimized': True, 'with_icon': True, 'installer': False})
+
     def test_translator(self):
         """Ensure the Qt translator is loaded."""
         main.main([sys.argv[0]])

=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_folders.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_folders.py	2012-03-23 14:04:57 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_folders.py	2012-04-03 13:15:23 +0000
@@ -187,7 +187,8 @@
 
     def test_info_is_requested_on_load(self):
         """The volumes info is requested to the backend."""
-        self.assert_backend_called('volumes_info', with_storage_info=False)
+        self.assert_backend_called('volumes_info', with_storage_info=False,
+                                   refresh=self.ui.remote_folders)
 
     def test_process_info(self):
         """The volumes info is processed when ready."""
@@ -409,6 +410,17 @@
                 item)
             it += 1
 
+    def test_tree_view_header(self):
+        """The tree view header is hidden but the text is correct."""
+        self.assertFalse(self.ui.ui.folders.header().isVisible())
+
+        name = self.ui.ui.folders.headerItem().text(gui.FOLDER_NAME_COL)
+        self.assertEqual(name, gui.FOLDERS_COLUMN_NAME)
+        name = self.ui.ui.folders.headerItem().text(gui.SUBSCRIPTION_COL)
+        self.assertEqual(name, gui.ALWAYS_SUBSCRIBED)
+        name = self.ui.ui.folders.headerItem().text(gui.EXPLORE_COL)
+        self.assertEqual(name, gui.FOLDERS_COLUMN_EXPLORE)
+
     def test_share_publish_button(self):
         """When clicking the share/publish button, the proper url is opened."""
         self.assertTrue(self.ui.ui.share_publish_button.isVisible())

=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_preferences.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_preferences.py	2012-03-01 22:05:51 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_preferences.py	2012-04-03 13:15:23 +0000
@@ -76,6 +76,21 @@
 
         self.assertFalse(self.ui.is_processing)
 
+    def test_process_info_limit_bandwidth(self):
+        """The ui is not processing when contents are load."""
+        self.ui.process_info(SAMPLE_SETTINGS)
+
+        self.assertTrue(self.ui.ui.limit_uploads_checkbox.isChecked())
+        self.assertTrue(self.ui.ui.limit_downloads_checkbox.isChecked())
+
+        settings = SAMPLE_SETTINGS.copy()
+        settings[gui.backend.DOWNLOAD_KEY] = -1
+        settings[gui.backend.UPLOAD_KEY] = -1
+        self.ui.process_info(settings)
+
+        self.assertFalse(self.ui.ui.limit_uploads_checkbox.isChecked())
+        self.assertFalse(self.ui.ui.limit_downloads_checkbox.isChecked())
+
     def test_info_is_requested_on_load(self):
         """The info is requested to the backend."""
         self.assert_backend_called('file_sync_settings_info')

=== modified file 'ubuntuone/controlpanel/gui/qt/tests/test_wizard.py'
--- ubuntuone/controlpanel/gui/qt/tests/test_wizard.py	2012-03-26 21:00:47 +0000
+++ ubuntuone/controlpanel/gui/qt/tests/test_wizard.py	2012-04-03 13:15:23 +0000
@@ -157,6 +157,7 @@
     @defer.inlineCallbacks
     def setUp(self):
         yield super(UbuntuOneWizardTestCase, self).setUp()
+        self.patch(gui.utils, 'uninstall_application', self.fail)
         self.patch(self.ui.confirm_dialog, 'exec_',
                    lambda: self.confirm_response)
 
@@ -260,7 +261,7 @@
                 button.click()
 
                 self.assertEqual(self._called, (signal_args, {}),
-                                msg % (name, signal, signal_args))
+                                 msg % (name, signal, signal_args))
                 self._called = False
 
     def test_done_rejected(self):
@@ -336,6 +337,16 @@
     page_name = 'license'
     stage_name = 'install'
 
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(UbuntuOneWizardLicensePage, self).setUp()
+        self.patch(gui.utils, 'uninstall_application', self._set_called)
+
+    def test_done_rejected(self):
+        """When the wizard is closed on the final page, emit rejected."""
+        super(UbuntuOneWizardLicensePage, self).test_done_rejected()
+        self.assertEqual(self._called, ((), {}))
+
 
 class UbuntuOneWizardLoginTestCase(UbuntuOneWizardTestCase):
     """Test the login through the wizard."""

=== modified file 'ubuntuone/controlpanel/gui/qt/wizard.py'
--- ubuntuone/controlpanel/gui/qt/wizard.py	2012-03-26 20:15:58 +0000
+++ ubuntuone/controlpanel/gui/qt/wizard.py	2012-04-03 13:15:23 +0000
@@ -23,7 +23,7 @@
 from ubuntu_sso.qt.sso_wizard_page import BaseWizardPage
 from ubuntu_sso.utils.ui import CLOSE_AND_SETUP_LATER
 
-from ubuntuone.controlpanel import cache
+from ubuntuone.controlpanel import cache, utils
 from ubuntuone.controlpanel.logger import log_call, setup_logging
 from ubuntuone.controlpanel.gui import (
     APP_NAME,
@@ -342,13 +342,9 @@
             response = self.confirm_dialog.exec_()
             if response == QtGui.QDialog.Accepted:
                 logger.warning('UbuntuOneWizard: user canceled setup.')
-                self.rejected.emit()
-        elif (self.currentId() == self.pages[self.license_page]):
-            response = self.confirm_dialog.exec_()
-            if response == QtGui.QDialog.Accepted:
-                logger.warning('UbuntuOneWizard: user wants to uninstall.')
-                # TODO: needs implementation in this project
-                ##qt.utils.uninstall_application()
+                if self.currentId() == self.pages[self.license_page]:
+                    logger.warning('UbuntuOneWizard: user wants to uninstall.')
+                    utils.uninstall_application()
                 self.rejected.emit()
         else:
             super(UbuntuOneWizard, self).done(result)

=== modified file 'ubuntuone/controlpanel/sd_client/__init__.py'
--- ubuntuone/controlpanel/sd_client/__init__.py	2012-01-18 14:06:35 +0000
+++ ubuntuone/controlpanel/sd_client/__init__.py	2012-04-03 13:15:23 +0000
@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
-
-# Authors: Natalia B Bidart <[e-mail]>
 #
-# Copyright 2011 Canonical Ltd.
+# Copyright 2012 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
@@ -18,7 +16,6 @@
 
 """The syncdaemon client."""
 
-import sys
 import warnings
 
 # pylint: disable=E0611
@@ -35,7 +32,6 @@
 
     def __init__(self):
         """Get a proxy for the SyncDaemonTool."""
-        self.status_changed_handler = None
         self.proxy = tools.SyncDaemonTool()
 
     def get_throttling_limits(self):
@@ -128,6 +124,10 @@
         """Retrieve the folders information from syncdaemon."""
         return self.proxy.get_folders()
 
+    def validate_path(self, path):
+        """Validates 'path' to create a new folder through syncdaemon."""
+        return self.proxy.validate_path(path)
+
     def create_folder(self, path):
         """Create a new folder through syncdaemon."""
         return self.proxy.create_folder(path)
@@ -200,11 +200,8 @@
 
     def set_status_changed_handler(self, handler):
         """Set the status handler function."""
-        self.status_changed_handler = handler
-        if sys.platform.startswith("linux"):
-            # pylint: disable=W0404
-            from ubuntuone.controlpanel.sd_client import linux
-            result = linux.set_status_changed_handler(handler)
-        else:
-            result = self.proxy.set_status_changed_handler(handler)
-        return result
+        return self.proxy.connect_signal('StatusChanged', handler)
+
+    def refresh_volumes(self):
+        """Refresh the volumes information from syncdaemon."""
+        return self.proxy.refresh_volumes()

=== removed file 'ubuntuone/controlpanel/sd_client/linux.py'
--- ubuntuone/controlpanel/sd_client/linux.py	2011-06-29 17:59:07 +0000
+++ ubuntuone/controlpanel/sd_client/linux.py	1970-01-01 00:00:00 +0000
@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Authors: Alejandro J. Cura <[e-mail]>
-# 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 use other DBus services."""
-
-import dbus.service
-
-from ubuntuone.controlpanel.logger import setup_logging
-
-
-logger = setup_logging('sd_client')
-
-
-def get_syncdaemon_proxy(object_path, dbus_interface):
-    """Get a DBus proxy for syncdaemon at 'object_path':'dbus_interface'."""
-    logger.debug('get_syncdaemon_proxy: object_path %r, dbus_interface %r',
-                 object_path, dbus_interface)
-    bus = dbus.SessionBus()
-    obj = bus.get_object(bus_name='com.ubuntuone.SyncDaemon',
-                         object_path=object_path,
-                         follow_name_owner_changes=True)
-    proxy = dbus.Interface(object=obj, dbus_interface=dbus_interface)
-    return proxy
-
-
-def set_status_changed_handler(handler):
-    """Connect 'handler' with syncdaemon's StatusChanged signal."""
-    proxy = get_syncdaemon_proxy('/status', 'com.ubuntuone.SyncDaemon.Status')
-    sig = proxy.connect_to_signal('StatusChanged', handler)
-    return proxy, sig

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2012-02-06 15:23:27 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2012-04-03 13:15:23 +0000
@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
-
-# Authors: Alejandro J. Cura <[e-mail]>
-# Authors: Natalia B. Bidart <[e-mail]>
 #
-# Copyright 2010 Canonical Ltd.
+# Copyright 2010-2012 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
@@ -169,6 +166,7 @@
         self.actions = []
         self.shares = []
         self.folders = []
+        self.volumes_refreshed = False
 
     def get_throttling_limits(self):
         """Return the sample speed limits."""
@@ -291,6 +289,10 @@
         """Unsubcribe from 'volume_id'."""
         self.subscribed_folders.remove(volume_id)
 
+    def validate_path(self, path):
+        """Validate a path for folder creation."""
+        return path != USER_HOME
+
     def create_folder(self, path):
         """Grab list of folders."""
         self.folders.append(path)
@@ -319,6 +321,11 @@
         """Grab list of shared (shares from the user to others)."""
         return SAMPLE_SHARED
 
+    def refresh_volumes(self):
+        """Refresh the volume list."""
+        self.volumes_refreshed = True
+        return defer.succeed(None)
+
 
 class MockReplicationClient(CallRecorder):
     """A mock replication_client module."""
@@ -860,10 +867,19 @@
             u'display_name': display_name,
         }
 
+        self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
+        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
+
     @inlineCallbacks
-    def expected_volumes(self, sample_shares, sample_folders,
+    def expected_volumes(self, sample_shares=None, sample_folders=None,
                          with_storage_info=True):
         """Get shares and group by sharing user, get folders and free space."""
+        if sample_shares is None:
+            sample_shares = self.be.sd_client.shares
+
+        if sample_folders is None:
+            sample_folders = self.be.sd_client.folders
+
         free_bytes = self.be.FREE_BYTES_NOT_AVAILABLE
         if with_storage_info:
             try:
@@ -926,11 +942,19 @@
     @inlineCallbacks
     def test_volumes_info(self):
         """The volumes_info method exercises its callback."""
-        self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
-
-        expected = yield self.expected_volumes(SAMPLE_SHARES, SAMPLE_FOLDERS)
+        expected = yield self.expected_volumes()
         result = yield self.be.volumes_info()
+
+        self.assertEqual(result, expected)
+        self.assertFalse(self.be.sd_client.volumes_refreshed)
+
+    @inlineCallbacks
+    def test_volumes_info_can_refresh_volumes(self):
+        """The volumes_info can be refreshed."""
+        expected = yield self.expected_volumes()
+        result = yield self.be.volumes_info(refresh=True)
+
+        self.assertTrue(self.be.sd_client.volumes_refreshed)
         self.assertEqual(result, expected)
 
     @inlineCallbacks
@@ -943,7 +967,6 @@
             path = path[len(USER_HOME) + 1:]
             item[u'path'] = os.path.join(root_path, path)
         self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
 
         yield self.be.volumes_info()
         for item in SAMPLE_FOLDERS:
@@ -956,11 +979,7 @@
     @inlineCallbacks
     def test_volumes_info_without_storage_info(self):
         """The volumes_info method exercises its callback."""
-        self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
-
-        expected = yield self.expected_volumes(SAMPLE_SHARES, SAMPLE_FOLDERS,
-                                               with_storage_info=False)
+        expected = yield self.expected_volumes(with_storage_info=False)
         result = yield self.be.volumes_info(with_storage_info=False)
         self.assertEqual(result, expected)
 
@@ -971,11 +990,8 @@
     @inlineCallbacks
     def test_volumes_are_cached(self):
         """The volume list is cached."""
-        self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
-
         expected = {}
-        info = yield self.expected_volumes(SAMPLE_SHARES, SAMPLE_FOLDERS)
+        info = yield self.expected_volumes()
         for _, _, data in info:
             for volume in data:
                 sid = volume['volume_id']
@@ -1024,10 +1040,8 @@
         ]
 
         self.patch(self.be.sd_client, 'shares', read_only_shares)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
 
-        expected = yield self.expected_volumes(read_only_shares,
-                                               SAMPLE_FOLDERS)
+        expected = yield self.expected_volumes()
         result = yield self.be.volumes_info()
         self.assertEqual(result, expected)
 
@@ -1035,10 +1049,8 @@
     def test_volumes_info_no_quota_for_root(self):
         """The volumes_info returns info even if quota call fails."""
         self.be.wc.failure = 500
-        self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
 
-        expected = yield self.expected_volumes(SAMPLE_SHARES, SAMPLE_FOLDERS)
+        expected = yield self.expected_volumes()
         result = yield self.be.volumes_info()
 
         self.assertEqual(len(result), len(expected))
@@ -1126,29 +1138,15 @@
     @inlineCallbacks
     def test_create_folder(self):
         """New folders can be created."""
+        self.patch(self.be.sd_client, 'folders', [])
+
         folder_path = os.path.join(USER_HOME, 'Test Me')
         yield self.be.create_folder(folder_path=folder_path)
 
         self.assertEqual(self.be.sd_client.folders, [folder_path])
 
-
-class BackendValidatePathForFolderTestCase(BackendBasicTestCase):
-    """Test for the path validator when creating folders."""
-
-    msg = '%r must not be a valid path for creating a folder.'
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(BackendValidatePathForFolderTestCase, self).setUp()
-        old_home = os.environ['HOME']
-        os.environ['HOME'] = USER_HOME
-        self.addCleanup(os.environ.__setitem__, 'HOME', old_home)
-        self.patch(self.be.sd_client, 'shares', SAMPLE_SHARES)
-        self.patch(self.be.sd_client, 'folders', SAMPLE_FOLDERS)
-        self.patch(backend, 'is_link', lambda p: False)
-
-    @defer.inlineCallbacks
-    def test_valid_if_folder_inside_home(self):
+    @defer.inlineCallbacks
+    def test_validate_path_for_folder(self):
         """Test proper validation of path for creating folders."""
         folder_path = os.path.join(USER_HOME, 'Test Me')
 
@@ -1157,68 +1155,11 @@
             '%r must be a valid path for creating a folder.' % folder_path)
 
     @defer.inlineCallbacks
-    def test_valid_if_folder_shares_a_prefix_with_an_udf(self):
-        """Test proper validation of path for creating folders.
-
-        If the user chooses a folder with the same prefix as an UDF, but
-        outside every UDF, the path is valid.
-
-        """
-        tricky_path = ROOT_PATH
-        assert not tricky_path.endswith(os.path.sep)
-        tricky_path += ' Suffix'
-        assert tricky_path.startswith(ROOT_PATH)
-
-        result = yield self.be.validate_path_for_folder(tricky_path)
-        self.assertTrue(result,
-            '%r must be a valid path for creating a folder.' % tricky_path)
-
-    @inlineCallbacks
-    def test_path_not_valid_if_outside_home(self):
-        """A folder outside ~ is not valid."""
-        outside_home = os.path.abspath(os.path.join(USER_HOME, os.path.pardir))
-
-        result = yield self.be.validate_path_for_folder(outside_home)
-        self.assertFalse(result, self.msg % outside_home)
-
-    @defer.inlineCallbacks
-    def test_not_valid_if_folder_inside_root(self):
-        """A folder inside the root is not valid."""
-        root_path = ROOT_PATH
-        # create a valid path inside the root
-        inside_root = os.path.abspath(os.path.join(root_path, 'test'))
-
-        result = yield self.be.validate_path_for_folder(inside_root)
-        self.assertFalse(result, self.msg % inside_root)
-
-    @defer.inlineCallbacks
-    def test_not_valid_if_folder_inside_an_udf(self):
-        """A folder inside an UDF is not valid."""
-        udf_path = SAMPLE_FOLDERS[-1]['path']
-        # create a valid path inside an existing UDF
-        inside_udf = os.path.abspath(os.path.join(udf_path, 'test'))
-
-        result = yield self.be.validate_path_for_folder(inside_udf)
-        self.assertFalse(result, self.msg % inside_udf)
-
-    @defer.inlineCallbacks
-    def test_not_valid_if_folder_is_parent_of_an_udf(self):
-        """A folder parent of an UDF is not valid."""
-        udf_path = SAMPLE_FOLDERS[-1]['path']
-        # create a valid path that is parent from an existing UDF
-        udf_parent = os.path.abspath(os.path.join(udf_path, os.path.pardir))
-
-        result = yield self.be.validate_path_for_folder(udf_parent)
-        self.assertFalse(result, self.msg % udf_parent)
-
-    @defer.inlineCallbacks
-    def test_not_valid_if_folder_is_link(self):
-        """A link path is not valid."""
-        self.patch(backend, 'is_link', lambda p: True)
-        path_link = os.path.join(USER_HOME, 'Test Me')
-
-        result = yield self.be.validate_path_for_folder(path_link)
-        self.assertFalse(result, self.msg % path_link)
+    def test_validate_path_for_folder_invalid(self):
+        """Test proper validation of path for creating folders."""
+        result = yield self.be.validate_path_for_folder(USER_HOME)
+        self.assertFalse(result,
+            '%r must not be a valid path for creating a folder.' % USER_HOME)
 
 
 class BackendSyncStatusTestCase(BackendBasicTestCase):
@@ -1598,6 +1539,7 @@
     @inlineCallbacks
     def test_file_sync_settings_info(self):
         """The settings_info method exercises its callback."""
+        self.patch(self.be.sd_client, "throttling", True)
         self.be.sd_client.limits = {"download": 1000, "upload": 100}
         expected = {
             backend.AUTOCONNECT_KEY: self.be.sd_client.autoconnect,
@@ -1614,6 +1556,25 @@
         self.assertEqual(expected, result)
 
     @inlineCallbacks
+    def test_file_sync_settings_info_with_limit(self):
+        """The settings_info method exercises its callback."""
+        self.patch(self.be.sd_client, "throttling", False)
+        self.be.sd_client.limits = {"download": 987456, "upload": 125698}
+        expected = {
+            backend.AUTOCONNECT_KEY: self.be.sd_client.autoconnect,
+            backend.SHOW_ALL_NOTIFICATIONS_KEY:
+                self.be.sd_client.show_all_notifications,
+            backend.SHARE_AUTOSUBSCRIBE_KEY:
+                self.be.sd_client.share_autosubscribe,
+            backend.UDF_AUTOSUBSCRIBE_KEY:
+                self.be.sd_client.udf_autosubscribe,
+            backend.DOWNLOAD_KEY: -1,
+            backend.UPLOAD_KEY: -1,
+        }
+        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)

=== modified file 'ubuntuone/controlpanel/tests/test_sd_client.py'
--- ubuntuone/controlpanel/tests/test_sd_client.py	2012-03-19 17:16:43 +0000
+++ ubuntuone/controlpanel/tests/test_sd_client.py	2012-04-03 13:15:23 +0000
@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
-
-# Authors: Alejandro J. Cura <[e-mail]>
-# Authors: Natalia B. Bidart <[e-mail]>
 #
-# Copyright 2010 Canonical Ltd.
+# Copyright 2010-2012 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
@@ -24,11 +21,7 @@
 
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks, returnValue
-from ubuntuone.devtools.testcases import skipIfNotOS
-# No name 'tools' in module 'ubuntuone.platform'
-# pylint: disable=E0611
 from ubuntuone.platform import tools
-# pylint: enable=E0611
 from ubuntuone.syncdaemon.interaction_interfaces import bool_str
 
 from ubuntuone.controlpanel import sd_client
@@ -164,6 +157,10 @@
         """Get the list of the shares "shared"/created/offered."""
         self.called['list_shared'] = None
 
+    def validate_path(self, path):
+        """Validate a path for folder creation."""
+        return path not in [f['path'] for f in self.folders.itervalues()]
+
     def create_folder(self, path):
         """Create a user defined folder in the specified path."""
         if path == '':  # simulate an error
@@ -183,14 +180,12 @@
     @inlineCallbacks
     def subscribe_folder(self, folder_id):
         """Subscribe to a user defined folder given its id."""
-        yield self._set_folder_attr(folder_id,
-                                                   u'subscribed', True)
+        yield self._set_folder_attr(folder_id, u'subscribed', True)
 
     @inlineCallbacks
     def unsubscribe_folder(self, folder_id):
         """Unsubscribe from a user defined folder given its id."""
-        yield self._set_folder_attr(folder_id,
-                                                   u'subscribed', False)
+        yield self._set_folder_attr(folder_id, u'subscribed', False)
 
     @inlineCallbacks
     def get_folders(self):
@@ -315,9 +310,9 @@
         """Return the shares link directory."""
         return self.shares_dir_link
 
-    def set_status_changed_handler(self, handler):
+    def connect_signal(self, signal_name, handler):
         """Set the handler for the status changed signal."""
-        self.called['status_changed_handler'] = handler
+        self.called[signal_name] = handler
 
 
 class BaseTestCase(TestCase):
@@ -519,6 +514,19 @@
         yield self.assertFailure(self.sd.get_folders(), CustomError)
 
     @inlineCallbacks
+    def test_validate_path(self):
+        """Check if a folder path is valid."""
+        path = '~/bar/baz'
+        result = yield self.sd.validate_path(path)
+
+        self.assertTrue(result)
+
+        yield self.sd.create_folder(path)
+        result = yield self.sd.validate_path(path)
+
+        self.assertFalse(result)
+
+    @inlineCallbacks
     def test_create_folder(self):
         """Create a new folder."""
         path = '~/bar/baz'
@@ -694,14 +702,12 @@
 
         self.assertEqual(self.sd.proxy.called['quit'], None)
 
-    @skipIfNotOS('win32', 'The tested function is only defined on windows')
     @inlineCallbacks
     def test_set_status_changed_handler(self):
         """Connect a handler to the status changed signal."""
         sample_handler = object()
         yield self.sd.set_status_changed_handler(sample_handler)
-        self.assertEqual(sample_handler,
-                   self.sd.proxy.called['status_changed_handler'])
+        self.assertEqual(sample_handler, self.sd.proxy.called['StatusChanged'])
 
 
 class BasicTestCase(BaseTestCase):

=== modified file 'ubuntuone/controlpanel/utils/__init__.py'
--- ubuntuone/controlpanel/utils/__init__.py	2012-03-22 23:28:19 +0000
+++ ubuntuone/controlpanel/utils/__init__.py	2012-04-03 13:15:23 +0000
@@ -32,19 +32,23 @@
 # ignore issues with the name of the method
 # pylint: disable=C0103
 
+no_op = lambda *args, **kwargs: None
+
 # import the platform dependent code.
 if sys.platform == 'win32':
     from ubuntuone.controlpanel.utils import windows
+    add_to_autostart = windows.add_to_autostart
     are_updates_present = windows.are_updates_present
     default_folders = windows.default_folders
     perform_update = windows.perform_update
-    add_to_autostart = windows.add_to_autostart
+    uninstall_application = windows.uninstall_application
 else:
     from ubuntuone.controlpanel.utils import linux
-    are_updates_present = lambda *args, **kwargs: False
+    add_to_autostart = no_op
+    are_updates_present = no_op
     default_folders = linux.default_folders
-    perform_update = lambda *args, **kwargs: None
-    add_to_autostart = lambda *args, **kwargs: None
+    perform_update = no_op
+    uninstall_application = no_op
 
 # pylint: enable=C0103
 

=== modified file 'ubuntuone/controlpanel/utils/tests/test_windows.py'
--- ubuntuone/controlpanel/utils/tests/test_windows.py	2012-03-23 21:20:18 +0000
+++ ubuntuone/controlpanel/utils/tests/test_windows.py	2012-04-03 13:15:23 +0000
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
-
 #
-# Copyright 2011 Canonical Ltd.
+# Copyright 2011-2012 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
@@ -28,6 +27,34 @@
 # let me use protected methods
 # pylint: disable=W0212
 
+SOME_EXE_NAME = 'foo.exe'
+
+
+class FrozenTestCase(TestCase):
+    """A base test case for handling frozen/not frozen systems."""
+
+    frozen = True
+    executable = 'path/to/current/exe/ubuntuone/dist/executable.exe'
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the different tests."""
+        yield super(FrozenTestCase, self).setUp()
+
+        for attr_name in ('frozen', 'executable'):
+            value_not_set = object()
+            value = getattr(utils.windows.sys, attr_name, value_not_set)
+
+            if self.frozen is not None:
+                setattr(utils.windows.sys, attr_name, getattr(self, attr_name))
+            elif self.frozen is None and value is not value_not_set:
+                delattr(utils.windows.sys, attr_name)
+
+            if self.frozen is not None and value is value_not_set:
+                self.addCleanup(delattr, utils.windows.sys, attr_name)
+            elif value is not value_not_set:
+                self.addCleanup(setattr, utils.windows.sys, attr_name, value)
+
 
 class AutoupdaterTestCase(TestCase):
     """Test the code that is used for the auto update process."""
@@ -36,7 +63,9 @@
     def setUp(self):
         """Prepare for the diff tests."""
         yield super(AutoupdaterTestCase, self).setUp()
-        self.auto_update_path = r'path\to\exe'
+        self._base_path = r'path\to\exe'
+        self.auto_update_path = os.path.join(self._base_path,
+                                    utils.windows.AUTOUPDATE_EXE_NAME)
         self.return_from_call = 0
         self.command = None
         self.args = []
@@ -48,8 +77,8 @@
             return self.return_from_call
 
         self.patch(utils.windows, 'getProcessValue', fake_execute_process)
-        self.patch(utils.windows, '_get_update_path',
-                   lambda: self.auto_update_path)
+        self.patch(utils.windows, 'get_exe_path',
+                   lambda exe_name: os.path.join(self._base_path, exe_name))
 
     @defer.inlineCallbacks
     def test_are_updates_present_true(self):
@@ -81,11 +110,9 @@
         """Test the method that performs the update."""
         self.patch(utils.windows.win32api, 'ShellExecute', self._set_called)
         utils.perform_update()
-        self.assertIn(self.auto_update_path, self._called[0][2])
-        self.assertEqual('runas', self._called[0][1])
-        self.assertEqual('--unattendedmodeui none', self._called[0][3])
-        self.assertEqual('', self._called[0][4])
-        self.assertEqual(0, self._called[0][5])
+        args = (None, 'runas', self.auto_update_path,
+                '--unattendedmodeui none', '', 0)
+        self.assertEqual(self._called, (args, {}))
 
 
 class FakeOpenKey(object):
@@ -164,7 +191,8 @@
              [((self.registry.OpenKey, 'Ubuntu One', 0, 1,
              '"%s\\ubuntuone-syncdaemon.exe"' % path), {}),
              ((self.registry.OpenKey, 'Ubuntu One Icon', 0, 1,
-             '"%s\\ubuntuone-control-panel-qt.exe" --minimized' % path),
+             '"%s\\ubuntuone-control-panel-qt.exe" '
+             '--minimized --with-icon' % path),
              {})])
 
     def test_not_added_if_not_frozen(self):
@@ -192,7 +220,7 @@
         for name in names:
             name = getattr(utils.windows.shellcon, 'CSIDL_%s' % name)
             folder = utils.windows.shell.SHGetFolderPath(0, name, None, 0)
-            expected.append(folder.encode('utf8'))
+            expected.append(folder)
 
         self.assertEqual(sorted(folders), sorted(expected))
 
@@ -216,15 +244,14 @@
         self.test_special_folders(names=('PERSONAL', 'MYMUSIC', 'MYPICTURES'))
 
 
-class GetPathTestCase(TestCase):
-    """Test the code that is used for the auto update process."""
+class GetExePathTestCase(FrozenTestCase):
+    """Test the path calculator when sys is frozen."""
 
     @defer.inlineCallbacks
     def setUp(self):
         """Set the different tests."""
-        yield super(GetPathTestCase, self).setUp()
+        yield super(GetExePathTestCase, self).setUp()
         self.called = []
-        self.exec_path = 'path/to/current/exe'
         self.exists = True
 
         def fake_abspath(path):
@@ -247,62 +274,70 @@
         self.patch(utils.windows.os.path, 'dirname', fake_dirname)
         self.patch(utils.windows.os.path, 'exists', fake_exists)
 
-    def _delete_frozen_state(self):
-        """Delete the frozen state."""
-        del utils.windows.sys.frozen
-        del utils.windows.sys.executable
-
-    def test_get_auto_update_path_frozen(self):
-        """Test the method used to get the autoupdate."""
-        # patch the diff parts of sys so that we get fake paths
-        is_frozen = hasattr(utils.windows.sys, 'frozen')
-        if not is_frozen:
-            utils.windows.sys.frozen = True
-            utils.windows.sys.executable = self.exec_path
-            self.addCleanup(self._delete_frozen_state)
-
-        # called method and assert that we have the correct result
-        path = utils.windows._get_update_path()
-        self.assertEqual(os.path.join(self.exec_path,
-                         utils.windows.AUTOUPDATE_EXE_NAME), path)
-        self.assertTrue('os.path.abspath' in self.called)
-        self.assertTrue('os.path.dirname' in self.called)
-        self.assertTrue('os.path.exists' in self.called)
-
-    def _reset_frozen_state(self, old_frozen, old_exec_path):
-        """Reset the frozen state."""
-        utils.windows.sys.frozen = old_frozen
-        utils.windows.sys.executable = old_exec_path
-
-    def _reset__file__(self, path):
-        """Reset the value of __file__."""
-        utils.windows.__file__ = path
-
-    def test_get_auto_update_path_not_frozen(self):
-        """Test the method used to get the autoupdate."""
-        is_frozen = hasattr(utils.windows.sys, 'frozen')
-        if is_frozen:
-            old_frozen = utils.windows.sys.frozen
-            old_exec_path = utils.windows.sys.executable
-            del utils.windows.sys.frozen
-            del utils.windows.sys.executable
-            self.addCleanup(self._reset_frozen_state, old_frozen,
-                            old_exec_path)
-        # set a fake __file__ for the module
-        old_file = utils.windows.__file__
-        utils.windows.__file__ = self.exec_path
-        self.addCleanup(self._reset__file__, old_file)
-
-        path = utils.windows._get_update_path()
-        self.assertEqual(os.path.join(self.exec_path,
-                         utils.windows.AUTOUPDATE_EXE_NAME), path)
-        self.assertEqual(2, self.called.count('os.path.dirname'))
-        self.assertTrue('os.path.exists' in self.called)
-
-    def test_get_auto_update_path_not_present(self):
+    def test_get_exe_path(self):
+        """Test the method used to get the autoupdate."""
+        path = utils.windows.get_exe_path(exe_name=SOME_EXE_NAME)
+
+        self.assertEqual(os.path.join(self.executable, SOME_EXE_NAME), path)
+
+        expected = ['os.path.abspath', 'os.path.dirname', 'os.path.dirname',
+                    'os.path.exists']
+        self.assertEqual(expected, self.called)
+
+    def test_get_exe_path_not_present(self):
         """Test the method used to get the autoupdate."""
         self.exists = False
 
         # called method and assert that we have the correct result
-        path = utils.windows._get_update_path()
-        self.assertEqual(None, path)
+        path = utils.windows.get_exe_path(exe_name=SOME_EXE_NAME)
+        self.assertTrue(path is None)
+
+
+class GetExePathNotFrozenTestCase(GetExePathTestCase):
+    """Test the path calculator when sys is not frozen."""
+
+    frozen = None
+
+    def test_get_exe_path(self):
+        """Test the method used to get the autoupdate."""
+        self.patch(utils.windows, '__file__', self.executable)
+
+        path = utils.windows.get_exe_path(exe_name=SOME_EXE_NAME)
+        self.assertEqual(os.path.join(self.executable, SOME_EXE_NAME), path)
+
+        expected = ['os.path.dirname', 'os.path.dirname', 'os.path.dirname',
+                    'os.path.exists']
+        self.assertEqual(expected, self.called)
+
+
+class UninstallApplicationTestCase(FrozenTestCase):
+    """Test the uninstall_application helper when sys is frozen."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(UninstallApplicationTestCase, self).setUp()
+        self.patch(utils.windows.win32api, "ShellExecute", self._set_called)
+        self.patch(os.path, "exists", lambda path: True)
+
+    def test_uninstall(self):
+        """The uninstaller is run."""
+        utils.uninstall_application()
+
+        exe_name = utils.windows.UNINSTALL_EXE_NAME
+        uninstall_path = utils.windows.get_exe_path(exe_name=exe_name)
+        self.assertEqual(self._called,
+            ((None, '', uninstall_path, '--mode win32', '', 0), {}))
+
+    def test_uninstall_exe_not_present(self):
+        """The uninstaller is not run if not available."""
+        self.patch(os.path, "exists", lambda path: False)
+
+        utils.uninstall_application()
+
+        self.assertFalse(self._called)
+
+
+class UninstallApplicationNotFrozenTestCase(UninstallApplicationTestCase):
+    """Test the uninstall_application helper when sys is not frozen."""
+
+    frozen = None

=== modified file 'ubuntuone/controlpanel/utils/windows.py'
--- ubuntuone/controlpanel/utils/windows.py	2012-03-23 21:48:53 +0000
+++ ubuntuone/controlpanel/utils/windows.py	2012-04-03 13:15:23 +0000
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
-
 #
-# Copyright 2011 Canonical Ltd.
+# Copyright 2011-2012 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
@@ -35,19 +34,41 @@
 logger = setup_logging('utils.windows')
 AUTOUPDATE_EXE_NAME = 'autoupdate-windows.exe'
 AUTORUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
-
-
-def _get_update_path():
+UNINSTALL_EXE_NAME = 'uninstall.exe'
+
+
+def get_exe_path(exe_name):
     """Return the path in which the autoupdate command is found."""
-    if hasattr(sys, 'frozen'):
+    if getattr(sys, 'frozen', False):
         exec_path = os.path.abspath(sys.executable)
     else:
         exec_path = os.path.dirname(__file__)
-    folder = os.path.dirname(exec_path)
-    update_path = os.path.join(folder, AUTOUPDATE_EXE_NAME)
-    if os.path.exists(update_path):
-        return update_path
-    return None
+
+    result = None
+    folder = os.path.dirname(os.path.dirname(exec_path))
+    exe_path = os.path.join(folder, exe_name)
+    if os.path.exists(exe_path):
+        result = exe_path
+
+    return result
+
+
+def add_to_autostart():
+    """Add syncdaemon to the session's autostart."""
+    if getattr(sys, "frozen", False):
+        sd_path = '"%s"' % os.path.join(os.path.dirname(
+            os.path.abspath(sys.executable)),
+            "ubuntuone-syncdaemon.exe")
+        u1cp_path = '"%s"' % os.path.join(os.path.dirname(
+            os.path.abspath(sys.executable)),
+            "ubuntuone-control-panel-qt.exe")
+
+        with _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, AUTORUN_KEY,
+                             0, _winreg.KEY_ALL_ACCESS) as key:
+            # pylint: disable=E0602
+            _winreg.SetValueEx(key, "Ubuntu One", 0, _winreg.REG_SZ, sd_path)
+            _winreg.SetValueEx(key, "Ubuntu One Icon", 0, _winreg.REG_SZ,
+                               u1cp_path + " --minimized --with-icon")
 
 
 @defer.inlineCallbacks
@@ -55,7 +76,7 @@
     """Return if there are updates for Ubuntu One."""
     result = False
     retcode = None
-    update_path = _get_update_path()
+    update_path = get_exe_path(exe_name=AUTOUPDATE_EXE_NAME)
     if update_path is not None:
         # If there is an update present we will get 0, non-zero otherwise
         retcode = yield getProcessValue(update_path, args=('--mode',
@@ -74,7 +95,7 @@
     # but the latter does not support XP
     # (Minimum supported client: Windows Vista)
     get_path = lambda name: shell.SHGetFolderPath(
-        0, getattr(shellcon, name), None, 0).encode('utf8')
+        0, getattr(shellcon, name), None, 0)
 
     folders = []
     # More information on these constants at
@@ -92,27 +113,15 @@
 
 def perform_update():
     """Spawn the autoupdate process and call the stop function."""
-    update_path = _get_update_path()
+    update_path = get_exe_path(exe_name=AUTOUPDATE_EXE_NAME)
     if update_path is not None:
         # lets call the updater with the commands that are required,
-        win32api.ShellExecute(None, 'runas',
-            update_path,
-            '--unattendedmodeui none', '', 0)
-
-
-def add_to_autostart():
-    """Add syncdaemon to the session's autostart."""
-    if getattr(sys, "frozen", False):
-        sd_path = '"%s"' % os.path.join(os.path.dirname(
-            os.path.abspath(sys.executable)),
-            "ubuntuone-syncdaemon.exe")
-        u1cp_path = '"%s"' % os.path.join(os.path.dirname(
-            os.path.abspath(sys.executable)),
-            "ubuntuone-control-panel-qt.exe")
-
-        with _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, AUTORUN_KEY,
-                             0, _winreg.KEY_ALL_ACCESS) as key:
-            # pylint: disable=E0602
-            _winreg.SetValueEx(key, "Ubuntu One", 0, _winreg.REG_SZ, sd_path)
-            _winreg.SetValueEx(key, "Ubuntu One Icon", 0, _winreg.REG_SZ,
-                               u1cp_path + " --minimized --with-icon")
+        win32api.ShellExecute(None, 'runas', update_path,
+                              '--unattendedmodeui none', '', 0)
+
+
+def uninstall_application():
+    """Uninstall Ubuntu One."""
+    uninstall_path = get_exe_path(exe_name=UNINSTALL_EXE_NAME)
+    if uninstall_path is not None:
+        win32api.ShellExecute(None, '', uninstall_path, '--mode win32', '', 0)