Merge lp:~ralsina/ubuntuone-windows-installer/local-folder-fixes into lp:ubuntuone-windows-installer

[Roberto Alsina]

Implement the "Computer-to-cloud" page of the installer according to spec and discussions.

Implement the "Computer-to-cloud" page of the installer according to spec and discussions.

[lp:~ralsina/ubuntuone-windows-installer/local-folder-fixes]

47. By Roberto Alsina on 2011-08-17

merged

48. By Roberto Alsina on 2011-08-17

added tests for pre/post initializePage

49. By Roberto Alsina on 2011-08-17

more tests, lint fixes

50. By Roberto Alsina on 2011-08-17

added tests for FolderItem

51. By Roberto Alsina on 2011-08-17

added tests for FolderItem

52. By Roberto Alsina on 2011-08-17

fixes

53. By Roberto Alsina on 2011-08-17

added test for special_folders

54. By Roberto Alsina on 2011-08-17

merged trunk

55. By Roberto Alsina on 2011-08-18

fixes

56. By Roberto Alsina on 2011-08-18

add test for 'no folder selected, no quota used'

57. By Roberto Alsina on 2011-08-18

suggested fix for the while True

58. By Roberto Alsina on 2011-08-18

Separate tests for local folders

59. By Roberto Alsina on 2011-08-18

style fixes

60. By Roberto Alsina on 2011-08-19

added two suggested tests

61. By Roberto Alsina on 2011-08-19

lint

62. By Roberto Alsina on 2011-08-23

solve conflict

63. By Roberto Alsina on 2011-08-23

merge conflict fix

64. By Roberto Alsina on 2011-08-23

grmbl

65. By Roberto Alsina on 2011-08-23

resolve further

Unmerged revisions

=== modified file 'data/qt/local_folders.ui'
--- data/qt/local_folders.ui	2011-08-08 21:48:11 +0000
+++ data/qt/local_folders.ui	2011-08-17 00:58:24 +0000
@@ -97,7 +97,7 @@
       </spacer>
      </item>
      <item>
-      <widget class="AddFolderButton" name="add_folder_button">
+      <widget class="QPushButton" name="add_folder_button">
        <property name="text">
         <string>Add a folder from this computer</string>
        </property>
@@ -188,13 +188,6 @@
    </item>
   </layout>
  </widget>
- <customwidgets>
-  <customwidget>
-   <class>AddFolderButton</class>
-   <extends>QPushButton</extends>
-   <header>ubuntuone.controlpanel.gui.qt.addfolder</header>
-  </customwidget>
- </customwidgets>
  <resources/>
  <connections/>
 </ui>

=== modified file 'ubuntuone_installer/gui/qt/local_folders.py'
--- ubuntuone_installer/gui/qt/local_folders.py	2011-08-17 00:58:24 +0000
+++ ubuntuone_installer/gui/qt/local_folders.py	2011-08-17 00:58:24 +0000
@@ -24,9 +24,14 @@
 import threading
 import Queue
 
-from twisted.internet.defer import inlineCallbacks
+from twisted.internet.defer import inlineCallbacks, returnValue
 from PyQt4 import QtCore, QtGui
-from ubuntuone.controlpanel.gui import humanize, sign_url
+from ubuntuone.controlpanel import backend
+from ubuntuone.controlpanel.gui import (
+    humanize,
+    sign_url,
+    FOLDER_INVALID_PATH
+)
 from ubuntuone.platform.credentials import CredentialsManagementTool
 from ubuntu_sso.qt.gui import SSOWizardPage
 
@@ -49,12 +54,19 @@
 
 class FolderItem(QtGui.QTreeWidgetItem):
     """Class representing a folder in the folder list UI."""
-    def __init__(self, strings, path=None, queue=None):
+    def __init__(self, strings, path=None, queue=None,
+        calculate=True, volume_id=None):
         super(FolderItem, self).__init__(strings)
-        self.thread = CalculateSize(path, queue)
-        self.thread.start()
-        self.size = None
+        if calculate:
+            self.thread = CalculateSize(path, queue)
+            self.thread.start()
+            self.size = None
+        else:
+            self.thread = CalculateSize(path, queue)
+            self.size = 0
         self.path = path
+        self.setCheckState(0, QtCore.Qt.Unchecked)
+        self.volume_id = volume_id
 
 
 class CalculateSize(threading.Thread):
