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

[Natalia Bidart]

- When user rejects the License, also uninstall the application (LP: #968327).

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

307. By Natalia Bidart on 2012-03-29

Merged trunk in.

308. By Natalia Bidart on 2012-03-30

Merged trunk in.

309. By Natalia Bidart on 2012-03-30

- No more runas as parameter to shellexecute.

310. By Natalia Bidart on 2012-03-30

Restoring the 'runas' param for autoupdate.

[Brian Curtin (brian.curtin)]

Looks fine, and IRL tests of uninstallation on Windows XP and Windows 7 both function properly with these changes.

review: Approve

[Manuel de la Peña (mandel)]

Everything looks good from spain.

review: Approve

=== 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-03-30 17:37:31 +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/gui.py'
--- ubuntuone/controlpanel/gui/qt/gui.py	2012-03-26 13:23:57 +0000
+++ ubuntuone/controlpanel/gui/qt/gui.py	2012-03-30 17:37:31 +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/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-03-30 17:37:31 +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-03-30 17:37:31 +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/utils/__init__.py'
--- ubuntuone/controlpanel/utils/__init__.py	2012-03-22 23:28:19 +0000
+++ ubuntuone/controlpanel/utils/__init__.py	2012-03-30 17:37:31 +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-27 18:55:37 +0000
+++ ubuntuone/controlpanel/utils/tests/test_windows.py	2012-03-30 17:37:31 +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):
@@ -217,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):
@@ -248,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-03-30 17:37:31 +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',
@@ -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)