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.

[Natalia Bidart (nataliabidart)]

* We should add a new test case for FolderItem in particular, asserting at least the following:
 - the checkstate is unchecked
 - the volume id is the one passed as parameter
 - the thread is started if calculate is True, not started if not
 - size is None if calculate, 0 if not

* Also, I would advice moving the self.thread assignment outside the if-else since is the same one no matter the value of calculate

* 4 double quotes instead of 3 in:

404 + """"Fake volumes info."""

* Always call super() and not the parent class directly. So, in this case:

475 def tearDown(self):
476 """Remove the temporary tree."""
477 shutil.rmtree(self.tmpdir)
478 BaseTestCase.tearDown(self)

we should call super(). But, considering we can move the rmtree to the setUp method as a cleanup function (which is preferred than using tearDown), we can remove this tearDown altogether.

* in test_status_after_initialize, these two assertions:

         self.assertFalse(self.ui.folders_info is None)
         self.assertFalse(self.ui.account_info is None)

will likely fail on slow machines, since get_info() returns a deferred which initializePage() is not waiting for. So, I would advice converting initializePage into an asynchronous method and yielding on this in the test. Or, alternatively, since you are already providing a test for get_info, you can just assert get_info was called, and remove the checks for volume_info, account_info, items, timer, etc.
Basically, test_status_after_initialize should only check:

 - self.ui.offer_frame is not visible
 - self.wizard().overlay is visible
 - get_info was called

* we need another test similar to test_status_post_get_info but testing that all volumes which type is not UDF are ignored.

* I'm confused about the call to item.thread.join() in get_info. Can you please help me understand why is needed at that point?

* this is not correct: self.assertTrue(item.volume_id). Since volume_id is not a boolean, we should assert equality against the value used when mocking volumes_info.

* test_size_calculation is creating a thread when calling CalculateSize but I think that thread is not being joined on. If so, can you please fix that?

* are there tests for change_page? I see one for the timer being stopped, but we need some for the try-except clause, and all the block right after the page_id == self.wizard().SYNC_NOW_OR_LATER_PAGE guard. Also, never have errors passing silently, please add a log message when handling the KeyError in self.wizard().currentIdChanged.disconnect().

I will continue the review once these are fixed.

review: Needs Fixing

[Roberto Alsina (ralsina)]

> * We should add a new test case for FolderItem in particular, asserting at
> least the following:
> - the checkstate is unchecked
> - the volume id is the one passed as parameter
> - the thread is started if calculate is True, not started if not
> - size is None if calculate, 0 if not

Added.

> * Also, I would advice moving the self.thread assignment outside the if-else
> since is the same one no matter the value of calculate

Moved.

> * 4 double quotes instead of 3 in:
>
> 404 + """"Fake volumes info."""

Fixed.

> * Always call super() and not the parent class directly. So, in this case:
>
> 475 def tearDown(self):
> 476 """Remove the temporary tree."""
> 477 shutil.rmtree(self.tmpdir)
> 478 BaseTestCase.tearDown(self)
>
> we should call super(). But, considering we can move the rmtree to the setUp
> method as a cleanup function (which is preferred than using tearDown), we can
> remove this tearDown altogether.

Done.

> * in test_status_after_initialize, these two assertions:
>
> self.assertFalse(self.ui.folders_info is None)
> self.assertFalse(self.ui.account_info is None)
>
> will likely fail on slow machines, since get_info() returns a deferred which
> initializePage() is not waiting for. So, I would advice converting
> initializePage into an asynchronous method and yielding on this in the test.