@@ -88,6 +100,9 @@
         self.queue = Queue.Queue()
         self.timer = QtCore.QTimer()
         self.items = {}
+        self.folders_info = None
+        self.account_info = None
+        self.cp_backend = backend.ControlBackend()
 
     # initializePage is inherited
     # pylint: disable=C0103
@@ -99,16 +114,72 @@
         self.wizard()._next_id = self.wizard().SYNC_NOW_OR_LATER_PAGE
         # Start with this invisible
         self.ui.offer_frame.setVisible(False)
-        if not self.ui.folder_list.topLevelItemCount():
+        # Block until we have server data
+        self.wizard().overlay.show()
+        self.get_info()
+
+    @inlineCallbacks
+    def get_info(self):
+        """Get information from CP backend and fill folder list."""
+        try:
+            volumes_info = yield self.cp_backend.volumes_info()
+            self.account_info = yield self.cp_backend.account_info()
+            self.folders_info = []
+            for _, _, volumes in volumes_info:
+                for volume in volumes:
+                    if volume[u'type'] == u"UDF":
+                        self.folders_info.append(volume)
+            self.ui.folder_list.clear()
+            for folder in self.folders_info:
+                item = yield self.add_folder(
+                    os.path.expanduser(folder['path']),
+                    validate=False, volume_id=folder['volume_id'])
+                if item:
+                    if folder['subscribed']:
+                        item.setCheckState(0, QtCore.Qt.Checked)
+                    item.thread.join()
+                    item.size = 0
             for folder_name in self.default_folders():
-                self.add_folder(folder_name)
-        self.timer.start(2000)
-        self.timer.timeout.connect(self.update_sizes)
+                item = yield self.add_folder(folder_name, validate=True)
+            self.timer.start(2000)
+            self.timer.timeout.connect(self.update_sizes)
+            self.wizard().overlay.hide()
+            self.wizard().currentIdChanged.connect(self.changed_page)
+        except:
+            logger.exception("Error getting backend info:")
+
+    @QtCore.pyqtSlot("int")
+    @inlineCallbacks
+    def changed_page(self, page_id):
+        """When moving to next page, create/[un]subscribe UDFs."""
+        self.timer.stop()
+        try:
+            self.wizard().currentIdChanged.disconnect(self.changed_page)
+        except KeyError:
+            pass
+        if page_id == self.wizard().SYNC_NOW_OR_LATER_PAGE:
+            # The page following this one
+            self.wizard().overlay.show()
+            for path, item in self.items.items():
+                if item.checkState(0) == QtCore.Qt.Checked:
+                    if item.volume_id:
+                        yield self.cp_backend.change_volume_settings(
+                            item.volume_id,
+                            dict(subscribed=True))
+                    else:
+                        yield self.cp_backend.create_folder(path)
+                else:
+                    if item.volume_id:
+                        yield self.cp_backend.change_volume_settings(
+                            item.volume_id,
+                            dict(subscribed=False))
+            self.wizard().overlay.hide()
 
     def default_folders(self):
         """Return a list of the folders to add by default."""
         if sys.platform == 'win32':
-            # Special Folder "My Documents"
+            # XXXX to be replaced by calls to xdg_base_directory's
+            # special_folders
             dll = ctypes.windll.shell32
             buf = ctypes.create_string_buffer(300)
             dll.SHGetSpecialFolderPathA(None, buf, 5, False)
@@ -122,61 +193,62 @@
             result = ['To be implemented']
         return result
 
-    def add_folder(self, path):
+    @inlineCallbacks
+    def add_folder(self, path, validate=True, volume_id=False):
         """Add a folder to the list."""
         if path in self.items:
-            return None
-        # FIXME: the path should actually be sent to u1cp to verify as valid
-        item = FolderItem([path, "", "remove"], path=path, queue=self.queue)
-        self.ui.folder_list.addTopLevelItem(item)
-        self.items[path] = item
-        return item
+            returnValue(None)
+        if validate:
+            is_valid = yield self.cp_backend.validate_path_for_folder(path)
+        else:
+            is_valid = True
+        if is_valid:
+            item = FolderItem([path, ""],
+                path=path, queue=self.queue, volume_id=volume_id)
+            self.ui.folder_list.addTopLevelItem(item)
+            self.items[path] = item
+            returnValue(item)
+        returnValue(None)
 
-    @inlineCallbacks
     def update_sizes(self):
         """Poll the queue were the threads put the size info."""
         try:
