Merge lp:~nataliabidart/ubuntu/natty/ubuntuone-control-panel/ubuntuone-control-panel-0.1.0 into lp:ubuntu/natty/ubuntuone-control-panel

[Natalia Bidart]

 * debian/control
    - depends on ubutuone-client >= 1.5.1
    - depends on ubuntu-sso-client >= 1.1.7

  * New upstream release.
    [ Natalia B. Bidart <email address hidden> ]
      * Updated list of messages to be shown on the overview panel (LP:
      #690379).
      * Implemented callback for failure when loading devices.
      * Added a spinner on every UbuntuOneBin to be shown while loading the
      panel content.
      * Devices can now be removed (LP: #691295).
      * Migrated dbus_client to use non-deprectaed SSO D-Bus API.
      * Added clear_credentials to dbus_client module.
      * Implemented devices tab (LP: #690649).
      * Maximun size is set using geometry hints (LP: #683164).
      * Added logging to dbus_service and backend.
      * Error signals now sent the object id when available (LP: #691292).
      * After machine was added, Folders page is shown (LP: #674459).*
      VolumesInfoError signal is now handled (LP: #690292).
      * VolumesInfoError signal is now handled (LP: #690292).
      * When FileSyncStatusError is received, no more DbusException messages
      are leaked to the end user (LP: #690305).
      * User can now subcribe and unsubscribe from folders (LP: #689646).
      * Dbus booleans are now those strings whose bool() defines its value. So,
      '' for False and any other non empty string for True (LP: #683619).
      * File sync status is retrieved and displayed in the right top corner
      (LP: #673670).
      * Adding handling for file sync disabled (only backend for now).
      * Management panel is not twined itself if CredentialsFound signal is
     received several times (LP: #683649).
    [ Rodney Dawes <email address hidden> ]
      * Default to None and initialize if None in code, instead of mutable
      defaults.

[Michael Terry (mterry)]

Pushed, with slight debian/changelog typo corrections.

review: Approve

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-12-06 12:27:11 +0000
+++ PKG-INFO	2010-12-22 14:37:52 +0000
@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: ubuntuone-control-panel
-Version: 0.0.9
+Version: 0.1.0
 Summary: Ubuntu One Control Panel
 Home-page: https://launchpad.net/ubuntuone-control-panel
 Author: Natalia Bidart

=== modified file 'bin/ubuntuone-control-panel-backend'
--- bin/ubuntuone-control-panel-backend	2010-12-06 12:27:11 +0000
+++ bin/ubuntuone-control-panel-backend	2010-12-22 14:37:52 +0000
@@ -18,6 +18,8 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Execute the DBus backend for the Ubuntu One control panel."""
 
+# Invalid name "ubuntuone-control-panel-backend", pylint: disable=C0103
+
 
 from ubuntuone.controlpanel import dbus_service
 

=== modified file 'bin/ubuntuone-control-panel-gtk'
--- bin/ubuntuone-control-panel-gtk	2010-12-06 12:27:11 +0000
+++ bin/ubuntuone-control-panel-gtk	2010-12-22 14:37:52 +0000
@@ -18,7 +18,7 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Execute the graphical interface for the Ubuntu One control panel."""
 
-import gtk
+# Invalid name "ubuntuone-control-panel-gtk", pylint: disable=C0103
 
 import dbus.mainloop.glib
 
@@ -26,6 +26,7 @@
 
 dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
 
+
 if __name__ == "__main__":
-    ui = ubuntuone.controlpanel.gtk.gui.ControlPanelWindow()
-    ui.main()
+    gui = ubuntuone.controlpanel.gtk.gui.ControlPanelWindow()
+    gui.main()

=== modified file 'data/account.ui'
--- data/account.ui	2010-12-06 12:27:11 +0000
+++ data/account.ui	2010-12-22 14:37:52 +0000
@@ -9,26 +9,107 @@
     <child>
       <object class="GtkHBox" id="hbox1">
         <property name="visible">True</property>
-        <property name="spacing">15</property>
+        <property name="spacing">10</property>
         <child>
-          <object class="GtkVBox" id="vbox1">
+          <object class="GtkVBox" id="account">
             <property name="visible">True</property>
             <property name="spacing">10</property>
             <child>
-              <object class="GtkHBox" id="name_box">
+              <object class="GtkVBox" id="data">
                 <property name="visible">True</property>
-                <property name="spacing">5</property>
+                <property name="spacing">10</property>
                 <child>
-                  <object class="GtkLabel" id="name_label">
+                  <object class="GtkVBox" id="vbox1">
                     <property name="visible">True</property>
-                    <property name="xalign">0</property>
-                    <property name="label">Name:</property>
+                    <child>
+                      <object class="GtkLabel" id="label1">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="label" translatable="yes">&lt;b&gt;Name:&lt;/b&gt;</property>
+                        <property name="use_markup">True</property>
+                      </object>
+                      <packing>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="name_label">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="xpad">12</property>
+                        <property name="label">tester name</property>
+                        <property name="use_markup">True</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
                   </object>
                   <packing>
-                    <property name="expand">False</property>
                     <property name="position">0</property>
                   </packing>
                 </child>
+                <child>
+                  <object class="GtkVBox" id="vbox2">
+                    <property name="visible">True</property>
+                    <child>
+                      <object class="GtkLabel" id="label3">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="label" translatable="yes">&lt;b&gt;Account type:&lt;/b&gt;</property>
+                        <property name="use_markup">True</property>
+                      </object>
+                      <packing>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="type_label">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="xpad">12</property>
+                        <property name="label">22GB awesomeness</property>
+                      </object>
+                      <packing>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkVBox" id="vbox3">
+                    <property name="visible">True</property>
+                    <child>
+                      <object class="GtkLabel" id="label2">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="label" translatable="yes">&lt;b&gt;Email address:&lt;/b&gt;</property>
+                        <property name="use_markup">True</property>
+                      </object>
+                      <packing>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkLabel" id="email_label">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="xpad">12</property>
+                        <property name="label">[e-mail]</property>
+                      </object>
+                      <packing>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
               </object>
               <packing>
                 <property name="expand">False</property>
@@ -36,48 +117,6 @@
               </packing>
             </child>
             <child>
-              <object class="GtkHBox" id="type_box">
-                <property name="visible">True</property>
-                <property name="spacing">5</property>
-                <child>
-                  <object class="GtkLabel" id="label2">
-                    <property name="visible">True</property>
-                    <property name="xalign">0</property>
-                    <property name="label" translatable="yes">Account type:</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="position">0</property>
-                  </packing>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkHBox" id="email_box">
-                <property name="visible">True</property>
-                <property name="spacing">5</property>
-                <child>
-                  <object class="GtkLabel" id="label3">
-                    <property name="visible">True</property>
-                    <property name="xalign">0</property>
-                    <property name="label" translatable="yes">Email address:</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="position">0</property>
-                  </packing>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="position">2</property>
-              </packing>
-            </child>
-            <child>
               <object class="GtkHButtonBox" id="hbuttonbox1">
                 <property name="layout_style">center</property>
                 <child>
@@ -97,7 +136,7 @@
               <packing>
                 <property name="expand">False</property>
                 <property name="pack_type">end</property>
-                <property name="position">3</property>
+                <property name="position">1</property>
               </packing>
             </child>
           </object>
@@ -108,6 +147,7 @@
         <child>
           <object class="GtkVButtonBox" id="vbuttonbox1">
             <property name="visible">True</property>
+            <property name="spacing">10</property>
             <property name="layout_style">center</property>
             <child>
               <object class="GtkLinkButton" id="linkbutton1">
@@ -144,6 +184,7 @@
           </object>
           <packing>
             <property name="expand">False</property>
+            <property name="pack_type">end</property>
             <property name="position">1</property>
           </packing>
         </child>

=== removed file 'data/controlpanel.ui'
--- data/controlpanel.ui	2010-12-06 12:27:11 +0000
+++ data/controlpanel.ui	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<interface>
-  <requires lib="gtk+" version="2.16"/>
-  <!-- interface-naming-policy project-wide -->
-  <object class="GtkVBox" id="itself">
-    <property name="visible">True</property>
-    <child>
-      <placeholder/>
-    </child>
-    <child>
-      <placeholder/>
-    </child>
-    <child>
-      <placeholder/>
-    </child>
-  </object>
-</interface>

=== added file 'data/device.ui'
--- data/device.ui	1970-01-01 00:00:00 +0000
+++ data/device.ui	2010-12-22 14:37:52 +0000
@@ -0,0 +1,203 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <requires lib="gtk+" version="2.16"/>
+  <!-- interface-naming-policy project-wide -->
+  <object class="GtkAdjustment" id="adjustment2">
+    <property name="upper">10000</property>
+    <property name="step_increment">1</property>
+  </object>
+  <object class="GtkAdjustment" id="adjustment1">
+    <property name="upper">10000</property>
+    <property name="step_increment">1</property>
+  </object>
+  <object class="GtkVBox" id="itself">
+    <property name="visible">True</property>
+    <property name="spacing">5</property>
+    <child>
+      <object class="GtkHBox" id="hbox1">
+        <property name="visible">True</property>
+        <property name="spacing">15</property>
+        <child>
+          <object class="GtkVBox" id="vbox1">
+            <property name="visible">True</property>
+            <property name="spacing">5</property>
+            <child>
+              <object class="GtkHBox" id="hbox2">
+                <property name="visible">True</property>
+                <child>
+                  <object class="GtkImage" id="device_type">
+                    <property name="visible">True</property>
+                    <property name="icon_name">computer</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="device_name">
+                    <property name="visible">True</property>
+                    <property name="xalign">0</property>
+                    <property name="xpad">5</property>
+                    <property name="label">My Laptop</property>
+                  </object>
+                  <packing>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="device_id">
+                    <property name="label" translatable="yes">device id (hidden)</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="date_added">
+                    <property name="label">30.02.09</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="position">3</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkTable" id="throttling">
+                <property name="visible">True</property>
+                <property name="n_rows">3</property>
+                <property name="n_columns">2</property>
+                <property name="column_spacing">3</property>
+                <property name="row_spacing">3</property>
+                <child>
+                  <object class="GtkCheckButton" id="limit_bandwidth">
+                    <property name="label" translatable="yes">Limit bandwidth usage</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">False</property>
+                    <property name="draw_indicator">True</property>
+                    <signal name="toggled" handler="on_limit_bandwidth_toggled" swapped="no"/>
+                  </object>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="max_upload_speed_label">
+                    <property name="visible">True</property>
+                    <property name="xalign">1</property>
+                    <property name="xpad">5</property>
+                    <property name="label" translatable="yes">Max upload speed (KiB/s)</property>
+                  </object>
+                  <packing>
+                    <property name="top_attach">1</property>
+                    <property name="bottom_attach">2</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="max_download_speed_label">
+                    <property name="visible">True</property>
+                    <property name="xalign">1</property>
+                    <property name="xpad">5</property>
+                    <property name="label" translatable="yes">Max download speed (KiB/s)</property>
+                  </object>
+                  <packing>
+                    <property name="top_attach">2</property>
+                    <property name="bottom_attach">3</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSpinButton" id="max_upload_speed">
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="invisible_char">•</property>
+                    <property name="activates_default">True</property>
+                    <property name="adjustment">adjustment1</property>
+                    <signal name="value-changed" handler="on_max_upload_speed_value_changed" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="left_attach">1</property>
+                    <property name="right_attach">2</property>
+                    <property name="top_attach">1</property>
+                    <property name="bottom_attach">2</property>
+                    <property name="x_options">GTK_FILL</property>
+                    <property name="y_options">GTK_FILL</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSpinButton" id="max_download_speed">
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="invisible_char">•</property>
+                    <property name="activates_default">True</property>
+                    <property name="adjustment">adjustment2</property>
+                    <signal name="value-changed" handler="on_max_download_speed_value_changed" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="left_attach">1</property>
+                    <property name="right_attach">2</property>
+                    <property name="top_attach">2</property>
+                    <property name="bottom_attach">3</property>
+                  </packing>
+                </child>
+                <child>
+                  <placeholder/>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkVButtonBox" id="vbuttonbox1">
+            <property name="visible">True</property>
+            <property name="layout_style">start</property>
+            <child>
+              <object class="GtkButton" id="remove">
+                <property name="label">gtk-remove</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+                <signal name="activate" handler="on_remove_clicked" swapped="no"/>
+                <signal name="clicked" handler="on_remove_clicked" swapped="no"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="pack_type">end</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+      <packing>
+        <property name="expand">False</property>
+        <property name="position">0</property>
+      </packing>
+    </child>
+    <child>
+      <object class="GtkLabel" id="warning_label">
+        <property name="visible">True</property>
+      </object>
+      <packing>
+        <property name="position">1</property>
+      </packing>
+    </child>
+  </object>
+</interface>

=== modified file 'data/devices.ui'
--- data/devices.ui	2010-12-06 12:27:11 +0000
+++ data/devices.ui	2010-12-22 14:37:52 +0000
@@ -7,7 +7,37 @@
     <property name="border_width">10</property>
     <property name="spacing">10</property>
     <child>
-      <placeholder/>
+      <object class="GtkScrolledWindow" id="scrolledwindow1">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="hscrollbar_policy">automatic</property>
+        <property name="vscrollbar_policy">automatic</property>
+        <child>
+          <object class="GtkViewport" id="viewport1">
+            <property name="visible">True</property>
+            <property name="resize_mode">queue</property>
+            <property name="shadow_type">none</property>
+            <child>
+              <object class="GtkAlignment" id="alignment1">
+                <property name="visible">True</property>
+                <property name="xscale">0</property>
+                <property name="yscale">0</property>
+                <child>
+                  <object class="GtkVBox" id="devices">
+                    <property name="visible">True</property>
+                    <child>
+                      <placeholder/>
+                    </child>
+                  </object>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
     </child>
   </object>
 </interface>

=== modified file 'data/folders.ui'
--- data/folders.ui	2010-12-06 12:27:11 +0000
+++ data/folders.ui	2010-12-22 14:37:52 +0000
@@ -7,7 +7,32 @@
     <property name="border_width">10</property>
     <property name="spacing">10</property>
     <child>
-      <placeholder/>
+      <object class="GtkScrolledWindow" id="scrolledwindow1">
+        <property name="visible">True</property>
+        <property name="can_focus">True</property>
+        <property name="hscrollbar_policy">automatic</property>
+        <property name="vscrollbar_policy">automatic</property>
+        <child>
+          <object class="GtkViewport" id="viewport1">
+            <property name="visible">True</property>
+            <property name="resize_mode">queue</property>
+            <property name="shadow_type">none</property>
+            <child>
+              <object class="GtkAlignment" id="folders">
+                <property name="visible">True</property>
+                <property name="xscale">0</property>
+                <property name="yscale">0</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+      <packing>
+        <property name="position">0</property>
+      </packing>
     </child>
   </object>
 </interface>

=== modified file 'data/management.ui'
--- data/management.ui	2010-12-06 12:27:11 +0000
+++ data/management.ui	2010-12-22 14:37:52 +0000
@@ -16,8 +16,23 @@
                 <property name="border_width">10</property>
                 <property name="spacing">10</property>
                 <child>
-                  <object class="GtkProgressBar" id="quota_progressbar">
+                  <object class="GtkHBox" id="quota_box">
                     <property name="visible">True</property>
+                    <child>
+                      <object class="GtkAlignment" id="alignment1">
+                        <property name="visible">True</property>
+                        <property name="xscale">0</property>
+                        <property name="yscale">0</property>
+                        <child>
+                          <object class="GtkProgressBar" id="quota_progressbar">
+                            <property name="visible">True</property>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
                   </object>
                   <packing>
                     <property name="expand">False</property>

=== modified file 'debian/changelog'
--- debian/changelog	2010-12-21 14:09:31 +0000
+++ debian/changelog	2010-12-22 14:37:52 +0000
@@ -1,3 +1,63 @@
+ubuntuone-control-panel (0.1.0-0ubuntu1) UNRELEASED; urgency=low
+
+  * debian/control
+    - depends on ubutuone-client >= 1.5.1
+    - depends on ubuntu-sso-client >= 1.1.7
+
+  * New upstream release.
+
+    [ Natalia B. Bidart <[e-mail]> ]
+
+      * Updated list of messages to be shown on the overview panel (LP:
+      #690379).
+
+      * Implemented callback for failure when loading devices.
+
+      * Added a spinner on every UbuntuOneBin to be shown while loading the
+      panel content.
+
+      * Devices can now be removed (LP: #691295).
+
+      * Migrated dbus_client to use non-deprectaed SSO D-Bus API.
+
+      * Added clear_credentials to dbus_client module.
+
+      * Implemented devices tab (LP: #690649).
+
+      * Maximun size is set using geometry hints (LP: #683164).
+
+      * Added logging to dbus_service and backend.
+
+      * Error signals now sent the object id when available (LP: #691292).
+
+      * After machine was added, Folders page is shown (LP: #674459).*
+      VolumesInfoError signal is now handled (LP: #690292).
+
+      * VolumesInfoError signal is now handled (LP: #690292).
+
+      * When FileSyncStatusError is received, no more DbusException messages
+      are leaked to the end user (LP: #690305).
+
+      * User can now subcribe and unsubscribe from folders (LP: #689646).
+
+      * Dbus booleans are now those strings whose bool() defines its value. So,
+      '' for False and any other non empty string for True (LP: #683619).
+
+      * File sync status is retrieved and displayed in the right top corner
+      (LP: #673670).
+
+      * Adding handling for file sync disabled (only backend for now).
+
+      * Management panel is not twined itself if CredentialsFound signal is
+     received several times (LP: #683649).
+
+    [ Rodney Dawes <[e-mail]> ]
+
+      * Default to None and initialize if None in code, instead of mutable
+      defaults.
+
+ -- Natalia Bidart (nessita) <[e-mail]>  Wed, 22 Dec 2010 11:15:04 -0300
+
 ubuntuone-control-panel (0.0.9-0ubuntu3) natty; urgency=low
 
   * debian/control

=== modified file 'debian/control'
--- debian/control	2010-12-21 14:09:31 +0000
+++ debian/control	2010-12-22 14:37:52 +0000
@@ -35,8 +35,8 @@
  python-simplejson,
  python-twisted-core,
  python-twisted-web,
- python-ubuntuone-client (>= 1.5.0),
- ubuntu-sso-client (>= 1.1.2),
+ python-ubuntuone-client (>= 1.5.1),
+ ubuntu-sso-client (>= 1.1.7),
 Description: Ubuntu One Control Panel Python Libraries
  Ubuntu One Control Panel provides a Python library to manage an Ubuntu One
  account.
@@ -50,8 +50,8 @@
  python-dbus,
  python-gobject,
  python-gtk2,
- python-ubuntuone-client (>= 1.5.0),
- ubuntu-sso-client (>= 1.1.2),
+ python-ubuntuone-client (>= 1.5.1),
+ ubuntu-sso-client (>= 1.1.7),
  ubuntuone-control-panel (= ${binary:Version}),
 Description: Ubuntu One Control Panel
  GTK+ desktop application to manage a Ubuntu One account.

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2010-12-06 12:27:11 +0000
+++ po/POTFILES.in	2010-12-22 14:37:52 +0000
@@ -1,7 +1,6 @@
 ubuntuone/controlpanel/gtk/gui.py
 [type: gettext/glade] data/account.ui
 [type: gettext/glade] data/applications.ui
-[type: gettext/glade] data/controlpanel.ui
 [type: gettext/glade] data/devices.ui
 [type: gettext/glade] data/management.ui
 [type: gettext/glade] data/overview.ui

=== modified file 'setup.py'
--- setup.py	2010-12-06 12:27:11 +0000
+++ setup.py	2010-12-22 14:37:52 +0000
@@ -75,7 +75,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntuone-control-panel',
-    version='0.0.9',
+    version='0.1.0',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntuone/controlpanel/__init__.py'
--- ubuntuone/controlpanel/__init__.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/__init__.py	2010-12-22 14:37:52 +0000
@@ -29,4 +29,4 @@
 DBUS_PREFERENCES_PATH = "/preferences"
 DBUS_PREFERENCES_IFACE = "com.ubuntuone.controlpanel.Preferences"
 
-WEBSERVICE_BASE_URL = "https://one.ubuntu.com/api/"
+WEBSERVICE_BASE_URL = u"https://one.ubuntu.com/api/"

=== modified file 'ubuntuone/controlpanel/backend.py'
--- ubuntuone/controlpanel/backend.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/backend.py	2010-12-22 14:37:52 +0000
@@ -22,8 +22,12 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
 
 from ubuntuone.controlpanel import dbus_client
+from ubuntuone.controlpanel.logger import setup_logging, log_call
 from ubuntuone.controlpanel.webclient import WebClient
 
+
+logger = setup_logging('backend')
+
 ACCOUNT_API = "account/"
 QUOTA_API = "quota/"
 DEVICES_API = "1.0/devices/"
@@ -33,6 +37,22 @@
 UPLOAD_KEY = "max_upload_speed"
 DOWNLOAD_KEY = "max_download_speed"
 
+FILE_SYNC_DISABLED = 'file-sync-disabled'
+FILE_SYNC_DISCONNECTED = 'file-sync-disconnected'
+FILE_SYNC_ERROR = 'file-sync-error'
+FILE_SYNC_IDLE = 'file-sync-idle'
+FILE_SYNC_STARTING = 'file-sync-starting'
+FILE_SYNC_SYNCING = 'file-sync-syncing'
+FILE_SYNC_UNKNOWN = 'file-sync-unknown'
+
+MSG_KEY = 'message'
+STATUS_KEY = 'status'
+
+
+def bool_str(value):
+    """Return the string representation of a bool (dbus-compatible)."""
+    return 'True' if value else ''
+
 
 class ControlBackend(object):
     """The control panel backend."""
@@ -40,20 +60,101 @@
     def __init__(self):
         """Initialize the webclient."""
         self.wc = WebClient(dbus_client.get_credentials)
+        self._status_changed_handler = None
+        self.status_changed_handler = lambda *a: None
+
+    def _process_file_sync_status(self, status):
+        """Process raw file sync status into custom format.
+
+        Return a dictionary with two members:
+        * STATUS_KEY: the current status of syncdaemon, can be one of:
+            FILE_SYNC_DISABLED, FILE_SYNC_STARTING, FILE_SYNC_DISCONNECTED,
+            FILE_SYNC_SYNCING, FILE_SYNC_IDLE, FILE_SYNC_ERROR,
+            FILE_SYNC_UNKNOWN
+        * MSG_KEY: a non translatable but human readable string of the status.
+
+        """
+        if not status:
+            return {MSG_KEY: '', STATUS_KEY: FILE_SYNC_DISABLED}
+
+        msg = '%s (%s)' % (status['description'], status['name'])
+        result = {MSG_KEY: msg}
+
+        # file synch is enabled
+        is_error = bool(status['is_error'])
+        is_synching = bool(status['is_connected'])
+        is_idle = bool(status['is_online']) and status['queues'] == 'IDLE'
+        is_disconnected = status['name'] == 'READY' and \
+                          'Not User' in status['connection']
+        is_starting = status['name'] in ('INIT', 'LOCAL_RESCAN', 'READY')
+
+        if is_error:
+            result[STATUS_KEY] = FILE_SYNC_ERROR
+        elif is_idle:
+            result[STATUS_KEY] = FILE_SYNC_IDLE
+        elif is_synching:
+            result[STATUS_KEY] = FILE_SYNC_SYNCING
+        elif is_disconnected:
+            result[STATUS_KEY] = FILE_SYNC_DISCONNECTED
+        elif is_starting:
+            result[STATUS_KEY] = FILE_SYNC_STARTING
+        else:
+            logger.warning('file_sync_status: unknown (got %r)', status)
+            result[STATUS_KEY] = FILE_SYNC_UNKNOWN
+
+        return result
+
+    def _set_status_changed_handler(self, handler):
+        """Set 'handler' to be called when file sync status changes."""
+        logger.debug('setting status_changed_handler to %r', handler)
+
+        def process_and_callback(status):
+            """Process syncdaemon's status and callback 'handler'."""
+            result = self._process_file_sync_status(status)
+            handler(result)
+
+        self._status_changed_handler = process_and_callback
+        dbus_client.set_status_changed_handler(process_and_callback)
+
+    def _get_status_changed_handler(self, handler):
+        """Return the handler to be called when file sync status changes."""
+        return self._status_changed_handler
+
+    status_changed_handler = property(_get_status_changed_handler,
+                                      _set_status_changed_handler)
 
     @inlineCallbacks
     def get_token(self):
-        """Return the token from the credentials"""
+        """Return the token from the credentials."""
         credentials = yield dbus_client.get_credentials()
         returnValue(credentials["token"])
 
     @inlineCallbacks
+    def device_is_local(self, device_id):
+        """Return whether 'device_id' is the local devicew or not."""
+        dtype, did = self.type_n_id(device_id)
+        local_token = yield self.get_token()
+        is_local = (dtype == DEVICE_TYPE_COMPUTER and did == local_token)
+        logger.info('device_is_local: result %r, ', is_local)
+        returnValue(is_local)
+
+    @log_call(logger.debug)
+    @inlineCallbacks
     def account_info(self):
         """Get the user account info."""
         result = {}
 
         account_info = yield self.wc.call_api(ACCOUNT_API)
-        result["type"] = account_info["subscription"]["description"]
+
+        if "current_plan" in account_info:
+            desc = account_info["current_plan"]
+        elif "subscription" in account_info \
+                 and "description" in account_info["subscription"]:
+            desc = account_info["subscription"]["description"]
+        else:
+            desc = ''
+
+        result["type"] = desc
         result["name"] = account_info["nickname"]
         result["email"] = account_info["email"]
 
@@ -63,11 +164,11 @@
 
         returnValue(result)
 
+    @log_call(logger.debug)
     @inlineCallbacks
     def devices_info(self):
         """Get the user devices info."""
         result = []
-        this_token = yield self.get_token()
         limit_bw = yield dbus_client.bandwidth_throttling_enabled()
         limits = yield dbus_client.get_throttling_limits()
 
@@ -77,19 +178,25 @@
             result.append(di)
             di["type"] = d["kind"]
             di["name"] = d["description"]
-            di["configurable"] = "0"
+            di["configurable"] = ''
             if di["type"] == DEVICE_TYPE_COMPUTER:
                 di["device_id"] = di["type"] + d["token"]
-                if d["token"] == this_token:
-                    di["configurable"] = "1"
-                    di["limit_bandwidth"] = "1" if limit_bw else "0"
-                    upload = limits["upload"]
-                    download = limits["download"]
-                    di[UPLOAD_KEY] = str(upload)
-                    di[DOWNLOAD_KEY] = str(download)
             if di["type"] == DEVICE_TYPE_PHONE:
                 di["device_id"] = di["type"] + str(d["id"])
 
+            is_local = yield self.device_is_local(di["device_id"])
+            di["is_local"] = bool_str(is_local)
+            # currently, only local devices are configurable.
+            # eventually, more the devices will be configurable.
+            di["configurable"] = bool_str(is_local)
+
+            if bool(di["configurable"]):
+                di["limit_bandwidth"] = bool_str(limit_bw)
+                upload = limits["upload"]
+                download = limits["download"]
+                di[UPLOAD_KEY] = str(upload)
+                di[DOWNLOAD_KEY] = str(download)
+
             # date_added is not in the webservice yet (LP: #673668)
             # di["date_added"] = ""
 
@@ -107,18 +214,17 @@
             return DEVICE_TYPE_PHONE, device_id[5:]
         return "No device", device_id
 
+    @log_call(logger.info)
     @inlineCallbacks
     def change_device_settings(self, device_id, settings):
         """Change the settings for the given device."""
-        dtype, did = self.type_n_id(device_id)
-        local_token = yield self.get_token()
-        is_local = (dtype == DEVICE_TYPE_COMPUTER and did == local_token)
+        is_local = yield self.device_is_local(device_id)
 
         if is_local and "limit_bandwidth" in settings:
-            limit_bw = settings["limit_bandwidth"]
-            if limit_bw == "0":
+            limit_bw = bool(settings["limit_bandwidth"])
+            if not limit_bw:
                 yield dbus_client.disable_bandwidth_throttling()
-            if limit_bw == "1":
+            else:
                 yield dbus_client.enable_bandwidth_throttling()
 
         if is_local and (UPLOAD_KEY in settings or
@@ -137,30 +243,78 @@
         # still pending: more work on the settings dict (LP: #673674)
         returnValue(device_id)
 
+    @log_call(logger.warning)
     @inlineCallbacks
     def remove_device(self, device_id):
         """Remove a device's tokens from the sso server."""
         dtype, did = self.type_n_id(device_id)
-        api = DEVICE_REMOVE_API % (dtype, did)
+        is_local = yield self.device_is_local(device_id)
+
+        api = DEVICE_REMOVE_API % (dtype.lower(), did)
         yield self.wc.call_api(api)
+
+        if is_local:
+            logger.warning('remove_device: device is local, id %r, '
+                           'clearing credentials.', device_id)
+            yield dbus_client.clear_credentials()
+
         returnValue(device_id)
 
+    @log_call(logger.debug)
+    @inlineCallbacks
     def file_sync_status(self):
         """Return the status of the file sync service."""
-        # still pending (LP: #673670)
-        returnValue((True, "Synchronizing"))
+        enabled = yield dbus_client.files_sync_enabled()
+        if enabled:
+            status = yield dbus_client.get_current_status()
+        else:
+            status = {}
+        returnValue(self._process_file_sync_status(status))
 
+    @log_call(logger.debug)
     @inlineCallbacks
     def volumes_info(self):
-        """Get the user defined volumes info."""
-        result = yield dbus_client.get_volumes()
+        """Get the volumes info."""
+        result = yield dbus_client.get_folders()
+        # later, we may request shares info as well
         returnValue(result)
 
+    @log_call(logger.debug)
+    @inlineCallbacks
+    def change_volume_settings(self, volume_id, settings):
+        """Change settings for 'volume_id'.
+
+        Currently, only supported setting is boolean 'subscribed'.
+
+        """
+        if 'subscribed' in settings:
+            subscribed = settings['subscribed']
+            if subscribed:
+                yield self.subscribe_volume(volume_id)
+            else:
+                yield self.unsubscribe_volume(volume_id)
+
+    @inlineCallbacks
+    def subscribe_volume(self, volume_id):
+        """Subscribe to 'volume_id'."""
+        # when dealing with shares, we need to check if 'volume_id'
+        # is a folder or a share
+        yield dbus_client.subscribe_folder(volume_id)
+
+    @inlineCallbacks
+    def unsubscribe_volume(self, volume_id):
+        """Unsubscribe from 'volume_id'."""
+        # when dealing with shares, we need to check if 'volume_id'
+        # is a folder or a share
+        yield dbus_client.unsubscribe_folder(volume_id)
+
+    @log_call(logger.debug)
     def query_bookmark_extension(self):
         """True if the bookmark extension has been installed."""
         # still pending (LP: #673672)
         returnValue(False)
 
+    @log_call(logger.debug)
     def install_bookmarks_extension(self):
         """Install the extension to sync bookmarks."""
         # still pending (LP: #673673)

=== modified file 'ubuntuone/controlpanel/dbus_client.py'
--- ubuntuone/controlpanel/dbus_client.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/dbus_client.py	2010-12-22 14:37:52 +0000
@@ -25,7 +25,8 @@
 from twisted.internet import defer
 
 from ubuntuone.clientdefs import APP_NAME
-from ubuntuone.syncdaemon import dbus_interface as sd_dbus_iface
+from ubuntuone.platform.linux import dbus_interface as sd_dbus_iface
+from ubuntuone.platform.linux.tools import SyncDaemonTool
 
 from ubuntuone.controlpanel.logger import setup_logging
 
@@ -45,36 +46,88 @@
     """Do nothing"""
 
 
+def get_sso_proxy():
+    """Get a DBus proxy for credentials management."""
+    bus = dbus.SessionBus()
+    obj = bus.get_object(bus_name=ubuntu_sso.DBUS_BUS_NAME,
+                         object_path=ubuntu_sso.DBUS_CREDENTIALS_PATH,
+                         follow_name_owner_changes=True)
+    proxy = dbus.Interface(object=obj,
+                           dbus_interface=ubuntu_sso.DBUS_CREDENTIALS_IFACE)
+    return proxy
+
+
 def get_credentials():
     """Get the credentials from the ubuntu-sso-client."""
     d = defer.Deferred()
-    bus = dbus.SessionBus()
-    obj = bus.get_object(bus_name=ubuntu_sso.DBUS_BUS_NAME,
-                         object_path=ubuntu_sso.DBUS_CRED_PATH,
-                         follow_name_owner_changes=True)
-    proxy = dbus.Interface(object=obj,
-                           dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME)
+    proxy = get_sso_proxy()
 
     def found_credentials(app_name, creds):
         """Credentials have been found."""
+        logger.debug('credentials were found for app_name %r.', app_name)
         if app_name == APP_NAME:
+            logger.info('credentials were found! (%r).', APP_NAME)
             d.callback(creds)
 
-    def credentials_error(app_name, error_message, detailed_error):
+    def credentials_error(app_name, error_dict=None):
         """No credentials could be retrieved."""
         if app_name == APP_NAME:
-            error = CredentialsError(app_name, error_message, detailed_error)
+            if error_dict is None:
+                error_dict = {'error_message': 'Credentials were not found.',
+                              'detailed_error': ''}
+
+            logger.error('credentials error (%r, %r).', app_name, error_dict)
+            error = CredentialsError(app_name, error_dict)
             d.errback(error)
 
     foundsig = proxy.connect_to_signal("CredentialsFound", found_credentials)
+    notfoundsig = proxy.connect_to_signal("CredentialsNotFound",
+                                          credentials_error)
     errorsig = proxy.connect_to_signal("CredentialsError", credentials_error)
-    proxy.login_or_register_to_get_credentials(APP_NAME, "tcurl", "help", 0,
-                                               reply_handler=no_op,
-                                               error_handler=d.errback)
+    logger.debug('calling get_credentials.')
+    proxy.find_credentials(APP_NAME, {'': ''},
+                           reply_handler=no_op, error_handler=d.errback)
 
     def cleanup_signals(result):
         """Remove signals after use."""
         foundsig.remove()
+        notfoundsig.remove()
+        errorsig.remove()
+        return result
+
+    d.addBoth(cleanup_signals)
+    return d
+
+
+def clear_credentials():
+    """Clear the credentials using the ubuntu-sso-client."""
+    d = defer.Deferred()
+    proxy = get_sso_proxy()
+
+    def credentials_cleared(app_name):
+        """Credentials have been cleared."""
+        logger.debug('credentials were cleared for app_name %r.', app_name)
+        if app_name == APP_NAME:
+            logger.info('credentials were cleared! (%r).', APP_NAME)
+            d.callback(app_name)
+
+    def credentials_error(app_name, error_dict=None):
+        """No credentials could be retrieved."""
+        if app_name == APP_NAME:
+            logger.error('credentials error (%r, %r).', app_name, error_dict)
+            error = CredentialsError(app_name, error_dict)
+            d.errback(error)
+
+    clearedsig = proxy.connect_to_signal("CredentialsCleared",
+                                         credentials_cleared)
+    errorsig = proxy.connect_to_signal("CredentialsError", credentials_error)
+    logger.warning('calling clear_credentials.')
+    proxy.clear_credentials(APP_NAME, {'': ''},
+                            reply_handler=no_op, error_handler=d.errback)
+
+    def cleanup_signals(result):
+        """Remove signals after use."""
+        clearedsig.remove()
         errorsig.remove()
         return result
 
@@ -106,6 +159,12 @@
                                 sd_dbus_iface.DBUS_IFACE_FOLDERS_NAME)
 
 
+def get_status_syncdaemon_proxy():
+    """Get a DBus proxy for syncdaemon status calls."""
+    return get_syncdaemon_proxy("/status",
+                                sd_dbus_iface.DBUS_IFACE_STATUS_NAME)
+
+
 def get_throttling_limits():
     """Get the speed limits from the syncdaemon."""
     d = defer.Deferred()
@@ -154,18 +213,16 @@
     return d
 
 
-def get_volumes():
-    """Retrieve the volumes information from syncdaemon."""
-    # grab folders
+def get_folders():
+    """Retrieve the folders information from syncdaemon."""
     d = defer.Deferred()
     proxy = get_folders_syncdaemon_proxy()
     proxy.get_folders(reply_handler=d.callback, error_handler=d.errback)
-    # grab shares?
     return d
 
 
-def create_volume(path):
-    """Create a new volume through syncdaemon."""
+def create_folder(path):
+    """Create a new folder through syncdaemon."""
     d = defer.Deferred()
     proxy = get_folders_syncdaemon_proxy()
 
@@ -183,3 +240,72 @@
 
     d.addBoth(cleanup_signals)
     return d
+
+
+def subscribe_folder(folder_id):
+    """Subscribe to 'folder_id'."""
+    d = defer.Deferred()
+    proxy = get_folders_syncdaemon_proxy()
+
+    sig = proxy.connect_to_signal('FolderSubscribed', d.callback)
+    cb = lambda folder_info, error: d.errback(VolumesError(folder_info, error))
+    esig = proxy.connect_to_signal('FolderSubscribeError', cb)
+
+    proxy.subscribe(folder_id, reply_handler=no_op, error_handler=no_op)
+
+    def cleanup_signals(result):
+        """Remove signals after use."""
+        sig.remove()
+        esig.remove()
+        return result
+
+    d.addBoth(cleanup_signals)
+    return d
+
+
+def unsubscribe_folder(folder_id):
+    """Unsubscribe 'folder_id'."""
+    d = defer.Deferred()
+    proxy = get_folders_syncdaemon_proxy()
+
+    sig = proxy.connect_to_signal('FolderUnSubscribed', d.callback)
+    cb = lambda folder_info, error: d.errback(VolumesError(folder_info, error))
+    esig = proxy.connect_to_signal('FolderUnSubscribeError', cb)
+
+    proxy.unsubscribe(folder_id, reply_handler=no_op, error_handler=no_op)
+
+    def cleanup_signals(result):
+        """Remove signals after use."""
+        sig.remove()
+        esig.remove()
+        return result
+
+    d.addBoth(cleanup_signals)
+    return d
+
+
+def get_current_status():
+    """Retrieve the current status from syncdaemon."""
+    d = defer.Deferred()
+    proxy = get_status_syncdaemon_proxy()
+    proxy.current_status(reply_handler=d.callback, error_handler=d.errback)
+    return d
+
+
+def set_status_changed_handler(handler):
+    """Connect 'handler' with syncdaemon's StatusChanged signal."""
+    proxy = get_status_syncdaemon_proxy()
+    sig = proxy.connect_to_signal('StatusChanged', handler)
+    return proxy, sig
+
+
+def files_sync_enabled():
+    """Get if file sync service is enabled."""
+    enabled = SyncDaemonTool(bus=None).is_files_sync_enabled()
+    return defer.succeed(enabled)
+
+
[e-mail]
+def set_files_sync_enabled(enabled):
+    """Set the file sync service to be 'enabled'."""
+    yield SyncDaemonTool(bus=dbus.SessionBus()).enable_files_sync(enabled)

=== modified file 'ubuntuone/controlpanel/dbus_service.py'
--- ubuntuone/controlpanel/dbus_service.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/dbus_service.py	2010-12-22 14:37:52 +0000
@@ -28,9 +28,15 @@
 from twisted.python.failure import Failure
 
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
-    DBUS_PREFERENCES_IFACE, utils)
-from ubuntuone.controlpanel.backend import ControlBackend
-from ubuntuone.controlpanel.logger import setup_logging
+    DBUS_PREFERENCES_IFACE)
+from ubuntuone.controlpanel.backend import (
+    ControlBackend, FILE_SYNC_DISABLED, FILE_SYNC_DISCONNECTED,
+    FILE_SYNC_ERROR, FILE_SYNC_IDLE, FILE_SYNC_STARTING, FILE_SYNC_SYNCING,
+    MSG_KEY, STATUS_KEY,
+)
+from ubuntuone.controlpanel.logger import setup_logging, log_call
+from ubuntuone.controlpanel.utils import (ERROR_TYPE, ERROR_MESSAGE,
+    failure_to_error_dict, exception_to_error_dict)
 
 
 logger = setup_logging('dbus_service')
@@ -55,15 +61,15 @@
     """
     result = {}
     if isinstance(error, Failure):
-        result = utils.failure_to_error_dict(error)
+        result = failure_to_error_dict(error)
     elif isinstance(error, Exception):
-        result = utils.exception_to_error_dict(error)
+        result = exception_to_error_dict(error)
     elif isinstance(error, dict):
         # ensure that both keys and values are unicodes
         result = dict(map(make_unicode, i) for i in error.iteritems())
     else:
         msg = 'Got unexpected error argument %r' % error
-        result = {utils.ERROR_TYPE: 'UnknownError', utils.ERROR_MESSAGE: msg}
+        result = {ERROR_TYPE: 'UnknownError', ERROR_MESSAGE: msg}
 
     return result
 
@@ -74,10 +80,14 @@
     With this call, a Failure is transformed into a string-string dict.
 
     """
-    def inner(error, *a):
+    def inner(error, _=None):
         """Do the Failure transformation."""
         error_dict = error_handler(error)
-        return f(error_dict)
+        if _ is not None:
+            result = f(_, error_dict)
+        else:
+            result = f(error_dict)
+        return result
 
     return inner
 
@@ -89,10 +99,14 @@
         """Create this instance of the backend."""
         super(ControlPanelBackend, self).__init__(*args, **kwargs)
         self.backend = backend
-        logger.debug('ControlPanelBackend created with %r, %r', args, kwargs)
+        self.backend.status_changed_handler = self.process_status
+        logger.debug('ControlPanelBackend: created with %r, %r.\n'
+                     'status_changed_handler is %r.',
+                     args, kwargs, self.process_status)
 
     # pylint: disable=C0103
 
+    @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def account_info(self):
         """Find out the account info for the current logged in user."""
@@ -100,16 +114,19 @@
         d.addCallback(self.AccountInfoReady)
         d.addErrback(transform_failure(self.AccountInfoError))
 
+    @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def AccountInfoReady(self, info):
         """The info for the current user is available right now."""
 
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def AccountInfoError(self, error):
         """The info for the current user is currently unavailable."""
 
     #---
 
+    @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def devices_info(self):
         """Find out the devices info for the logged in user."""
@@ -117,67 +134,122 @@
         d.addCallback(self.DevicesInfoReady)
         d.addErrback(transform_failure(self.DevicesInfoError))
 
+    @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
     def DevicesInfoReady(self, info):
         """The info for the devices is available right now."""
 
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def DevicesInfoError(self, error):
         """The info for the devices is currently unavailable."""
 
     #---
 
+    @log_call(logger.info)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="sa{ss}")
-    def change_device_settings(self, token, settings):
+    def change_device_settings(self, device_id, settings):
         """Configure a given device."""
-        d = self.backend.change_device_settings(token, settings)
+        d = self.backend.change_device_settings(device_id, settings)
         d.addCallback(self.DeviceSettingsChanged)
-        d.addErrback(transform_failure(self.DeviceSettingsChangeError))
+        d.addErrback(transform_failure(self.DeviceSettingsChangeError),
+                     device_id)
 
+    @log_call(logger.info)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
-    def DeviceSettingsChanged(self, token):
+    def DeviceSettingsChanged(self, device_id):
         """The settings for the device were changed."""
 
-    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
-    def DeviceSettingsChangeError(self, error):
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="sa{ss}")
+    def DeviceSettingsChangeError(self, device_id, error):
         """Problem changing settings for the device."""
 
     #---
 
+    @log_call(logger.warning)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="s")
-    def remove_device(self, token):
+    def remove_device(self, device_id):
         """Remove a given device."""
-        d = self.backend.remove_device(token)
+        d = self.backend.remove_device(device_id)
         d.addCallback(self.DeviceRemoved)
-        d.addErrback(transform_failure(self.DeviceRemovalError))
+        d.addErrback(transform_failure(self.DeviceRemovalError), device_id)
 
+    @log_call(logger.warning)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
-    def DeviceRemoved(self, token):
+    def DeviceRemoved(self, device_id):
         """The removal for the device was completed."""
 
-    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
-    def DeviceRemovalError(self, error):
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="sa{ss}")
+    def DeviceRemovalError(self, device_id, error):
         """Problem removing the device."""
 
     #---
 
+    def process_status(self, status_dict):
+        """Match status with signals."""
+        logger.info('process_status: new status received %r', status_dict)
+        status = status_dict[STATUS_KEY]
+        msg = status_dict[MSG_KEY]
+        if status == FILE_SYNC_DISABLED:
+            self.FileSyncStatusDisabled(msg)
+        elif status == FILE_SYNC_STARTING:
+            self.FileSyncStatusStarting(msg)
+        elif status == FILE_SYNC_DISCONNECTED:
+            self.FileSyncStatusDisconnected(msg)
+        elif status == FILE_SYNC_SYNCING:
+            self.FileSyncStatusSyncing(msg)
+        elif status == FILE_SYNC_IDLE:
+            self.FileSyncStatusIdle(msg)
+        elif status == FILE_SYNC_ERROR:
+            error_dict = {ERROR_TYPE: 'FileSyncStatusError',
+                          ERROR_MESSAGE: msg}
+            self.FileSyncStatusError(error_dict)
+        else:
+            self.FileSyncStatusError(error_handler(status_dict))
+
+    @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def file_sync_status(self):
         """Get the status of the file sync service."""
         d = self.backend.file_sync_status()
-        d.addCallback(lambda args: self.FileSyncStatusReady(*args))
+        d.addCallback(self.process_status)
         d.addErrback(transform_failure(self.FileSyncStatusError))
 
-    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="bs")
-    def FileSyncStatusReady(self, enabled, status):
-        """The new file sync status is available."""
-
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusDisabled(self, msg):
+        """The file sync status is disabled."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusStarting(self, msg):
+        """The file sync service is starting."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusDisconnected(self, msg):
+        """The file sync service is waiting for user to request connection."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusSyncing(self, msg):
+        """The file sync service is currently syncing."""
+
+    @log_call(logger.debug)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
+    def FileSyncStatusIdle(self, msg):
+        """The file sync service is idle."""
+
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def FileSyncStatusError(self, error):
         """Problem getting the file sync status."""
 
     #---
 
+    @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def volumes_info(self):
         """Find out the volumes info for the logged in user."""
@@ -185,35 +257,40 @@
         d.addCallback(self.VolumesInfoReady)
         d.addErrback(transform_failure(self.VolumesInfoError))
 
-    @utils.log_call(logger.info)
+    @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="aa{ss}")
     def VolumesInfoReady(self, info):
         """The info for the volumes is available right now."""
 
-    @utils.log_call(logger.error)
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def VolumesInfoError(self, error):
         """The info for the volumes is currently unavailable."""
 
     #---
 
+    @log_call(logger.info)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="sa{ss}")
     def change_volume_settings(self, volume_id, settings):
         """Configure a given volume."""
         d = self.backend.change_volume_settings(volume_id, settings)
         d.addCallback(self.VolumeSettingsChanged)
-        d.addErrback(transform_failure(self.VolumeSettingsChangeError))
+        d.addErrback(transform_failure(self.VolumeSettingsChangeError),
+                     volume_id)
 
+    @log_call(logger.info)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="s")
-    def VolumeSettingsChanged(self, token):
+    def VolumeSettingsChanged(self, volume_id):
         """The settings for the volume were changed."""
 
-    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
-    def VolumeSettingsChangeError(self, error):
+    @log_call(logger.error)
+    @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="sa{ss}")
+    def VolumeSettingsChangeError(self, volume_id, error):
         """Problem changing settings for the volume."""
 
     #---
 
+    @log_call(logger.debug)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def query_bookmark_extension(self):
         """Check if the extension to sync bookmarks is installed."""
@@ -221,16 +298,19 @@
         d.addCallback(self.QueryBookmarksResult)
         d.addErrback(transform_failure(self.QueryBookmarksError))
 
+    @log_call(logger.debug)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="b")
     def QueryBookmarksResult(self, enabled):
         """The bookmark extension is or is not installed."""
 
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def QueryBookmarksError(self, error):
         """Problem getting the status of the extension."""
 
     #---
 
+    @log_call(logger.info)
     @method(dbus_interface=DBUS_PREFERENCES_IFACE, in_signature="")
     def install_bookmarks_extension(self):
         """Install the extension to sync bookmarks."""
@@ -238,10 +318,12 @@
         d.addCallback(lambda _: self.InstallBookmarksSuccess())
         d.addErrback(transform_failure(self.InstallBookmarksError))
 
+    @log_call(logger.info)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="")
     def InstallBookmarksSuccess(self):
         """The extension to sync bookmarks has been installed."""
 
+    @log_call(logger.error)
     @signal(dbus_interface=DBUS_PREFERENCES_IFACE, signature="a{ss}")
     def InstallBookmarksError(self, error):
         """Problem installing the extension to sync bookmarks."""
@@ -274,8 +356,10 @@
     return dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
 
 
-def publish_backend(backend=ControlBackend()):
+def publish_backend(backend=None):
     """Publish the backend on the DBus."""
+    if backend is None:
+        backend = ControlBackend()
     return ControlPanelBackend(backend=backend,
                                object_path=DBUS_PREFERENCES_PATH,
                                bus_name=get_busname())

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2010-12-22 14:37:52 +0000
@@ -21,6 +21,7 @@
 from __future__ import division
 
 import gettext
+import operator
 
 from functools import wraps
 
@@ -46,8 +47,10 @@
 
 from ubuntuone.controlpanel import (DBUS_BUS_NAME, DBUS_PREFERENCES_PATH,
     DBUS_PREFERENCES_IFACE)
-from ubuntuone.controlpanel.logger import setup_logging
-from ubuntuone.controlpanel.utils import get_data_file, log_call
+from ubuntuone.controlpanel.backend import (DEVICE_TYPE_PHONE,
+    DEVICE_TYPE_COMPUTER, bool_str)
+from ubuntuone.controlpanel.logger import setup_logging, log_call
+from ubuntuone.controlpanel.utils import get_data_file
 
 
 logger = setup_logging('gtk.gui')
@@ -58,16 +61,22 @@
 ORANGE = '#c95724'
 LOADING = _('Loading...')
 OVERVIEW_MSGS = [
-    _('<b>Ubuntu One</b> Music Store. '
-      'A cloud enabled mobile shopping experience.\n'
-      '<small>«this is custom text #1»</small>'),
-    _('<i>Mobile</i> contacts sync. '
-      '<span foreground="red">Your portable address book.</span>\n'
-      '<small>«this is custom text #3»</small>'),
-    _('...'),
-    _('Sync data between computers.\n'
-      '<small>«this is custom text #<i>N</i>»</small>')]
+    _('Backup and access your files from <b>any</b> computer (Ubuntu &amp; '
+      'Windows), mobile device (Android) or the web.'),
+    _('A <b>portable address book</b> that unifies your most important '
+      'contact sources: mobile phones, social networks, email clients and '
+      'services.'),
+    _('A <b>personal music library</b> that can be streamed to Android, '
+       'iPhone and AirPlay-enabled devices.'),
+    _('Add to that music library with a <b>Music Store</b> that automatically '
+      'delivers to your personal cloud and connected devices.'),
+    _('Keep your <b>Firefox bookmarks</b> and <b>Tomboy notes</b> in sync '
+      'across computers (Ubuntu &amp; Windows).'),
+    _('<b>2GB</b> of free storage.'),
+]
+VALUE_ERROR = _('Value could not be retrieved.')
 WARNING_MARKUP = '<span foreground="%s"><b>%%s</b></span>' % ORANGE
+KILOBYTES = 1024
 
 
 def filter_by_app_name(f):
@@ -85,16 +94,9 @@
     return filter_by_app_name_inner
 
 
-def dbus_str_to_bool(boolstr):
-    """Transform a dbus string representation of a boolean to True/False."""
-    return False if (not boolstr or boolstr == '0') else True
-
-
 class ControlPanelMixin(object):
     """The main interface for the Ubuntu One control panel."""
 
-    VALUE_ERROR = _('Value could not be retrieved.')
-
     def __init__(self, filename=None):
         bus = dbus.SessionBus()
         try:
@@ -155,6 +157,8 @@
         self.set_title(self.TITLE % {'app_name': U1_APP_NAME})
         self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
         self.set_icon_name('ubuntuone')
+        self.set_size_request(-1, 525)  # bug #683164
+
         self.connect('delete-event', lambda w, e: gtk.main_quit())
         self.show()
 
@@ -170,25 +174,49 @@
         gtk.main()
 
 
-class ControlPanel(gtk.VBox, ControlPanelMixin):
+class ControlPanel(gtk.Notebook):
     """The control panel per se, can be added into any other widget."""
 
     # should not be any larger than 736x525
 
     def __init__(self, window_id=0):
-        gtk.VBox.__init__(self)
-        ControlPanelMixin.__init__(self, filename='controlpanel.ui')
+        gtk.Notebook.__init__(self)
         self._window_id = window_id
 
-        self.overview = OverviewPanel(window_id=window_id)
+        self.set_show_tabs(False)
+        self.set_show_border(False)
+
+        self.overview = OverviewPanel(window_id=self._window_id)
+        self.insert_page(self.overview, position=0)
+
+        self.management = ManagementPanel()
+        self.insert_page(self.management, position=1)
+
         self.overview.connect('credentials-found',
                               self.on_show_management_panel)
-        self.add(self.overview)
+        self.management.connect('local-device-removed',
+                                self.on_show_overview_panel)
+
         self.show()
-
-    def on_show_management_panel(self, *args, **kwargs):
-        """Show the netbook (main panel)."""
-        self.add(ManagementPanel())
+        self.on_show_overview_panel()
+
+        logger.debug('%s: started (window size %r).',
+                     self.__class__.__name__, self.get_size_request())
+
+    def on_show_overview_panel(self, widget=None):
+        """Show the overview panel."""
+        self.set_current_page(0)
+
+    def on_show_management_panel(self, widget=None,
+                                 credentials_are_new=False, token=None):
+        """Show the notebook (main panel)."""
+        if self.get_current_page() == 0:
+            self.management.load()
+            if credentials_are_new:
+                # redirect user to Folders page to review folders subscription
+                self.management.folders_button.clicked()
+
+            self.next_page()
 
 
 class UbuntuOneBin(gtk.VBox):
@@ -204,8 +232,26 @@
         self.title = PanelTitle(markup='<b>' + title + '</b>')
         self.pack_start(self.title, expand=False)
 
+        self.message = LabelLoading(LOADING)
+        self.pack_start(self.message, expand=False)
+
         self.show_all()
 
+    @log_call(logger.debug)
+    def on_success(self, message=''):
+        """Use this callback to stop the Loading and show 'message'."""
+        self.message.stop()
+        self.message.set_markup(message)
+
+    @log_call(logger.error)
+    def on_error(self, message=None):
+        """Use this callback to stop the Loading and set a warning message."""
+        if message == None:
+            message = VALUE_ERROR
+
+        self.message.stop()
+        self.message.set_markup(WARNING_MARKUP % message)
+
 
 class OverviewPanel(GreyableBin, ControlPanelMixin):
     """The overview panel. Introduces Ubuntu One to the not logged user."""
@@ -222,7 +268,6 @@
     BULLET = '<span foreground="%s">✔</span>' % ORANGE
 
     def __init__(self, messages=None, window_id=0):
-        gtk.link_button_set_uri_hook(lambda *a: None)
         GreyableBin.__init__(self)
         ControlPanelMixin.__init__(self, filename='overview.ui')
         self.add(self.itself)
@@ -230,6 +275,9 @@
         self.warning_label.set_property('xalign', 0.5)
         self.warning_label.connect('size-allocate', self.on_size_allocate)
 
+        self.connect_button.set_uri('')
+
+        self._credentials_are_new = False
         self._messages = messages
         self._window_id = window_id
         self._build_messages()
@@ -320,13 +368,14 @@
     @log_call(logger.info)
     def on_credentials_found(self, app_name, credentials):
         """SSO backend notifies of credentials found."""
-        self.emit('credentials-found', app_name, credentials)
-        self.hide()
+        self.set_property('greyed', False)
+        self.emit('credentials-found', self._credentials_are_new, credentials)
 
     @filter_by_app_name
     @log_call(logger.info)
     def on_credentials_not_found(self, app_name):
         """SSO backend notifies of credentials not found."""
+        self._credentials_are_new = True
         self.set_property('greyed', False)
 
     @filter_by_app_name
@@ -365,42 +414,36 @@
     """The account panel. The user can manage the subscription."""
 
     TITLE = _('Welcome to Ubuntu One!')
+    NAME = _('Name')
+    TYPE = _('Account type')
+    EMAIL = _('Email address')
 
     def __init__(self):
         UbuntuOneBin.__init__(self)
         ControlPanelMixin.__init__(self, filename='account.ui')
-        self.pack_start(self.itself)
+        self.add(self.itself)
         self.show()
 
         self.backend.connect_to_signal('AccountInfoReady',
                                        self.on_account_info_ready)
         self.backend.connect_to_signal('AccountInfoError',
                                        self.on_account_info_error)
-
-        self.name_label = LabelLoading(LOADING)
-        self.name_box.pack_start(self.name_label)
-
-        self.type_label = LabelLoading(LOADING)
-        self.type_box.pack_start(self.type_label)
-
-        self.email_label = LabelLoading(LOADING)
-        self.email_box.pack_start(self.email_label)
+        self.account.hide()
 
     @log_call(logger.debug)
     def on_account_info_ready(self, info):
         """Backend notifies of account info."""
-        for i in ('name', 'type', 'email'):
+        self.on_success()
+
+        for i in (u'name', u'type', u'email'):
             label = getattr(self, '%s_label' % i)
-            label.set_markup('<b>%s</b>' % info[i])
-            label.stop()
+            label.set_markup('%s' % (info[i]))
+        self.account.show()
 
     @log_call(logger.error)
     def on_account_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching account info."""
-        for i in ('name', 'type', 'email'):
-            label = getattr(self, '%s_label' % i)
-            label.set_markup(WARNING_MARKUP % self.VALUE_ERROR)
-            label.stop()
+        self.on_error()
 
 
 class FoldersPanel(UbuntuOneBin, ControlPanelMixin):
@@ -408,48 +451,241 @@
 
     TITLE = _('Listed below are the folders available on this machine. '
               'Subscribed means the folder will receive and send updates.')
+    NO_VOLUMES = _('No folders to show.')
 
     def __init__(self):
         UbuntuOneBin.__init__(self)
         ControlPanelMixin.__init__(self, filename='folders.ui')
-        self.pack_start(self.itself)
+        self.add(self.itself)
         self.show_all()
 
-        self.header = (gtk.Label(), gtk.Label())
-        self.header[0].set_markup('<b>' + _('Local path') + '</b>')
-        self.header[1].set_markup('<b>' + _('Subscribed') + '</b>')
-
         self.backend.connect_to_signal('VolumesInfoReady',
                                        self.on_volumes_info_ready)
         self.backend.connect_to_signal('VolumesInfoError',
                                        self.on_volumes_info_error)
-        self.backend.volumes_info()
+        self.volumes = None
+        self._subscribed = []
 
-    @log_call(logger.debug)
     def on_volumes_info_ready(self, info):
         """Backend notifies of volumes info."""
-        folders = gtk.Table(rows=len(info) + 1, columns=2)
-
-        folders.attach(self.header[0], 0, 1, 0, 1)
-        folders.attach(self.header[1], 1, 2, 0, 1, xoptions=0)
-
+
+        if self.volumes is not None:
+            self.folders.remove(self.volumes)
+            self.volumes = None
+
+        if not info:
+            self.on_success(self.NO_VOLUMES)
+            return
+        else:
+            self.on_success()
+
+        self.volumes = gtk.Table(rows=len(info) + 1, columns=2)
+
+        header = (gtk.Label(), gtk.Label())
+        header[0].set_markup('<b>' + _('Local path') + '</b>')
+        header[1].set_markup('<b>' + _('Subscribed') + '</b>')
+        self.volumes.attach(header[0], 0, 1, 0, 1)
+        self.volumes.attach(header[1], 1, 2, 0, 1, xoptions=0)
+        self.volumes.show_all()
+
+        info.sort(key=operator.itemgetter('suggested_path'))
         for i, volume in enumerate(info):
-            path = gtk.Label(volume['path'])
+            path = gtk.Label(volume['suggested_path'])
             path.set_property('xalign', 0)
-            folders.attach(path, 0, 1, i + 1, i + 2)
-
-            subscribed = gtk.CheckButton()
-            subscribed.set_active(dbus_str_to_bool(volume['subscribed']))
-            folders.attach(subscribed, 1, 2, i + 1, i + 2, xoptions=0)
-
-        alig = gtk.Alignment(xalign=0.5)
-        alig.add(folders)
-        alig.show_all()
-        self.itself.pack_start(alig, expand=False)
+            path.show()
+            self.volumes.attach(path, 0, 1, i + 1, i + 2)
+
+            subscribed = gtk.CheckButton(volume['volume_id'])
+            subscribed.set_active(bool(volume['subscribed']))
+            subscribed.show()
+            subscribed.get_child().hide()
+            subscribed.connect('clicked', self.on_subscribed_clicked)
+            self._subscribed.append(subscribed)
+            self.volumes.attach(subscribed, 1, 2, i + 1, i + 2, xoptions=0)
+
+        self.folders.add(self.volumes)
 
     @log_call(logger.error)
     def on_volumes_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching volumes info."""
+        self.on_error()
+
+    def on_subscribed_clicked(self, checkbutton):
+        """The user toggled 'checkbutton'."""
+        volume_id = checkbutton.get_label()
+        subscribed = bool_str(checkbutton.get_active())
+        self.backend.change_volume_settings(volume_id,
+                                            {'subscribed': subscribed})
+
+    def load(self):
+        """Load the volume list."""
+        self.backend.volumes_info()
+        self.message.start()
+
+
+class Device(gtk.VBox, ControlPanelMixin):
+    """The device widget."""
+
+    DEVICE_CHANGE_ERROR = _('The settings could not be changed,\n'
+                            'previous values were restored.')
+    DEVICE_REMOVAL_ERROR = _('The device could not be removed.')
+
+    def __init__(self):
+        gtk.VBox.__init__(self)
+        ControlPanelMixin.__init__(self, filename='device.ui')
+
+        self._updating = False
+        self._last_settings = {}
+        self.id = None
+        self.is_local = False
+        self.configurable = False
+
+        self.update(device_id=None, device_name='',
+                    is_local=False, configurable=False, limit_bandwidth=False,
+                    max_upload_speed=0, max_download_speed=0)
+
+        self.add(self.itself)
+        self.show()
+
+        self.backend.connect_to_signal('DeviceSettingsChanged',
+                                       self.on_device_settings_changed)
+        self.backend.connect_to_signal('DeviceSettingsChangeError',
+                                       self.on_device_settings_change_error)
+        self.backend.connect_to_signal('DeviceRemoved',
+                                       self.on_device_removed)
+        self.backend.connect_to_signal('DeviceRemovalError',
+                                       self.on_device_removal_error)
+
+    def _change_device_settings(self, *args):
+        """Update backend settings for this device."""
+        if self._updating:
+            return
+
+        # Not disabling the GUI to avoid annyong twitchings
+        #self.set_sensitive(False)
+        self.warning_label.set_text('')
+        self.backend.change_device_settings(self.id, self.__dict__)
+
+    def _block_signals(f):
+        """Execute 'f' while having the _updating flag set."""
+
+        # pylint: disable=E0213,W0212,E1102
+
+        @wraps(f)
+        def inner(self, *args, **kwargs):
+            """Execute 'f' while having the _updating flag set."""
+            old = self._updating
+            self._updating = True
+
+            result = f(self, *args, **kwargs)
+
+            self._updating = old
+            return result
+
+        return inner
+
+    on_limit_bandwidth_toggled = _change_device_settings
+    on_max_upload_speed_value_changed = _change_device_settings
+    on_max_download_speed_value_changed = _change_device_settings
+
+    def on_remove_clicked(self, widget):
+        """Remove button was clicked or activated."""
+        self.backend.remove_device(self.id)
+        self.set_sensitive(False)
+
+    @_block_signals
+    def update(self, **kwargs):
+        """Update according to named parameters.
+
+        Possible settings are:
+            * device_id (string, not shown to the user)
+            * device_name (string)
+            * type (either DEVICE_TYPE_PHONE or DEVICE_TYPE_COMPUTER)
+            * is_local (True/False)
+            * configurable (True/False)
+            * if configurable, the following can be set:
+                * limit_bandwidth (True/False)
+                * max_upload_speed (bytes)
+                * max_download_speed (bytes)
+
+        """
+        if 'device_id' in kwargs:
+            self.id = kwargs['device_id']
+
+        if 'device_name' in kwargs:
+            self.device_name.set_markup('<b>%s</b>' % kwargs['device_name'])
+
+        if 'device_type' in kwargs:
+            dtype = kwargs['device_type']
+            if dtype in (DEVICE_TYPE_COMPUTER, DEVICE_TYPE_PHONE):
+                self.device_type.set_from_icon_name(dtype.lower(),
+                                                    gtk.ICON_SIZE_BUTTON)
+
+        if 'is_local' in kwargs:
+            self.is_local = bool(kwargs['is_local'])
+
+        if 'configurable' in kwargs:
+            self.configurable = bool(kwargs['configurable'])
+            self.throttling.set_visible(self.configurable)
+
+        if 'limit_bandwidth' in kwargs:
+            self.limit_bandwidth.set_active(bool(kwargs['limit_bandwidth']))
+
+        for speed in ('max_upload_speed', 'max_download_speed'):
+            if speed in kwargs:
+                value = int(kwargs[speed]) // KILOBYTES
+                getattr(self, speed).set_value(value)
+
+        self._last_settings = self.__dict__
+
+    @property
+    def __dict__(self):
+        result = {
+            'device_id': self.id,
+            'device_name': self.device_name.get_text(),
+            'device_type': self.device_type.get_icon_name()[0].capitalize(),
+            'is_local': bool_str(self.is_local),
+            'configurable': bool_str(self.configurable),
+            'limit_bandwidth': bool_str(self.limit_bandwidth.get_active()),
+            'max_upload_speed': \
+                str(self.max_upload_speed.get_value_as_int() * KILOBYTES),
+            'max_download_speed': \
+                str(self.max_download_speed.get_value_as_int() * KILOBYTES),
+        }
+        return result
+
+    @log_call(logger.info)
+    def on_device_settings_changed(self, device_id):
+        """The change of this device settings succeded."""
+        if device_id != self.id:
+            return
+        self.set_sensitive(True)
+        self.warning_label.set_text('')
+        self._last_settings = self.__dict__
+
+    @log_call(logger.error)
+    def on_device_settings_change_error(self, device_id, error_dict=None):
+        """The change of this device settings failed."""
+        if device_id != self.id:
+            return
+        self.update(**self._last_settings)
+        self._set_warning(self.DEVICE_CHANGE_ERROR, self.warning_label)
+        self.set_sensitive(True)
+
+    @log_call(logger.warning)
+    def on_device_removed(self, device_id):
+        """The removal of this device succeded."""
+        if device_id != self.id:
+            return
+        self.hide()
+
+    @log_call(logger.error)
+    def on_device_removal_error(self, device_id, error_dict=None):
+        """The removal of this device failed."""
+        if device_id != self.id:
+            return
+        self._set_warning(self.DEVICE_REMOVAL_ERROR, self.warning_label)
+        self.set_sensitive(True)
 
 
 class DevicesPanel(UbuntuOneBin, ControlPanelMixin):
@@ -457,13 +693,62 @@
 
     TITLE = _('The devices connected with your personal cloud network are '
               'listed below:')
+    NO_DEVICES = _('No devices to show.')
 
     def __init__(self):
         UbuntuOneBin.__init__(self)
         ControlPanelMixin.__init__(self, filename='devices.ui')
-        self.pack_start(self.itself)
+        self.add(self.itself)
         self.show()
 
+        self._devices = {}
+
+        self.backend.connect_to_signal('DevicesInfoReady',
+                                       self.on_devices_info_ready)
+        self.backend.connect_to_signal('DevicesInfoError',
+                                       self.on_devices_info_error)
+        self.backend.connect_to_signal('DeviceRemoved',
+                                       self.on_device_removed)
+
+    def on_devices_info_ready(self, info):
+        """Backend notifies of devices info."""
+        for child in self.devices.get_children():
+            self.devices.remove(child)
+
+        if not info:
+            self.on_success(self.NO_DEVICES)
+        else:
+            self.on_success()
+
+        for device_info in info:
+            device = Device()
+            device_info['device_name'] = device_info.pop('name', '')
+            device_info['device_type'] = device_info.pop('type',
+                                                         DEVICE_TYPE_COMPUTER)
+            device.update(**device_info)
+            self.devices.pack_start(device)
+            self._devices[device.id] = device
+
+    @log_call(logger.error)
+    def on_devices_info_error(self, error_dict=None):
+        """Backend notifies of an error when fetching volumes info."""
+        self.on_error()
+
+    @log_call(logger.warning)
+    def on_device_removed(self, device_id):
+        """The removal of a device succeded."""
+        if device_id in self._devices:
+            child = self._devices.pop(device_id)
+            self.devices.remove(child)
+
+            if child.is_local:
+                self.emit('local-device-removed')
+
+    def load(self):
+        """Load the device list."""
+        self.backend.devices_info()
+        self.message.start()
+
 
 class ApplicationsPanel(UbuntuOneBin, ControlPanelMixin):
     """The applications panel."""
@@ -474,9 +759,12 @@
     def __init__(self):
         UbuntuOneBin.__init__(self)
         ControlPanelMixin.__init__(self, filename='applications.ui')
-        self.pack_start(self.itself)
+        self.add(self.itself)
         self.show()
 
+        self.message.stop()
+        self.message.set_text('Under construction')
+
 
 class ManagementPanel(gtk.VBox, ControlPanelMixin):
     """The management panel.
@@ -486,11 +774,21 @@
     """
 
     QUOTA_LABEL = _('%(used)s used of %(total)s (%(percentage).1f%%)')
+    FILE_SYNC_DISABLED = _('File synchronization service is not enabled.')
+    FILE_SYNC_STARTING = _('File synchronization service is starting,\n'
+                           'please wait...')
+    FILE_SYNC_DISCONNECTED = _('File synchronization service is ready,\nplease'
+                               ' connect it to access your personal cloud. ')
+    FILE_SYNC_SYNCING = _('File synchronization service is fully functional,\n'
+                          'performing synchronization now...')
+    FILE_SYNC_IDLE = _('File synchronization service is idle,\n'
+                       'all the files are synchronized.')
+    FILE_SYNC_ERROR = _('File synchronization status can not be retrieved.')
 
     def __init__(self):
         gtk.VBox.__init__(self)
         ControlPanelMixin.__init__(self, filename='management.ui')
-        self.pack_start(self.itself)
+        self.add(self.itself)
         self.show()
 
         self.backend.connect_to_signal('AccountInfoReady',
@@ -498,10 +796,25 @@
         self.backend.connect_to_signal('AccountInfoError',
                                        self.on_account_info_error)
 
+        self.backend.connect_to_signal('FileSyncStatusDisabled',
+                                       self.on_file_sync_status_disabled)
+        self.backend.connect_to_signal('FileSyncStatusStarting',
+                                       self.on_file_sync_status_starting)
+        self.backend.connect_to_signal('FileSyncStatusDisconnected',
+                                       self.on_file_sync_status_disconnected)
+        self.backend.connect_to_signal('FileSyncStatusSyncing',
+                                       self.on_file_sync_status_syncing)
+        self.backend.connect_to_signal('FileSyncStatusIdle',
+                                       self.on_file_sync_status_idle)
+        self.backend.connect_to_signal('FileSyncStatusError',
+                                       self.on_file_sync_status_error)
+
         self.header.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_BG))
+
         self.quota_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
+        self.quota_box.pack_start(self.quota_label, expand=False)
+
         self.status_label = LabelLoading(LOADING, fg_color=DEFAULT_FG)
-        self.status_box.pack_start(self.quota_label, expand=False)
         self.status_box.pack_end(self.status_label, expand=False)
 
         self.account = AccountPanel()
@@ -520,7 +833,10 @@
                                          gtk.gdk.Color(DEFAULT_FG))
             self.notebook.insert_page(getattr(self, tab), position=page_num)
 
-        self.backend.account_info()
+        self.folders_button.connect('clicked', lambda b: self.folders.load())
+        self.devices_button.connect('clicked', lambda b: self.devices.load())
+        self.devices.connect('local-device-removed',
+                             lambda widget: self.emit('local-device-removed'))
 
     def _update_quota(self, msg, data=None):
         """Update the quota info."""
@@ -532,6 +848,17 @@
             fraction = data.get('percentage', 0.0) / 100
         self.quota_progressbar.set_fraction(fraction)
 
+    def _update_status(self, msg):
+        """Update the status info."""
+        self.status_label.set_markup(msg)
+        self.status_label.stop()
+
+    def load(self):
+        """Load the account info and file sync status list."""
+        self.backend.account_info()
+        self.backend.file_sync_status()
+        self.account_button.clicked()
+
     @log_call(logger.debug)
     def on_account_info_ready(self, info):
         """Backend notifies of account info."""
@@ -544,9 +871,42 @@
     @log_call(logger.error)
     def on_account_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching account info."""
-        self._update_quota(WARNING_MARKUP % self.VALUE_ERROR)
+        self._update_quota(WARNING_MARKUP % VALUE_ERROR)
+
+    @log_call(logger.info)
+    def on_file_sync_status_disabled(self, msg):
+        """Backend notifies of file sync status being disabled."""
+        self._update_status(self.FILE_SYNC_DISABLED)
+
+    @log_call(logger.info)
+    def on_file_sync_status_starting(self, msg):
+        """Backend notifies of file sync status being starting."""
+        self._update_status(self.FILE_SYNC_STARTING)
+
+    @log_call(logger.info)
+    def on_file_sync_status_disconnected(self, msg):
+        """Backend notifies of file sync status being ready."""
+        self._update_status(self.FILE_SYNC_DISCONNECTED)
+
+    @log_call(logger.info)
+    def on_file_sync_status_syncing(self, msg):
+        """Backend notifies of file sync status being syncing."""
+        self._update_status(self.FILE_SYNC_SYNCING)
+
+    @log_call(logger.info)
+    def on_file_sync_status_idle(self, msg):
+        """Backend notifies of file sync status being idle."""
+        self._update_status(self.FILE_SYNC_IDLE)
+
+    @log_call(logger.error)
+    def on_file_sync_status_error(self, error_dict=None):
+        """Backend notifies of an error when fetching file sync status."""
+        self._update_status(WARNING_MARKUP % self.FILE_SYNC_ERROR)
 
 
 gobject.signal_new('credentials-found', OverviewPanel,
                     gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-                   (gobject.TYPE_STRING, gobject.TYPE_PYOBJECT))
+                   (gobject.TYPE_BOOLEAN, gobject.TYPE_PYOBJECT))
+
+gobject.signal_new('local-device-removed', DevicesPanel,
+                    gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2010-12-22 14:37:52 +0000
@@ -40,9 +40,28 @@
     'email': 'test.com', 'quota_total': '12345', 'quota_used': '9999'}
 
 FAKE_VOLUMES_INFO = [
-    {'volume_id': '0', 'path': '~/foo', 'subscribed': '0'},
-    {'volume_id': '1', 'path': '~/bar', 'subscribed': '1'},
-    {'volume_id': '2', 'path': '~/baz', 'subscribed': '1'},
+    {'volume_id': '0', 'suggested_path': '~/foo', 'subscribed': ''},
+    {'volume_id': '1', 'suggested_path': '~/bar', 'subscribed': 'True'},
+    {'volume_id': '2', 'suggested_path': '~/baz', 'subscribed': 'True'},
+]
+
+FAKE_DEVICE_INFO = {
+    'device_id': '1258-6854', 'device_name': 'Baz', 'device_type': 'Computer',
+    'is_local': 'True', 'configurable': 'True', 'limit_bandwidth': 'True',
+    'max_upload_speed': '1000', 'max_download_speed': '72548',
+}
+
+FAKE_DEVICES_INFO = [
+    {'device_id': '0', 'name': 'Foo', 'type': 'Computer',
+     'is_local': '', 'configurable': ''},
+    {'device_id': '1', 'name': 'Bar', 'type': 'Phone',
+     'is_local': '', 'configurable': ''},
+    {'device_id': '2', 'name': 'Z', 'type': 'Computer',
+     'is_local': '', 'configurable': 'True', 'limit_bandwidth': '',
+     'max_upload_speed': '0', 'max_download_speed': '0'},
+    {'device_id': '1258-6854', 'name': 'Baz', 'type': 'Computer',
+     'is_local': 'True', 'configurable': 'True', 'limit_bandwidth': 'True',
+     'max_upload_speed': '1000', 'max_download_speed': '72548'},  # local
 ]
 
 
@@ -108,8 +127,11 @@
     bus_name = gui.DBUS_BUS_NAME
     object_path = gui.DBUS_PREFERENCES_PATH
     iface = gui.DBUS_PREFERENCES_IFACE
-    exposed_methods = ['account_info', 'devices_info', 'volumes_info',
-                       'file_sync_status']
+    exposed_methods = [
+        'account_info', 'devices_info', 'change_device_settings',
+        'volumes_info', 'change_volume_settings', 'file_sync_status',
+        'remove_device',
+    ]
 
 
 class FakedSessionBus(object):
@@ -193,7 +215,6 @@
     def assert_warning_correct(self, warning, text):
         """Check that 'warning' is visible, showing 'text'."""
         self.assertTrue(warning.get_visible(), 'Must be visible.')
-        self.assertEqual(warning.get_text(), text)
         self.assertEqual(warning.get_label(), gui.WARNING_MARKUP % text)
 
     def assert_function_decorated(self, decorator, func):
@@ -268,29 +289,39 @@
         self.assertEqual(self.ui.get_icon_name(), 'ubuntuone')
 
     def test_max_size(self):
-        """Max size is not bigger than 966x576 (LP: #645526)."""
-        self.assertTrue(self.ui.get_size_request() <= (966, 576))
-
-
-class ControlPanelTestCase(ControlPanelMixinTestCase):
+        """Max size is not bigger than 736x525 (LP: #645526, LP: #683164)."""
+        self.assertTrue(self.ui.get_size_request() <= (736, 525))
+
+
+class ControlPanelTestCase(BaseTestCase):
     """The test suite for the control panel itself."""
 
     klass = gui.ControlPanel
     kwargs = {'window_id': 7}
-    ui_filename = 'controlpanel.ui'
-
-    def test_is_a_vbox(self):
+
+    def assert_current_tab_correct(self, expected_tab):
+        """Check that the wiget 'expected_tab' is the current page."""
+        actual = self.ui.get_nth_page(self.ui.get_current_page())
+        self.assertTrue(expected_tab is actual)
+
+    def test_is_a_notebook(self):
         """Inherits from gtk.VBox."""
-        self.assertIsInstance(self.ui, gui.gtk.VBox)
+        self.assertIsInstance(self.ui, gui.gtk.Notebook)
 
     def test_startup_visibility(self):
         """The widget is visible at startup."""
-        self.assertTrue(self.ui.itself.get_visible(),
+        self.assertTrue(self.ui.get_visible(),
                         'must be visible at startup.')
 
+    def test_startup_props(self):
+        """The tabs and border are not shown."""
+        self.assertFalse(self.ui.get_show_border(), 'must not show border.')
+        self.assertFalse(self.ui.get_show_tabs(), 'must not show tabs.')
+
     def test_overview_is_shown_at_startup(self):
         """The overview is shown at startup."""
         self.assertIsInstance(self.ui.overview, gui.OverviewPanel)
+        self.assert_current_tab_correct(self.ui.overview)
 
     def test_window_id_is_passed_to_child(self):
         """The child gets the window_id."""
@@ -299,8 +330,48 @@
     def test_on_show_management_panel(self):
         """A ManagementPanel is shown when the callback is executed."""
         self.ui.on_show_management_panel()
-        children = self.ui.get_children()
-        self.assertIsInstance(children[-1], gui.ManagementPanel)
+        self.assert_current_tab_correct(self.ui.management)
+
+    def test_on_show_management_panel_is_idempotent(self):
+        """Only one ManagementPanel is shown."""
+        self.ui.on_show_management_panel()
+        self.ui.on_show_management_panel()
+
+        self.assert_current_tab_correct(self.ui.management)
+
+    def test_credentials_found_shows_account_management_panel(self):
+        """On 'credentials-found' signal, the management panel is shown.
+
+        If first signal parameter is False, visible tab should be account.
+
+        """
+        self.patch(self.ui.management, 'load', self._set_called)
+        self.ui.overview.emit('credentials-found', False, object())
+
+        self.assert_current_tab_correct(self.ui.management)
+        self.assertEqual(self.ui.management.notebook.get_current_page(),
+                         self.ui.management.ACCOUNT_PAGE)
+        self.assertEqual(self._called, ((), {}))
+
+    def test_credentials_found_shows_folders_management_panel(self):
+        """On 'credentials-found' signal, the management panel is shown.
+
+        If first signal parameter is True, visible tab should be folders.
+
+        """
+        a_token = object()
+        self.ui.overview.emit('credentials-found', True, a_token)
+
+        self.assert_current_tab_correct(self.ui.management)
+        self.assertEqual(self.ui.management.notebook.get_current_page(),
+                         self.ui.management.FOLDERS_PAGE)
+
+    def test_local_device_removed_shows_overview_panel(self):
+        """On 'local-device-removed' signal, the overview panel is shown."""
+        self.ui.overview.emit('credentials-found', True, object())
+        self.ui.management.emit('local-device-removed')
+
+        self.assert_current_tab_correct(self.ui.overview)
 
 
 class UbuntuOneBinTestCase(BaseTestCase):
@@ -334,6 +405,37 @@
         ui = self.klass()  # no title given
         self.assertEqual(ui.title.label.get_text(), '')
 
+    def test_message_is_a_label_loading(self):
+        """Message is the correct widget."""
+        self.assertIsInstance(self.ui.message, gui.LabelLoading)
+        self.assertIn(self.ui.message, self.ui.get_children())
+
+    def test_on_success(self):
+        """Callback to stop the Loading and clear messages."""
+        self.ui.on_success()
+        self.assertEqual(self.ui.message.get_label(), '')
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_success_with_message(self):
+        """Callback to stop the Loading and show a info message."""
+        msg = 'WOW! <i>this rocks</i>'
+        self.ui.on_success(message=msg)
+        self.assertEqual(self.ui.message.get_label(), msg)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error(self):
+        """Callback to stop the Loading and clear messages."""
+        self.ui.on_error()
+        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error_with_message(self):
+        """Callback to stop the Loading and show a info message."""
+        msg = 'WOW! <i>this does not rock</i> :-/'
+        self.ui.on_error(message=msg)
+        self.assert_warning_correct(self.ui.message, msg)
+        self.assertFalse(self.ui.message.active)
+
 
 class OverwiewPanelTestCase(ControlPanelMixinTestCase):
     """The test suite for the overview panel."""
@@ -418,6 +520,7 @@
 
     def test_find_credentials_is_called(self):
         """Credentials are asked to SSO backend."""
+        self.assertFalse(self.ui._credentials_are_new)
         self.assert_backend_called('find_credentials', (gui.U1_APP_NAME, {}),
                                    backend=self.ui.sso_backend)
 
@@ -427,13 +530,28 @@
 
         self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
 
-        self.assertFalse(self.ui.get_visible())
-        self.assertEqual(self._called, ((self.ui, gui.U1_APP_NAME, TOKEN), {}))
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+        # assume credentials were in local keyring
+        self.assertEqual(self._called, ((self.ui, False, TOKEN), {}))
+
+    def test_on_credentials_found_when_creds_are_not_new(self):
+        """Callback 'on_credentials_found' distinguish if creds are new."""
+        self.ui.connect('credentials-found', self._set_called)
+
+        # credentials weren't in the system
+        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        # now they are!
+        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
+
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+        # assume credentials were not in local keyring
+        self.assertEqual(self._called, ((self.ui, True, TOKEN), {}))
 
     def test_on_credentials_not_found(self):
         """Callback 'on_credentials_not_found' is correct."""
         self.ui.on_credentials_not_found(gui.U1_APP_NAME)
         self.assertTrue(self.ui.get_visible())
+        self.assertTrue(self.ui._credentials_are_new)
 
     def test_on_credentials_error(self):
         """Callback 'on_credentials_error' is correct."""
@@ -626,11 +744,11 @@
 
     def assert_account_info_correct(self, info):
         """Check that the displayed account info matches 'info'."""
-        self.assertEqual(self.ui.name_label.get_text(),
+        self.assertEqual(self.ui.name_label.get_label(),
                          FAKE_ACCOUNT_INFO['name'])
-        self.assertEqual(self.ui.type_label.get_text(),
+        self.assertEqual(self.ui.type_label.get_label(),
                          FAKE_ACCOUNT_INFO['type'])
-        self.assertEqual(self.ui.email_label.get_text(),
+        self.assertEqual(self.ui.email_label.get_label(),
                          FAKE_ACCOUNT_INFO['email'])
 
     def test_is_an_ubuntuone_bin(self):
@@ -645,15 +763,9 @@
         """Is visible."""
         self.assertTrue(self.ui.get_visible())
 
-    def test_type_label_is_loading(self):
-        """Placeholder for type label is a Loading widget."""
-        self.assertIsInstance(self.ui.type_label, gui.LabelLoading)
-        self.assertIn(self.ui.type_label, self.ui.type_box.get_children())
-
-    def test_email_label_is_loading(self):
-        """Placeholder for email label is a Loading widget."""
-        self.assertIsInstance(self.ui.email_label, gui.LabelLoading)
-        self.assertIn(self.ui.email_label, self.ui.email_box.get_children())
+    def test_account_info_is_not_visible(self):
+        """Account info is not visible."""
+        self.assertFalse(self.ui.account.get_visible())
 
     def test_backend_signals(self):
         """The proper signals are connected to the backend."""
@@ -666,18 +778,16 @@
         """The account info is processed when ready."""
         self.ui.on_account_info_ready(FAKE_ACCOUNT_INFO)
         self.assert_account_info_correct(FAKE_ACCOUNT_INFO)
-
-        for widget in (self.ui.name_label, self.ui.type_label,
-                       self.ui.email_label):
-            self.assertFalse(widget.active)
+        self.assertTrue(self.ui.account.get_visible())
+        self.assertFalse(self.ui.message.active)
+        self.assertEqual(self.ui.message.get_label(), '')
 
     def test_on_account_info_error(self):
         """The account info couldn't be retrieved."""
         self.ui.on_account_info_error()
-        for widget in (self.ui.name_label, self.ui.type_label,
-                       self.ui.email_label):
-            self.assert_warning_correct(widget, self.ui.VALUE_ERROR)
-            self.assertFalse(widget.active)
+        self.assertFalse(self.ui.account.get_visible())
+        self.assertFalse(self.ui.message.active)
+        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
 
 
 class FoldersTestCase(ControlPanelMixinTestCase):
@@ -686,6 +796,10 @@
     klass = gui.FoldersPanel
     ui_filename = 'folders.ui'
 
+    def setUp(self):
+        super(FoldersTestCase, self).setUp()
+        self.ui.load()
+
     def test_is_an_ubuntuone_bin(self):
         """Inherits from UbuntuOneBin."""
         self.assertIsInstance(self.ui, gui.UbuntuOneBin)
@@ -705,34 +819,393 @@
         self.assertEqual(self.ui.backend._signals['VolumesInfoError'],
                          [self.ui.on_volumes_info_error])
 
-    def test_volumes_info_is_requested(self):
+    def test_volumes_info_is_requested_on_load(self):
         """The volumes info is requested to the backend."""
+        # clean backend calls
+        self.ui.backend._called.pop('volumes_info', None)
+        self.ui.load()
+
         self.assert_backend_called('volumes_info', ())
 
-    def _test_on_volumes_info_ready(self):
+    def test_message_after_load(self):
+        """The volumes label is active when contents are load."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+        self.ui.load()
+
+        self.assertTrue(self.ui.message.active)
+
+    def test_message_after_non_empty_volumes_info_ready(self):
+        """The volumes label is a LabelLoading."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        self.assertFalse(self.ui.message.active)
+
+    def test_message_after_empty_volumes_info_ready(self):
+        """When there are no volumes, a notification is shown."""
+        self.ui.on_volumes_info_ready([])
+
+        self.assertFalse(self.ui.message.active)
+        self.assertEqual(self.ui.message.get_text(), self.ui.NO_VOLUMES)
+
+    def test_on_volumes_info_ready(self):
         """The volumes info is processed when ready."""
         self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
 
-        volumes = self.ui.itself.get_children()
+        self.assertEqual(self.ui.folders.get_children(), [self.ui.volumes])
+
+        volumes = self.ui.volumes.get_children()
+        volumes.reverse()
+
+        header = volumes[:2]  # grab header
+        self.assertEqual(header[0].get_text(), 'Local path')
+        self.assertEqual(header[1].get_text(), 'Subscribed')
+
+        volumes = volumes[2:]  # drop header
+        labels = filter(lambda w: isinstance(w, gui.gtk.Label), volumes)
+        checks = filter(lambda w: isinstance(w, gui.gtk.CheckButton), volumes)
+
+        self.assertEqual(len(checks), len(FAKE_VOLUMES_INFO))
+
+        for label, check, volume in zip(labels, checks, FAKE_VOLUMES_INFO):
+            self.assertEqual(volume['suggested_path'], label.get_text())
+            self.assertEqual(bool(volume['subscribed']), check.get_active())
+            self.assertEqual(volume['volume_id'], check.get_label())
+            self.assertFalse(check.get_child().get_visible())
+
+    def test_on_volumes_info_ready_clears_the_list(self):
+        """The old volumes info is cleared before updated."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        self.assertEqual(len(self.ui.folders.get_children()), 1)
+        child = self.ui.folders.get_children()[0]
+        self.assertEqual(child, self.ui.volumes)
+
+        volumes = filter(lambda w: isinstance(w, gui.gtk.CheckButton),
+                         self.ui.volumes.get_children())
         self.assertEqual(len(volumes), len(FAKE_VOLUMES_INFO))
 
-        for i, volume in enumerate(FAKE_VOLUMES_INFO):
-            vol_widget = volumes[i]
-            self.assertEqual(vol_widget.id, volume['volume_id'])
-            self.assertEqual(vol_widget.path.get_text(), volume['path'])
-            subscribed = gui.dbus_str_to_bool(volume['subscribed'])
-            self.assertEqual(vol_widget.subscribed.get_active(), subscribed)
+    def test_on_volumes_info_ready_with_no_volumes(self):
+        """When there are no volumes, a notification is shown."""
+        self.ui.on_volumes_info_ready([])
+        # no volumes table
+        self.assertEqual(len(self.ui.folders.get_children()), 0)
+        self.assertTrue(self.ui.volumes is None)
+
+    def test_on_subscribed_clicked(self):
+        """Clicking on 'subscribed' updates the folder subscription."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        method = 'change_volume_settings'
+        for checkbutton in self.ui._subscribed:
+            checkbutton.clicked()
+            fid = checkbutton.get_label()
+
+            subscribed = gui.bool_str(checkbutton.get_active())
+            self.assert_backend_called(method,
+                                       (fid, {'subscribed': subscribed}))
+            # clean backend calls
+            self.ui.backend._called.pop(method)
+
+            checkbutton.clicked()
+            subscribed = gui.bool_str(checkbutton.get_active())
+            self.assert_backend_called('change_volume_settings',
+                                       (fid, {'subscribed': subscribed}))
 
     def test_on_volumes_info_error(self):
         """The volumes info couldn't be retrieved."""
         self.ui.on_volumes_info_error()
-
-    def _test_on_volumes_info_ready_clears_the_list(self):
-        """The old volumes info is cleared before updated."""
-        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
-        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
-        volumes = self.ui.itself.get_children()
-        self.assertEqual(len(volumes), len(FAKE_VOLUMES_INFO))
+        self.assert_warning_correct(warning=self.ui.message,
+                                    text=gui.VALUE_ERROR)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_volumes_info_error_after_success(self):
+        """The volumes info couldn't be retrieved after a prior success."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        self.ui.on_volumes_info_error()
+
+        self.test_on_volumes_info_error()
+        self.test_on_volumes_info_ready_with_no_volumes()
+
+
+class DeviceTestCase(ControlPanelMixinTestCase):
+    """The test suite for the device widget."""
+
+    klass = gui.Device
+    ui_filename = 'device.ui'
+
+    def assert_device_equal(self, device, expected):
+        """Assert that the device has the values from expected."""
+        self.assertEqual(device.id,
+                         expected['device_id'])
+        self.assertEqual(device.device_name.get_text(),
+                         expected['device_name'])
+        self.assertEqual(device.device_type.get_icon_name()[0],
+                         expected['device_type'].lower())
+        self.assertEqual(device.is_local,
+                         bool(expected['is_local']))
+        self.assertEqual(device.configurable,
+                         bool(expected['configurable']))
+        self.assertEqual(device.limit_bandwidth.get_active(),
+                         bool(expected['limit_bandwidth']))
+
+        value = int(expected['max_upload_speed']) // gui.KILOBYTES
+        self.assertEqual(device.max_upload_speed.get_value_as_int(), value)
+        value = int(expected['max_download_speed']) // gui.KILOBYTES
+        self.assertEqual(device.max_download_speed.get_value_as_int(), value)
+
+    def assert_device_settings_changed(self):
+        """Changing throttling settings updates the backend properly."""
+        expected = self.ui.__dict__
+        self.assert_backend_called('change_device_settings',
+                                   (self.ui.id, expected))
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def modify_settings(self):
+        """Modify settings so values actually change."""
+        new_val = not self.ui.limit_bandwidth.get_active()
+        self.ui.limit_bandwidth.set_active(new_val)
+
+        new_val = self.ui.max_upload_speed.get_value_as_int() + 1
+        self.ui.max_upload_speed.set_value(new_val)
+
+        new_val = self.ui.max_download_speed.get_value_as_int() + 1
+        self.ui.max_download_speed.set_value(new_val)
+
+    def test_is_a_vbox(self):
+        """Inherits from VBox."""
+        self.assertIsInstance(self.ui, gui.gtk.VBox)
+
+    def test_inner_widget_is_packed(self):
+        """The 'itself' vbox is packed into the widget."""
+        self.assertIn(self.ui.itself, self.ui.get_children())
+
+    def test_is_visible(self):
+        """Is visible."""
+        self.assertTrue(self.ui.get_visible())
+
+    def test_is_sensitive(self):
+        """Is sensitive."""
+        self.assertTrue(self.ui.get_sensitive())
+
+    def test_warning_label_is_cleared(self):
+        """The warning label is cleared."""
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_default_values(self):
+        """Default values are correct."""
+        self.assertEqual(self.ui.id, None)
+        self.assertEqual(self.ui.device_name.get_text(), '')
+        self.assertEqual(self.ui.device_type.get_icon_name()[0],
+                         gui.DEVICE_TYPE_COMPUTER.lower())
+        self.assertEqual(self.ui.is_local, False)
+        self.assertEqual(self.ui.configurable, False)
+        self.assertEqual(self.ui.limit_bandwidth.get_active(), False)
+        self.assertEqual(self.ui.max_upload_speed.get_value_as_int(), 0)
+        self.assertEqual(self.ui.max_download_speed.get_value_as_int(), 0)
+
+    def test_init_does_not_call_backend(self):
+        """When updating, the backend is not called."""
+        self.assertEqual(self.ui.backend._called, {})
+
+    def test_update_device_name(self):
+        """A device can be updated from a dict."""
+        value = 'The death star'
+        self.ui.update(device_name=value)
+        self.assertEqual(value, self.ui.device_name.get_text())
+
+    def test_update_unicode_device_name(self):
+        """A device can be updated from a dict."""
+        value = u'Ñoño Ñandú'
+        self.ui.update(device_name=value)
+        self.assertEqual(value, self.ui.device_name.get_text())
+
+    def test_update_device_type_computer(self):
+        """A device can be updated from a dict."""
+        dtype = gui.DEVICE_TYPE_COMPUTER
+        self.ui.update(device_type=dtype)
+        self.assertEqual((dtype.lower(), gui.gtk.ICON_SIZE_BUTTON),
+                         self.ui.device_type.get_icon_name())
+
+    def test_update_device_type_phone(self):
+        """A device can be updated from a dict."""
+        dtype = gui.DEVICE_TYPE_PHONE
+        self.ui.update(device_type=dtype)
+        self.assertEqual((dtype.lower(), gui.gtk.ICON_SIZE_BUTTON),
+                         self.ui.device_type.get_icon_name())
+
+    def test_update_is_not_local(self):
+        """A device can be updated from a dict."""
+        self.ui.update(is_local='')
+        self.assertFalse(self.ui.is_local)
+
+    def test_update_is_local(self):
+        """A device can be updated from a dict."""
+        self.ui.update(is_local='True')
+        self.assertTrue(self.ui.is_local)
+
+    def test_update_non_configurable(self):
+        """A device can be updated from a dict."""
+        self.ui.update(configurable='')
+        self.assertFalse(self.ui.configurable)
+        self.assertFalse(self.ui.throttling.get_visible())
+
+    def test_update_configurable(self):
+        """A device can be updated from a dict."""
+        self.ui.update(configurable='True')
+        self.assertTrue(self.ui.configurable)
+        self.assertTrue(self.ui.throttling.get_visible())
+
+    def test_update_limit_bandwidth(self):
+        """A device can be updated from a dict."""
+        self.ui.update(limit_bandwidth='')
+        self.assertFalse(self.ui.limit_bandwidth.get_active())
+
+        self.ui.update(limit_bandwidth='True')
+        self.assertTrue(self.ui.limit_bandwidth.get_active())
+
+    def test_update_upload_speed(self):
+        """A device can be updated from a dict."""
+        value = '12345'
+        self.ui.update(max_upload_speed=value)
+        self.assertEqual(int(value) // gui.KILOBYTES,
+                         self.ui.max_upload_speed.get_value_as_int())
+
+    def test_update_download_speed(self):
+        """A device can be updated from a dict."""
+        value = '987654'
+        self.ui.update(max_download_speed=value)
+        self.assertEqual(int(value) // gui.KILOBYTES,
+                         self.ui.max_download_speed.get_value_as_int())
+
+    def test_update_does_not_call_backend(self):
+        """When updating, the backend is not called."""
+        self.ui.update(**FAKE_DEVICE_INFO)
+        self.assertEqual(self.ui.backend._called, {})
+        self.assert_device_equal(self.ui, FAKE_DEVICE_INFO)
+
+    def test_on_limit_bandwidth_toggled(self):
+        """When toggling limit_bandwidth, backend is updated."""
+        self.ui.limit_bandwidth.toggled()
+        self.assert_device_settings_changed()
+
+    def test_on_max_upload_speed_value_changed(self):
+        """When setting max_upload_speed, backend is updated."""
+        self.ui.max_upload_speed.set_value(25)
+        self.assert_device_settings_changed()
+
+    def test_on_max_download_speed_value_changed(self):
+        """When setting max_download_speed, backend is updated."""
+        self.ui.max_download_speed.set_value(52)
+        self.assert_device_settings_changed()
+
+    def test_backend_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.backend._signals['DeviceSettingsChanged'],
+                         [self.ui.on_device_settings_changed])
+        self.assertEqual(self.ui.backend._signals['DeviceSettingsChangeError'],
+                         [self.ui.on_device_settings_change_error])
+        self.assertEqual(self.ui.backend._signals['DeviceRemoved'],
+                         [self.ui.on_device_removed])
+        self.assertEqual(self.ui.backend._signals['DeviceRemovalError'],
+                         [self.ui.on_device_removal_error])
+
+    def test_on_device_settings_changed(self):
+        """When settings were changed for this device, enable it."""
+        self.modify_settings()
+        self.ui.on_device_settings_changed(device_id=self.ui.id)
+
+        self.assertTrue(self.ui.get_sensitive())
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+        self.assertEqual(self.ui.__dict__, self.ui._last_settings)
+
+    def test_on_device_settings_change_after_error(self):
+        """Change success after error."""
+        self.modify_settings()
+        self.ui.on_device_settings_change_error(device_id=self.ui.id)  # error
+
+        self.test_on_device_settings_changed()
+
+    def test_on_device_settings_changed_different_id(self):
+        """When settings were changed for other device, nothing changes."""
+        self.modify_settings()
+        self.ui.on_device_settings_changed(device_id='yadda')
+
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_on_device_settings_change_error(self):
+        """When settings were not changed for this device, notify the user.
+
+        Also, confirm that old values were restored.
+
+        """
+        self.ui.update(**FAKE_DEVICE_INFO)  # use known values
+
+        self.modify_settings()
+
+        self.ui.on_device_settings_change_error(device_id=self.ui.id)  # error
+
+        self.assertTrue(self.ui.get_sensitive())
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.DEVICE_CHANGE_ERROR)
+        self.assert_device_equal(self.ui, FAKE_DEVICE_INFO)  # restored info
+
+    def test_on_device_settings_change_error_after_success(self):
+        """Change error after success."""
+        self.modify_settings()
+        self.ui.on_device_settings_changed(device_id=self.ui.id)
+
+        self.test_on_device_settings_change_error()
+
+    def test_on_device_settings_change_error_different_id(self):
+        """When settings were not changed for other device, do nothing."""
+        self.modify_settings()
+        self.ui.on_device_settings_change_error(device_id='yudo')
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_remove(self):
+        """Clicking on remove calls the backend properly."""
+        self.ui.is_local = False
+        self.ui.remove.clicked()
+
+        self.assert_backend_called('remove_device', (self.ui.id,))
+        self.assertFalse(self.ui.get_sensitive(),
+                         'Must be disabled while removing.')
+
+    def test_on_device_removed(self):
+        """On this device removed, hide and destroy."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removed(device_id=self.ui.id)
+
+        self.assertFalse(self.ui.get_visible(),
+                         'Must not be visible after removed.')
+
+    def test_on_device_removed_other_id(self):
+        """On other device removed, do nothing."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removed(device_id='foo')
+
+        self.assertTrue(self.ui.get_visible(),
+                        'Must be visible after other device was removed.')
+
+    def test_on_device_removal_error(self):
+        """On this device removal error, re-enable and show error."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removal_error(device_id=self.ui.id)
+
+        self.assertTrue(self.ui.get_sensitive(),
+                        'Must be enabled after removal error.')
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.DEVICE_REMOVAL_ERROR)
+
+    def test_on_device_removal_error_other_id(self):
+        """On other device removal error, do nothing."""
+        self.ui.remove.clicked()
+        self.ui.on_device_removal_error(device_id='foo')
+
+        self.assertFalse(self.ui.get_sensitive(),
+                         'Must be disabled after other device removal error.')
 
 
 class DevicesTestCase(ControlPanelMixinTestCase):
@@ -753,6 +1226,144 @@
         """Is visible."""
         self.assertTrue(self.ui.get_visible())
 
+    def test_backend_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.backend._signals['DevicesInfoReady'],
+                         [self.ui.on_devices_info_ready])
+        self.assertEqual(self.ui.backend._signals['DevicesInfoError'],
+                         [self.ui.on_devices_info_error])
+        self.assertEqual(self.ui.backend._signals['DeviceRemoved'],
+                         [self.ui.on_device_removed])
+
+    def test_devices_info_is_requested_on_load(self):
+        """The devices info is requested to the backend."""
+        # clean backend calls
+        self.ui.backend._called.pop('devices_info', None)
+        self.ui.load()
+
+        self.assert_backend_called('devices_info', ())
+
+    def test_message_after_load(self):
+        """The devices label is active when contents are load."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        self.ui.load()
+
+        self.assertTrue(self.ui.message.active)
+
+    def test_message_after_non_empty_devices_info_ready(self):
+        """The devices label is a LabelLoading."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+
+        self.assertFalse(self.ui.message.active)
+
+    def test_message_after_empty_devices_info_ready(self):
+        """When there are no devices, a notification is shown."""
+        self.ui.on_devices_info_ready([])
+
+        self.assertFalse(self.ui.message.active)
+        self.assertEqual(self.ui.message.get_text(), self.ui.NO_DEVICES)
+
+    def test_on_devices_info_ready(self):
+        """The devices info is processed when ready."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+
+        children = self.ui.devices.get_children()
+        self.assertEqual(len(children), len(FAKE_DEVICES_INFO))
+
+        for child, device in zip(children, FAKE_DEVICES_INFO):
+            self.assertIsInstance(child, gui.Device)
+
+            self.assertEqual(device['device_id'], child.id)
+            self.assertEqual(device['device_name'],
+                             child.device_name.get_text())
+            self.assertEqual(device['device_type'].lower(),
+                             child.device_type.get_icon_name()[0])
+            self.assertEqual(bool(device['is_local']),
+                             child.is_local)
+            self.assertEqual(bool(device['configurable']),
+                             child.configurable)
+
+            if bool(device['configurable']):
+                self.assertEqual(bool(device['limit_bandwidth']),
+                                 child.limit_bandwidth.get_active())
+                value = int(device['max_upload_speed']) // gui.KILOBYTES
+                self.assertEqual(value,
+                                 child.max_upload_speed.get_value_as_int())
+                value = int(device['max_download_speed']) // gui.KILOBYTES
+                self.assertEqual(value,
+                                 child.max_download_speed.get_value_as_int())
+
+    def test_on_devices_info_ready_have_devices_cached(self):
+        """The devices are cached for further removal."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+
+        for child in self.ui.devices.get_children():
+            self.assertTrue(self.ui._devices[child.id] is child)
+
+    def test_on_devices_info_ready_clears_the_list(self):
+        """The old devices info is cleared before updated."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+
+        devices = self.ui.devices.get_children()
+        self.assertEqual(len(devices), len(FAKE_DEVICES_INFO))
+
+    def test_on_devices_info_ready_with_no_devices(self):
+        """When there are no devices, a notification is shown."""
+        self.ui.on_devices_info_ready([])
+        self.assertEqual(len(self.ui.devices.get_children()), 0)
+
+    def test_on_devices_info_error(self):
+        """The devices info couldn't be retrieved."""
+        self.ui.on_devices_info_error()
+
+        self.assert_warning_correct(warning=self.ui.message,
+                                    text=gui.VALUE_ERROR)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_devices_info_error_after_success(self):
+        """The devices info couldn't be retrieved after a prior success."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+
+        self.ui.on_devices_info_error()
+
+        self.test_on_devices_info_error()
+        self.test_on_devices_info_ready_with_no_devices()
+
+    def test_on_device_removed(self):
+        """When a child device was removed, remove and destroy."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        did = FAKE_DEVICES_INFO[0]['device_id']
+        device = self.ui._devices[did]
+        self.ui.on_device_removed(device_id=did)
+
+        self.assertTrue(device not in self.ui.devices.get_children())
+        self.assertTrue(did not in self.ui._devices)
+
+    def test_on_local_device_removed(self):
+        """Removing the local device emits local-device-removed."""
+        self.ui.connect('local-device-removed', self._set_called)
+
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        local_device = FAKE_DEVICES_INFO[-1]
+        assert bool(local_device['is_local'])
+        local_device_id = local_device['device_id']
+        assert self.ui._devices[local_device_id].is_local
+
+        self.ui.on_device_removed(device_id=local_device_id)
+
+        self.assertEqual(self._called, ((self.ui,), {}))
+
+    def test_on_device_removed_for_no_child_device(self):
+        """On other device removed, do nothing."""
+        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
+        old_devices = self.ui.devices.get_children()
+
+        self.ui.on_device_removed(device_id='foo')
+
+        new_devices = self.ui.devices.get_children()
+        self.assertEqual(new_devices, old_devices)
+
 
 class ApplicationsTestCase(ControlPanelMixinTestCase):
     """The test suite for the applications panel."""
@@ -842,15 +1453,16 @@
 class ManagementPanelAccountTestCase(ManagementPanelTestCase):
     """The test suite for the management panel (account tab)."""
 
-    def test_backend_signals(self):
+    def test_backend_account_signals(self):
         """The proper signals are connected to the backend."""
         self.assertEqual(self.ui.backend._signals['AccountInfoReady'],
                          [self.ui.on_account_info_ready])
         self.assertEqual(self.ui.backend._signals['AccountInfoError'],
                          [self.ui.on_account_info_error])
 
-    def test_account_info_is_requested(self):
+    def test_account_info_is_requested_on_load(self):
         """The account info is requested to the backend."""
+        self.ui.load()
         self.assert_backend_called('account_info', ())
 
     def test_account_panel_is_packed(self):
@@ -877,12 +1489,31 @@
         actual = self.ui.notebook.get_nth_page(self.ui.APPLICATIONS_PAGE)
         self.assertTrue(self.ui.applications is actual)
 
-    def test_placeholders_are_loading(self):
-        """Placeholders for labels are a Loading widget."""
-        widgets = (self.ui.quota_label, self.ui.status_label)
-        for widget in widgets:
-            self.assertIsInstance(widget, gui.LabelLoading)
-            self.assertIn(widget, self.ui.status_box.get_children())
+    def test_entering_folders_tab_loads_content(self):
+        """The volumes info is loaded when entering the Folders tab."""
+        self.patch(self.ui.folders, 'load', self._set_called)
+        # clean backend calls
+        self.ui.folders_button.clicked()
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_entering_devices_tab_loads_content(self):
+        """The devices info is loaded when entering the Devices tab."""
+        self.patch(self.ui.devices, 'load', self._set_called)
+        # clean backend calls
+        self.ui.devices_button.clicked()
+
+        self.assertEqual(self._called, ((), {}))
+
+    def test_quota_placeholder_is_loading(self):
+        """Placeholders for quota label is a Loading widget."""
+        self.assertIsInstance(self.ui.quota_label, gui.LabelLoading)
+        self.assertIn(self.ui.quota_label, self.ui.quota_box.get_children())
+
+    def test_file_sync_status_placeholder_is_loading(self):
+        """Placeholders for file sync label is a Loading widget."""
+        self.assertIsInstance(self.ui.status_label, gui.LabelLoading)
+        self.assertIn(self.ui.status_label, self.ui.status_box.get_children())
 
     def test_on_account_info_ready(self):
         """The account info is processed when ready."""
@@ -896,5 +1527,80 @@
         """The account info couldn't be retrieved."""
         self.ui.on_account_info_error()
         for widget in (self.ui.quota_label,):
-            self.assert_warning_correct(widget, self.ui.VALUE_ERROR)
+            self.assert_warning_correct(widget, gui.VALUE_ERROR)
             self.assertFalse(widget.active)
+
+    def test_backend_file_sync_signals(self):
+        """The proper signals are connected to the backend."""
+        matches = (
+            ('FileSyncStatusDisabled', [self.ui.on_file_sync_status_disabled]),
+            ('FileSyncStatusStarting', [self.ui.on_file_sync_status_starting]),
+            ('FileSyncStatusDisconnected',
+             [self.ui.on_file_sync_status_disconnected]),
+            ('FileSyncStatusSyncing', [self.ui.on_file_sync_status_syncing]),
+            ('FileSyncStatusIdle', [self.ui.on_file_sync_status_idle]),
+            ('FileSyncStatusError', [self.ui.on_file_sync_status_error]),
+        )
+        for sig, handlers in matches:
+            self.assertEqual(self.ui.backend._signals[sig], handlers)
+
+    def test_file_sync_status_is_requested_on_load(self):
+        """The file sync status is requested to the backend."""
+        self.ui.load()
+        self.assert_backend_called('file_sync_status', ())
+
+    def test_on_file_sync_status_disabled(self):
+        """The file sync is disabled."""
+        self.ui.on_file_sync_status_disabled('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_DISABLED)
+
+    def test_on_file_sync_status_starting(self):
+        """The file sync status is starting."""
+        self.ui.on_file_sync_status_starting('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_STARTING)
+
+    def test_on_file_sync_status_disconnected(self):
+        """The file sync status is disconnected."""
+        self.ui.on_file_sync_status_disconnected('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_DISCONNECTED)
+
+    def test_on_file_sync_status_syncing(self):
+        """The file sync status is syncing."""
+        self.ui.on_file_sync_status_syncing('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_SYNCING)
+
+    def test_on_file_sync_status_idle(self):
+        """The file sync status is idle."""
+        self.ui.on_file_sync_status_idle('msg')
+
+        self.assertFalse(self.ui.status_label.active)
+        self.assertEqual(self.ui.status_label.get_text(),
+                         self.ui.FILE_SYNC_IDLE)
+
+    def test_on_file_sync_status_error(self):
+        """The file sync status couldn't be retrieved."""
+        self.ui.on_file_sync_status_error({'error_msg': 'error msg'})
+
+        self.assert_warning_correct(self.ui.status_label,
+                                    self.ui.FILE_SYNC_ERROR)
+        self.assertFalse(self.ui.status_label.active)
+
+    def test_local_device_removed_is_emitted(self):
+        """Signal local-device-removed is sent when DevicesPanel emits it."""
+        self.ui.connect('local-device-removed', self._set_called)
+
+        self.ui.devices.emit('local-device-removed')
+
+        self.assertEqual(self._called, ((self.ui,), {}))

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_widgets.py'
--- ubuntuone/controlpanel/gtk/tests/test_widgets.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_widgets.py	2010-12-22 14:37:52 +0000
@@ -75,33 +75,26 @@
     def test_creation(self):
         """A LabelLoading can be created."""
         self.assertEqual(self.widget.label.get_text(), '')
-        self.assertFalse(self.widget.label.get_visible())
+        self.assertTrue(self.widget.label.get_visible())
 
         self.assertIsInstance(self.widget.loading, widgets.Loading)
         self.assertTrue(self.widget.loading.get_visible())
-        self.assertTrue(self.widget.active)
+        self.assertTrue(self.widget.active)  # loading label is packed
 
     def test_stop(self):
         """Stop hides the Loading widget."""
         self.widget.stop()
-        self.assertTrue(self.widget.label.get_visible())
-        self.assertFalse(self.widget.loading.get_visible())
+
+        self.assertTrue(self.widget.get_child() is self.widget.label)
         self.assertFalse(self.widget.active)
 
     def test_start(self):
         """Start shows the Loading widget."""
         self.widget.start()
-        self.assertFalse(self.widget.label.get_visible())
-        self.assertTrue(self.widget.loading.get_visible())
+
+        self.assertTrue(self.widget.get_child() is self.widget.loading)
         self.assertTrue(self.widget.active)
 
-    def test_children(self):
-        """A LabelLoading have proper children."""
-        children = self.widget.get_children()
-        self.assertEqual(2, len(children))
-        self.assertTrue(self.widget.label is children[0])
-        self.assertTrue(self.widget.loading is children[-1])
-
     def test_get_text(self):
         """Text can be queried."""
         text = 'Test me.'

=== modified file 'ubuntuone/controlpanel/gtk/widgets.py'
--- ubuntuone/controlpanel/gtk/widgets.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/gtk/widgets.py	2010-12-22 14:37:52 +0000
@@ -49,7 +49,7 @@
         self.show_all()
 
 
-class LabelLoading(gtk.HBox):
+class LabelLoading(gtk.Alignment):
     """A spinner and a label."""
 
     def __init__(self, loading_label, fg_color=None, *args, **kwargs):
@@ -57,29 +57,36 @@
         self.loading = Loading(loading_label, fg_color=fg_color)
 
         self.label = gtk.Label()
+        self.label.show()
         if fg_color is not None:
             self.label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(fg_color))
 
-        self.pack_start(self.label, expand=False)
-        self.pack_start(self.loading, expand=False)
+        self.add(self.loading)
 
         self.show()
+        self.set(xalign=0.5, yalign=0.5, xscale=0, yscale=0)
+        self.set_padding(padding_top=5, padding_bottom=0,
+                         padding_left=5, padding_right=5)
         self.start()
 
     @property
     def active(self):
         """Whether the Loading widget is visible or not."""
-        return not self.label.get_visible() and self.loading.get_visible()
+        return self.get_child() is self.loading
 
     def start(self):
         """Show the Loading instead of the Label widget."""
-        self.label.hide()
-        self.loading.show()
+        for child in self.get_children():
+            self.remove(child)
+
+        self.add(self.loading)
 
     def stop(self):
         """Show the label instead of the Loading widget."""
-        self.label.show()
-        self.loading.hide()
+        for child in self.get_children():
+            self.remove(child)
+
+        self.add(self.label)
 
     def set_text(self, text):
         """Set 'text' to be the label's text."""

=== modified file 'ubuntuone/controlpanel/integrationtests/__init__.py'
--- ubuntuone/controlpanel/integrationtests/__init__.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/integrationtests/__init__.py	2010-12-22 14:37:52 +0000
@@ -43,8 +43,13 @@
     def setUp(self):
         super(DBusClientTestCase, self).setUp()
         self.mock = None
+        self._called = False
         dbus_service.init_mainloop()
 
+    def _set_called(self, *args, **kwargs):
+        """Keep track of function calls, useful for monkeypatching."""
+        self._called = (args, kwargs)
+
     def register_mockserver(self, bus_name, object_path, object_class,
                             **kwargs):
         """The mock service is registered on the DBus."""

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_client_sd.py	2010-12-22 14:37:52 +0000
@@ -204,13 +204,13 @@
 
 
 class FoldersMockDBusSyncDaemon(sd_dbus_iface.Folders):
-    """A mock object that mimicks syncdaemon regarding the folders iface."""
+    """A mock object that mimicks syncdaemon regarding the Folders iface."""
 
     # __init__ method from a non direct base class 'Object' is called
     # __init__ method from base class 'Folders' is not called
     # pylint: disable=W0231, W0233
 
-    def __init__(self, object_path, conn, vm=None):
+    def __init__(self, object_path, conn):
         self.udfs = {}
         self.udf_id = 1
         dbus.service.Object.__init__(self,
@@ -220,9 +220,15 @@
     def _new_udf(cls, uid, path, subscribed=False):
         """Create a new faked udf."""
         udf = {}
-        udf['path'] = udf['suggested_path'] = path
-        udf['id'] = uid
-        udf['subscribed'] = subscribed
+        if isinstance(path, str):
+            path = path.decode('utf-8')
+        udf[u'path'] = udf[u'suggested_path'] = path
+        udf[u'volume_id'] = unicode(uid)
+        udf[u'subscribed'] = sd_dbus_iface.bool_str(subscribed)
+        udf[u'node_id'] = u'a18f4cbd-a846-4405-aaa1-b28904817089'
+        udf[u'generation'] = u''
+        udf[u'type'] = u'UDF'
+
         return udf
 
     @dbus.service.method(sd_dbus_iface.DBUS_IFACE_FOLDERS_NAME,
@@ -231,9 +237,10 @@
         """Create a user defined folder in the specified path."""
         if path == '':  # simulate an error
             self.emit_folder_create_error(path, 'create failed!')
+            return
 
         udf = self._new_udf(self.udf_id, path)
-        self.udfs[self.udf_id] = udf
+        self.udfs[udf['volume_id']] = udf
         self.udf_id += 1
         self.emit_folder_created(udf)
 
@@ -243,6 +250,7 @@
         """Delete the folder specified by folder_id"""
         if folder_id not in self.udfs:
             self.emit_folder_delete_error(folder_id, 'failed!')
+            return
 
         udf = self.udfs.pop(folder_id)
         self.emit_folder_deleted(udf)
@@ -260,8 +268,9 @@
         if folder_id not in self.udfs:
             # simulate error
             self.emit_folder_subscribe_error(folder_id, 'some error')
+            return
 
-        self.udfs[folder_id]['subscribed'] = True
+        self.udfs[folder_id]['subscribed'] = sd_dbus_iface.bool_str(True)
         self.emit_folder_subscribed(self.udfs[folder_id])
 
     @dbus.service.method(sd_dbus_iface.DBUS_IFACE_FOLDERS_NAME,
@@ -271,8 +280,9 @@
         if folder_id not in self.udfs:
             # simulate error
             self.emit_folder_unsubscribe_error(folder_id, 'some error')
+            return
 
-        self.udfs[folder_id]['subscribed'] = False
+        self.udfs[folder_id]['subscribed'] = sd_dbus_iface.bool_str(False)
         self.emit_folder_unsubscribed(self.udfs[folder_id])
 
     @dbus.service.method(sd_dbus_iface.DBUS_IFACE_FOLDERS_NAME,
@@ -296,49 +306,208 @@
 
     def setUp(self):
         super(FoldersTestCase, self).setUp()
-
-        def _get_udf_dict(udf):
-            """Get a dict with all the attributes of: udf."""
-            udf_dict = udf.copy()
-            for k, val in udf_dict.items():
-                if val is None:
-                    udf_dict[unicode(k)] = ''
-                elif k == 'subscribed':
-                    udf_dict[unicode(k)] = sd_dbus_iface.bool_str(val)
-                elif k in ('path', 'suggested_path') and isinstance(val, str):
-                    udf_dict[unicode(k)] = val.decode('utf-8')
-                else:
-                    udf_dict[unicode(k)] = unicode(val)
-            return udf_dict
-
-        self.patch(sd_dbus_iface, '_get_udf_dict', _get_udf_dict)
+        self.patch(sd_dbus_iface, '_get_udf_dict', lambda udf: udf)
         self.register_mockserver(sd_dbus_iface.DBUS_IFACE_NAME,
                                  "/folders", FoldersMockDBusSyncDaemon)
 
     @inlineCallbacks
-    def test_get_volumes(self):
-        """Retrieve volumes info list."""
+    def test_get_folders(self):
+        """Retrieve folders info list."""
         path = '~/bar/baz'
-        yield dbus_client.create_volume(path)
+        yield dbus_client.create_folder(path)
 
-        result = yield dbus_client.get_volumes()
+        result = yield dbus_client.get_folders()
 
         expected = FoldersMockDBusSyncDaemon._new_udf(1, path)
         self.assertEqual(result, [sd_dbus_iface._get_udf_dict(expected)])
 
     @inlineCallbacks
-    def test_create_volume(self):
-        """Create a new volume."""
-        path = '~/bar/baz'
-        volume_info = yield dbus_client.create_volume(path)
+    def test_get_folders_error(self):
+        """Handle error when retrieving current syncdaemon status."""
+        path = '~/bar/baz'
+        yield dbus_client.create_folder(path)
+
+        def fail(value):
+            """Fake an error."""
+            raise TestDBusException(value)
+
+        self.patch(sd_dbus_iface, '_get_udf_dict', fail)
+
+        try:
+            yield dbus_client.get_folders()
+        except dbus.DBusException:
+            pass  # test passes!
+        else:
+            self.fail('dbus_client.get_folders should be errbacking')
+
+    @inlineCallbacks
+    def test_create_folder(self):
+        """Create a new folder."""
+        path = '~/bar/baz'
+        folder_info = yield dbus_client.create_folder(path)
 
         expected = FoldersMockDBusSyncDaemon._new_udf(1, path)
-        self.assertEqual(sd_dbus_iface._get_udf_dict(expected), volume_info)
-
-    @inlineCallbacks
-    def test_create_volume_error(self):
-        """Create a new volume fails."""
-        try:
-            yield dbus_client.create_volume(path='')
-        except dbus_client.VolumesError, e:
-            self.assertEqual(e[0], {'path': ''})
+        self.assertEqual(sd_dbus_iface._get_udf_dict(expected), folder_info)
+
+    @inlineCallbacks
+    def test_create_folder_error(self):
+        """Create a new folder fails."""
+        path = ''
+        try:
+            yield dbus_client.create_folder(path=path)
+        except dbus_client.VolumesError, e:
+            self.assertEqual(e[0], {'path': path})
+        else:
+            self.fail('dbus_client.create_folder should be errbacking')
+
+    @inlineCallbacks
+    def test_subscribe_folder(self):
+        """Subscribe to a folder."""
+        path = '~/bar/baz'
+        folder_info = yield dbus_client.create_folder(path)
+        fid = folder_info['volume_id']
+        yield dbus_client.subscribe_folder(fid)
+
+        result = yield dbus_client.get_folders()
+        expected, = filter(lambda folder: folder['volume_id'] == fid, result)
+        self.assertEqual(expected['subscribed'], 'True')
+
+    @inlineCallbacks
+    def test_subscribe_folder_error(self):
+        """Subscribe to a folder."""
+        fid = u'does not exist'
+        try:
+            yield dbus_client.subscribe_folder(fid)
+        except dbus_client.VolumesError, e:
+            self.assertEqual(e[0], {'id': fid})
+        else:
+            self.fail('dbus_client.subscribe_folder should be errbacking')
+
+    @inlineCallbacks
+    def test_unsubscribe_folder(self):
+        """Unsubscribe to a folder."""
+        path = '~/bar/baz'
+        folder_info = yield dbus_client.create_folder(path)
+        fid = folder_info['volume_id']
+        yield dbus_client.subscribe_folder(fid)
+        # folder is subscribed
+
+        yield dbus_client.unsubscribe_folder(fid)
+
+        result = yield dbus_client.get_folders()
+        expected, = filter(lambda folder: folder['volume_id'] == fid, result)
+        self.assertEqual(expected['subscribed'], '')
+
+    @inlineCallbacks
+    def test_unsubscribe_folder_error(self):
+        """Unsubscribe to a folder."""
+        fid = u'does not exist'
+        try:
+            yield dbus_client.unsubscribe_folder(fid)
+        except dbus_client.VolumesError, e:
+            self.assertEqual(e[0], {'id': fid})
+        else:
+            self.fail('dbus_client.unsubscribe_folder should be errbacking')
+
+
+class StatusMockDBusSyncDaemon(dbus.service.Object):
+    """A mock object that mimicks syncdaemon regarding the Status iface."""
+
+    state_dict = {
+        'name': 'TEST',
+        'description': 'Some test state, nothing else.',
+        'is_error': '',
+        'is_connected': 'True',
+        'is_online': '',
+        'queues': 'GORGEOUS',
+        'connection': '',
+    }
+
+    def _get_current_state(self):
+        """Get the current status of the system."""
+        return self.state_dict
+
+    @dbus.service.method(sd_dbus_iface.DBUS_IFACE_STATUS_NAME,
+                         in_signature='', out_signature='a{ss}')
+    def current_status(self):
+        """Return the current faked status of the system."""
+        return self._get_current_state()
+
+    # pylint: disable=C0103
+    # Invalid name "StatusChanged"
+
+    @dbus.service.signal(sd_dbus_iface.DBUS_IFACE_STATUS_NAME)
+    def StatusChanged(self, status):
+        """Fire a signal to notify that the status of the system changed."""
+
+    def emit_status_changed(self, state=None):
+        """Emit StatusChanged."""
+        self.StatusChanged(self._get_current_state())
+
+
+class StatusTestCase(DBusClientTestCase):
+    """Test for the status dbus client methods."""
+
+    def setUp(self):
+        super(StatusTestCase, self).setUp()
+        self.register_mockserver(sd_dbus_iface.DBUS_IFACE_NAME,
+                                 "/status", StatusMockDBusSyncDaemon)
+
+    @inlineCallbacks
+    def test_get_current_status(self):
+        """Retrieve current syncdaemon status."""
+        status = yield dbus_client.get_current_status()
+
+        self.assertEqual(StatusMockDBusSyncDaemon.state_dict, status)
+
+    @inlineCallbacks
+    def test_get_current_status_error(self):
+        """Handle error when retrieving current syncdaemon status."""
+
+        def fail(value):
+            """Fake an error."""
+            raise TestDBusException(value)
+
+        self.patch(StatusMockDBusSyncDaemon, '_get_current_state', fail)
+
+        try:
+            yield dbus_client.get_current_status()
+        except dbus.DBusException:
+            pass  # test passes!
+        else:
+            self.fail('dbus_client.get_current_status should be errbacking')
+
+    def test_set_status_changed_handler(self):
+        """A proper callback can be connected to StatusChanged signal."""
+        _, sig = dbus_client.set_status_changed_handler(self._set_called)
+
+        self.assertEqual(sig._handler, self._set_called)
+        self.assertEqual(sig._member, 'StatusChanged')
+        self.assertEqual(sig._path, '/status')
+        self.assertEqual(sig._interface, sd_dbus_iface.DBUS_IFACE_STATUS_NAME)
+
+
+class FileSyncTestCase(DBusClientTestCase):
+    """Test for the files sync enabled dbus client methods."""
+
+    @inlineCallbacks
+    def test_files_sync_enabled(self):
+        """Retrieve whether file sync is enabled."""
+        expected = object()
+        self.patch(dbus_client.SyncDaemonTool, 'is_files_sync_enabled',
+                   lambda _: expected)
+
+        enabled = yield dbus_client.files_sync_enabled()
+
+        self.assertEqual(expected, enabled)
+
+    @inlineCallbacks
+    def test_set_files_sync_enabled(self):
+        """Set if file sync is enabled or not."""
+        self.patch(dbus_client.SyncDaemonTool, 'enable_files_sync',
+                   self._set_called)
+        expected = object()
+        # set the opposite value
+        yield dbus_client.set_files_sync_enabled(expected)
+
+        self.assertEqual(self._called, ((expected,), {}))

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_client_sso.py	2010-12-22 14:37:52 +0000
@@ -23,8 +23,9 @@
 # DBus signals have CamelCased names
 
 import dbus
-import ubuntu_sso
 
+from ubuntu_sso import (DBUS_BUS_NAME,
+    DBUS_CREDENTIALS_PATH, DBUS_CREDENTIALS_IFACE)
 from twisted.internet.defer import inlineCallbacks
 
 from ubuntuone.controlpanel import dbus_client
@@ -36,6 +37,8 @@
     "token": "ABCDEF12345678",
     "access_token": "DEADCAFE2010",
 }
+OTHER_CREDS = {"token": "other!"}
+SAMPLE_ERROR = {"error message": "test", "detailed_error": "error details"}
 
 # pylint: disable=C0322
 # pylint, you have to go to decorator's school
@@ -44,116 +47,161 @@
 class MockDBusSSOService(dbus.service.Object):
     """A mock object that mimicks ussoc."""
 
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Get creds from the keyring, login/register if needed."""
-        self.CredentialsFound(app_name, SAMPLE_CREDS)
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Credentials were finally found."""
-
-
-class MockDBusSSOServiceOther(dbus.service.Object):
-    """A mock object that mimicks ussoc."""
-
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Get creds from the keyring, login/register if needed."""
-        self.CredentialsFound("wrong app name", {})
-        self.CredentialsFound(app_name, SAMPLE_CREDS)
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Credentials were finally found."""
-
-
-class MockDBusSSOClientOtherFailing(dbus.service.Object):
-    """A mock object that mimicks ussoc."""
-
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Get creds from the keyring, login/register if needed."""
-        self.CredentialsError("wrong app", "error message", "error details")
-        self.CredentialsFound(app_name, SAMPLE_CREDS)
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Credentials were finally found."""
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sss")
-    def CredentialsError(self, app_name, error_message, detailed_error):
-        """Some error happened and credentials were not found."""
-
-
-class MockDBusSSOClientFailing(dbus.service.Object):
-    """A mock object that mimicks ussoc but fails."""
-
-    @dbus.service.method(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx")
-    def login_or_register_to_get_credentials(self, app_name, tcurl, hlp, wid):
-        """Fail while trying to get creds from the keyring."""
-        self.CredentialsError(app_name, "error message", "error details")
-
-    @dbus.service.signal(dbus_interface=ubuntu_sso.DBUS_IFACE_CRED_NAME,
-                         signature="sss")
-    def CredentialsError(self, app_name, error_message, detailed_error):
-        """Some error happened and credentials were not found."""
+    found = True
+    wrong_app = None
+    error = None
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def find_credentials(self, app_name, args):
+        """Get creds from the keyring, login/register if needed."""
+        if self.wrong_app is None and self.error is None:
+            if self.found:
+                self.CredentialsFound(app_name, SAMPLE_CREDS)
+            else:
+                self.CredentialsNotFound(app_name)
+        elif self.wrong_app is not None and self.error is None:
+            self.CredentialsFound(self.wrong_app, OTHER_CREDS)
+        elif self.wrong_app is None and self.error is not None:
+            self.CredentialsError(app_name, self.error)
+        else:
+            self.CredentialsError(self.wrong_app, self.error)
+
+        self.CredentialsFound(app_name, SAMPLE_CREDS)
+
+    @dbus.service.method(dbus_interface=DBUS_CREDENTIALS_IFACE,
+                         in_signature='sa{ss}', out_signature='')
+    def clear_credentials(self, app_name, args):
+        """Clear the credentials for an application."""
+        self.found = False
+
+        if self.wrong_app is None and self.error is None:
+            self.CredentialsCleared(app_name)
+        elif self.wrong_app is not None and self.error is None:
+            self.CredentialsCleared(self.wrong_app)
+        elif self.wrong_app is None and self.error is not None:
+            self.CredentialsError(app_name, self.error)
+        else:
+            self.CredentialsError(self.wrong_app, self.error)
+
+        self.CredentialsCleared(app_name)
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsFound(self, app_name, credentials):
+        """Signal thrown when the credentials are found."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsNotFound(self, app_name):
+        """Signal thrown when the credentials are not found."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsCleared(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='s')
+    def CredentialsStored(self, app_name):
+        """Signal thrown when the credentials were cleared."""
+
+    @dbus.service.signal(DBUS_CREDENTIALS_IFACE, signature='sa{ss}')
+    def CredentialsError(self, app_name, error_dict):
+        """Signal thrown when there is a problem getting the credentials."""
 
 
 class SSOClientTestCase(DBusClientTestCase):
     """Test for the SSO dbus client."""
 
+    def setUp(self):
+        super(SSOClientTestCase, self).setUp()
+        self.register_mockserver(DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
+                                 MockDBusSSOService)
+        MockDBusSSOService.wrong_app = None
+        MockDBusSSOService.error = None
+        MockDBusSSOService.found = True
+
+    # get_credentials
+
     @inlineCallbacks
     def test_get_credentials_ok(self):
         """Test the success case for get_credentials."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH, MockDBusSSOService)
         creds = yield dbus_client.get_credentials()
         self.assertEqual(creds, SAMPLE_CREDS)
 
     @inlineCallbacks
+    def test_get_credentials_not_found(self):
+        """Credentials were not found."""
+        yield dbus_client.clear_credentials()  # not found will be sent
+        yield self.assertFailure(dbus_client.get_credentials(),
+                                 dbus_client.CredentialsError)
+
+    @inlineCallbacks
     def test_get_credentials_other(self):
         """Creds for other apps are ignored."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusSSOServiceOther)
+        MockDBusSSOService.wrong_app = 'other app!'
         creds = yield dbus_client.get_credentials()
         self.assertEqual(creds, SAMPLE_CREDS)
 
     @inlineCallbacks
     def test_get_credentials_error(self):
         """Test what happens when the creds can't be retrieved."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusSSOClientFailing)
-
+        MockDBusSSOService.error = SAMPLE_ERROR
         yield self.assertFailure(dbus_client.get_credentials(),
                                  dbus_client.CredentialsError)
 
     @inlineCallbacks
     def test_get_credentials_other_error(self):
         """Other creds err before ours are retrieved."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusSSOClientOtherFailing)
-
+        MockDBusSSOService.wrong_app = 'other app!'
+        MockDBusSSOService.error = SAMPLE_ERROR
         creds = yield dbus_client.get_credentials()
         self.assertEqual(creds, SAMPLE_CREDS)
 
+    # clear_credentials
+
+    @inlineCallbacks
+    def test_clear_credentials_ok(self):
+        """Test the success case for clear_credentials."""
+        result = yield dbus_client.clear_credentials()
+        self.assertEqual(result, dbus_client.APP_NAME)
+
+    @inlineCallbacks
+    def test_clear_credentials_other(self):
+        """Creds for other apps are ignored."""
+        MockDBusSSOService.wrong_app = 'other app!'
+        result = yield dbus_client.clear_credentials()
+        self.assertEqual(result, dbus_client.APP_NAME)
+
+    @inlineCallbacks
+    def test_clear_credentials_error(self):
+        """Test what happens when the creds can't be retrieved."""
+        MockDBusSSOService.error = SAMPLE_ERROR
+        yield self.assertFailure(dbus_client.clear_credentials(),
+                                 dbus_client.CredentialsError)
+
+    @inlineCallbacks
+    def test_clear_credentials_other_error(self):
+        """Other creds err before ours are retrieved."""
+        MockDBusSSOService.wrong_app = 'other app!'
+        MockDBusSSOService.error = SAMPLE_ERROR
+        result = yield dbus_client.clear_credentials()
+        self.assertEqual(result, dbus_client.APP_NAME)
+
+
+class NoMethodsSSOClientTestCase(DBusClientTestCase):
+    """Test for the SSO dbus client when the service provides no methods."""
+
+    def setUp(self):
+        super(NoMethodsSSOClientTestCase, self).setUp()
+        self.register_mockserver(DBUS_BUS_NAME, DBUS_CREDENTIALS_PATH,
+                                 MockDBusNoMethods)
+
     @inlineCallbacks
     def test_get_credentials_dbus_error(self):
         """Test what happens when there's a DBus error."""
-        self.register_mockserver(ubuntu_sso.DBUS_BUS_NAME,
-                                 ubuntu_sso.DBUS_CRED_PATH,
-                                 MockDBusNoMethods)
+        yield self.assertFailure(dbus_client.get_credentials(),
+                                 dbus.DBusException)
 
-        yield self.assertFailure(dbus_client.get_credentials(),
+    @inlineCallbacks
+    def test_clear_credentials_dbus_error(self):
+        """Test what happens when there's a DBus error."""
+        yield self.assertFailure(dbus_client.clear_credentials(),
                                  dbus.DBusException)

=== modified file 'ubuntuone/controlpanel/integrationtests/test_dbus_service.py'
--- ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/integrationtests/test_dbus_service.py	2010-12-22 14:37:52 +0000
@@ -45,8 +45,8 @@
         "name": "Ubuntu One @ darkstar",
         "date_added": "2008-12-06T18:15:38.0",
         "type": "computer",
-        "configurable": "1",
-        "limit_bandwidth": "1",
+        "configurable": 'True',
+        "limit_bandwidth": 'True',
         "max_upload_speed": "12345",
         "max_download_speed": "54321",
         "available_services": "files, contacts, music, bookmarks",
@@ -57,7 +57,7 @@
         "name": "Ubuntu One @ brightmoon",
         "date_added": "2010-09-22T20:45:38.0",
         "type": "computer",
-        "configurable": "0",
+        "configurable": '',
         "available_services": "files, contacts, bookmarks",
         "enabled_services": "files, bookmarks",
     },
@@ -68,19 +68,19 @@
         "volume_id": "volume-0",
         "path": "/home/user/Documents",
         "suggested_path": "~/Documents",
-        "subscribed": "1",
+        "subscribed": 'True',
     },
     {
         "volume_id": "volume-1",
         "path": "/home/user/Music",
         "suggested_path": "~/Music",
-        "subscribed": "0",
+        "subscribed": '',
     },
     {
         "volume_id": "volume-2",
         "path": "/home/user/Pictures/Photos",
         "suggested_path": "~/Pictures/Photos",
-        "subscribed": "0",
+        "subscribed": '',
     },
 ]
 
@@ -115,7 +115,13 @@
 
 class MockBackend(object):
     """A mock backend."""
+
     exception = None
+    sample_status = {
+        dbus_service.MSG_KEY: 'test me please',
+        dbus_service.STATUS_KEY: dbus_service.FILE_SYNC_IDLE,
+    }
+    status_changed_handler = None
 
     def _process(self, result):
         """Process the request with the given result."""
@@ -142,7 +148,7 @@
 
     def file_sync_status(self):
         """Return the status of the file sync service."""
-        return self._process((True, "Synchronizing"))
+        return self._process(self.sample_status)
 
     def volumes_info(self):
         """Get the user volumes info."""
@@ -170,6 +176,11 @@
         """Initialize each test run."""
         super(DBusServiceTestCase, self).setUp()
         dbus_service.init_mainloop()
+        self._called = False
+
+    def _set_called(self, *args, **kwargs):
+        """Keep track of function calls, useful for monkeypatching."""
+        self._called = (args, kwargs)
 
     def test_register_service(self):
         """The DBus service is successfully registered."""
@@ -193,7 +204,7 @@
     def test_error_handler_with_failure(self):
         """Ensure to build a string-string dict to pass to error signals."""
         error = dbus_service.Failure(TypeError('oh no!'))
-        expected = dbus_service.utils.failure_to_error_dict(error)
+        expected = dbus_service.failure_to_error_dict(error)
 
         result = dbus_service.error_handler(error)
 
@@ -202,7 +213,7 @@
     def test_error_handler_with_exception(self):
         """Ensure to build a string-string dict to pass to error signals."""
         error = TypeError('oh no, no again!')
-        expected = dbus_service.utils.exception_to_error_dict(error)
+        expected = dbus_service.exception_to_error_dict(error)
 
         result = dbus_service.error_handler(error)
 
@@ -231,8 +242,8 @@
     def test_error_handler_default(self):
         """Ensure to build a string-string dict to pass to error signals."""
         msg = 'Got unexpected error argument %r' % None
-        expected = {dbus_service.utils.ERROR_TYPE: 'UnknownError',
-                    dbus_service.utils.ERROR_MESSAGE: msg}
+        expected = {dbus_service.ERROR_TYPE: 'UnknownError',
+                    dbus_service.ERROR_MESSAGE: msg}
 
         result = dbus_service.error_handler(None)
 
@@ -330,7 +341,7 @@
                 self.assertIn("date_added", device_info)
                 self.assertIn("type", device_info)
                 self.assertIn("configurable", device_info)
-                if int(device_info["configurable"]):
+                if bool(device_info["configurable"]):
                     self.assertIn("limit_bandwidth", device_info)
                     self.assertIn("max_upload_speed", device_info)
                     self.assertIn("max_download_speed", device_info)
@@ -372,19 +383,6 @@
                 self.backend.remove_device, sample_token)
         return self.assert_correct_method_call(*args)
 
-    def test_file_sync_status(self):
-        """The file sync status is reported."""
-
-        def got_signal(enabled, status):
-            """The correct status was received."""
-            self.assertEqual(enabled, True)
-            self.assertEqual(status, "Synchronizing")
-            self.deferred.callback("success")
-
-        args = ("FileSyncStatusReady", "FileSyncStatusError", got_signal,
-                self.backend.file_sync_status)
-        return self.assert_correct_method_call(*args)
-
     def test_volumes_info(self):
         """The volumes info is reported."""
 
@@ -408,7 +406,7 @@
 
         args = ("VolumeSettingsChanged", "VolumeSettingsChangeError",
                 got_signal, self.backend.change_volume_settings,
-                expected_volume_id, {'subscribed': '0'})
+                expected_volume_id, {'subscribed': ''})
         return self.assert_correct_method_call(*args)
 
     def test_query_bookmarks_extension(self):
@@ -451,11 +449,87 @@
 
         """
 
-        def got_error_signal(error_dict):
+        def got_error_signal(*a):
             """The error signal was received."""
-            self.assertEqual(error_dict[dbus_service.utils.ERROR_TYPE],
+            if len(a) == 1:
+                error_dict = a[0]
+            else:
+                an_id, error_dict = a
+                self.assertEqual(an_id, args[0])
+
+            self.assertEqual(error_dict[dbus_service.ERROR_TYPE],
                              'AssertionError')
             self.deferred.callback("success")
 
         return super(OperationsErrorTestCase, self).assert_correct_method_call(
             error_sig, success_sig, got_error_signal, method, *args)
+
+
+class FileSyncTestCase(OperationsTestCase):
+    """Test for the DBus service when requesting file sync status."""
+
+    def assert_correct_status_signal(self, status, sync_signal,
+                                     error_signal="FileSyncStatusError",
+                                     expected_msg=None):
+        """The file sync status is reported properly."""
+        MockBackend.sample_status[dbus_service.STATUS_KEY] = status
+        if expected_msg is None:
+            expected_msg = MockBackend.sample_status[dbus_service.MSG_KEY]
+
+        def got_signal(msg):
+            """The correct status was received."""
+            self.assertEqual(msg, expected_msg)
+            self.deferred.callback("success")
+
+        args = (sync_signal, error_signal, got_signal,
+                self.backend.file_sync_status)
+        return self.assert_correct_method_call(*args)
+
+    def test_file_sync_status_unknown(self):
+        """The file sync status is reported properly."""
+        msg = MockBackend.sample_status
+        args = ('invalid-file-sync-status', "FileSyncStatusError",
+                "FileSyncStatusIdle", msg)
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_error(self):
+        """The file sync status is reported properly."""
+        msg = MockBackend.sample_status[dbus_service.MSG_KEY]
+        err_dict = {dbus_service.ERROR_TYPE: 'FileSyncStatusError',
+                    dbus_service.ERROR_MESSAGE: msg}
+        args = (dbus_service.FILE_SYNC_ERROR, "FileSyncStatusError",
+                "FileSyncStatusIdle", err_dict)
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_disabled(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_DISABLED, "FileSyncStatusDisabled")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_starting(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_STARTING, "FileSyncStatusStarting")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_disconnected(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_DISCONNECTED,
+                "FileSyncStatusDisconnected")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_syncing(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_SYNCING, "FileSyncStatusSyncing")
+        return self.assert_correct_status_signal(*args)
+
+    def test_file_sync_status_idle(self):
+        """The file sync status is reported properly."""
+        args = (dbus_service.FILE_SYNC_IDLE, "FileSyncStatusIdle")
+        return self.assert_correct_status_signal(*args)
+
+    def test_status_changed_handler(self):
+        """The status changed handler is properly set."""
+        be = MockBackend()
+        cpbe = dbus_service.ControlPanelBackend(backend=be)
+
+        self.assertEqual(be.status_changed_handler, cpbe.process_status)

=== modified file 'ubuntuone/controlpanel/logger.py'
--- ubuntuone/controlpanel/logger.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/logger.py	2010-12-22 14:37:52 +0000
@@ -22,6 +22,7 @@
 import os
 import sys
 
+from functools import wraps
 from logging.handlers import RotatingFileHandler
 
 # pylint: disable=F0401,E0611
@@ -41,7 +42,7 @@
 MAIN_HANDLER.setLevel(LOG_LEVEL)
 
 
-def setup_logging(log_domain):
+def setup_logging(log_domain, prefix=None):
     """Create a logger for 'log_domain'.
 
     Final domain will be 'ubuntuone.controlpanel.<log_domain>.
@@ -52,6 +53,28 @@
     logger.addHandler(MAIN_HANDLER)
     if os.environ.get('DEBUG'):
         debug_handler = logging.StreamHandler(sys.stderr)
+        if prefix is not None:
+            fmt = prefix + "%(name)s - %(levelname)s\n%(message)s\n"
+            formatter = logging.Formatter(fmt)
+            debug_handler.setFormatter(formatter)
         logger.addHandler(debug_handler)
 
     return logger
+
+
+def log_call(log_func):
+    """Decorator to add log info using 'log_func'."""
+
+    def middle(f):
+        """Add logging when calling 'f'."""
+
+        @wraps(f)
+        def inner(*args, **kwargs):
+            """Call f(*args, **kwargs)."""
+            log_func('%s: args %r, kwargs %r.', f.__name__, args, kwargs)
+            res = f(*args, **kwargs)
+            return res
+
+        return inner
+
+    return middle

=== modified file 'ubuntuone/controlpanel/tests/test_backend.py'
--- ubuntuone/controlpanel/tests/test_backend.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/tests/test_backend.py	2010-12-22 14:37:52 +0000
@@ -23,10 +23,21 @@
 
 from twisted.internet import defer
 from twisted.internet.defer import inlineCallbacks
+from ubuntuone.devtools.handlers import MementoHandler
 
 from ubuntuone.controlpanel import backend
-from ubuntuone.controlpanel.backend import (ACCOUNT_API, QUOTA_API,
-                                            DEVICES_API, DEVICE_REMOVE_API)
+from ubuntuone.controlpanel.backend import (ACCOUNT_API,
+    DEVICES_API, DEVICE_REMOVE_API, QUOTA_API,
+    FILE_SYNC_DISABLED,
+    FILE_SYNC_DISCONNECTED,
+    FILE_SYNC_ERROR,
+    FILE_SYNC_IDLE,
+    FILE_SYNC_STARTING,
+    FILE_SYNC_SYNCING,
+    FILE_SYNC_UNKNOWN,
+    MSG_KEY, STATUS_KEY,
+)
+
 from ubuntuone.controlpanel.tests import TestCase
 from ubuntuone.controlpanel.webclient import WebClientError
 
@@ -44,7 +55,7 @@
         "dbpath": "u/abc/def/12345"
     },
     "couchdb_root": "https://couchdb.one.ubuntu.com/u/abc/def/12345",
-    "email": "[e-mail]",
+    "email": "[e-mail]",%s
     "nickname": "Andrew P. Zoilo",
     "id": 12345,
     "subscription": {
@@ -63,6 +74,13 @@
 }
 """
 
+CURRENT_PLAN = "Ubuntu One Basic (2 GB) + 1 x 20-Pack with 20 GB (monthly)"
+SAMPLE_CURRENT_PLAN = '\n    "current_plan": "%s",' % CURRENT_PLAN
+
+SAMPLE_ACCOUNT_NO_CURRENT_PLAN = SAMPLE_ACCOUNT_JSON % ''
+SAMPLE_ACCOUNT_WITH_CURRENT_PLAN = SAMPLE_ACCOUNT_JSON % SAMPLE_CURRENT_PLAN
+
+
 SAMPLE_QUOTA_JSON = """
 {
     "total": 53687091200,
@@ -78,6 +96,14 @@
     "email": "[e-mail]",
 }
 
+EXPECTED_ACCOUNT_INFO_WITH_CURRENT_PLAN = {
+    "quota_used": "2350345156",
+    "quota_total": "53687091200",
+    "type": CURRENT_PLAN,
+    "name": "Andrew P. Zoilo",
+    "email": "[e-mail]",
+}
+
 SAMPLE_DEVICES_JSON = """
 [
     {
@@ -103,12 +129,14 @@
         "device_id": "ComputerABCDEF01234token",
         "name": "Ubuntu One @ darkstar",
         "type": "Computer",
-        "configurable": "0",
+        "is_local": '',
+        "configurable": '',
     },
     {
-        'configurable': '1',
+        'is_local': 'True',
+        'configurable': 'True',
         'device_id': 'ComputerABC1234DEF',
-        'limit_bandwidth': "0",
+        'limit_bandwidth': '',
         'max_download_speed': '-1',
         'max_upload_speed': '-1',
         'name': 'Ubuntu One @ localhost',
@@ -118,13 +146,49 @@
         "device_id": "Phone1000",
         "name": "Nokia E65",
         "type": "Phone",
-        "configurable": "0",
+        "configurable": '',
+        "is_local": '',
     },
 ]
 
-SAMPLE_VOLUMES = [
-    {'volume_id': 'test1', 'path': '~/test1', 'subscribed': False},
-    {'volume_id': 'test2', 'path': '~/test2', 'subscribed': True},
+SAMPLE_FOLDERS = [
+    {u'generation': u'2', u'node_id': u'341da068-81d8-437a-8f75-5bb9d86455ba',
+     u'path': u'/home/tester/Public', u'subscribed': u'True',
+     u'suggested_path': u'~/Public',
+     u'type': u'UDF', u'volume_id': u'9ea892f8-15fa-4201-bdbf-8de99fa5f588'},
+    {u'generation': u'', u'node_id': u'11fbc86c-0d7a-49f5-ae83-8402caf66c6a',
+     u'path': u'/home/tester/Documents', u'subscribed': u'',
+     u'suggested_path': u'~/Documents',
+     u'type': u'UDF', u'volume_id': u'2db262f5-a151-4c19-969c-bb5ced753c61'},
+    {u'generation': u'24', u'node_id': u'9ee0e130-a7c7-4d76-a5e3-5df506221b48',
+     u'path': u'/home/tester/Pictures/Photos', u'subscribed': u'True',
+     u'suggested_path': u'~/Pictures/Photos',
+     u'type': u'UDF', u'volume_id': u'1deb2874-3d28-46ae-9999-d5f48de9f460'},
+]
+
+SAMPLE_SHARES = [
+    {u'accepted': u'True', u'access_level': u'View',
+     u'free_bytes': u'39892622746', u'generation': u'2704',
+     u'name': u're', u'node_id': u'c483f419-ed28-490a-825d-a8c074e2d795',
+     u'other_username': u'otheruser', u'other_visible_name': u'Other User',
+     u'path': u'/home/tester/.local/share/ubuntuone/shares/re from Other User',
+     u'type': u'Share', u'volume_id': u'4a1b263b-a2b3-4f66-9e66-4cd18050810d'},
+    {u'accepted': u'True', u'access_level': u'Modify',
+     u'free_bytes': u'39892622746', u'generation': u'2704',
+     u'name': u'do', u'node_id': u'84544ea4-aefe-4f91-9bb9-ed7b0a805baf',
+     u'other_username': u'otheruser', u'other_visible_name': u'Other User',
+     u'path': u'/home/tester/.local/share/ubuntuone/shares/do from Other User',
+     u'type': u'Share', u'volume_id': u'7d130dfe-98b2-4bd5-8708-9eeba9838ac0'},
+]
+
+SAMPLE_SHARED = [
+    {u'accepted': u'True', u'access_level': u'View',
+     u'free_bytes': u'', u'generation': u'',
+     u'name': u'bar', u'node_id': u'31e47530-9448-4f03-b4dc-4154fdf35225',
+     u'other_username': u'otheruser', u'other_visible_name': u'Other User',
+     u'path': u'/home/tester/Ubuntu One/bar',
+     u'type': u'Shared',
+     u'volume_id': u'79584900-517f-4dff-b2f3-20e8c1e79365'},
 ]
 
 
@@ -152,11 +216,24 @@
     creds = SAMPLE_CREDENTIALS
     throttling = False
     limits = {"download": -1, "upload": -1}
+    file_sync = True
+    status = {
+        'name': 'TEST', 'queues': 'GORGEOUS', 'connection': '',
+        'description': 'Some test state, nothing else.',
+        'is_error': '', 'is_connected': 'True', 'is_online': '',
+    }
+    status_changed_handler = None
+    subscribed_folders = []
 
     def get_credentials(self):
         """Return the mock credentials."""
         return defer.succeed(self.creds)
 
+    def clear_credentials(self):
+        """Clear the mock credentials."""
+        MockDBusClient.creds = None
+        return defer.succeed(None)
+
     def get_throttling_limits(self):
         """Return the sample speed limits."""
         return self.limits
@@ -178,9 +255,41 @@
         """Disable bw throttling."""
         self.throttling = False
 
-    def get_volumes(self):
-        """Grab list of folders and shares."""
-        return SAMPLE_VOLUMES
+    def files_sync_enabled(self):
+        """Get if file sync service is enabled."""
+        return self.file_sync
+
+    def set_files_sync_enabled(self, enabled):
+        """Set the file sync service to be 'enabled'."""
+        self.file_sync = enabled
+
+    def get_folders(self):
+        """Grab list of folders."""
+        return SAMPLE_FOLDERS
+
+    def subscribe_folder(self, volume_id):
+        """Subcribe to 'volume_id'."""
+        self.subscribed_folders.append(volume_id)
+
+    def unsubscribe_folder(self, volume_id):
+        """Unsubcribe from 'volume_id'."""
+        self.subscribed_folders.remove(volume_id)
+
+    def get_current_status(self):
+        """Grab syncdaemon status."""
+        return self.status
+
+    def set_status_changed_handler(self, handler):
+        """Connect a handler for tracking syncdaemon status changes."""
+        self.status_changed_handler = handler
+
+    def get_shares(self):
+        """Grab list of shares (shares from others to the user)."""
+        return SAMPLE_SHARES
+
+    def get_shared(self):
+        """Grab list of shared (shares from the user to others)."""
+        return SAMPLE_SHARED
 
 
 class BackendBasicTestCase(TestCase):
@@ -189,11 +298,17 @@
     timeout = 3
 
     def setUp(self):
+        super(BackendBasicTestCase, self).setUp()
         self.patch(backend, "WebClient", MockWebClient)
         self.patch(backend, "dbus_client", MockDBusClient())
         self.local_token = "Computer" + SAMPLE_CREDENTIALS["token"]
         self.be = backend.ControlBackend()
 
+        self.memento = MementoHandler()
+        backend.logger.addHandler(self.memento)
+
+        MockDBusClient.creds = SAMPLE_CREDENTIALS
+
     def test_backend_creation(self):
         """The backend instance is successfully created."""
         self.assertEqual(self.be.wc.__class__, MockWebClient)
@@ -204,6 +319,16 @@
         token = yield self.be.get_token()
         self.assertEqual(token, SAMPLE_CREDENTIALS["token"])
 
+    @inlineCallbacks
+    def test_device_is_local(self):
+        """The device_is_local returns the right result."""
+        result = yield self.be.device_is_local(self.local_token)
+        self.assertTrue(result)
+
+        did = EXPECTED_DEVICES_INFO[0]['device_id']
+        result = yield self.be.device_is_local(did)
+        self.assertFalse(result)
+
 
 class BackendAccountTestCase(BackendBasicTestCase):
     """Account tests for the backend."""
@@ -212,12 +337,21 @@
     def test_account_info(self):
         """The account_info method exercises its callback."""
         # pylint: disable=E1101
-        self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_JSON
+        self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_NO_CURRENT_PLAN
         self.be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
         result = yield self.be.account_info()
         self.assertEqual(result, EXPECTED_ACCOUNT_INFO)
 
     @inlineCallbacks
+    def test_account_info_with_current_plan(self):
+        """The account_info method exercises its callback."""
+        # pylint: disable=E1101
+        self.be.wc.results[ACCOUNT_API] = SAMPLE_ACCOUNT_WITH_CURRENT_PLAN
+        self.be.wc.results[QUOTA_API] = SAMPLE_QUOTA_JSON
+        result = yield self.be.account_info()
+        self.assertEqual(result, EXPECTED_ACCOUNT_INFO_WITH_CURRENT_PLAN)
+
+    @inlineCallbacks
     def test_account_info_fails(self):
         """The account_info method exercises its errback."""
         # pylint: disable=E1101
@@ -248,11 +382,23 @@
         """The remove_device method calls the right api."""
         dtype, did = "Computer", "SAMPLE-TOKEN"
         device_id = dtype + did
-        apiurl = DEVICE_REMOVE_API % (dtype, did)
+        apiurl = DEVICE_REMOVE_API % (dtype.lower(), did)
         # pylint: disable=E1101
         self.be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
         result = yield self.be.remove_device(device_id)
         self.assertEqual(result, device_id)
+        # credentials were not cleared
+        self.assertEqual(MockDBusClient.creds, SAMPLE_CREDENTIALS)
+
+    @inlineCallbacks
+    def test_remove_device_clear_credentials_if_local_device(self):
+        """The remove_device method clears the credentials if is local."""
+        apiurl = DEVICE_REMOVE_API % ('computer', SAMPLE_CREDENTIALS['token'])
+        # pylint: disable=E1101
+        self.be.wc.results[apiurl] = SAMPLE_DEVICES_JSON
+        yield self.be.remove_device(self.local_token)
+        # credentials were cleared
+        self.assertEqual(MockDBusClient.creds, None)
 
     @inlineCallbacks
     def test_remove_device_fails(self):
@@ -266,10 +412,10 @@
         """The device settings are updated."""
         backend.dbus_client.throttling = False
         yield self.be.change_device_settings(self.local_token,
-                                        {"limit_bandwidth": "1"})
+                                        {"limit_bandwidth": 'True'})
         self.assertEqual(backend.dbus_client.throttling, True)
         yield self.be.change_device_settings(self.local_token,
-                                        {"limit_bandwidth": "0"})
+                                        {"limit_bandwidth": ''})
         self.assertEqual(backend.dbus_client.throttling, False)
 
     @inlineCallbacks
@@ -298,7 +444,7 @@
         new_settings = {
             "max_download_speed": "99",
             "max_upload_speed": "99",
-            "limit_bandwidth": "1",
+            "limit_bandwidth": 'True',
         }
         yield self.be.change_device_settings("wrong token!", new_settings)
         self.assertEqual(backend.dbus_client.throttling, False)
@@ -313,4 +459,197 @@
     def test_volumes_info(self):
         """The volumes_info method exercises its callback."""
         result = yield self.be.volumes_info()
-        self.assertEqual(result, SAMPLE_VOLUMES)
+        # later, we should unify folders and shares info
+        self.assertEqual(result, SAMPLE_FOLDERS)
+
+    @inlineCallbacks
+    def test_subscribe_volume(self):
+        """The subscribe_volume method subscribes a folder."""
+        fid = '0123-4567'
+        yield self.be.subscribe_volume(volume_id=fid)
+        self.addCleanup(lambda: MockDBusClient.subscribed_folders.remove(fid))
+
+        self.assertEqual(MockDBusClient.subscribed_folders, [fid])
+
+    @inlineCallbacks
+    def test_unsubscribe_volume(self):
+        """The unsubscribe_volume method unsubscribes a folder."""
+        fid = '0123-4567'
+        yield self.be.subscribe_volume(volume_id=fid)
+        self.assertEqual(MockDBusClient.subscribed_folders, [fid])
+
+        yield self.be.unsubscribe_volume(volume_id=fid)
+
+        self.assertEqual(MockDBusClient.subscribed_folders, [])
+
+    @inlineCallbacks
+    def test_change_volume_settings(self):
+        """The volume settings can be changed."""
+        fid = '0123-4567'
+
+        yield self.be.change_volume_settings(fid, {'subscribed': True})
+        self.assertEqual(MockDBusClient.subscribed_folders, [fid])
+
+        yield self.be.change_volume_settings(fid, {'subscribed': False})
+        self.assertEqual(MockDBusClient.subscribed_folders, [])
+
+    @inlineCallbacks
+    def test_change_volume_settings_no_setting(self):
+        """The change volume settings does not fail on empty settings."""
+        yield self.be.change_volume_settings('test', {})
+        self.assertEqual(MockDBusClient.subscribed_folders, [])
+
+
+class BackendSyncStatusTestCase(BackendBasicTestCase):
+    """Syncdaemon state for the backend."""
+
+    def _build_msg(self):
+        """Build expected message regarding file sync status."""
+        return '%s (%s)' % (MockDBusClient.status['description'],
+                            MockDBusClient.status['name'])
+
+    @inlineCallbacks
+    def assert_correct_status(self, status, msg=None):
+        """Check that the resulting status is correct."""
+        expected = {MSG_KEY: self._build_msg() if msg is None else msg,
+                    STATUS_KEY: status}
+        result = yield self.be.file_sync_status()
+        self.assertEqual(expected, result)
+
+    @inlineCallbacks
+    def test_disabled(self):
+        """The syncdaemon status is processed and emitted."""
+        self.patch(MockDBusClient, 'file_sync', False)
+        yield self.assert_correct_status(FILE_SYNC_DISABLED, msg='')
+
+    @inlineCallbacks
+    def test_error(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': 'True',  # nothing else matters
+            'is_online': '', 'is_connected': '',
+            'name': 'AUTH_FAILED', 'connection': '', 'queues': '',
+            'description': 'auth failed',
+        }
+        yield self.assert_correct_status(FILE_SYNC_ERROR)
+
+    @inlineCallbacks
+    def test_starting_when_init_not_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'Not User With Network', 'queues': '',
+            'name': 'INIT', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_init_with_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'INIT', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_local_rescan_not_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'Not User With Network', 'queues': '',
+            'name': 'LOCAL_RESCAN', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_local_rescan_with_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'LOCAL_RESCAN', 'description': 'something new',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_starting_when_ready_with_user(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'connection': 'With User With Network', 'queues': '',
+            'name': 'READY', 'description': 'something nicer',
+        }
+        yield self.assert_correct_status(FILE_SYNC_STARTING)
+
+    @inlineCallbacks
+    def test_disconnected(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'queues': '', 'description': 'something new',
+            'connection': 'Not User With Network',  # user didn't connect
+            'name': 'READY',  # must be READY, otherwise is STARTING
+        }
+        yield self.assert_correct_status(FILE_SYNC_DISCONNECTED)
+
+    @inlineCallbacks
+    def test_syncing_if_online(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': 'True', 'is_connected': 'True',
+            'name': 'QUEUE_MANAGER', 'connection': '',
+            'queues': 'WORKING_ON_CONTENT',  # anything but IDLE
+            'description': 'something nicer',
+        }
+        yield self.assert_correct_status(FILE_SYNC_SYNCING)
+
+    @inlineCallbacks
+    def test_syncing_even_if_not_online(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': 'True',
+            'name': 'CHECK_VERSION', 'connection': '',
+            'queues': 'WORKING_ON_CONTENT',
+            'description': 'something nicer',
+        }
+        yield self.assert_correct_status(FILE_SYNC_SYNCING)
+
+    @inlineCallbacks
+    def test_idle(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': 'True', 'is_connected': 'True',
+            'name': 'QUEUE_MANAGER', 'connection': '',
+            'queues': 'IDLE',
+            'description': 'something nice',
+        }
+        yield self.assert_correct_status(FILE_SYNC_IDLE)
+
+    @inlineCallbacks
+    def test_unknown(self):
+        """The syncdaemon status is processed and emitted."""
+        MockDBusClient.status = {
+            'is_error': '', 'is_online': '', 'is_connected': '',
+            'name': '', 'connection': '', 'queues': '',
+            'description': '',
+        }
+        yield self.assert_correct_status(FILE_SYNC_UNKNOWN)
+
+        has_warning = self.memento.check_warning('file_sync_status: unknown',
+                                                 repr(MockDBusClient.status))
+        self.assertTrue(has_warning)
+
+    def test_status_changed(self):
+        """The file_sync_status is the status changed handler."""
+        self.be.status_changed_handler = self._set_called
+        status = {'name': 'foo', 'description': 'bar', 'is_error': '',
+                  'is_connected': '', 'is_online': '', 'queues': ''}
+        # pylint: disable=E1101
+        backend.dbus_client.status_changed_handler(status)
+
+        # pylint: disable=W0212
+        # Access to a protected member _process_file_sync_status
+        expected_status = self.be._process_file_sync_status(status)
+        self.assertEqual(self._called, ((expected_status,), {}))

=== modified file 'ubuntuone/controlpanel/utils.py'
--- ubuntuone/controlpanel/utils.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/utils.py	2010-12-22 14:37:52 +0000
@@ -20,8 +20,6 @@
 
 import os
 
-from functools import wraps
-
 import dbus
 
 from ubuntuone.controlpanel.logger import setup_logging
@@ -68,24 +66,6 @@
     return os.path.join(get_project_dir(), filename)
 
 
-def log_call(log_func):
-    """Decorator to add log info using 'log_func'."""
-
-    def middle(f):
-        """Add logging when calling 'f'."""
-
-        @wraps(f)
-        def inner(*args, **kwargs):
-            """Call f(*args, **kwargs)."""
-            log_func('%s: args %r, kwargs %r.', f.__name__, args, kwargs)
-            res = f(*args, **kwargs)
-            return res
-
-        return inner
-
-    return middle
-
-
 def is_dbus_no_reply(failure):
     """Decide if 'failure' is a DBus NoReply Error."""
     exc = failure.value

=== modified file 'ubuntuone/controlpanel/webclient.py'
--- ubuntuone/controlpanel/webclient.py	2010-12-06 12:27:11 +0000
+++ ubuntuone/controlpanel/webclient.py	2010-12-22 14:37:52 +0000
@@ -48,22 +48,24 @@
 
     def _handler(self, session, msg, d):
         """Handle the result of an http message."""
-        logger.debug("WebClient: got http response: %d", msg.status_code)
+        logger.debug("WebClient: got http response %d for uri %r",
+                     msg.status_code, msg.get_uri().to_string(False))
+        data = msg.response_body.data
         if msg.status_code == 200:
-            result = simplejson.loads(msg.response_body.data)
+            result = simplejson.loads(data)
             d.callback(result)
         else:
-            e = WebClientError(msg.status_code, msg)
+            e = WebClientError(msg.status_code, data)
             d.errback(e)
 
     def _call_api_with_creds(self, credentials, api_name):
         """Get a given url from the webservice with credentials."""
-        url = self.base_url + api_name
+        url = (self.base_url + api_name).encode('utf-8')
         method = "GET"
+        logger.debug("WebClient: getting url: %s, %s", method, url)
         msg = Soup.Message.new(method, url)
         add_oauth_headers(msg.request_headers.append, method, url, credentials)
         d = defer.Deferred()
-        logger.debug("WebClient: getting url: %s", url)
         self.session.queue_message(msg, self._handler, d)
         return d