Sadly that's not possible, because initializePage can't be a generator (it's called by Qt).

> Or, alternatively, since you are already providing a test for get_info, you
> can just assert get_info was called, and remove the checks for volume_info,
> account_info, items, timer, etc.
> Basically, test_status_after_initialize should only check:
>
> - self.ui.offer_frame is not visible
> - self.wizard().overlay is visible
> - get_info was called

Done.

> * we need another test similar to test_status_post_get_info but testing that
> all volumes which type is not UDF are ignored.

Added a volume of type "SHARE" to the fake volume_info, and it's checked to be ignored
(the number of items created stays the same)

> * I'm confused about the call to item.thread.join() in get_info. Can you
> please help me understand why is needed at that point?

It was there to ensure the thread was finished before setting item.size.
Fixed a buglet where I was not setting calculate=False when adding a UDF, so
it's not needed anymore.

> * this is not correct: self.assertTrue(item.volume_id). Since volume_id is not
> a boolean, we should assert equality against the value used when mocking
> volumes_info.

Changed.

> * test_size_calculation is creating a thread when calling CalculateSize but I
> think that thread is not being joined on. If so, can you please fix that?

No, it's not starting a thread, it's calling what the thread would run when started, which
is an ordinary function.

> * are there tests for change_page? I see one for the timer being stopped, but
> we need some for the try-except clause, and all the block right after the
> page_id == self.wizard().SYNC_NOW_OR_LATER_PAGE guard.

There are these, that I think cover the block after the if:

test_changed_page_existing_udf_behaviour (existing ...

[Natalia Bidart (nataliabidart)]

> > * Always call super() and not the parent class directly. So, in this case:
> >
> > 475 def tearDown(self):
> > 476 """Remove the temporary tree."""
> > 477 shutil.rmtree(self.tmpdir)
> > 478 BaseTestCase.tearDown(self)
> >
> > we should call super(). But, considering we can move the rmtree to the setUp
> > method as a cleanup function (which is preferred than using tearDown), we
> can
> > remove this tearDown altogether.
>
> Done.

Great! Small change: can you please call self.addCleanup(shutil.rmtree, self.tmpdir) instead of using a lambda?

> > * we need another test similar to test_status_post_get_info but testing that
> > all volumes which type is not UDF are ignored.
>
> Added a volume of type "SHARE" to the fake volume_info, and it's checked to be
> ignored
> (the number of items created stays the same)

Thanks for adding this. Can you please add an assertion that checks that the SHARE id is not being loaded? because we can have the same amount of created items and yet have a buggy content in items.

Something like: self.assertNotIn(the-share-id, self.ui.items)

I will keep reviewing later today!

[Roberto Alsina (ralsina)]

> Great! Small change: can you please call self.addCleanup(shutil.rmtree,
> self.tmpdir) instead of using a lambda?

Done.

> Thanks for adding this. Can you please add an assertion that checks that the
> SHARE id is not being loaded? because we can have the same amount of created
> items and yet have a buggy content in items.
>
> Something like: self.assertNotIn(the-share-id, self.ui.items)

Added!

[Natalia Bidart (nataliabidart)]

* The comment added:

# Block until we have server data828944

may be misleading, since the app does not block but shows a loading message until the result from the backend is ready.

* If get_info fails, the overlay is never hid nor the user finds out that something went wrong. I filed bug #828944 so you can fix this in an incoming branch.

* test_exception_on_account_info should yield on get_info so we ensure that the call does not explodes "later". In this test, when solving bug #828944, you should check the overlay was hidden and a message was shown to the user (we may need input from design here).

* there are no tests for the showing/hiding of the overlay inside change_page.

* there are no tests for add_folder when the params validate, calculate and volume_id are other than the defaults. Also, having volume_id defaulting to False may be a typo? volume_id, when defined, is a uuid...

* it seems to me that update_sizes is not completely covered by tests. I think that the try-except for the RuntimeError is not tested, as well as the while True. For that last feature, we should have more than one thing being calculated its size, to show the sum of the sizes.
Also, we should confirm we're testing this case:

"if the user has no UDFs created and selects nothing" -> we should show the quota used only

and that the show_hide_offer method received the proper parameter.

* correct me if I'm wrong, but seems like there is no test for on_folder_list_itemChanged nor on_add_folder_button_clicked.

* question: would you agree to move all the tests for the local_folders module into its own test module, so we can follow the convention? The convention is: per every foo.py, there should be a test_foo.py.

review: Needs Fixing

[Roberto Alsina (ralsina)]

> * The comment added:
>
> # Block until we have server data828944
>
> may be misleading, since the app does not block but shows a loading message
> until the result from the backend is ready.

Changed.

> * If get_info fails, the overlay is never hid nor the user finds out that
> something went wrong. I filed bug #828944 so you can fix this in an incoming
> branch.

Thanks, will look into it.

> * test_exception_on_account_info should yield on get_info so we ensure that
> the call does not explodes "later". In this test, when solving bug #828944,
> you should check the overlay was hidden and a message was shown to the user
> (we may need input from design here).

Agreed.

> * there are no tests for the showing/hiding of the overlay inside change_page.

Added asserts to the changed_page tests.

> * there are no tests for add_folder when the params validate, calculate and
> volume_id are other than the defaults. Also, having volume_id defaulting to
> False may be a typo? volume_id, when defined, is a uuid...

I just wanted something to say "if not volume_id". I will default it to None.

> * it seems to me that update_sizes is not completely covered by tests. I think
> that the try-except for the RuntimeError is not tested, as well as the while
> True. For that last feature, we should have more than one thing being
> calculated its size, to show the sum of the sizes.

The RuntimeError only happens when a list item is deleted by Qt before its thread
returns the result (for example, if the user leaves the page and comes back),
and it just means we can ignore that item. I am not sure how to test that, because
if I delete the items manually, it will not cause that error, unless the thread
was running while I did it. It's pretty tricky to reproduce.

The while True breaks when the Queue is empty (which will happen eventually ;-),
or any other exception occurs. You mean add a test to ensure it ends?

> Also, we should confirm we're testing this case:
>
> "if the user has no UDFs created and selects nothing" -> we should show the
> quota used only

This was covered by test_total_size_unchecked (when there are UDFs, it should return the quota used)
and I now added test_total_size_unchecked_no_udfs (nothing checked, no UDFs, no quota used, should be 0)

> and that the show_hide_offer method received the proper parameter.

Added a fake show_hide_offer and asserts to check that.

> * correct me if I'm wrong, but seems like there is no test for
> on_folder_list_itemChanged

added test_on_folder_list_item_changed_col_0 and col_1

> nor on_add_folder_button_clicked.

This was already covered by test_add_folder_clicked_valid and test_add_folder_clicked_invalid.

> * question: would you agree to move all the tests for the local_folders module
> into its own test module, so we can follow the convention? The convention is:
> per every foo.py, there should be a test_foo.py.

Sure. Moved.

[Natalia Bidart (nataliabidart)]

> > * there are no tests for add_folder when the params validate, calculate and
> > volume_id are other than the defaults. Also, having volume_id defaulting to
> > False may be a typo? volume_id, when defined, is a uuid...
>
> I just wanted something to say "if not volume_id". I will default it to None.

Makes sense.

Also, did you add tests cases for the params not having the default values?

> > * it seems to me that update_sizes is not completely covered by tests. I
> think
> > that the try-except for the RuntimeError is not tested, as well as the while
> > True. For that last feature, we should have more than one thing being
> > calculated its size, to show the sum of the sizes.
>
> The RuntimeError only happens when a list item is deleted by Qt before its
> thread
> returns the result (for example, if the user leaves the page and comes back),
> and it just means we can ignore that item. I am not sure how to test that,
> because
> if I delete the items manually, it will not cause that error, unless the
> thread
> was running while I did it. It's pretty tricky to reproduce.

You can patch item.setText, or humanize, to raise RuntimeError and check that it was handled.

> The while True breaks when the Queue is empty (which will happen eventually
> ;-),
> or any other exception occurs. You mean add a test to ensure it ends?

Nopes, I mean that if we remove the while True, I think the tests keep passing. And I think that is caused becasue no test is ensuring that the whole content of the queue is used to calculate the final size.

Thanks!

[Roberto Alsina (ralsina)]

> > > * there are no tests for add_folder when the params validate, calculate
> and
> > > volume_id are other than the defaults. Also, having volume_id defaulting
> to
> > > False may be a typo? volume_id, when defined, is a uuid...
> >
> > I just wanted something to say "if not volume_id". I will default it to
> None.
>
> Makes sense.
>
> Also, did you add tests cases for the params not having the default values?

Yes, madam!

test_not_validating_invalid_item_addition
test_not_calculating_item_addition
test_volume_id_item_addition

> > > * it seems to me that update_sizes is not completely covered by tests. I
> > think
> > > that the try-except for the RuntimeError is not tested, as well as the
> while
> > > True. For that last feature, we should have more than one thing being
> > > calculated its size, to show the sum of the sizes.
> >
> > The RuntimeError only happens when a list item is deleted by Qt before its
> > thread
> > returns the result (for example, if the user leaves the page and comes
> back),
> > and it just means we can ignore that item. I am not sure how to test that,
> > because
> > if I delete the items manually, it will not cause that error, unless the
> > thread
> > was running while I did it. It's pretty tricky to reproduce.
>
> You can patch item.setText, or humanize, to raise RuntimeError and check that
> it was handled.

Ok, will do!

> > The while True breaks when the Queue is empty (which will happen eventually
> > ;-),
> > or any other exception occurs. You mean add a test to ensure it ends?
>
> Nopes, I mean that if we remove the while True, I think the tests keep
> passing. And I think that is caused becasue no test is ensuring that the whole
> content of the queue is used to calculate the final size.

Actually, it works without the while True, it just does it slower (it may require the timer calling
the function several times). But sure, I could do a test putting some stuff in the queue and checking that it's empty at the end.

[Natalia Bidart (nataliabidart)]

Simple lint and pep8 issues:

ubuntuone_installer/gui/qt/tests/test_gui.py:
    30: [W0611] Unused import TestCase

./ubuntuone_installer/gui/qt/local_folders.py:33:24: E202 whitespace before ')'
./ubuntuone_installer/gui/qt/tests/test_local_folders.py:80:35: E202 whitespace before '}'

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

Approving lint issues are being fixed ATM.

review: Approve

[John Lenton (chipaca)]

ok

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

Attempt to merge into lp:ubuntuone-windows-installer failed due to conflicts:

text conflict in ubuntuone_installer/gui/qt/tests/test_gui.py

[Ubuntu One Auto Pilot (otto-pilot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Ubuntu One Auto Pilot (otto-pilot)]

Attempt to merge into lp:ubuntuone-windows-installer failed due to conflicts:

text conflict in ubuntuone_installer/gui/qt/tests/test_gui.py

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

65. By Roberto Alsina on 2011-08-23

resolve further

=== 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-23 13:43:25 +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-15 21:41:54 +0000
+++ ubuntuone_installer/gui/qt/local_folders.py	2011-08-23 13:43:25 +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
+        # Don't calculate sizes of UDFs
+        if calculate and not volume_id:
+            self.thread.start()
+            self.size = None
+        else:
+            self.size = 0
         self.path = path
+        self.setCheckState(0, QtCore.Qt.Unchecked)
+        self.volume_id = volume_id
 
 
 class CalculateSize(threading.Thread):
@@ -83,22 +95,17 @@
             local_folders_ui.Ui_Form(), None, parent)
         self.setTitle(LOCAL_FOLDERS_TITLE)
         self.setSubTitle()
-
         header_view = self.ui.folder_list.header()
         header_view.setResizeMode(0, header_view.Stretch)
-
         self.queue = Queue.Queue()
         self.timer = QtCore.QTimer()
         self.items = {}
-        for folder_name in self.default_folders():
-            self.add_folder(folder_name)
-        self.update_sizes()
-        self.timer.start(2000)
-        self.timer.timeout.connect(self.update_sizes)
+        self.folders_info = None
+        self.account_info = None
+        self.cp_backend = backend.ControlBackend()
 
     # initializePage is inherited
     # pylint: disable=C0103
-    @inlineCallbacks
     def initializePage(self):
         """UI details."""
         self.wizard().setButtonLayout([
@@ -107,15 +114,75 @@
         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():
+        # Show overlay 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."""
+        # pylint: disable=W0702
+        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'],
+                    calculate=False,
+                    )
+                if item:
+                    if folder['subscribed']:
+                        item.setCheckState(0, QtCore.Qt.Checked)
+                    item.size = 0
             for folder_name in self.default_folders():
-                self.add_folder(folder_name)
-            yield 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)
@@ -129,56 +196,60 @@
             result = ['To be implemented']
         return result
 
-    def add_folder(self, path):
+    @inlineCallbacks
+    def add_folder(self, path, validate=True, calculate=True, volume_id=None):
         """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,
+                calculate=calculate)
+            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))
-        except Queue.Empty:
-            pass
-        total = 0
+        while True:
+            try:
+                path, size = self.queue.get(False)
+            except Queue.Empty:
+                break
+            else:
+                item = self.items.get(path)
+                if item:
+                    item.size = size
+                    try:
+                        item.setText(1, humanize(size))
+                    except RuntimeError:
+                        del self.items[path]
+        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()
-        except:
-            logger.exception('Error while trying to get account info:')
-
-        quota = user_info['quota_total']
+        """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:
@@ -193,31 +264,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
+        url = "https://one.ubuntu.com/services/#storage_panel"
         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)
+            signed_url = sign_url(url, creds)
         else:
-            signed_url = "https://one.ubuntu.com/services/#storage_panel"
+            signed_url = url
         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-22 14:05:02 +0000
+++ ubuntuone_installer/gui/qt/tests/test_gui.py	2011-08-23 13:43:25 +0000
@@ -20,9 +20,6 @@
 """Tests for the Qt UI."""
 
 import os
-import Queue
-import shutil
-import tempfile
 
 from twisted.internet import defer
 from PyQt4 import QtGui, QtCore
@@ -32,7 +29,6 @@
 from ubuntuone_installer.gui.qt import gui
 from ubuntuone_installer.gui.qt.tests import BaseTestCase
 from ubuntuone_installer.gui.qt import forgotten
-from ubuntuone_installer.gui.qt import local_folders
 from ubuntuone_installer.gui.qt import setup_account
 from ubuntuone_installer.gui.qt.ui import (
     setup_account_ui,
@@ -217,6 +213,7 @@
         self.ui.restart()
         self.ui.show()
 
+        # pylint: disable=W0212
         preferences_page._button_clicked(QtGui.QWizard.CustomButton2)
         self.assertEqual(
             preferences_page.preferences_widget.restore_button_clicked, True)
@@ -245,6 +242,7 @@
         self.assertEqual(tree_folders.isHeaderHidden(), True)
         tree_folders = folders_page.folders_widget.ui.folders
         self.assertEqual(tree_folders.isColumnHidden(2), True)
+        # pylint: disable=W0212
         self.assertEqual(self.ui._next_id, self.ui.CONGRATULATIONS_PAGE)
 
     def test_folders_page_next_id(self):
@@ -571,120 +569,19 @@
         self.shown = True
 
 
-class FakeCPBackend(object):
-    """Fake Control Panel backend."""
-
-    def account_info(self, *args):
-        """Fake account info."""
-        return defer.succeed({"quota_total": 1000})
-
-
-class FakeAddFolderButton(object):
-    """Fake Control Panel "Add Folder" button."""
-    backend = FakeCPBackend()
-
-
-class LocalFoldersTestCase(BaseTestCase):
-    """Test the LocalFoldersPage code."""
-
-    class_ui = local_folders.LocalFoldersPage
-
-    def setUp(self):
-        """Initialize this test instance."""
-        # Create a test folder with a known size
-        self.tmpdir = tempfile.mkdtemp()
-        f = open(os.path.join(self.tmpdir, 'test_file'), 'wb')
-        f.write(" " * 600)
-        f.close()
-        os.mkdir(os.path.join(self.tmpdir, 'test_dir'))
-        f = open(os.path.join(self.tmpdir, 'test_dir', 'test_file_2'), 'wb')
-        f.write(" " * 737)
-        f.close()
-        super(LocalFoldersTestCase, self).setUp()
-
-    def tearDown(self):
-        """Remove the temporary tree."""
-        shutil.rmtree(self.tmpdir)
-        BaseTestCase.tearDown(self)
-
-    def test_size_calculation(self):
-        """Test the recursive folder size calculation."""
-        queue = Queue.Queue()
-        csize = local_folders.CalculateSize(self.tmpdir, queue)
-        csize.run()
-        path, size = queue.get()
-        self.assertEqual(path, self.tmpdir)
-        self.assertEqual(size, 1337)
-
-    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())
-
-    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)")
-
-    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.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())
-
-    def test_add_missing_folder(self):
-        """Behaviour for adding a folder that doesn't exist.
-
-        * It's added.
-        * Has size 0.
-        """
-
-        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(os.path.join("xyzzy", "xyzzy", "xyzzy"))
-        self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
-        item.thread.run()
-        item.thread.join()
-        self.ui.update_sizes()
-        self.assertEqual(0, item.size)
-        # world did not explode
-
-    def test_over_quota(self):
-        """After removing all folders, offer_frame should be hidden.
-
-        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())
-        self.ui.update_sizes()
-        self.assertEqual(self._called, ((False,), {}))
-        self.ui.show_hide_offer(self.ui.quota() + 1)
-        self.assertEqual(self._called, ((True,), {}))
-
-
-LocalFoldersTestCase.skip = 'We need to re-write this test case entirely,' \
-                            'see bug #824675 for reference.'
+class FakeWizard(object):
+    """Replace wizard() function on wizard pages."""
+
+    params = None
+
+    # Invalid name "setButtonLayout"
+    # pylint: disable=C0103
+
+    def setButtonLayout(self, *args, **kwargs):
+        """Fake the functionality of setButtonLayout on QWizard class."""
+        FakeWizard.params = (args, kwargs)
+
+    # pylint: enable=C0103
 
 
 class FakeWizard(object):

=== added file 'ubuntuone_installer/gui/qt/tests/test_local_folders.py'
--- ubuntuone_installer/gui/qt/tests/test_local_folders.py	1970-01-01 00:00:00 +0000
+++ ubuntuone_installer/gui/qt/tests/test_local_folders.py	2011-08-23 13:43:25 +0000
@@ -0,0 +1,585 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Roberto Alsina <[e-mail]>
+#
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the local folders page."""
+
+import os
+import Queue
+import shutil
+import tempfile
+
+from twisted.internet import defer
+from PyQt4 import QtGui, QtCore
+
+from ubuntuone_installer.gui.qt import local_folders
+from ubuntuone_installer.gui.qt.tests import BaseTestCase, TestCase
+from ubuntuone_installer.gui.qt.tests.test_gui import FakeOverlay
+
+
+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 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,
+            "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,
+            },
+            {
+                'type': u'SHARE',
+                'path': os.path.expanduser(u'~/foobar'),
+                'volume_id': 'shared',
+                '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 FakeFailingCPBackend(object):
+    """Fake Control Panel backend that fails."""
+
+    def account_info(self, *args):
+        """Fake account info."""
+        return defer.fail(Exception())
+
+    def volumes_info(self, *args):
+        """Fake account info."""
+        return defer.fail(Exception())
+
+
+class FakeSignal(object):
+
+    """A fake PyQt signal."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize."""
+        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."""
+        if self.target:
+            self.target(*args)
+
+
+class FakeMainWindow(object):
+
+    """A fake MainWindow."""
+
+    loginSuccess = FakeSignal()
+    registrationSuccess = FakeSignal()
+    userCancellation = FakeSignal()
+    shown = False
+    _buttonlayout = None
+    SYNC_NOW_OR_LATER_PAGE = 4
+    overlay = FakeOverlay()
+    currentIdChanged = FakeSignal()
+
+    def show(self):
+        """Fake method."""
+        self.shown = True
+
+    # pylint: disable=C0103
+    def setButtonLayout(self, *args):
+        """Save ButtonLayout."""
+        self._buttonlayout = args
+
+
+class FakeCalculateSize(object):
+
+    """A fake CalculateSize."""
+
+    def __init__(self, *args, **kwargs):
+        self.started = False
+
+    def start(self):
+        """Fake start."""
+        self.started = True
+
+
+class FolderItemTestCase(TestCase):
+
+    """Tests for the FolderItem class."""
+
+    def test_folder_item_new_udf(self):
+        """Test when created like a new UDF."""
+        self.patch(local_folders, "CalculateSize", FakeCalculateSize)
+        item = local_folders.FolderItem(["s1", "s2"], "path")
+        self.assertTrue(item.size is None)
+        self.assertEqual(item.path, "path")
+        # pylint: disable=E1101
+        self.assertTrue(item.thread.started)
+        self.assertEqual(item.checkState(0), QtCore.Qt.Unchecked)
+        self.assertTrue(item.volume_id is None)
+
+    def test_folder_item_existing_udf(self):
+        """Test when created like an existing UDF."""
+        self.patch(local_folders, "CalculateSize", FakeCalculateSize)
+        item = local_folders.FolderItem(["s1", "s2"], "path",
+            calculate=False, volume_id="xyzzy")
+        self.assertEqual(item.size, 0)
+        self.assertEqual(item.path, "path")
+        # pylint: disable=E1101
+        self.assertFalse(item.thread.started)
+        self.assertEqual(item.checkState(0), QtCore.Qt.Unchecked)
+        self.assertEqual(item.volume_id, "xyzzy")
+
+
+class LocalFoldersTestCase(BaseTestCase):
+    """Test the LocalFoldersPage code."""
+
+    class_ui = local_folders.LocalFoldersPage
+
+    def setUp(self):
+        """Initialize this test instance."""
+        # Create a test folder with a known size
+        self.tmpdir = tempfile.mkdtemp()
+        f = open(os.path.join(self.tmpdir, 'test_file'), 'wb')
+        f.write(" " * 600)
+        f.close()
+        os.mkdir(os.path.join(self.tmpdir, 'test_dir'))
+        f = open(os.path.join(self.tmpdir, 'test_dir', 'test_file_2'), 'wb')
+        f.write(" " * 737)
+        f.close()
+        self.addCleanup(shutil.rmtree, self.tmpdir)
+        self.fake_wizard = FakeMainWindow()
+        self.patch(local_folders.backend, "ControlBackend", FakeCPBackend)
+        super(LocalFoldersTestCase, self).setUp()
+        self.patch(self.ui, "wizard", lambda: self.fake_wizard)
+
+    def test_status_before_initialize(self):
+        """Test status of the page components before initializePage()."""
+        self.assertIsInstance(self.ui.timer, QtCore.QTimer)
+        self.assertFalse(self.ui.timer.isActive())
+        self.assertTrue(self.ui.folders_info is None)
+        self.assertTrue(self.ui.account_info is None)
+        self.assertEqual(self.ui.items, {})
+        self.assertEqual(self.ui.ui.folder_list.topLevelItemCount(), 0)
+
+    def test_status_after_initialize(self):
+        """Test status of page components after initializePage()."""
+        self.patch(self.ui, "get_info", self._set_called)
+        self.ui.initializePage()
+        self.assertTrue(self.ui.wizard().overlay.show_counter, 1)
+        self.assertTrue(self.ui.wizard().overlay.hide_counter, 0)
+        self.assertFalse(self.ui.ui.offer_frame.isVisible())
+        self.assertEqual(self._called, ((), {}))
+
+    @defer.inlineCallbacks
+    def test_status_after_get_info(self):
+        """Test status of page components after get_info()."""
+        yield self.ui.get_info()
+        self.assertTrue(self.ui.wizard().overlay.hide_counter, 1)
+        self.assertEqual(self.ui.ui.folder_list.topLevelItemCount(), 5)
+        self.assertEqual(self.ui.wizard().currentIdChanged.target,
+            self.ui.changed_page)
+        self.assertEqual(
+            self.ui.items[os.path.expanduser('~/xyzzy')].checkState(0),
+            QtCore.Qt.Checked)
+        self.assertEqual(
+            self.ui.items[os.path.expanduser('~/zxyzzy')].checkState(0),
+            QtCore.Qt.Unchecked)
+        check_states = [self.ui.items[item].checkState(0)
+            for item in self.ui.items]
+        self.assertEqual(len([
+            x for x in check_states if x != QtCore.Qt.Unchecked]), 1)
+        self.assertNotIn('shared', self.ui.items)
+
+    @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.assertEqual(item.volume_id, 'asdfgh')
+
+    @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.assertEqual(item.volume_id, 'qwerty')
+
+    def test_size_calculation(self):
+        """Test the recursive folder size calculation."""
+        queue = Queue.Queue()
+        csize = local_folders.CalculateSize(self.tmpdir, queue)
+        csize.run()
+        path, size = queue.get()
+        self.assertEqual(path, self.tmpdir)
+        self.assertEqual(size, 1337)
+
+    @defer.inlineCallbacks
+    def test_item_addition(self):
+        """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_not_validating_invalid_item_addition(self):
+        """Try to add an invalid folder, and not validate it."""
+        self.ui.ui.folder_list.clear()
+        self.ui.cp_backend._is_valid = False
+        yield self.ui.add_folder(self.tmpdir, validate=False)
+        self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
+
+    @defer.inlineCallbacks
+    def test_not_calculating_item_addition(self):
+        """Try to add a folder, and not calculate it."""
+        self.ui.ui.folder_list.clear()
+        yield self.ui.add_folder(self.tmpdir, calculate=False)
+        self.assertEqual(self.ui.items[self.tmpdir].size, 0)
+        self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
+
+    @defer.inlineCallbacks
+    def test_volume_id_item_addition(self):
+        """Try to add a folder with a volume_id."""
+        self.ui.ui.folder_list.clear()
+        yield self.ui.add_folder(self.tmpdir, volume_id="vol")
+        self.assertEqual(self.ui.items[self.tmpdir].volume_id, "vol")
+        self.assertEqual(1, self.ui.ui.folder_list.topLevelItemCount())
+
+    @defer.inlineCallbacks
+    def test_total_size(self):
+        """Test that the header reflects the change in item sizes."""
+        self.patch(self.ui, "show_hide_offer", self._set_called)
+        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)")
+        self.assertEqual(self._called, ((1537L,), {}))
+
+    @defer.inlineCallbacks
+    def test_total_size_unchecked(self):
+        """Unchecked items use no space beyond quota_used."""
+        self.patch(self.ui, "show_hide_offer", self._set_called)
+        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)")
+        self.assertEqual(self._called, ((200L,), {}))
+
+    @defer.inlineCallbacks
+    def test_total_size_unchecked_no_udfs(self):
+        """No checked items and no quota used should amount to 0 bytes."""
+        self.patch(self.ui, "show_hide_offer", self._set_called)
+        yield self.ui.get_info()
+        self.ui.account_info['quota_used'] = 0
+        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 (0 bytes)")
+        self.assertEqual(self._called, ((0,), {}))
+
+    @defer.inlineCallbacks
+    def test_total_size_udf(self):
+        """UDFs use no space beyond quota_used."""
+        self.patch(self.ui, "show_hide_offer", self._set_called)
+        yield self.ui.get_info()
+        for _, item in self.ui.items.items():
+            if item.thread.is_alive():
+                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)")
+        self.assertEqual(self._called, ((200L,), {}))
+
+    def test_add_twice(self):
+        """Behaviour for adding the same folder twice:
+
+        * It's added only once.
+        """
+        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:
+
+        * It's added.
+        * Has size 0.
+        """
+
+        yield self.ui.get_info()
+        self.ui.ui.folder_list.clear()
+        self.assertEqual(0, self.ui.ui.folder_list.topLevelItemCount())
+        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()
+        self.ui.update_sizes()
+        self.assertEqual(0, item.size)
+        # world did not explode
+
+    def test_over_quota(self):
+        """After removing all folders, offer_frame should be hidden.
+
+        Push the user over quota, it should be visible.
+        """
+        self.patch(self.ui.ui.offer_frame, "setVisible", self._set_called)
+        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_clicked_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_clicked_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,
+        }
+        # pylint: disable=W0212
+        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()
+        show_counter = self.ui.wizard().overlay.show_counter
+        hide_counter = self.ui.wizard().overlay.hide_counter
+        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})])
+        self.assertEqual(self.ui.wizard().overlay.show_counter,
+            show_counter + 1)
+        self.assertEqual(self.ui.wizard().overlay.hide_counter,
+            hide_counter + 1)
+
+    @defer.inlineCallbacks
+    def test_changed_page_new_udf_behaviour(self):
+        """Create UDFs for non-existing, checked UDFs."""
+        yield self.ui.get_info()
+        show_counter = self.ui.wizard().overlay.show_counter
+        hide_counter = self.ui.wizard().overlay.hide_counter
+        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',)])
+        self.assertEqual(self.ui.wizard().overlay.show_counter,
+            show_counter + 1)
+        self.assertEqual(self.ui.wizard().overlay.hide_counter,
+            hide_counter + 1)
+
+    def test_exception_on_account_info(self):
+        """When account_info fails, nothing should happen."""
+        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."""
+        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())
+
+    def test_special_folders(self):
+        """Test that default_folders does the right thing."""
+        folders = self.ui.default_folders()
+        self.assertEqual(len(folders), 3)
+        self.assertEqual(folders, [os.path.abspath(f) for f in folders])
+        # pylint: disable=W0404
+        import ctypes
+        dll = ctypes.windll.shell32
+        buf = ctypes.create_string_buffer(300)
+        dll.SHGetSpecialFolderPathA(None, buf, 5, False)
+        docs = buf.value
+        dll.SHGetSpecialFolderPathA(None, buf, 13, False)
+        music = buf.value
+        dll.SHGetSpecialFolderPathA(None, buf, 39, False)
+        pictures = buf.value
+        expected = [docs, music, pictures]
+        self.assertEqual(sorted(folders), sorted(expected))
+
+    def test_on_folder_list_item_changed_col_0(self):
+        """Test that it calls the right thing."""
+        self.patch(self.ui, 'update_sizes', self._set_called)
+        self.ui.on_folder_list_itemChanged("item", 0)
+        self.assertEqual(self._called, ((), {}))
+
+    def test_on_folder_list_item_changed_col_1(self):
+        """Test that it calls nothing."""
+        self.patch(self.ui, 'update_sizes', self._set_called)
+        self.ui.on_folder_list_itemChanged("item", 1)
+        self.assertFalse(self._called)
+
+    @defer.inlineCallbacks
+    def test_runtime_error(self):
+        """Test that runtime error is handled correctly."""
+
+        def raise_runtime(*args):
+            """Dummy function that raises RuntimeError."""
+            raise RuntimeError
+
+        yield self.ui.get_info()
+        item = yield self.ui.add_folder(
+            "dummy", validate=False, calculate=False)
+        self.patch(item, 'setText', raise_runtime)
+        self.ui.queue.put(["dummy", 1000])
+        self.assertIn("dummy", self.ui.items)
+        self.ui.update_sizes()
+        self.assertNotIn("dummy", self.ui.items)
+
+    @defer.inlineCallbacks
+    def test_queue_is_emptied(self):
+        """Test that update_sizes empties the queue."""
+        self.ui.account_info = {
+            "quota_total": 1000,
+            "quota_used": 200,
+        }
+        yield self.ui.add_folder("dummy1", validate=False, calculate=False)
+        yield self.ui.add_folder("dummy2", validate=False, calculate=False)
+        self.ui.queue.put(["dummy1", 1000])
+        self.ui.queue.put(["dummy2", 1000])
+        self.assertFalse(self.ui.queue.empty())
+        self.ui.update_sizes()
+        self.assertTrue(self.ui.queue.empty())