-            path, size = self.queue.get(False)
-            item = self.items.get(path)
-            if item:
-                item.size = size
-                item.setText(1, humanize(size))
+            while True:
+                path, size = self.queue.get(False)
+                item = self.items.get(path)
+                if item:
+                    item.size = size
+                    try:
+                        item.setText(1, humanize(size))
+                    except RuntimeError:
+                        del self.items[path]
         except Queue.Empty:
             pass
-        total = 0
+        total = long(self.account_info['quota_used'])
         for path, item in self.items.items():
             if item.size is None:
                 total = LOCAL_FOLDERS_CALCULATING
                 break
-            total += item.size
-
+            if not item.volume_id and item.checkState(0) == QtCore.Qt.Checked:
+                # Existing UDFs are already accounted for, count if marked.
+                total += item.size
         if isinstance(total, long):
-            yield self.show_hide_offer(total)
+            self.show_hide_offer(total)
             total = humanize(total)
         else:
-            yield self.show_hide_offer(0)
+            self.show_hide_offer(0)
         self.ui.folder_list.headerItem().setText(
             1, LOCAL_FOLDERS_SPACE_HEADER % total)
 
-    @inlineCallbacks
     def show_hide_offer(self, cur_size):
-        """Show or hide the offer to buy space according to the total size.
-
-        Returns a deferred that is triggered when the update is finished.
-
-        """
-        # pylint: disable=W0702
-        try:
-            user_info = yield self.ui.add_folder_button.backend.account_info()
-            quota = user_info['quota_total']
-            if cur_size > quota:
-                self.ui.offer_frame.setVisible(True)
-            else:
-                self.ui.offer_frame.setVisible(False)
-            self.ui.offer_label.setText(LOCAL_FOLDERS_OFFER_LABEL %
-                {"quota": humanize(quota)})
-        except:
-            logger.exception('Error while trying to update the quota:')
+        """Show or hide the offer to buy space according to the total size."""
+        quota = self.account_info['quota_total']
+        if cur_size > quota:
+            self.ui.offer_frame.setVisible(True)
+        else:
+            self.ui.offer_frame.setVisible(False)
+        self.ui.offer_label.setText(LOCAL_FOLDERS_OFFER_LABEL %
+            {"quota": humanize(quota)})
 
     def stop_threads(self):
         """Stop all pending threads."""
@@ -185,31 +257,44 @@
 
     # itemClicked is a Qt signal name.
     # pylint: disable=C0103
-    def on_folder_list_itemClicked(self, item, column):
+    def on_folder_list_itemChanged(self, item, column):
         """Delete folder from the list."""
-        if column == 2:
-            del(self.items[item.path])
-            item.thread._stop = True
-            self.ui.folder_list.takeTopLevelItem(
-                self.ui.folder_list.indexOfTopLevelItem(item))
-        self.update_sizes()
+        if column == 0:
+            self.update_sizes()
 
     @inlineCallbacks
     @QtCore.pyqtSlot()
     def on_add_storage_button_clicked(self):
         """user clicked on the "Add more storage" button."""
-
+        # Really want to catch everything
         # pylint: disable=W0702
         try:
             credtool = CredentialsManagementTool()
             creds = yield credtool.find_credentials()
         except:
-            logger.exception('Error while trying to update que quota:')
+            logger.exception('Error while trying to get credentials:')
             creds = {}
-
         if creds:
             signed_url = sign_url(
                 "https://one.ubuntu.com/services/#storage_panel", creds)
         else:
             signed_url = "https://one.ubuntu.com/services/#storage_panel"
         QtGui.QDesktopServices.openUrl(QtCore.QUrl(signed_url))
+
+    @inlineCallbacks
+    @QtCore.pyqtSlot()
+    def on_add_folder_button_clicked(self):
+        """user clicked on the "Add Folder" button."""
+        folder = QtGui.QFileDialog.getExistingDirectory(parent=self)
+        folder = unicode(folder)
+        if folder == '':
+            return
+
+        is_valid = yield self.cp_backend.validate_path_for_folder(folder)
+        if not is_valid:
+            user_home = os.path.expanduser('~')
+            text = FOLDER_INVALID_PATH % {'folder_path': folder,
+                                          'home_folder': user_home}
+            QtGui.QMessageBox.warning(self, '', text, QtGui.QMessageBox.Close)
+            return
+        yield self.add_folder(folder, validate=False, volume_id=False)

=== modified file 'ubuntuone_installer/gui/qt/tests/test_gui.py'
--- ubuntuone_installer/gui/qt/tests/test_gui.py	2011-08-17 00:58:24 +0000
+++ ubuntuone_installer/gui/qt/tests/test_gui.py	2011-08-17 00:58:24 +0000
@@ -529,15 +529,20 @@
 
     def __init__(self, *args, **kwargs):
         """Initialize."""
-        self.target = lambda *args: None
+        self.target = None
 
     def connect(self, target):
         """Fake connect."""
         self.target = target
 
+    def disconnect(self, *args):
+        """Fake disconnect."""
+        self.target = None
+
     def emit(self, *args):
         """Fake emit."""
-        self.target(*args)
+        if self.target:
+            self.target(*args)
 
 
 class FakeMainWindow(object):
@@ -548,7 +553,10 @@
     registrationSuccess = FakeSignal()
     userCancellation = FakeSignal()
     shown = False
+    _buttonlayout = None
     SYNC_NOW_OR_LATER_PAGE = 4
+    overlay = FakeOverlay()
+    currentIdChanged = FakeSignal()
 
     def show(self):
         """Fake method."""
@@ -563,9 +571,71 @@
 class FakeCPBackend(object):
     """Fake Control Panel backend."""
 
+    def __init__(self):
+        """Initialize."""
+        self._is_valid = True
+        self.volume_setings_changes = []
+        self.folders_created = []
+
     def account_info(self, *args):
         """Fake account info."""
-        return defer.succeed({"quota_total": 1000})
+        return defer.succeed({
+            "quota_total": 1000,
+            "quota_used": 200,
+            })
+
+    def volumes_info(self, *args):
+        """"Fake volumes info."""
+        return defer.succeed(((None, None,
+            [
+            {
+                'type': u'UDF',
+                'path': os.path.expanduser(u'~/xyzzy'),
+                'volume_id': 'asdfgh',
+                'subscribed': True
+            },
+            {
+                'type': u'UDF',
+                'path': os.path.expanduser(u'~/zxyzzy'),
+                'volume_id': 'qwerty',
+                'subscribed': False
+            },
+            ],
+        ),))
+
+    def validate_path_for_folder(self, path):
+        """Fake folder validation."""
+        return self._is_valid
+
+    def change_volume_settings(self, *args):
+        """Fake change volume settings."""
+        self.volume_setings_changes.append(args)
+
+    def create_folder(self, *args):
+        """Fake folder creation."""
+        self.folders_created.append(args)
+
+
+class FakeFileDialog(object):
+
+    """A fake QFileDialog class."""
+
+    # pylint: disable=C0103
+    def getExistingDirectory(self, *args, **kwargs):
+        """Fake existing folder name."""
+        return u"whatever"
+
+
+class FakeMessageBox(object):
+
+    """A fake QMessageBox class."""
+
+    Close = 2
+    _warning = None
+
+    def warning(self, *args, **kwargs):
+        """Fake warning."""
+        self._warning = (args, kwargs)
 
 
 class FakeFailingCPBackend(object):
@@ -598,6 +668,7 @@
         f.write(" " * 737)
         f.close()
         self.fake_wizard = FakeMainWindow()
+        self.patch(local_folders.backend, "ControlBackend", FakeCPBackend)
         super(LocalFoldersTestCase, self).setUp()
         self.patch(self.ui, "wizard", lambda: self.fake_wizard)
 
@@ -606,6 +677,24 @@
         shutil.rmtree(self.tmpdir)
         BaseTestCase.tearDown(self)
 
+    @defer.inlineCallbacks
+    def test_subscribed_udf_checked(self):
+        """Check that subscribed UDF items are created correctly."""
+        yield self.ui.get_info()
+        item = self.ui.items[os.path.expanduser(u'~/xyzzy')]
+        self.assertEqual(item.checkState(0), QtCore.Qt.Checked)
+        self.assertEqual(item.size, 0)
+        self.assertTrue(item.volume_id)
+
+    @defer.inlineCallbacks
+    def test_unsubscribed_udf_checked(self):
+        """Check that unsubscribed UDF items are created correctly."""
+        yield self.ui.get_info()
+        item = self.ui.items[os.path.expanduser(u'~/zxyzzy')]
+        self.assertEqual(item.checkState(0), QtCore.Qt.Unchecked)
+        self.assertEqual(item.size, 0)
+        self.assertTrue(item.volume_id)
+
     def test_size_calculation(self):
         """Test the recursive folder size calculation."""
         queue = Queue.Queue()
@@ -615,38 +704,77 @@
         self.assertEqual(path, self.tmpdir)
         self.assertEqual(size, 1337)
 
+    @defer.inlineCallbacks
     def test_item_addition(self):
-        """Add an item (plus the default one), then remove them."""
-        self.ui.add_folder(self.tmpdir)
-        self.assertEqual(4, self.ui.ui.folder_list.topLevelItemCount())
-
+        """Add a folder."""
+        self.ui.ui.folder_list.clear()
+        yield self.ui.add_folder(self.tmpdir)
+        self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
+
+    @defer.inlineCallbacks
+    def test_invalid_item_addition(self):
+        """Try to add an invalid folder."""
+        self.ui.ui.folder_list.clear()
+        self.ui.cp_backend._is_valid = False
+        yield self.ui.add_folder(self.tmpdir)
+        self.assertEqual(0, self.ui.ui.folder_list.topLevelItemCount())
+
+    @defer.inlineCallbacks
     def test_total_size(self):
         """Test that the header reflects the change in item sizes."""
-        while self.ui.ui.folder_list.topLevelItemCount():
-            self.ui.on_folder_list_itemClicked(
-                self.ui.ui.folder_list.topLevelItem(0), 2)
-        self.assertEqual(0, self.ui.ui.folder_list.topLevelItemCount())
-        item = self.ui.add_folder(self.tmpdir)
-        item.size = 1337
-        item.thread.run()
-        item.thread.join()
-        self.ui.update_sizes()
-        self.assertEqual(unicode(self.ui.ui.folder_list.headerItem().text(1)),
-            u"Space (1337)")
+        yield self.ui.get_info()
+        self.ui.ui.folder_list.clear()
+        self.ui.items = {}
+        item = yield self.ui.add_folder(self.tmpdir)
+        item.thread.run()
+        item.thread.join()
+        item.size = 1337
+        item.setCheckState(0, QtCore.Qt.Checked)
+        self.ui.update_sizes()
+        self.assertEqual(unicode(self.ui.ui.folder_list.headerItem().text(1)),
+            u"Space (1.5 KiB)")
+
+    @defer.inlineCallbacks
+    def test_total_size_unchecked(self):
+        """Unchecked items use no space beyond quota_used."""
+        yield self.ui.get_info()
+        self.ui.ui.folder_list.clear()
+        self.ui.items = {}
+        item = yield self.ui.add_folder(self.tmpdir)
+        item.thread.run()
+        item.thread.join()
+        item.size = 1337
+        item.setCheckState(0, QtCore.Qt.Unchecked)
+        self.ui.update_sizes()
+        self.assertEqual(unicode(self.ui.ui.folder_list.headerItem().text(1)),
+            u"Space (200 bytes)")
+
+    @defer.inlineCallbacks
+    def test_total_size_udf(self):
+        """UDFs use no space beyond quota_used."""
+        yield self.ui.get_info()
+        for _, item in self.ui.items.items():
+            item.thread.join()
+            if item.volume_id:
+                item.setCheckState(0, QtCore.Qt.Checked)
+            else:
+                item.setCheckState(0, QtCore.Qt.Unchecked)
+        self.ui.update_sizes()
+        self.assertEqual(unicode(self.ui.ui.folder_list.headerItem().text(1)),
+            u"Space (200 bytes)")
 
     def test_add_twice(self):
         """Behaviour for adding the same folder twice:
 
         * It's added only once.
         """
-        while self.ui.ui.folder_list.topLevelItemCount():
-            self.ui.on_folder_list_itemClicked(
-                self.ui.ui.folder_list.topLevelItem(0), 2)
+        self.ui.ui.folder_list.clear()
         self.assertEqual(0, self.ui.ui.folder_list.topLevelItemCount())
         self.ui.add_folder(self.tmpdir)
         self.ui.add_folder(self.tmpdir)
         self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
 
+    @defer.inlineCallbacks
     def test_add_missing_folder(self):
         """Behaviour for adding a folder that doesn't exist:
 
@@ -654,11 +782,11 @@
         * Has size 0.
         """
 
-        while self.ui.ui.folder_list.topLevelItemCount():
-            self.ui.on_folder_list_itemClicked(
-                self.ui.ui.folder_list.topLevelItem(0), 2)
+        yield self.ui.get_info()
+        self.ui.ui.folder_list.clear()
         self.assertEqual(0, self.ui.ui.folder_list.topLevelItemCount())
-        item = self.ui.add_folder(os.path.join("xyzzy", "xyzzy", "xyzzy"))
+        item = yield self.ui.add_folder(os.path.join(
+            "xyzzy", "xyzzy", "xyzzy"))
         self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
         item.thread.run()
         item.thread.join()
@@ -672,27 +800,79 @@
         Push the user over quota, it should be visible.
         """
         self.patch(self.ui.ui.offer_frame, "setVisible", self._set_called)
-        while self.ui.ui.folder_list.topLevelItemCount():
-            self.ui.on_folder_list_itemClicked(
-                self.ui.ui.folder_list.topLevelItem(0), 2)
-        self.assertEqual(0, self.ui.ui.folder_list.topLevelItemCount())
+        yield self.ui.get_info()
+        self.ui.ui.folder_list.clear()
         self.ui.update_sizes()
         self.assertEqual(self._called, ((False,), {}))
         self.ui.show_hide_offer(self.ui.quota() + 1)
         self.assertEqual(self._called, ((True,), {}))
 
+    def test_add_folder_valid(self):
+        """Test behaviour when adding a valid folder via the button."""
+        self.patch(QtGui, "QFileDialog", FakeFileDialog())
+        self.patch(self.ui, "add_folder", self._set_called)
+        self.ui.ui.add_folder_button.click()
+        self.assertEqual(self._called,
+            ((u'whatever',), {'validate': False, 'volume_id': False}))
+
+    def test_add_folder_invalid(self):
+        """Test behaviour when adding an invalid folder via the button."""
+        self.patch(QtGui, "QFileDialog", FakeFileDialog())
+        message_box = FakeMessageBox()
+        self.patch(QtGui, "QMessageBox", message_box)
+        self.patch(self.ui, "add_folder", self._set_called)
+        self.ui.cp_backend._is_valid = False
+        self.ui.ui.add_folder_button.click()
+        self.assertEqual(self._called, False)
+        user_home = os.path.expanduser('~')
+        text = local_folders.FOLDER_INVALID_PATH % {
+            'folder_path': "whatever",
+            'home_folder': user_home,
+        }
+        self.assertEqual(message_box._warning,
+            ((self.ui,
+             '', text, 2), {}))
+
+    @defer.inlineCallbacks
+    def test_changed_page_existing_udf_behaviour(self):
+        """If a UDF is checked, subscribe it, if not, unsubscribe it."""
+        yield self.ui.get_info()
+        self.ui.changed_page(self.ui.wizard().SYNC_NOW_OR_LATER_PAGE)
+        self.assertEqual(self.ui.cp_backend.volume_setings_changes,
+            [('asdfgh', {'subscribed': True}),
+             ('qwerty', {'subscribed': False})])
+
+    @defer.inlineCallbacks
+    def test_changed_page_new_udf_behaviour(self):
+        """Create UDFs for non-existing, checked UDFs."""
+        yield self.ui.get_info()
+        self.ui.ui.folder_list.clear()
+        self.ui.items = {}
+        item = yield self.ui.add_folder("whatever")
+        item.setCheckState(0, QtCore.Qt.Checked)
+        item = yield self.ui.add_folder("whatever2")
+        item.setCheckState(0, QtCore.Qt.Unchecked)
+        self.ui.changed_page(self.ui.wizard().SYNC_NOW_OR_LATER_PAGE)
+        self.assertEqual(self.ui.cp_backend.folders_created,
+            [('whatever',)])
+
     def test_exception_on_account_info(self):
         """When account_info fails, nothing should happen."""
-        self.patch(self.ui.ui.add_folder_button,
-            "backend", FakeFailingCPBackend())
-        self.ui.show_hide_offer(1000)
+        self.patch(self.ui,
+            "cp_backend", FakeFailingCPBackend())
+        self.ui.get_info()
         # Still here
 
     def test_timer_is_started(self):
-        """ When displaying the page, the timer should start."""
+        """When displaying the page, the timer should start."""
         self.ui.initializePage()
         self.assertTrue(self.ui.timer.isActive())
 
+    def test_timer_is_stopped(self):
+        """When leaving the page, the timer should stop."""
+        self.ui.changed_page(-1)
+        self.assertFalse(self.ui.timer.isActive())
+
 
 class SetupAccountTestCase(BaseTestCase):
     """Test the SetupAccountPage code."""