Merge lp:~statik/ubuntu/maverick/magicicada/zero-one-two into lp:ubuntu/maverick/magicicada

[Elliot Murphy]

New upstream release of Magicicada. I've testbuilt and installed, and it upgrades and runs just fine.

=== modified file 'PKG-INFO'
--- PKG-INFO	2010-06-08 10:53:02 +0000
+++ PKG-INFO	2010-07-09 18:33:43 +0000
@@ -1,7 +1,7 @@
 Metadata-Version: 1.1
 Name: magicicada
-Version: 0.1.1
-Summary: A GTK+ frontend for the "Chicharra" part of Ubuntu One client.
+Version: 0.1.2
+Summary: A GTK+ frontend for the "Chicharra" part of Ubuntu One.
 Home-page: https://launchpad.net/magicicada
 Author: Natalia Bidart
 Author-email: [e-mail]
@@ -14,6 +14,6 @@
 Requires: pango
 Requires: twisted.internet
 Requires: twisted.trial.unittest
-Requires: ubuntuone.syncdaemon
+Requires: ubuntuone.syncdaemon.tools
 Requires: xdg.BaseDirectory
 Provides: magicicada
 
=== modified file 'README.txt'
--- README.txt	2010-06-08 10:53:02 +0000
+++ README.txt	2010-07-09 18:33:43 +0000
@@ -1,3 +1,16 @@
 This is Magicicada!
 
 A GTK+ frontend for the "Chicharra" part of Ubuntu One client.
+
+-----------
+HOWTO do a source release:
+
+ * edit setup.py and increment the version number.
+ * 'python setup.py sdist'
+ * look at the contents of the tarball created in dist/ to be sure they are ok
+ * sign the tarball by a command like:
+     gpg -a --detach-sign magicicada-0.2.tar.gz
+     this should create a file like magicicada-0.2.tar.gz.asc
+ * Upload the new release to launchpad with a command like:
+     lp-project-upload magicicada 0.2 magicicada-0.2.tar.gz
+ * Announce the release, ping someone to build updated packages for the PPA and Ubuntu.
 
=== modified file 'bin/magicicada'
--- bin/magicicada	2010-06-08 10:53:02 +0000
+++ bin/magicicada	2010-07-09 18:33:43 +0000
@@ -1,8 +1,21 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
-### BEGIN LICENSE
-# This file is in the public domain
-### END LICENSE
+#
+# Copyright 2010 Chicharreros
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Script to run Magicicada."""
 
 import sys
 import os
@@ -11,14 +24,6 @@
 from gettext import gettext as _
 gettext.textdomain('magicicada')
 
-# optional Launchpad integration
-# this shouldn't crash if not found as it is simply used for bug reporting
-try:
-    import LaunchpadIntegration
-    launchpad_available = True
-except:
-    launchpad_available = False
-
 # Add project root directory (enable symlink, and trunk execution).
 PROJECT_ROOT_DIRECTORY = os.path.abspath(
     os.path.dirname(os.path.dirname(os.path.realpath(sys.argv[0]))))
@@ -48,6 +53,5 @@
     from twisted.internet import reactor
 
     # Run the application.
-    window = MagicicadaUI(launchpad_available=launchpad_available,
-                          on_destroy=lambda *a, **kw: reactor.stop())
+    window = MagicicadaUI(on_destroy=lambda *a, **kw: reactor.stop())
     reactor.run()
 
=== added symlink 'data/media/icon.png'
=== target is u'logo-032.png'
=== added directory 'data/tests'
=== added file 'data/tests/metadata-test.txt'
=== modified file 'data/ui/gui.glade'
--- data/ui/gui.glade	2010-06-08 10:53:02 +0000
+++ data/ui/gui.glade	2010-07-09 18:33:43 +0000
@@ -257,6 +257,7 @@
             </child>
             <child>
               <object class="GtkToolButton" id="raw_metadata">
+                <property name="visible">True</property>
                 <property name="sensitive">False</property>
                 <property name="label" translatable="yes">Metadata</property>
                 <property name="use_underline">True</property>
@@ -384,7 +385,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext1"/>
                               <attributes>
-                                <attribute name="text">0</attribute>
+                                <attribute name="markup">0</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -396,7 +397,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext2"/>
                               <attributes>
-                                <attribute name="text">1</attribute>
+                                <attribute name="markup">1</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -408,7 +409,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext4"/>
                               <attributes>
-                                <attribute name="text">2</attribute>
+                                <attribute name="markup">2</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -420,7 +421,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext3"/>
                               <attributes>
-                                <attribute name="text">3</attribute>
+                                <attribute name="markup">3</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -476,7 +477,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext5"/>
                               <attributes>
-                                <attribute name="text">0</attribute>
+                                <attribute name="markup">0</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -488,7 +489,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext6"/>
                               <attributes>
-                                <attribute name="text">1</attribute>
+                                <attribute name="markup">1</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -500,7 +501,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext8"/>
                               <attributes>
-                                <attribute name="text">2</attribute>
+                                <attribute name="markup">2</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -512,7 +513,7 @@
                             <child>
                               <object class="GtkCellRendererText" id="cellrenderertext7"/>
                               <attributes>
-                                <attribute name="text">3</attribute>
+                                <attribute name="markup">3</attribute>
                               </attributes>
                             </child>
                           </object>
@@ -1051,4 +1052,65 @@
       <action-widget response="0">shares_to_others_close</action-widget>
     </action-widgets>
   </object>
+  <object class="GtkFileChooserDialog" id="file_chooser">
+    <property name="border_width">5</property>
+    <property name="type_hint">normal</property>
+    <property name="has_separator">False</property>
+    <property name="create_folders">False</property>
+    <signal name="file_activated" handler="on_file_chooser_open_clicked"/>
+    <child internal-child="vbox">
+      <object class="GtkVBox" id="dialog-vbox7">
+        <property name="visible">True</property>
+        <property name="spacing">2</property>
+        <child>
+          <placeholder/>
+        </child>
+        <child internal-child="action_area">
+          <object class="GtkHButtonBox" id="dialog-action_area7">
+            <property name="visible">True</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="file_chooser_cancel">
+                <property name="label">gtk-cancel</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="file_chooser_open">
+                <property name="label">gtk-open</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="clicked" handler="on_file_chooser_open_clicked"/>
+                <signal name="activate" handler="on_file_chooser_open_clicked"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="pack_type">end</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-6">file_chooser_cancel</action-widget>
+      <action-widget response="0">file_chooser_open</action-widget>
+    </action-widgets>
+  </object>
 </interface>
 
=== modified file 'debian/changelog'
--- debian/changelog	2010-06-08 10:53:02 +0000
+++ debian/changelog	2010-07-09 18:33:43 +0000
@@ -1,3 +1,9 @@
+magicicada (0.1.2-0ubuntu1) maverick; urgency=low
+
+  * New upstream release.
+
+ -- Elliot Murphy <[e-mail]>  Fri, 09 Jul 2010 14:14:53 -0400
+
 magicicada (0.1.1-0ubuntu1) maverick; urgency=low
 
   [ Elliot Murphy ]
 
=== modified file 'magicicada/__init__.py'
--- magicicada/__init__.py	2010-06-08 10:53:02 +0000
+++ magicicada/__init__.py	2010-07-09 18:33:43 +0000
@@ -18,33 +18,52 @@
 
 """Magicicada."""
 
-import gtk
-import sys
+import logging
+import os
 
 import gettext
-from gettext import gettext as _
+_ = gettext.gettext
 gettext.textdomain('magicicada')
 
-from twisted.internet import gtk2reactor # for gtk-2.0
+import gtk
+
+# optional Launchpad integration
+# this shouldn't crash if not found as it is simply used for bug reporting
+try:
+    import LaunchpadIntegration
+    launchpad_available = True
+except ImportError:
+    launchpad_available = False
+
+from twisted.internet import gtk2reactor  # for gtk-2.0
 gtk2reactor.install()
 
-from magicicada import syncdaemon, logger
-from magicicada.helpers import humanize_bytes, get_data_file, get_builder, NO_OP
+from magicicada import syncdaemon, logger as logger_helper
+from magicicada.helpers import humanize_bytes, get_data_file, get_builder, \
+    log, NO_OP
 
 CONTENT_QUEUE = 'content'
 META_QUEUE = 'meta'
+UBUNTU_ONE_ROOT = os.path.expanduser('~/Ubuntu One')
 
 # set up the logging for all the project
-logger.set_up()
+logger_helper.set_up()
+logger = logging.getLogger('magicicada.ui')
+console = logging.StreamHandler()
+console.setLevel(logging.DEBUG)
+#logger.addHandler(console)
+
 
 class MagicicadaUI(object):
+    """Magicicada GUI main class."""
 
-    STATUS_JOINER = " - "
+    CURRENT_ROW = '<b><span foreground="#000099">%s</span></b>'
+    STATUS_JOINER = ' - '
     STATUS = {
         'initial': _('Service is not started, click Start to continue.'),
     }
 
-    def __init__(self, launchpad_available=False, on_destroy=NO_OP,
+    def __init__(self, on_destroy=NO_OP,
                  syncdaemon_class=syncdaemon.SyncDaemon):
         """Init."""
         self.builder = get_builder('gui.glade')
@@ -66,27 +85,28 @@
         self.active_indicator = gtk.gdk.pixbuf_new_from_file(active_filename)
 
         widgets = (
-            'start', 'stop', 'connect', 'disconnect', # toolbar buttons
-            'folders', 'folders_dialog', # folders
+            'start', 'stop', 'connect', 'disconnect',  # toolbar buttons
+            'folders', 'folders_dialog',  # folders
             'folders_store', 'folders_close',
-            'shares_to_me', 'shares_to_me_dialog', # shares_to_me
+            'shares_to_me', 'shares_to_me_dialog',  # shares_to_me
             'shares_to_me_store', 'shares_to_me_close',
-            'shares_to_others', 'shares_to_others_dialog', # shares_to_others
+            'shares_to_others', 'shares_to_others_dialog',  # shares_to_others
             'shares_to_others_store', 'shares_to_others_close',
-            'is_started', 'is_connected', 'is_online', # status bar images
-            'status_label', 'status_icon', # status label and systray icon
-            'metaq_view', 'contentq_view', # queues tree views
-            'metaq_store', 'contentq_store', # queues list stores
-            'metaq_label', 'contentq_label', # queues labels
-            'raw_metadata', # raw metadata
-            'about_dialog', # dialogs
-            'main_window'
-        )
+            'raw_metadata',  # raw metadata
+            'is_started', 'is_connected', 'is_online',  # status bar images
+            'status_label', 'status_icon',  # status label and systray icon
+            'metaq_view', 'contentq_view',  # queues tree views
+            'metaq_store', 'contentq_store',  # queues list stores
+            'metaq_label', 'contentq_label',  # queues labels
+            'file_chooser', 'file_chooser_open', 'file_chooser_cancel',
+            'about_dialog', 'main_window')
+
         for widget in widgets:
             obj = self.builder.get_object(widget)
             setattr(self, widget, obj)
             assert obj is not None, '%s must not be None' % widget
 
+        self.raw_metadata_dialog = self._new_metadata_dialog()
         self.volumes = (self.folders, self.shares_to_me, self.shares_to_others)
         self.windows = (self.main_window, self.about_dialog,
                          self.folders_dialog)
@@ -97,8 +117,8 @@
         for w in self.windows:
             w.set_icon(self._icon)
 
-        about_filename = get_data_file('media', 'logo-128.png')
-        self.about_dialog.set_logo(gtk.gdk.pixbuf_new_from_file(about_filename))
+        about_fname = get_data_file('media', 'logo-128.png')
+        self.about_dialog.set_logo(gtk.gdk.pixbuf_new_from_file(about_fname))
 
         self.sd = syncdaemon_class()
         self.sd.on_started_callback = self.on_started
@@ -110,13 +130,44 @@
         self.sd.status_changed_callback = self.on_status_changed
         self.sd.content_queue_changed_callback = self.on_content_queue_changed
         self.sd.meta_queue_changed_callback = self.on_meta_queue_changed
+        self.sd.on_metadata_ready_callback = self.on_metadata_ready
 
         self.widget_is_visible = lambda w: w.get_property('visible')
         self.widget_enabled = lambda w: self.widget_is_visible(w) and \
                                         w.is_sensitive()
-
+        self.file_chooser.set_current_folder(UBUNTU_ONE_ROOT)
+        self.last_metadata_path = None
         self.update()
 
+    def _new_metadata_dialog(self):
+        """Return a new metadata dialog."""
+        dialog = gtk.Dialog(title='Raw metadata', parent=self.main_window,
+                            flags=gtk.DIALOG_NO_SEPARATOR,
+                            buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
+        dialog.set_size_request(600, 300)
+        dialog.set_position(gtk.WIN_POS_CENTER)
+        setattr(self, 'raw_metadata_dialog', dialog)
+
+        close_button = dialog.action_area.get_children()[-1]
+        close_button.connect('clicked', self.on_raw_metadata_close_clicked)
+        close_button.connect('activate', self.on_raw_metadata_close_clicked)
+        setattr(self, 'raw_metadata_close', close_button)
+
+        image = gtk.Image()
+        image.set_from_animation(self.loading_animation)
+        setattr(self, 'raw_metadata_image', image)
+
+        dialog.get_child().add(image)
+
+        text_view = gtk.TextView()
+        text_view.set_editable(False)
+        text_view.set_wrap_mode(gtk.WRAP_WORD)
+        dialog.get_child().add(text_view)
+        setattr(self, 'raw_metadata_view', text_view)
+
+        dialog.hide() # XXX to be fixed later
+        return dialog
+
     # GTK callbacks
 
     def on_main_window_destroy(self, widget, data=None):
@@ -131,7 +182,7 @@
 
     def on_about_activate(self, widget, data=None):
         """Display the about box."""
-        response = self.about_dialog.run()
+        self.about_dialog.run()
         self.about_dialog.hide()
 
     def on_start_clicked(self, widget, data=None):
@@ -144,6 +195,7 @@
         """Stop syncdaemon."""
         for v in self.volumes:
             v.set_sensitive(False)
+        self.raw_metadata.set_sensitive(False)
 
         if self.widget_enabled(self.disconnect):
             self.on_disconnect_clicked(self.disconnect)
@@ -179,13 +231,14 @@
                    item.subscribed, item.volume)
             self.folders_store.append(row)
 
-        res = self.folders_dialog.run()
+        self.folders_dialog.run()
         self.folders_dialog.hide()
 
     def on_shares_to_me_close_clicked(self, widget, data=None):
         """Close the shares_to_me dialog."""
         self.shares_to_me_dialog.response(gtk.RESPONSE_CLOSE)
 
+    @log(logger)
     def _on_shares_clicked(self, items, store, dialog):
         """List shares to the user or to others."""
         if items is None:
@@ -201,7 +254,7 @@
                    item.path, item.volume_id)
             store.append(row)
 
-        res = dialog.run()
+        dialog.run()
         dialog.hide()
 
     def on_shares_to_me_clicked(self, widget, data=None):
@@ -220,8 +273,27 @@
                                 self.shares_to_others_store,
                                 self.shares_to_others_dialog)
 
+    def on_file_chooser_open_clicked(self, widget, data=None):
+        """Close the file_chooser dialog."""
+        self.file_chooser.response(gtk.FILE_CHOOSER_ACTION_OPEN)
+
+    def on_raw_metadata_close_clicked(self, widget, data=None):
+        """Close the raw_metadata dialog."""
+        self.raw_metadata_dialog.hide()
+
     def on_raw_metadata_clicked(self, widget, data=None):
         """Show raw metadata for a path choosen by the user."""
+        res = self.file_chooser.run()
+        self.file_chooser.hide()
+        if res != gtk.FILE_CHOOSER_ACTION_OPEN:
+            return
+
+        self.last_metadata_path = self.file_chooser.get_filename()
+        self.sd.get_metadata(path=self.last_metadata_path)
+        self.raw_metadata_view.hide()
+        self.raw_metadata_image.show()
+        self._start_loading(self.raw_metadata_image)
+        self.raw_metadata_dialog.show()
 
     def on_status_icon_activate(self, widget, data=None):
         """Systray icon was clicked."""
@@ -242,6 +314,7 @@
 
         for v in self.volumes:
             v.set_sensitive(True)
+        self.raw_metadata.set_sensitive(True)
 
         self._update_queues_and_status(self.sd.current_state)
 
@@ -285,6 +358,7 @@
         """Callback'ed when syncadaemon is offline."""
         self._activate_indicator(self.is_online, sensitive=False)
 
+    @log(logger)
     def on_status_changed(self, name=None, description=None,
                           is_error=False, is_connected=True, is_online=True,
                           queues=None, connection=None):
@@ -295,17 +369,22 @@
             text = self.STATUS['initial']
         self.status_label.set_text(text)
 
-    def _on_queue_changed(self, queue_name, items, *args, **kwargs):
+    @log(logger)
+    def _on_queue_changed(self, queue_name, items, must_highlight):
         """Callback'ed when a queue changed."""
         if items is None:
             items = []
 
+        markup = lambda value: self.CURRENT_ROW % value \
+                 if must_highlight and value is not None else value
         queue_label = getattr(self, '%sq_label' % queue_name)
         queue_view = getattr(self, '%sq_view' % queue_name)
         queue_store = getattr(self, '%sq_store' % queue_name)
         queue_store.clear()
-        for item in items:
+        for i, item in enumerate(items):
             row = (item.operation, item.path, item.share, item.node)
+            if i == 0:
+                row = map(markup, row)
             queue_store.append(row)
 
         items_len = len(items)
@@ -317,11 +396,27 @@
 
     def on_content_queue_changed(self, items, *args, **kwargs):
         """Callback'ed when syncadaemon's content queue changed."""
-        self._on_queue_changed(CONTENT_QUEUE, items, args, kwargs)
+        state = self.sd.current_state
+        highlight = state.processing_content and state.is_online
+        self._on_queue_changed(CONTENT_QUEUE, items, highlight)
 
     def on_meta_queue_changed(self, items, *args, **kwargs):
         """Callback'ed when syncadaemon's meta queue changed."""
-        self._on_queue_changed(META_QUEUE, items, args, kwargs)
+        state = self.sd.current_state
+        highlight = state.processing_meta and state.is_online
+        self._on_queue_changed(META_QUEUE, items, highlight)
+
+    @log(logger)
+    def on_metadata_ready(self, path, metadata):
+        """Lower layer has the requested metadata for 'path'."""
+        logger.debug('on_metadata_ready: path: %r, last_metadata_path: %r',
+                     path, self.last_metadata_path)
+        if path != self.last_metadata_path:
+            return
+        self.raw_metadata_image.hide()
+        self.raw_metadata_view.show()
+        text = '\n'.join('%s: %s' % i for i in metadata.iteritems())
+        self.raw_metadata_view.get_buffer().set_text(text)
 
     # custom
 
@@ -340,7 +435,8 @@
         self.on_meta_queue_changed(self.sd.meta_queue)
         self.on_content_queue_changed(self.sd.content_queue)
         self.on_status_changed(name=state.name, description=state.description,
-                               queues=state.queues, connection=state.connection)
+                               queues=state.queues,
+                               connection=state.connection)
 
     def update(self):
         """Update UI based on SD current state."""
 
=== removed file 'magicicada/cmd_pof.py'
--- magicicada/cmd_pof.py	2010-06-08 10:53:02 +0000
+++ magicicada/cmd_pof.py	1970-01-01 00:00:00 +0000
@@ -1,190 +0,0 @@
-# DISCLAIMER: this is a proof of concept, we need tests for this!
-# Author: Facundo Batista
-
-# this always first
-from twisted.internet import glib2reactor
-glib2reactor.install()
-
-import functools
-import re
-import time
-
-import dbus
-from dbus.mainloop.glib import DBusGMainLoop
-from twisted.internet import reactor
-
-from ubuntuone.syncdaemon import tools
-
-# main connected stuff
-loop = DBusGMainLoop(set_as_default=True)
-bus = dbus.SessionBus(mainloop=loop)
-sync_daemon_tool = tools.SyncDaemonTool(bus)
-
-DATE_FMT = "%Y-%m-%d"
-TIME_FMT = "%H:%M:%S"
-
-RE_OP_LISTDIR = re.compile("ListDir\(share_id=(.*?), node_id=(.*?), .*")
-RE_OP_UNLINK = re.compile("Unlink\(share_id=(.*?), node_id=(.*?), .*")
-RE_OP_MAKEFILE = re.compile(
-                "MakeFile\(share_id=(.*?), parent_id=(.*?), name=(.*?), .*")
-
-class DBusHandler(object):
-    def __init__(self):
-        # status changed
-        bus.add_signal_receiver(self.on_status_changed,
-                            dbus_interface='com.ubuntuone.SyncDaemon.Status',
-                            signal_name='StatusChanged')
-        # content queue changed
-        bus.add_signal_receiver(self.on_CQ_changed,
-                            dbus_interface='com.ubuntuone.SyncDaemon.Status',
-                            signal_name='ContentQueueChanged')
-
-        # upload or download
-        for s in ('DownloadStarted', 'DownloadFinished',
-                  'UploadStarted', 'UploadFinished'):
-            bus.add_signal_receiver(functools.partial(self.on_updown_activ, s),
-                                    signal_name=s)
-
-        # get the first one
-        d = sync_daemon_tool.get_status()
-        d.addCallback(self.on_status_changed)
-
-        self._date = None
-        self._last_CQ_data = None
-        self._last_MQ_data = None
-        self._state = None
-        self._mqcaller = None
-
-    def on_updown_activ(self, signal, *data):
-        """Upload or download activity."""
-        path = data[0]
-        if signal in ('UploadStarted', 'DownloadStarted'):
-            self._show("{0}: {1}".format(signal, path))
-        else:
-            self._show("{0}: {1}".format(signal, path))
-
-    def on_CQ_changed(self, data):
-        """Content Queue changed, update it."""
-        def show_cq(data):
-            """Show the CONTENT queue."""
-            if data == self._last_CQ_data:
-                return
-
-            # it changed!
-            self._last_CQ_data = data
-            self._show("Content Queue:")
-            if data:
-                for d in data:
-                    print "           ", self._format_CQ_data(d)
-            else:
-                print "           (empty)"
-
-        d = sync_daemon_tool.waiting_content()
-        d.addCallback(show_cq)
-
-    def _show(self, message):
-        date = time.strftime(DATE_FMT)
-        if date !=  self._date:
-            self._date = date
-            print "-- {0} --".format(self._date)
-
-        now = time.strftime(TIME_FMT)
-        print "{0}  {1}".format(now, message)
-
-    def _format_MQ_data(self, data):
-        """Format the meta queue information."""
-        if data.startswith("ListDir"):
-            m = RE_OP_LISTDIR.match(data)
-            if not m:
-                m = "Got a ListDir, but failed to match: %r" % (data,)
-                raise ValueError(m)
-            share_id, node_id = m.groups()
-            name = self._find_out_path(share_id, node_id)
-            return "ListDir: {0}  ({1}:{2})".format(name, share_id, node_id)
-
-        if data.startswith("Unlink"):
-            m = RE_OP_UNLINK.match(data)
-            if not m:
-                m = "Got an Unlink, but failed to match: %r" % (data,)
-                raise ValueError(m)
-            share_id, node_id = m.groups()
-            name = self._find_out_path(share_id, node_id)
-            return "Unlink: {0}  ({1}:{2})".format(name, share_id, node_id)
-
-        if data.startswith("MakeFile"):
-            m = RE_OP_MAKEFILE.match(data)
-            if not m:
-                m = "Got a Makefile, but failed to match: %r" % (data,)
-                raise ValueError(m)
-            share_id, parent_id, name = m.groups()
-            parent = self._find_out_path(share_id, parent_id)
-            return "MakeFile: {0}  (in {1})".format(name, parent)
-
-        # these operations are very simple
-        if data in ('GetPublicFiles', 'AccountInquiry', 'FreeSpaceInquiry',
-                    'ListVolumes', 'ListShares'):
-            return data
-
-        return "Op? {0}".format(data)
-
-    def _format_CQ_data(self, data):
-        """Format the content queue information."""
-        return "{operation}: {path}  ({share}:{node})".format(**data)
-
-    def _find_out_path(self, share_id, node_id):
-        """Curse the destiny!"""
-        return "?"
-
-    def on_status_changed(self, state):
-        """Show the state nicely."""
-        self._state = state
-        if state["is_error"]:
-            print "State: Error!"
-            return
-
-        # normal
-        self._show("State: {name}   Q: {queues}   C: {connection}".format(
-                                                                    **state))
-        self._check_MQ()
-
-    def _check_MQ(self):
-        """Check MQ if we should."""
-        # check if we have something to show in MQ!
-        if self._state['name'] != 'QUEUE_MANAGER' or self._state['queues'] \
-                            not in ('WORKING_ON_METADATA', 'WORKING_ON_BOTH'):
-            return
-
-        # we have a previous call later running?
-        if self._mqcaller is not None and self._mqcaller.active():
-            self._mqcaller.cancel()
-
-        def show_mq(data):
-            """Show the META queue."""
-            if data == self._last_MQ_data:
-                return
-
-            # it changed!
-            self._last_MQ_data = data
-            self._show("Meta Queue:")
-            if data:
-                for d in data:
-                    print "           ", self._format_MQ_data(d)
-            else:
-                print "           (empty)"
-
-        d = sync_daemon_tool.waiting_metadata()
-        d.addCallback(show_mq)
-
-        self._mqcaller = reactor.callLater(1, self._check_MQ)
-
-def main():
-    print "Check if it's running..."
-    if not tools.is_running():
-        print "ERROR: SD is not running!"
-        reactor.stop()
-
-    sh = DBusHandler()
-
-if __name__ == "__main__":
-    reactor.callWhenRunning(main)
-    reactor.run()
 
=== modified file 'magicicada/dbusiface.py'
--- magicicada/dbusiface.py	2010-06-08 10:53:02 +0000
+++ magicicada/dbusiface.py	2010-07-09 18:33:43 +0000
@@ -32,6 +32,8 @@
 # log!
 logger = logging.getLogger('magicicada.dbusiface')
 
+# we use here camel case names, because this variables are used later as
+# classes, so pylint: disable-msg=C0103
 QueueData = collections.namedtuple('QueueData', 'operation path share node')
 FolderData = collections.namedtuple('FolderData',
                                 'node path suggested_path subscribed volume')
@@ -50,14 +52,23 @@
                 "(Move)\(share_id=(.*?), node_id=(.*?), old_parent_id=(.*?), "
                 "new_parent_id=(.*?), new_name=(.*?)\)")
 
+# DBus exceptions store the type inside, as a string :|
+DBUSERR_NOREPLY = 'org.freedesktop.DBus.Error.NoReply'
+DBUSERR_NAMENOOWNER = 'org.freedesktop.DBus.Error.NameHasNoOwner'
+DBUSERR_PYKEYERROR = 'org.freedesktop.DBus.Python.KeyError'
+
+# some constants
+NOT_SYNCHED_PATH = "Not a valid path!"
+
 
 def _is_retry_exception(err):
     """Check if the exception is a retry one."""
     if isinstance(err, dbus.exceptions.DBusException):
-        if err.get_dbus_name() == 'org.freedesktop.DBus.Error.NoReply':
+        if err.get_dbus_name() == DBUSERR_NOREPLY:
             return True
     return False
 
+
 def retryable(func):
     """Call the function until its deferred succeed (max 5 times)."""
 
@@ -68,7 +79,7 @@
         while opportunities:
             try:
                 res = yield func(*a, **k)
-            except Exception, err:
+            except Exception, err:  # pylint: disable-msg=W0703
                 opportunities -= 1
                 if opportunities == 0 or not _is_retry_exception(err):
                     raise
@@ -99,6 +110,8 @@
             (self._on_name_owner_changed, None, 'NameOwnerChanged'),
             (self._on_folder_created, 'Folders', 'FolderCreated'),
             (self._on_folder_deleted, 'Folders', 'FolderDeleted'),
+            (self._on_folder_subscribed, 'Folders', 'FolderSubscribed'),
+            (self._on_folder_unsubscribed, 'Folders', 'FolderUnSubscribed'),
             (self._on_share_created, 'Shares', 'ShareCreated'),
             (self._on_share_deleted, 'Shares', 'ShareDeleted'),
             (self._on_share_changed, 'Shares', 'ShareChanged'),
@@ -114,7 +127,6 @@
                                             signal_name=signal_name)
             self._dbus_matches.append((match, dbus_interface, signal_name))
 
-
     def shutdown(self):
         """Shut down the SyncDaemon."""
         logger.info("DBus interface going down")
@@ -180,6 +192,16 @@
         logger.info("Received Folder deleted")
         self.msd.on_sd_folders_changed()
 
+    def _on_folder_subscribed(self, _):
+        """Call the SD callback."""
+        logger.info("Received Folder subscribed")
+        self.msd.on_sd_folders_changed()
+
+    def _on_folder_unsubscribed(self, _):
+        """Call the SD callback."""
+        logger.info("Received Folder unsubscribed")
+        self.msd.on_sd_folders_changed()
+
     def _on_share_created(self, _):
         """Call the SD callback."""
         logger.info("Received Share created")
@@ -198,6 +220,7 @@
     @retryable
     def get_content_queue(self):
         """Get the content queue from SDT."""
+
         def process(data):
             """Enhance data format."""
             logger.info("Processing Content Queue items (%d)", len(data))
@@ -217,31 +240,32 @@
     def _parse_mq(self, data):
         """Parse MetaQueue string to extract its data."""
         if data in ('AccountInquiry', 'FreeSpaceInquiry', 'GetPublicFiles',
-                    'ListShares', 'ListVolumes', 'Query'):
+                    'ListShares', 'ListVolumes', 'Query',
+                    'ChangePublicAccess', 'AnswerShare'):
             return QueueData(operation=data, path=None, node=None, share=None)
 
         m = RE_OP_LISTDIR.match(data)
         if m:
             op, share, node = m.groups()
-            path = '?' # we should get the real path, no API now
+            path = '?'  # we should get the real path, no API now
             return QueueData(operation=op, path=path, node=node, share=share)
 
         m = RE_OP_MAKEFILE.match(data)
         if m:
             op, share, parent, name = m.groups()
-            path = '/?.../' + name # we should get the real path, no API now
+            path = '/?.../' + name  # we should get the real path, no API now
             return QueueData(operation=op, path=path, node=None, share=share)
 
         m = RE_OP_MAKEDIR.match(data)
         if m:
             op, share, parent, name = m.groups()
-            path = '/?.../' + name # we should get the real path, no API now
+            path = '/?.../' + name  # we should get the real path, no API now
             return QueueData(operation=op, path=path, node=None, share=share)
 
         m = RE_OP_UNLINK.match(data)
         if m:
             op, share, node, = m.groups()
-            path = '?' # we should get the real path, no API now
+            path = '?'  # we should get the real path, no API now
             return QueueData(operation=op, path=path, node=node, share=share)
 
         m = RE_OP_MOVE.match(data)
@@ -262,6 +286,7 @@
     @retryable
     def get_meta_queue(self):
         """Get the meta queue from SDT."""
+
         def process(data):
             """Enhance data format."""
             logger.info("Processing Meta Queue items (%d)", len(data))
@@ -280,6 +305,7 @@
     @retryable
     def get_folders(self):
         """Get the folders info from SDT."""
+
         def process(data):
             """Enhance data format."""
             logger.info("Processing Folders items (%d)", len(data))
@@ -323,8 +349,7 @@
         try:
             self._bus.get_name_owner('com.ubuntuone.SyncDaemon')
         except dbus.exceptions.DBusException, err:
-            if err.get_dbus_name() != \
-                                'org.freedesktop.DBus.Error.NameHasNoOwner':
+            if err.get_dbus_name() != DBUSERR_NAMENOOWNER:
                 raise
             started = False
         else:
@@ -359,6 +384,7 @@
     @retryable
     def get_shares_to_me(self):
         """Get the shares to me ('shares') info from SDT."""
+
         def process(data):
             """Enhance data format."""
             logger.info("Processing Shares To Me items (%d)", len(data))
@@ -372,6 +398,7 @@
     @retryable
     def get_shares_to_others(self):
         """Get the shares to others ('shared') info from SDT."""
+
         def process(data):
             """Enhance data format."""
             logger.info("Processing Shares To Others items (%d)", len(data))
@@ -381,3 +408,24 @@
         d = self.sync_daemon_tool.list_shared()
         d.addCallback(process)
         return d
+
+    @retryable
+    def get_metadata(self, path):
+        """Return the raw metadata."""
+        logger.info("Getting metadata for %r", path)
+
+        def fix_failure(failure):
+            """Get the failure and return a nice message."""
+            if failure.check(dbus.exceptions.DBusException):
+                if failure.value.get_dbus_name() == DBUSERR_PYKEYERROR:
+                    return NOT_SYNCHED_PATH
+            return failure
+
+        def process(metadata):
+            """Process the metadata."""
+            logger.debug("Got metadata for path %r: %r", path, metadata)
+            return dict(metadata)
+
+        d = self.sync_daemon_tool.get_metadata(path)
+        d.addCallbacks(process, fix_failure)
+        return d
 
=== modified file 'magicicada/helpers.py'
--- magicicada/helpers.py	2010-06-08 10:53:02 +0000
+++ magicicada/helpers.py	2010-07-09 18:33:43 +0000
@@ -13,18 +13,15 @@
 
 import gtk
 import os
-import sys
 
 from functools import wraps
 
 from magicicada.magicicadaconfig import get_data_file
 
-import gettext
-from gettext import gettext as _
-gettext.textdomain('magicicada')
 
 NO_OP = lambda *a, **kw: None
 
+
 def get_builder(builder_file_name):
     """Return a fully-instantiated gtk.Builder instance from specified ui file.
 
@@ -41,21 +38,37 @@
     builder.add_from_file(ui_filename)
     return builder
 
-def print_debug(f):
-    """Print debug info for 'f'."""
-
-    @wraps(f)
-    def inner(*args, **kwargs):
-        """Wrap f."""
-        sys.stderr.write('Calling %s %s %s\n' % (f.__name__, args, kwargs))
-        result = f(*args, **kwargs)
-        return result
-
-    return inner
-
-# from 
-# http://code.activestate.com/recipes/577081-humanized-representation-of-a-number-of-bytes/
-def humanize_bytes(bytes, precision=1):
+
+def log(logger):
+    """Log input/ouput info for 'f' using 'logger'."""
+
+    def decorator(f):
+        """The decorator per se."""
+
+        @wraps(f)
+        def inner(*args, **kwargs):
+            """Wrap 'f', log input args and result using 'logger'."""
+            name = f.__name__
+            result = None
+            logger.debug("Calling '%s' with args '%s' and kwargs '%s'.",
+                         name, args, kwargs)
+            try:
+                result = f(*args, **kwargs)
+            except Exception:  # pylint: disable-msg=W0703
+                logger.exception('%s failed with exception:', name)
+            logger.debug("Returning from '%s' with result '%s'.", name, result)
+            return result
+
+        return inner
+
+    return decorator
+
+
+# from http://code.activestate.com/recipes/
+#                       577081-humanized-representation-of-a-number-of-bytes/
+
+
+def humanize_bytes(numbytes, precision=1):
     """Return a humanized string representation of a number of bytes.
 
     Assumes `from __future__ import division`.
@@ -83,11 +96,12 @@
         (1<<30L, 'GB'),
         (1<<20L, 'MB'),
         (1<<10L, 'kB'),
-        (1, 'bytes')
-    )
-    if bytes == 1:
+        (1, 'bytes'))
+
+    if numbytes == 1:
         return '1 byte'
     for factor, suffix in abbrevs:
-        if bytes >= factor:
+        if numbytes >= factor:
             break
-    return '%.*f %s' % (precision, bytes / factor, suffix)
+    # pylint: disable-msg=W0631
+    return '%.*f %s' % (precision, numbytes / factor, suffix)
 
=== modified file 'magicicada/logger.py'
--- magicicada/logger.py	2010-06-08 10:53:02 +0000
+++ magicicada/logger.py	2010-07-09 18:33:43 +0000
@@ -53,4 +53,3 @@
                                   '%Y-%m-%d %H:%M:%S')
     handler.setFormatter(formatter)
     logger.setLevel(logging.DEBUG)
-
 
=== modified file 'magicicada/magicicadaconfig.py'
--- magicicada/magicicadaconfig.py	2010-06-08 10:53:02 +0000
+++ magicicada/magicicadaconfig.py	2010-07-09 18:33:43 +0000
@@ -3,13 +3,15 @@
 # This file is in the public domain
 ### END LICENSE
 
+"""Magicicada configuration file."""
+
 # THIS IS Magicicada CONFIGURATION FILE
 # YOU CAN PUT THERE SOME GLOBAL VALUE
 # Do not touch unless you know what you're doing.
 # you're warned :)
 
 __all__ = [
-    'project_path_not_found',
+    'ProjectPathNotFound',
     'get_data_file',
     'get_data_path',
     ]
@@ -21,11 +23,8 @@
 
 import os
 
-import gettext
-from gettext import gettext as _
-gettext.textdomain('magicicada')
 
-class project_path_not_found(Exception):
+class ProjectPathNotFound(Exception):
     """Raised when we can't find the project directory."""
 
 
@@ -53,6 +52,6 @@
 
     abs_data_path = os.path.abspath(path)
     if not os.path.exists(abs_data_path):
-        raise project_path_not_found
+        raise ProjectPathNotFound
 
     return abs_data_path
 
=== modified file 'magicicada/syncdaemon.py'
--- magicicada/syncdaemon.py	2010-06-08 10:53:02 +0000
+++ magicicada/syncdaemon.py	2010-07-09 18:33:43 +0000
@@ -25,14 +25,19 @@
 from magicicada.dbusiface import DBusInterface
 from magicicada.helpers import NO_OP
 
+
 # log!
 logger = logging.getLogger('magicicada.syncdaemon')
 
 
 class State(object):
     """Hold the state of SD."""
-    _attrs =  ['name', 'description', 'is_error', 'is_connected',
-               'is_online', 'queues', 'connection', 'is_started']
+
+    _attrs = ['name', 'description', 'is_error', 'is_connected',
+              'is_online', 'queues', 'connection', 'is_started']
+
+    _meta = ('WORKING_ON_METADATA', 'WORKING_ON_BOTH')
+    _content = ('WORKING_ON_CONTENT', 'WORKING_ON_BOTH')
 
     def __init__(self):
         # starting defaults
@@ -47,12 +52,16 @@
 
     def __getattribute__(self, name):
         """Return the value if there."""
-        if name[0] == "_":
+        if name[0] == "_" or name == 'set':
             return object.__getattribute__(self, name)
+        elif name == 'processing_meta':
+            return self.__dict__['queues'] in self._meta
+        elif name == 'processing_content':
+            return self.__dict__['queues'] in self._content
         else:
             return self.__dict__[name]
 
-    def _set(self, **data):
+    def set(self, **data):
         """Set the attributes from data, if allowed."""
         for name, value in data.iteritems():
             if name not in self._attrs:
@@ -97,6 +106,7 @@
         self.on_folders_changed_callback = NO_OP
         self.on_shares_to_me_changed_callback = NO_OP
         self.on_shares_to_others_changed_callback = NO_OP
+        self.on_metadata_ready_callback = None  # mandatory
 
         # mq needs to be polled to know progress
         self._mqcaller = None
@@ -104,11 +114,10 @@
 
         # load initial data if ubuntuone-client already started
         if self.dbus.is_sd_started():
-            self.current_state._set(is_started=True)
+            self.current_state.set(is_started=True)
             self._get_initial_data()
         else:
-            self.current_state._set(is_started=False)
-
+            self.current_state.set(is_started=False)
 
     def shutdown(self):
         """Shut down the SyncDaemon."""
@@ -165,14 +174,14 @@
     def on_sd_name_owner_changed(self, now_active):
         """SyncDaemon name owner changed."""
         logger.info("SD Name Owner changed: %s", now_active)
-        self.current_state._set(is_started=now_active)
+        self.current_state.set(is_started=now_active)
 
         def set_status(name, description):
             """Set status after the name owner change."""
             d = dict(name=name, description=description, is_error=False,
                      is_connected=False, is_online=False, queues='',
                      connection='')
-            self.current_state._set(**d)
+            self.current_state.set(**d)
 
         if now_active:
             set_status('STARTED', 'ubuntuone-client just started')
@@ -189,6 +198,7 @@
 
     def _send_status_changed(self, name, description, is_error, is_connected,
                              is_online, queues, connection):
+        """Send status changed signal."""
         logger.debug("    new status: name=%r, description=%r, is_error=%s, "
                      "is_connected=%s, is_online=%s, queues=%r, connection=%r",
                      name, description, is_error, is_connected, is_online,
@@ -205,7 +215,7 @@
             self.on_offline_callback()
 
         # set current state to new values and call status changed cb
-        self.current_state._set(name=name, description=description,
+        self.current_state.set(name=name, description=description,
                                 is_error=is_error, is_connected=is_connected,
                                 is_online=is_online, queues=queues,
                                 connection=connection)
@@ -213,7 +223,8 @@
                                      is_online, queues, connection)
 
         # if corresponds, supervise MQ
-        self._check_mq()
+        if self._mqcaller is None:
+            self._check_mq()
 
     @defer.inlineCallbacks
     def on_sd_content_queue_changed(self):
@@ -226,27 +237,30 @@
             self.content_queue_changed_callback(new_cq)
 
     @defer.inlineCallbacks
+    def _get_mq_data(self):
+        """Get MQ info and call back if needed."""
+        new_mq = yield self.dbus.get_meta_queue()
+        if new_mq != self.meta_queue:
+            logger.info("SD Meta Queue changed: %d items", len(new_mq))
+            self.meta_queue = new_mq
+            self.meta_queue_changed_callback(new_mq)
+
     def _check_mq(self):
         """Check MQ if we should."""
-        state = self.current_state
-        if state.queues not in ('WORKING_ON_METADATA', 'WORKING_ON_BOTH'):
-            logger.info("Check MQ called but States not in MQ")
+        # cancel previous (if any) and check again later
+        if self._mqcaller is not None and self._mqcaller.active():
+            self._mqcaller.cancel()
+
+        if not self.current_state.processing_meta:
+            logger.info("Check MQ called, States not in MQ, call a last time")
+            self._mqcaller = None
+            self._get_mq_data()
         else:
             logger.info("Asking for MQ information")
 
-            # have we a previous call later still running?
-            if self._mqcaller is not None and self._mqcaller.active():
-                self._mqcaller.cancel()
-
             # get the info
-            new_mq = yield self.dbus.get_meta_queue()
-
-            if new_mq != self.meta_queue:
-                logger.info("SD Meta Queue changed: %d items", len(new_mq))
-                self.meta_queue = new_mq
-                self.meta_queue_changed_callback(new_mq)
-
-            # check again later
+            self._get_mq_data()
+
             self._mqcaller = reactor.callLater(self._mq_poll_time,
                                                self._check_mq)
 
@@ -270,3 +284,11 @@
         """Tell the SyncDaemon that the user wants it to disconnect."""
         logger.info("Telling u1.SD to disconnect")
         self.dbus.disconnect()
+
+    def get_metadata(self, path):
+        """Get the metadata for given path."""
+        if self.on_metadata_ready_callback is None:
+            raise ValueError("Missing the mandatory cback for get_metadata.")
+
+        d = self.dbus.get_metadata(path)
+        d.addCallback(lambda resp: self.on_metadata_ready_callback(path, resp))
 
=== modified file 'magicicada/tests/helpers.py'
--- magicicada/tests/helpers.py	2010-06-08 10:53:02 +0000
+++ magicicada/tests/helpers.py	2010-07-09 18:33:43 +0000
@@ -36,14 +36,18 @@
     def check(self, level, msg):
         """Check that something is logged."""
         for rec in self.records:
-            if rec.levelname == level and rec.message == msg:
+            if rec.levelname == level and str(msg) in rec.message:
                 return True
         return False
 
-    def check_inf(self, msg):
+    def check_error(self, msg):
+        """Shortcut for ERROR check."""
+        return self.check('ERROR', msg)
+
+    def check_info(self, msg):
         """Shortcut for INFO check."""
         return self.check('INFO', msg)
 
-    def check_dbg(self, msg):
+    def check_debug(self, msg):
         """Shortcut for DEBUG check."""
         return self.check('DEBUG', msg)
 
=== modified file 'magicicada/tests/test_dbusiface.py'
--- magicicada/tests/test_dbusiface.py	2010-06-08 10:53:02 +0000
+++ magicicada/tests/test_dbusiface.py	2010-07-09 18:33:43 +0000
@@ -28,8 +28,13 @@
 from magicicada.tests.helpers import MementoHandler
 
 
+# It's ok to access private data in the test suite
+# pylint: disable-msg=W0212
+
+
 class FakeSessionBus(object):
     """Fake Session Bus."""
+
     def __init__(self, **kwargs):
         self._callbacks = {}
         self.fake_name_owner = "foo"
@@ -43,8 +48,12 @@
         del self._callbacks[(dbus_interface, signal_name)]
 
     def get_name_owner(self, name):
-        """Fakes the response of the method."""
+        """Fake the response of the method."""
         assert name == 'com.ubuntuone.SyncDaemon'
+
+        # will return a string, or raise an exception instance, never
+        # raise a string
+        # pylint: disable-msg=W0701
         if isinstance(self.fake_name_owner, str):
             return self.fake_name_owner
         else:
@@ -53,6 +62,7 @@
 
 class CallLoguer(object):
     """Class that logs the methods called."""
+
     def __init__(self):
         self._called_method = None, ()
         self._fake_response = None
@@ -62,19 +72,25 @@
         if name[0] == "_":
             return object.__getattribute__(self, name)
         else:
+
             def f(*args):
+                """Fake function."""
                 setattr(self, "_called_method", (name, args))
                 if self._fake_response is None:
                     # no hurt in returning a deferred, it may be needed
                     return defer.Deferred()
                 methname, response = self._fake_response
                 assert methname == name
-                return response
+                if isinstance(response, Exception):
+                    return defer.fail(response)
+                else:
+                    return defer.succeed(response)
             return f
 
 
 class FakeSDTool(CallLoguer):
     """Fake real SyncDaemonTool."""
+
     def __init__(self, _):
         CallLoguer.__init__(self)
 
@@ -104,9 +120,9 @@
         return called_args
 
     def fake_sdt_response(self, method_name, response):
-        """Fakes SDT answer in deferred mode."""
-        self.dbus.sync_daemon_tool._fake_response = (method_name,
-                                                     defer.succeed(response))
+        """Fake SDT answer in deferred mode."""
+        self.dbus.sync_daemon_tool._fake_response = (method_name, response)
+
 
 class TestSignalHooking(SafeTests):
     """Signal hooking tests.
@@ -114,6 +130,7 @@
     We can not check if the methods are really called, because DBus holds the
     method object itself, so no chance in monkeypatching.
     """
+
     def _get_hooked(self, iface, signal):
         """Return the hooked method if any."""
         if iface is None:
@@ -152,6 +169,16 @@
         self.assertEqual(self._get_hooked('Folders', 'FolderDeleted'),
                          self.dbus._on_folder_deleted)
 
+    def test_folder_subscribed_changed(self):
+        """Test folder subscribed changed callback."""
+        self.assertEqual(self._get_hooked('Folders', 'FolderSubscribed'),
+                         self.dbus._on_folder_subscribed)
+
+    def test_folder_unsubscribed_changed(self):
+        """Test folder unsubscribed changed callback."""
+        self.assertEqual(self._get_hooked('Folders', 'FolderUnSubscribed'),
+                         self.dbus._on_folder_unsubscribed)
+
     def test_share_created(self):
         """Test share created callback."""
         self.assertEqual(self._get_hooked('Shares', 'ShareCreated'),
@@ -188,7 +215,7 @@
 
 
 class TestDataProcessingStatus(SafeTests):
-    """Processes Status before sending it to SyncDaemon."""
+    """Process Status before sending it to SyncDaemon."""
 
     @defer.inlineCallbacks
     def test_get_status(self):
@@ -224,7 +251,7 @@
 
 
 class TestDataProcessingNameOwner(SafeTests):
-    """Processes Name Owner data before sending it to SyncDaemon."""
+    """Process Name Owner data before sending it to SyncDaemon."""
 
     def test_name_owner_changed_no_syncdaemon(self):
         """Test name owner changed callback."""
@@ -245,7 +272,7 @@
 
 
 class TestDataProcessingCQ(SafeTests):
-    """Processes CQ data before sending it to SyncDaemon."""
+    """Process CQ data before sending it to SyncDaemon."""
 
     @defer.inlineCallbacks
     def test_nodata(self):
@@ -288,7 +315,7 @@
 
 
 class TestDataProcessingMQ(SafeTests):
-    """Processes MQ data before sending it to SyncDaemon."""
+    """Process MQ data before sending it to SyncDaemon."""
 
     @defer.inlineCallbacks
     def test_nodata(self):
@@ -461,9 +488,33 @@
         self.assertEqual(data.share, 'a')
         self.assertEqual(data.node, 'b')
 
+    @defer.inlineCallbacks
+    def test_ChangePublicAccess(self):
+        """Test meta with ChangePublicAccess."""
+        cmd = 'ChangePublicAccess'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'ChangePublicAccess')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
+    @defer.inlineCallbacks
+    def test_AnswerShare(self):
+        """Test meta with AnswerShare."""
+        cmd = 'AnswerShare'
+        self.fake_sdt_response('waiting_metadata', [cmd])
+        rcv = yield self.dbus.get_meta_queue()
+        data = rcv[0]
+        self.assertEqual(data.operation, 'AnswerShare')
+        self.assertEqual(data.path, None)
+        self.assertEqual(data.share, None)
+        self.assertEqual(data.node, None)
+
 
 class TestDataProcessingFolders(SafeTests):
-    """Processes Folders data before sending it to SyncDaemon."""
+    """Process Folders data before sending it to SyncDaemon."""
 
     @defer.inlineCallbacks
     def test_nodata(self):
@@ -520,10 +571,40 @@
         self.dbus._on_folder_deleted(None)
         self.get_msd_called("on_sd_folders_changed")
 
+    def test_folders_changed_from_subscribed(self):
+        """Test folders changed callback from subscribed."""
+        self.dbus._on_folder_subscribed(None)
+        self.get_msd_called("on_sd_folders_changed")
+
+    def test_folders_changed_from_unsubscribed(self):
+        """Test folders changed callback from unsubscribed."""
+        self.dbus._on_folder_unsubscribed(None)
+        self.get_msd_called("on_sd_folders_changed")
+
+
+class TestDataProcessingMetadata(SafeTests):
+    """Process Metadata data before sending it to SyncDaemon."""
+
+    @defer.inlineCallbacks
+    def test_info_ok(self):
+        """Test get metadata and see response."""
+        md = dbus.Dictionary({'a': 3, 'c': 4}, signature=dbus.Signature('ss'))
+        self.fake_sdt_response('get_metadata', md)
+        rcv = yield self.dbus.get_metadata('path')
+        self.assertEqual(rcv, dict(a=3, c=4))
+
+    @defer.inlineCallbacks
+    def test_info_bad(self):
+        """Test get metadata and get the error."""
+        exc = dbus.exceptions.DBusException(
+                                name='org.freedesktop.DBus.Python.KeyError')
+        self.fake_sdt_response('get_metadata', exc)
+        rcv = yield self.dbus.get_metadata('not a real path')
+        self.assertEqual(rcv, dbusiface.NOT_SYNCHED_PATH)
 
 
 class TestDataProcessingShares(SafeTests):
-    """Processes Shares data before sending it to SyncDaemon."""
+    """Process Shares data before sending it to SyncDaemon."""
 
     @defer.inlineCallbacks
     def test_sharestome_nodata(self):
@@ -693,68 +774,74 @@
 
     def test_instancing(self):
         """Just logged SD instancing."""
-        self.assertTrue(self.handler.check_inf("DBus interface starting"))
+        self.assertTrue(self.handler.check_info("DBus interface starting"))
 
     def test_shutdown(self):
         """Log when SD shutdowns."""
         self.dbus.shutdown()
-        self.assertTrue(self.handler.check_inf("DBus interface going down"))
+        self.assertTrue(self.handler.check_info("DBus interface going down"))
 
     def test_waiting_content(self):
         """Test call to waiting content."""
         self.dbus.get_content_queue()
-        self.assertTrue(self.handler.check_inf("Getting content queue"))
+        self.assertTrue(self.handler.check_info("Getting content queue"))
 
     def test_waiting_meta(self):
         """Test call to waiting meta."""
         self.dbus.get_meta_queue()
-        self.assertTrue(self.handler.check_inf("Getting meta queue"))
+        self.assertTrue(self.handler.check_info("Getting meta queue"))
 
     def test_get_status(self):
         """Test call to status."""
         self.dbus.get_status()
-        self.assertTrue(self.handler.check_inf("Getting status"))
+        self.assertTrue(self.handler.check_info("Getting status"))
 
     def test_get_folders(self):
         """Test call to folders."""
         self.dbus.get_folders()
-        self.assertTrue(self.handler.check_inf("Getting folders"))
+        self.assertTrue(self.handler.check_info("Getting folders"))
+
+    def test_get_metadata(self):
+        """Test call to metadata."""
+        self.dbus.get_metadata('path')
+        msg = "Getting metadata for u'path'"
+        self.assertTrue(self.handler.check_info(msg))
 
     def test_get_shares_to_me(self):
         """Test call to shares to me."""
         self.dbus.get_shares_to_me()
-        self.assertTrue(self.handler.check_inf("Getting shares to me"))
+        self.assertTrue(self.handler.check_info("Getting shares to me"))
 
     def test_get_shares_to_other(self):
         """Test call to shares to others."""
         self.dbus.get_shares_to_others()
-        self.assertTrue(self.handler.check_inf("Getting shares to others"))
+        self.assertTrue(self.handler.check_info("Getting shares to others"))
 
     def test_is_sd_started(self):
         """Test call to is_sd_started."""
         self.dbus.is_sd_started()
-        self.assertTrue(self.handler.check_inf(
+        self.assertTrue(self.handler.check_info(
                         "Checking if SD is started: True"))
 
     def test_start(self):
         """Test call to start."""
         self.dbus.start()
-        self.assertTrue(self.handler.check_inf("Calling start"))
+        self.assertTrue(self.handler.check_info("Calling start"))
 
     def test_quit(self):
         """Test call to quit."""
         self.dbus.quit()
-        self.assertTrue(self.handler.check_inf("Calling quit"))
+        self.assertTrue(self.handler.check_info("Calling quit"))
 
     def test_connect(self):
         """Test call to connect."""
         self.dbus.connect()
-        self.assertTrue(self.handler.check_inf("Calling connect"))
+        self.assertTrue(self.handler.check_info("Calling connect"))
 
     def test_disconnect(self):
         """Test call to disconnect."""
         self.dbus.disconnect()
-        self.assertTrue(self.handler.check_inf("Calling disconnect"))
+        self.assertTrue(self.handler.check_info("Calling disconnect"))
 
     def test_status_changed(self):
         """Test status changed callback."""
@@ -762,58 +849,71 @@
                  is_connected='True', is_online='', queues='queues',
                  connection='connection')
         self.dbus._on_status_changed(d)
-        self.assertTrue(self.handler.check_inf("Received Status changed"))
-        self.assertTrue(self.handler.check_dbg("Status changed data: %r" % d))
+        self.assertTrue(self.handler.check_info("Received Status changed"))
+        msg = "Status changed data: %r" % d
+        self.assertTrue(self.handler.check_debug(msg))
 
     def test_content_queue_changed(self):
         """Test content queue changed callback."""
         self.dbus._on_content_queue_changed("foo")
-        self.assertTrue(self.handler.check_inf(
+        self.assertTrue(self.handler.check_info(
                         "Received Content Queue changed"))
 
     def test_name_owner_changed_other(self):
         """Test name owner changed callback, no SD."""
         self.dbus._on_name_owner_changed("other", "", "T")
-        self.assertFalse(self.handler.check_inf("Received Name Owner changed"))
+        msg = "Received Name Owner changed"
+        self.assertFalse(self.handler.check_info(msg))
 
     def test_name_owner_changed_syncdaemon(self):
         """Test name owner changed callback, SD value ok."""
         self.dbus._on_name_owner_changed("com.ubuntuone.SyncDaemon", "", "T")
-        self.assertTrue(self.handler.check_inf("Received Name Owner changed"))
-        self.assertTrue(self.handler.check_dbg("Name Owner data: u'' u'T'"))
+        self.assertTrue(self.handler.check_info("Received Name Owner changed"))
+        self.assertTrue(self.handler.check_debug("Name Owner data: u'' u'T'"))
 
     def test_name_owner_changed_yes_syncdaemon_TF(self):
         """Test name owner changed callback, SD value bad."""
         self.dbus._on_name_owner_changed("com.ubuntuone.SyncDaemon", "F", "T")
-        self.assertTrue(self.handler.check_inf("Received Name Owner changed"))
-        self.assertTrue(self.handler.check_dbg("Name Owner data: u'F' u'T'"))
+        self.assertTrue(self.handler.check_info("Received Name Owner changed"))
+        self.assertTrue(self.handler.check_debug("Name Owner data: u'F' u'T'"))
         self.assertTrue(self.handler.check("ERROR",
                         "Name Owner invalid data: Same bool in old and new!"))
 
     def test_folder_created_changed(self):
         """Test folder created changed callback."""
         self.dbus._on_folder_created("foo")
-        self.assertTrue(self.handler.check_inf("Received Folder created"))
+        self.assertTrue(self.handler.check_info("Received Folder created"))
 
     def test_folder_deleted_changed(self):
         """Test folder deleted changed callback."""
         self.dbus._on_folder_deleted("foo")
-        self.assertTrue(self.handler.check_inf("Received Folder deleted"))
+        self.assertTrue(self.handler.check_info("Received Folder deleted"))
+
+    def test_folder_subscribed_changed(self):
+        """Test folder subscribed changed callback."""
+        self.dbus._on_folder_subscribed("foo")
+        self.assertTrue(self.handler.check_info("Received Folder subscribed"))
+
+    def test_folder_unsubscribed_changed(self):
+        """Test folder unsubscribed changed callback."""
+        self.dbus._on_folder_unsubscribed("foo")
+        self.assertTrue(self.handler.check_info(
+                                            "Received Folder unsubscribed"))
 
     def test_share_created(self):
         """Test share created callback."""
         self.dbus._on_share_created("foo")
-        self.assertTrue(self.handler.check_inf("Received Share created"))
+        self.assertTrue(self.handler.check_info("Received Share created"))
 
     def test_share_deleted(self):
         """Test share deleted callback."""
         self.dbus._on_share_deleted("foo")
-        self.assertTrue(self.handler.check_inf("Received Share deleted"))
+        self.assertTrue(self.handler.check_info("Received Share deleted"))
 
     def test_share__changed(self):
         """Test share changed callback."""
         self.dbus._on_share_changed("foo")
-        self.assertTrue(self.handler.check_inf("Received Share changed"))
+        self.assertTrue(self.handler.check_info("Received Share changed"))
 
     @defer.inlineCallbacks
     def test_content_queue_processing(self):
@@ -821,9 +921,9 @@
         c = dict(operation='oper', path='path', share='share', node='node')
         self.fake_sdt_response('waiting_content', [c])
         yield self.dbus.get_content_queue()
-        self.assertTrue(self.handler.check_inf(
+        self.assertTrue(self.handler.check_info(
                         "Processing Content Queue items (1)"))
-        self.assertTrue(self.handler.check_dbg(
+        self.assertTrue(self.handler.check_debug(
                         "    Content Queue data: %s" % c))
 
     @defer.inlineCallbacks
@@ -831,9 +931,9 @@
         """Test with one item in the queue."""
         self.fake_sdt_response('waiting_metadata', ['ListShares'])
         yield self.dbus.get_meta_queue()
-        self.assertTrue(self.handler.check_inf(
+        self.assertTrue(self.handler.check_info(
                         "Processing Meta Queue items (1)"))
-        self.assertTrue(self.handler.check_dbg(
+        self.assertTrue(self.handler.check_debug(
                         "    Meta Queue data: u'ListShares'"))
 
     @defer.inlineCallbacks
@@ -843,8 +943,18 @@
                  suggested_path=u'sgp', type='UDF', volume_id='vid')
         self.fake_sdt_response('get_folders', [d])
         yield self.dbus.get_folders()
-        self.assertTrue(self.handler.check_inf("Processing Folders items (1)"))
-        self.assertTrue(self.handler.check_dbg("    Folders data: %r" % d))
+        msg = "Processing Folders items (1)"
+        self.assertTrue(self.handler.check_info(msg))
+        self.assertTrue(self.handler.check_debug("    Folders data: %r" % d))
+
+    @defer.inlineCallbacks
+    def test_metadata_processing(self):
+        """Test get metadata."""
+        d = dict(lot_of_data="I don't care")
+        self.fake_sdt_response('get_metadata', d)
+        yield self.dbus.get_metadata('path')
+        self.assertTrue(self.handler.check_debug(
+                        "Got metadata for path u'path': %r" % d))
 
     @defer.inlineCallbacks
     def test_sharestome_processing(self):
@@ -855,9 +965,9 @@
                  volume_id=u'vol', type=u'Share')
         self.fake_sdt_response('get_shares', [d])
         yield self.dbus.get_shares_to_me()
-        self.assertTrue(self.handler.check_inf(
+        self.assertTrue(self.handler.check_info(
                         "Processing Shares To Me items (1)"))
-        self.assertTrue(self.handler.check_dbg("    Share data: %r" % d))
+        self.assertTrue(self.handler.check_debug("    Share data: %r" % d))
 
     @defer.inlineCallbacks
     def test_sharestoothers_processing(self):
@@ -868,16 +978,17 @@
                  volume_id=u'vol', type=u'Shared')
         self.fake_sdt_response('list_shared', [d])
         yield self.dbus.get_shares_to_others()
-        self.assertTrue(self.handler.check_inf(
+        self.assertTrue(self.handler.check_info(
                         "Processing Shares To Others items (1)"))
-        self.assertTrue(self.handler.check_dbg("    Share data: %r" % d))
+        self.assertTrue(self.handler.check_debug("    Share data: %r" % d))
 
 
 class RetryDecoratorTests(TwistedTestCase):
     """Test the retry decorator."""
 
     class Helper(object):
-        """Fails some times, finally succeeds."""
+        """Fail some times, finally succeed."""
+
         def __init__(self, limit, excep=None):
             self.cant = 0
             self.limit = limit
@@ -915,7 +1026,7 @@
         self.assertTrue(dbusiface._is_retry_exception(err))
 
     def get_decorated_func(self, func):
-        """Executes the test calling the received function."""
+        """Execute the test calling the received function."""
 
         @dbusiface.retryable
         def f():
 
=== modified file 'magicicada/tests/test_magicicada.py'
--- magicicada/tests/test_magicicada.py	2010-06-08 10:53:02 +0000
+++ magicicada/tests/test_magicicada.py	2010-07-09 18:33:43 +0000
@@ -18,6 +18,9 @@
 
 """Tests for magicicada."""
 
+import logging
+import sys
+
 from functools import wraps
 
 import gobject
@@ -26,33 +29,57 @@
 
 from twisted.trial.unittest import TestCase
 
-from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, syncdaemon
+from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, \
+                       UBUNTU_ONE_ROOT, syncdaemon
 from magicicada.dbusiface import QueueData, FolderData, ShareData
-from magicicada.helpers import NO_OP, humanize_bytes
+from magicicada.helpers import NO_OP, humanize_bytes, get_data_file
+from magicicada.tests.helpers import MementoHandler
+
+
+# It's ok to access private data in the test suite
+# pylint: disable-msg=W0212
+# Arguments number differs from overridden method
+# pylint: disable-msg=W0221
+
 
 def process_gtk_pendings():
-    while gtk.events_pending(): gtk.main_iteration()
+    """Process all gtk pending events."""
+    while gtk.events_pending():
+        gtk.main_iteration()
+
 
 def close_dialog((dialog, test)):
     """Call the 'test', close 'dialog'."""
-    try:
-        process_gtk_pendings()
-        test()
-        process_gtk_pendings()
-    finally:
-        dialog.response(gtk.RESPONSE_CLOSE)
-        process_gtk_pendings()
-    return False # do not be called again
+    response = gtk.RESPONSE_CLOSE
+    try:
+        process_gtk_pendings()
+        test()
+    finally:
+        dialog.response(response)
+        process_gtk_pendings()
+    return False  # do not be called again
+
+
+def test_and_click((button, test)):
+    """Call the 'test', and click 'button'."""
+    try:
+        test()
+    finally:
+        button.clicked()
+    return False  # do not be called again
 
 
 class FakedSyncdaemon(object):
     """A faked syncdaemon."""
 
     def __init__(self):
+        self._meta_path = None
+
         self.current_state = syncdaemon.State()
         self.meta_queue = []
         self.content_queue = []
         self.folders = []
+        self.processing_meta = False
 
         self.on_started_callback = NO_OP
         self.on_stopped_callback = NO_OP
@@ -63,13 +90,16 @@
         self.status_changed_callback = NO_OP
         self.content_queue_changed_callback = NO_OP
         self.meta_queue_changed_callback = NO_OP
+        self.on_metadata_ready_callback = None  # mandatory
         self.shutdown = NO_OP
 
         self.start = lambda: setattr(self.current_state, 'is_started', True)
         self.quit = lambda: setattr(self.current_state, 'is_started', False)
-        self.connect = lambda: setattr(self.current_state, 'is_connected', True)
-        self.disconnect = \
-                    lambda: setattr(self.current_state, 'is_connected', False)
+        self.connect = lambda: setattr(self.current_state,
+                                       'is_connected', True)
+        self.disconnect = lambda: \
+                          setattr(self.current_state, 'is_connected', False)
+        self.get_metadata = lambda path: setattr(self, '_meta_path', path)
 
 
 class MagicicadaUITestCase(TestCase):
@@ -78,13 +108,14 @@
     def setUp(self):
         """Init."""
         self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon)
-        self._called = False
-        self.set_called = lambda *args, **kwargs: setattr(self, '_called', True)
+        self.called = False
+        self.response = None
+        self.set_called = lambda *args, **kwargs: setattr(self, 'called', True)
 
     def tearDown(self):
         """Cleanup."""
         self.ui.on_main_window_destroy(self.ui.main_window)
-        self._called = False
+        self.called = False
 
     def do_start(self):
         """Simulate that start fully happened."""
@@ -106,14 +137,16 @@
             result.append(data_type(**kwargs))
         return result
 
-    def assert_store_correct(self, store, items):
+    def assert_store_correct(self, store, items, markup=None):
         """Test that 'store' has 'items' as content."""
         msg = 'amount of rows for %s must be %s (got %s).'
         self.assertEqual(len(store), len(items),
                          msg % (store, len(items), len(store)))
+
         # assert rows content equal to items content
         tree_iter = store.get_iter_root()
         tmp = list(reversed(items))
+        do_markup = markup is not None
         msg = "column %i ('%s') must be '%s' (got '%s' instead)"
         while tree_iter is not None:
             head = tmp.pop()
@@ -122,27 +155,68 @@
                 expected = getattr(head, field)
                 if store.get_column_type(i).name == 'gboolean':
                     expected = bool(expected)
-                self.assertEqual(expected, actual, msg % (i, field, expected, actual))
+                elif do_markup:
+                    expected = markup(expected)
+                self.assertEqual(expected, actual,
+                                 msg % (i, field, expected, actual))
 
             tree_iter = store.iter_next(tree_iter)
+            do_markup = False  # only for first row
 
     def assert_indicator_disabled(self, indicator):
         """Test that 'indicator' is not sensitive."""
-        self.assertFalse(indicator.is_sensitive(), 'indicator is not sensitive')
+        self.assertFalse(indicator.is_sensitive(),
+                         'indicator must not be sensitive.')
 
     def assert_indicator_ready(self, indicator):
         """Test that 'indicator' is sensitive and green."""
-        self.assertTrue(indicator.is_sensitive(), 'indicator is sensitive')
-        expected = indicator.get_pixbuf() # a test on its own
+        self.assertTrue(indicator.is_sensitive(),
+                        'indicator must be sensitive.')
+        expected = indicator.get_pixbuf()  # a test on its own
         self.assertEqual(self.ui.active_indicator, expected,
-                         'indicator is the correct pixbuf')
+                         'indicator must have the correct pixbuf.')
 
     def assert_indicator_loading(self, indicator):
         """Test that 'indicator' is sensitive and loading."""
-        self.assertTrue(indicator.is_sensitive(), 'indicator is sensitive')
-        expected = indicator.get_animation() # a test on its own
+        self.assertTrue(indicator.is_sensitive(),
+                        'indicator must be sensitive.')
+        expected = indicator.get_animation()  # a test on its own
         self.assertEqual(self.ui.loading_animation, expected,
-                         'indicator is the correct animation')
+                         'indicator must have the correct animation.')
+
+    def assert_widget_availability(self, widget_name, enabled=True):
+        """Check button availability according to 'enabled'."""
+        widget = getattr(self.ui, widget_name)
+        self.assertTrue(self.ui.widget_is_visible(widget),
+                        '%s should be visible' % widget_name)
+        sensitive = widget.is_sensitive()
+        msg = '%s should %sbe sensitive'
+        self.assertTrue(sensitive if enabled else not sensitive,
+                        msg % (widget_name, '' if enabled else 'not '))
+
+    def assert_dialog_properties(self, dialog_name, title, size=(600, 300),
+                                 modal=True):
+        """The dialog 'dialog_name' has correct properties."""
+        dialog = getattr(self.ui, dialog_name)
+        actual = dialog.size_request()
+        msg = 'size must be %s (got %s instead).'
+        self.assertEquals(size, actual, msg % (size, actual))
+
+        msg = '%s must %sbe modal.'
+        self.assertEqual(modal, dialog.get_modal(),
+                         msg % (dialog_name, '' if modal else 'not '))
+
+        position = dialog.get_property('window-position')
+        self.assertEqual(gtk.WIN_POS_CENTER, position,
+                        '%s must be centered.' % dialog_name)
+
+        actual = dialog.get_title()
+        msg = '%s title must be %s (got %s instead)'
+        self.assertEqual(title, actual, msg % (dialog_name, title, actual))
+
+        msg = '%s must have main_window as parent.'
+        #self.assertTrue(dialog.parent is self.ui.main_window,
+        #                msg % dialog_name)
 
 
 class MagicicadaUIBasicTestCase(MagicicadaUITestCase):
@@ -157,7 +231,7 @@
         """SyncDaemon instance is shutdown at destroy time."""
         self.patch(self.ui.sd, 'shutdown', self.set_called)
         self.ui.on_main_window_destroy(self.ui.main_window)
-        self.assertTrue(self._called,
+        self.assertTrue(self.called,
                         'syncdaemon.shutdown must be called at destroy time.')
 
     def test_main_window_is_visible(self):
@@ -192,7 +266,7 @@
         """Update is called at startup."""
         self.patch(MagicicadaUI, 'update', self.set_called)
         self.ui = MagicicadaUI(syncdaemon_class=FakedSyncdaemon)
-        self.assertTrue(self._called,
+        self.assertTrue(self.called,
                         'update was called at startup.')
 
 
@@ -215,11 +289,11 @@
         """Test on_start_clicked."""
         self.patch(self.ui.sd, 'start', self.set_called)
         self.ui.on_start_clicked(self.ui.start)
-        self.assertTrue(self._called, 'syncdaemon.start was called.')
+        self.assertTrue(self.called, 'syncdaemon.start was called.')
 
     def test_on_connect_clicked(self):
         """Test on_connect_clicked."""
-        self.do_start() # need to be started
+        self.do_start()  # need to be started
         self.ui.on_connect_clicked(self.ui.connect)
 
         self.assertTrue(self.ui.widget_is_visible(self.ui.connect))
@@ -234,7 +308,7 @@
         """Test on_connect_clicked."""
         self.patch(self.ui.sd, 'connect', self.set_called)
         self.ui.on_connect_clicked(self.ui.connect)
-        self.assertTrue(self._called, 'syncdaemon.connect was called.')
+        self.assertTrue(self.called, 'syncdaemon.connect was called.')
 
     def test_on_stop_clicked(self):
         """Test on_stop_clicked."""
@@ -243,7 +317,7 @@
         self.patch(self.ui, 'on_disconnect_clicked', self.set_called)
         self.ui.on_stop_clicked(self.ui.stop)
 
-        self.assertFalse(self._called, 'on_disconnect_clicked was not called.')
+        self.assertFalse(self.called, 'on_disconnect_clicked was not called.')
 
         self.assertFalse(self.ui.widget_is_visible(self.ui.start))
         self.assertTrue(self.ui.widget_is_visible(self.ui.stop))
@@ -259,13 +333,13 @@
         self.patch(self.ui, 'on_disconnect_clicked', self.set_called)
         self.ui.on_stop_clicked(self.ui.stop)
 
-        self.assertTrue(self._called, 'on_disconnect_clicked was called.')
+        self.assertTrue(self.called, 'on_disconnect_clicked was called.')
 
     def test_on_stop_clicked_stops_syncdaemon(self):
         """Test on_stop_clicked."""
         self.patch(self.ui.sd, 'quit', self.set_called)
         self.ui.on_stop_clicked(self.ui.stop)
-        self.assertTrue(self._called, 'syncdaemon.quit was called.')
+        self.assertTrue(self.called, 'syncdaemon.quit was called.')
 
     def test_on_disconnect_clicked(self):
         """Test on_disconnect_clicked."""
@@ -280,7 +354,7 @@
         """Test on_disconnect_clicked."""
         self.patch(self.ui.sd, 'disconnect', self.set_called)
         self.ui.on_disconnect_clicked(self.ui.disconnect)
-        self.assertTrue(self._called, 'syncdaemon.disconnect was called.')
+        self.assertTrue(self.called, 'syncdaemon.disconnect was called.')
 
 
 class MagicicadaUISystrayIconTestCase(MagicicadaUITestCase):
@@ -294,14 +368,15 @@
 
     def test_main_window_is_shown_when_clicked_after_hidden(self):
         """Main window is shown when the icon is clicked after hidden."""
-        self.ui.on_status_icon_activate(self.ui.status_icon) # hide
-        self.ui.on_status_icon_activate(self.ui.status_icon) # show
+        self.ui.on_status_icon_activate(self.ui.status_icon)  # hide
+        self.ui.on_status_icon_activate(self.ui.status_icon)  # show
         msg = 'main_window should be visible when icon clicked after hidden.'
         self.assertTrue(self.ui.widget_is_visible(self.ui.main_window), msg)
 
 
 def skip_abstract_class(test):
     """If 'test' belongs to an abstract class, don't run it."""
+
     @wraps(test)
     def inner(klass):
         """Execute 'test' only if not in an abstract class."""
@@ -336,6 +411,24 @@
         # operation path share node
         return res
 
+    def expected_markup(self, value):
+        """Return the markup for row at index 'i'."""
+        processing_meta = self.name == META_QUEUE and \
+                          self.ui.sd.current_state.processing_meta
+        processing_content = self.name == CONTENT_QUEUE and \
+                          self.ui.sd.current_state.processing_content
+        assert not (processing_meta and processing_content)
+        must_highlight = self.ui.sd.current_state.is_online and \
+                         (processing_meta or processing_content)
+        result = self.ui.CURRENT_ROW % value \
+                 if must_highlight and value is not None else value
+        return result
+
+    def assert_store_correct(self, store, items):
+        """Test that 'store' has 'items' as content."""
+        args = (store, items, self.expected_markup)
+        super(_MagicicadaUIQueueTestCase, self).assert_store_correct(*args)
+
     @skip_abstract_class
     def test_callback_is_connected(self):
         """Queue changed callback is connected."""
@@ -364,6 +457,13 @@
         self.assert_store_correct(self.queue_store, [])
 
     @skip_abstract_class
+    def test_on_queue_changed_handles_an_item_none(self):
+        """On queue changed handles None as items."""
+        items = [QueueData(operation='Test', path='', share=None, node=None)]
+        self.sd_changed(items)
+        self.assert_store_correct(self.queue_store, items)
+
+    @skip_abstract_class
     def test_model_is_cleared_before_updating(self):
         """The model is cleared before upadting with a new set of data."""
         items = self.build_some_data()
@@ -400,7 +500,7 @@
         cb = 'on_%s_queue_changed' % self.name
         self.patch(self.ui, cb, self.set_called)
         self.ui.on_stopped()
-        self.assertTrue(self._called,
+        self.assertTrue(self.called,
                         '%s was called on_stopped.' % cb)
 
     @skip_abstract_class
@@ -425,12 +525,64 @@
         self.do_start()
         self.assert_store_correct(self.queue_store, items)
 
-        items = items[:len(items)/2]
+        items = items[:len(items) / 2]
         self.set_sd_queue(items)
         self.ui.on_stop_clicked(self.ui.stop)
         self.ui.on_stopped()
         self.assert_store_correct(self.queue_store, items)
 
+    def assert_current_processing_row_is_different(self):
+        """Row being processed is highlighted."""
+        items = self.build_some_data()
+        self.sd_changed(items)
+
+        item = items[0]
+        attrs = type(item)._fields
+
+        markup = self.expected_markup
+        expected = tuple(markup(getattr(item, attr)) for attr in attrs)
+
+        iter_root = self.queue_store.get_iter_root()
+        actual = self.queue_store.get(iter_root, *xrange(len(attrs)))
+
+        msg = 'first row for %s queue must be %s (got %s instead)' % \
+              (self.name, expected, actual)
+        self.assertEqual(expected, actual, msg)
+
+    @skip_abstract_class
+    def test_current_processing_row_is_different_if_online(self):
+        """Row being processed is highlighted."""
+        self.ui.sd.current_state.set(is_online=True)
+
+        self.ui.sd.current_state.set(queues='')
+        self.assert_current_processing_row_is_different()
+
+        self.ui.sd.current_state.set(queues='WORKING_ON_METADATA')
+        self.assert_current_processing_row_is_different()
+
+        self.ui.sd.current_state.set(queues='WORKING_ON_CONTENT')
+        self.assert_current_processing_row_is_different()
+
+        self.ui.sd.current_state.set(queues='WORKING_ON_BOTH')
+        self.assert_current_processing_row_is_different()
+
+    @skip_abstract_class
+    def test_current_processing_row_is_not_different_if_offline(self):
+        """Row being processed is highlighted."""
+        self.ui.sd.current_state.set(is_online=False)
+
+        self.ui.sd.current_state.set(queues='')
+        self.assert_current_processing_row_is_different()
+
+        self.ui.sd.current_state.set(queues='WORKING_ON_METADATA')
+        self.assert_current_processing_row_is_different()
+
+        self.ui.sd.current_state.set(queues='WORKING_ON_CONTENT')
+        self.assert_current_processing_row_is_different()
+
+        self.ui.sd.current_state.set(queues='WORKING_ON_BOTH')
+        self.assert_current_processing_row_is_different()
+
 
 class MagicicadaUIContentQueueTestCase(_MagicicadaUIQueueTestCase):
     """UI test cases for content queue view."""
@@ -477,13 +629,14 @@
         """Status callback is connected."""
         self.assertEqual(self.ui.sd.status_changed_callback,
                          self.ui.on_status_changed,
-                         'status_changed callback must be set')
+                         'status_changed callback must be set.')
 
     def test_status_label_ellipsizes(self):
         """The status label ellipsizes."""
         expected = pango.ELLIPSIZE_END
         actual = self.ui.status_label.get_ellipsize()
-        self.assertEqual(expected, actual, 'label ellipsizes is ELLIPSIZE_END.')
+        self.assertEqual(expected, actual,
+                         'label ellipsizes is ELLIPSIZE_END.')
 
     def test_on_status_changed_updates_status_label(self):
         """On status changed, the status label is updated."""
@@ -493,7 +646,7 @@
 
     def test_on_status_changed_updates_status_label_even_on_weird_cases(self):
         """On status changed, the status label is updated."""
-        keywords = ('name', 'description', 'queues', 'connection') # need order
+        keywords = ('name', 'description', 'queues', 'connection')  # order
         for attr in keywords:
             old_value = self.kwargs[attr]
 
@@ -509,7 +662,7 @@
 
     def test_update_is_correct_for_status_label(self):
         """Correctly updates the status label."""
-        self.ui.sd.current_state._set(**self.kwargs)
+        self.ui.sd.current_state.set(**self.kwargs)
         self.ui.update()
         self.assert_status_label_correct(**self.kwargs)
 
@@ -517,7 +670,7 @@
         """On SD stoppped, the UI updates the status label."""
         self.patch(self.ui, 'on_status_changed', self.set_called)
         self.ui.on_stopped()
-        self.assertTrue(self._called,
+        self.assertTrue(self.called,
                         'on_status_changed was called on_stopped.')
 
     def test_status_label_default_if_not_started(self):
@@ -532,12 +685,12 @@
 
     def test_status_label_is_updated_on_started_and_on_stopped(self):
         """Status label is updated on_started."""
-        self.ui.sd.current_state._set(**self.kwargs)
+        self.ui.sd.current_state.set(**self.kwargs)
         self.do_start()
         self.assert_status_label_correct(**self.kwargs)
 
         self.kwargs['name'] = 'CHANGED'
-        self.ui.sd.current_state._set(**self.kwargs)
+        self.ui.sd.current_state.set(**self.kwargs)
 
         self.ui.on_stop_clicked(self.ui.stop)
         self.ui.on_stopped()
@@ -551,7 +704,7 @@
         """Test that correctly updates the 'indicator'."""
         cs = self.ui.sd.current_state
         for expected in (True, False):
-            cs._set(**{indicator: expected})
+            cs.set(**{indicator: expected})
 
             self.ui.update()
 
@@ -684,67 +837,64 @@
         self.volume_dialog_name = '%s_dialog' % self.name
         self.volume_dialog = getattr(self.ui, self.volume_dialog_name)
         self.on_volume_clicked = getattr(self.ui, 'on_%s_clicked' % self.name)
+        self.volume_close = getattr(self.ui, '%s_close' % self.name)
 
     def build_some_data(self, limit=5):
         """Build some data to act as volume."""
         kwargs = dict(data_type=self.data_type, limit=limit)
-        res = super(_MagicicadaUIVolumeTestCase, self).build_some_data(**kwargs)
-        return res
+        r = super(_MagicicadaUIVolumeTestCase, self).build_some_data(**kwargs)
+        return r
 
-    def assert_volume_availability(self, enabled):
+    def assert_widget_availability(self, enabled=True):
         """Check volume availability according to 'enabled'."""
-        self.assertTrue(self.ui.widget_is_visible(self.volume),
-                        '%s should be visible' % self.name)
-        sensitive = self.volume.is_sensitive()
-        msg = '%s should %sbe sensitive'
-        self.assertTrue(sensitive if enabled else not sensitive,
-                        msg % (self.name, '' if enabled else 'not '))
+        s = super(_MagicicadaUIVolumeTestCase, self)
+        s.assert_widget_availability(self.name, enabled)
 
     @skip_abstract_class
     def test_volume_are_disabled_until_started(self):
         """Folders and shares are disabled until online."""
         # disabled at startup
-        self.assert_volume_availability(enabled=False)
+        self.assert_widget_availability(enabled=False)
 
         # enabled when started
         self.do_start()
-        self.assert_volume_availability(enabled=True)
+        self.assert_widget_availability(enabled=True)
 
     @skip_abstract_class
     def test_volume_are_enabled_until_stopped(self):
         """Folders and shares are enabled until offline."""
         self.do_connect()
-        self.assert_volume_availability(enabled=True)
+        self.assert_widget_availability(enabled=True)
 
         self.ui.on_online()
-        self.assert_volume_availability(enabled=True)
+        self.assert_widget_availability(enabled=True)
 
         self.ui.on_offline()
-        self.assert_volume_availability(enabled=True)
+        self.assert_widget_availability(enabled=True)
 
         self.ui.on_disconnect_clicked(self.ui.disconnect)
         self.ui.on_disconnected()
-        self.assert_volume_availability(enabled=True)
+        self.assert_widget_availability(enabled=True)
 
         # disabled when stopped
         self.ui.on_stop_clicked(self.ui.stop)
-        self.assert_volume_availability(enabled=False)
+        self.assert_widget_availability(enabled=False)
         self.ui.on_stopped()
-        self.assert_volume_availability(enabled=False)
+        self.assert_widget_availability(enabled=False)
 
     @skip_abstract_class
     def test_volume_close_emits_response_close(self):
         """Test volume close button emits RESPONSE_CLOSE when clicked."""
-        self.response = None
+
         def record_response(value):
             """Record the response received."""
             self.response = value
+
         self.patch(self.volume_dialog, 'response', record_response)
 
-        volume_close = '%s_close' % self.name
-        getattr(self.ui, volume_close).clicked()
+        self.volume_close.clicked()
         self.assertEqual(gtk.RESPONSE_CLOSE, self.response,
-                         '%s should emit RESPONSE_CLOSE.' % volume_close)
+                         'volume close button should emit RESPONSE_CLOSE.')
 
     @skip_abstract_class
     def test_on_volume_clicked(self):
@@ -799,36 +949,25 @@
         self.on_volume_clicked(self.volume)
 
     @skip_abstract_class
-    def test_volume_dialog_props(self):
+    def test_volume_dialog_properties(self):
         """The volume dialog has correct properties."""
-        size = self.volume_dialog.size_request()
-        self.assertEquals((600, 300), size)
-
-        self.assertTrue(self.volume_dialog.get_modal(),
-                        '%s must be modal.' % self.volume_dialog_name)
-
-        position = self.volume_dialog.get_property('window-position')
-        self.assertEqual(gtk.WIN_POS_CENTER, position,
-                        '%s must be centered.' % self.volume_dialog_name)
-
-        actual = self.volume_dialog.get_title()
-        expected = self.name.replace('_', ' ').capitalize()
-        msg = '%s title must be %s (got %s instead)'
-        self.assertEqual(expected, actual,
-                         msg % (self.volume_dialog_name, expected, actual))
+        title = self.name.replace('_', ' ').capitalize()
+        self.assert_dialog_properties(dialog_name=self.volume_dialog_name,
+                                      title=title)
+
 
 class MagicicadaUIFoldersTestCase(_MagicicadaUIVolumeTestCase):
     """UI test cases for folders."""
 
     name = 'folders'
-    data_type = FolderData # node path suggested_path subscribed volume
+    data_type = FolderData  # node path suggested_path subscribed volume
 
 
 class _MagicicadaUISharesTestCase(_MagicicadaUIVolumeTestCase):
     """UI test cases for shares_to_me."""
 
-    data_type = ShareData # accepted access_level free_bytes name node_id
-                          # other_username other_visible_name path volume_id
+    data_type = ShareData  # accepted access_level free_bytes name node_id
+                           # other_username other_visible_name path volume_id
 
     @skip_abstract_class
     def test_bytes_are_humanized(self):
@@ -862,3 +1001,279 @@
 
     name = 'shares_to_others'
 
+
+class MagicicadaUIMetadataTestCase(MagicicadaUITestCase):
+    """UI test cases for metadata display."""
+
+    name = 'raw_metadata'
+
+    def setUp(self):
+        """Init."""
+        super(MagicicadaUIMetadataTestCase, self).setUp()
+        self.path = get_data_file('tests', 'metadata-test.txt')
+        self.metadata = dict(bla='ble', foo='bar')
+
+    def assert_widget_availability(self, enabled=True):
+        """Check button availability according to 'enabled'."""
+        s = super(MagicicadaUIMetadataTestCase, self)
+        s.assert_widget_availability(self.name, enabled)
+
+    def assert_dialog_visibility(self, dialog, text_view, image):
+        """Check the visibility for dialog, text_view and image."""
+        msg = '%s visibility should be %s (got %s instead).'
+        visible = self.ui.widget_is_visible(self.ui.raw_metadata_dialog)
+        self.assertEqual(dialog, visible,
+                         msg % ('raw_metadata_dialog', dialog, visible))
+
+        visible = self.ui.widget_is_visible(self.ui.raw_metadata_view)
+        self.assertEqual(text_view, visible,
+                         msg % ('raw_metadata_view', text_view, visible))
+
+        visible = self.ui.widget_is_visible(self.ui.raw_metadata_image)
+        self.assertEqual(image, visible,
+                         msg % ('raw_metadata_image', image, visible))
+
+    def test_raw_metadata_are_disabled_until_started(self):
+        """Raw metadata button is disabled until online."""
+        # disabled at startup
+        self.assert_widget_availability(enabled=False)
+
+        # enabled when started
+        self.do_start()
+        self.assert_widget_availability(enabled=True)
+
+    def test_raw_metadata_are_enabled_until_stopped(self):
+        """Raw metadata button is enabled until offline."""
+        self.do_connect()
+        self.assert_widget_availability(enabled=True)
+
+        self.ui.on_online()
+        self.assert_widget_availability(enabled=True)
+
+        self.ui.on_offline()
+        self.assert_widget_availability(enabled=True)
+
+        self.ui.on_disconnect_clicked(self.ui.disconnect)
+        self.ui.on_disconnected()
+        self.assert_widget_availability(enabled=True)
+
+        # disabled when stopped
+        self.ui.on_stop_clicked(self.ui.stop)
+        self.assert_widget_availability(enabled=False)
+        self.ui.on_stopped()
+        self.assert_widget_availability(enabled=False)
+
+    def test_raw_metadata_close_hides_the_dialog(self):
+        """Test raw_metadata close button emits RESPONSE_CLOSE when clicked."""
+        self.ui.raw_metadata_close.clicked()
+        self.assertFalse(self.ui.widget_is_visible(
+                         self.ui.raw_metadata_dialog),
+                         'raw_metadata_dialog should not be visible.')
+
+    def test_file_chooser_open_emits_response_ok(self):
+        """Test volume close button emits RESPONSE_CLOSE when clicked."""
+
+        def record_response(value):
+            """Record the response received."""
+            self.response = value
+
+        self.patch(self.ui.file_chooser, 'response', record_response)
+
+        self.ui.file_chooser_open.clicked()
+        self.assertEqual(gtk.FILE_CHOOSER_ACTION_OPEN, self.response,
+                         'open button should emit FILE_CHOOSER_ACTION_OPEN.')
+
+    def test_on_raw_metadata_clicked(self):
+        """Test on_raw_metadata_clicked."""
+        self.assertFalse(self.ui.widget_is_visible(
+                         self.ui.raw_metadata_dialog),
+                         'raw_metadata_dialog should not be visible.')
+
+        self.ui.file_chooser.set_filename(self.path)
+
+        def test_file_chooser():
+            """Auxiliar to assert over the file_chooser."""
+            self.assertTrue(self.ui.widget_is_visible(self.ui.file_chooser),
+                           'file_chooser must be visible on metadata clicked.')
+
+        gobject.timeout_add(100, test_and_click,
+                            (self.ui.file_chooser_open, test_file_chooser))
+        self.ui.on_raw_metadata_clicked(self.ui.raw_metadata)
+
+        self.assertFalse(self.ui.widget_is_visible(self.ui.file_chooser),
+                        'file_chooser must be visible after metadata clicked.')
+        self.assertEqual(self.path, self.ui.file_chooser.get_filename(),
+                         'filename returned by file chooser must be correct.')
+
+        # raw_metadata_dialog is enabled and shows the loading animation
+        self.assert_dialog_visibility(dialog=True, text_view=False, image=True)
+        expected = self.ui.raw_metadata_image.get_animation()
+        self.assertEqual(self.ui.loading_animation, expected,
+                     'raw_metadata_image must have the correct animation.')
+
+        # Check that the metadata was asked to the SD
+        self.assertEqual(self.ui.sd._meta_path, self.path)
+        # SD will eventually callback us with the metadata
+        self.ui.on_metadata_ready(self.path, self.metadata)
+
+        # raw_metadata_dialog is enabled and shows the metadata
+        self.assert_dialog_visibility(dialog=True, text_view=True, image=False)
+
+        # user closes the dialog
+        self.ui.raw_metadata_close.clicked()
+
+        # dialog was closed already
+        self.assertFalse(self.ui.widget_is_visible(
+                         self.ui.raw_metadata_dialog),
+                         'raw_metadata_dialog should not be visible.')
+
+    def test_raw_metadata_dialog_properties(self):
+        """The raw_metadata dialog has correct properties."""
+        title = self.name.replace('_', ' ').capitalize()
+        self.assert_dialog_properties(dialog_name='raw_metadata_dialog',
+                                      title=title, modal=False)
+
+        actual = self.ui.raw_metadata_view.get_wrap_mode()
+        msg = 'wrap mode for view must be gtk.WRAP_WORD (got %s instead).'
+        self.assertEqual(gtk.WRAP_WORD, actual, msg % actual)
+
+    def test_callback_is_connected(self):
+        """Metadata ready callback is connected."""
+        self.assertEqual(self.ui.sd.on_metadata_ready_callback,
+                         self.ui.on_metadata_ready,
+                         'on_metadata_ready_callback callback must be set.')
+
+    def test_file_chooser_is_hidden_at_startup(self):
+        """File chooser exists but is not visible."""
+        self.assertFalse(self.ui.widget_is_visible(self.ui.file_chooser),
+                         'file_chooser must be hidden by default.')
+
+    def test_file_chooser_current_folder_is_ubuntu_one_root(self):
+        """File chooser default folder is ~/Ubuntu One."""
+        process_gtk_pendings()  # WOW! Needed to get proper value below
+        actual = self.ui.file_chooser.get_current_folder()
+        msg = 'file_chooser default folder must be %s (got %s instead).'
+        self.assertEqual(actual, UBUNTU_ONE_ROOT,
+                         msg % (UBUNTU_ONE_ROOT, actual))
+
+    def test_filename_is_used_only_if_open_clicked(self):
+        """Filename is used only if user clicked open."""
+        self.patch(self.ui.sd, 'get_metadata', self.set_called)
+        gobject.timeout_add(100, test_and_click,
+                            (self.ui.file_chooser_cancel, NO_OP))
+        self.ui.on_raw_metadata_clicked(self.ui.raw_metadata)
+
+        self.assertFalse(self.called,
+                        'get_metadata should not be called if no file chosen.')
+
+    def test_filename_is_stored_if_open_clicked(self):
+        """Filename is stored as 'last_metadata_path' if user clicked open."""
+        self.assertTrue(self.ui.last_metadata_path is None,
+                        'last_metadata_path must be None.')
+        self.ui.file_chooser.set_filename(self.path)
+        gobject.timeout_add(100, test_and_click,
+                            (self.ui.file_chooser_open, NO_OP))
+        self.ui.on_raw_metadata_clicked(self.ui.raw_metadata)
+
+        self.assertEqual(self.path, self.ui.last_metadata_path,
+                         'last_metadata_path should be what the user choose.')
+
+    def test_on_metadata_ready(self):
+        """Callback on_metadata_ready updates the raw_metadata_view."""
+        path = 'bla'
+        self.ui.last_metadata_path = path
+        self.ui.on_metadata_ready(path, self.metadata)
+
+        buff = self.ui.raw_metadata_view.get_buffer()
+        self.assertTrue(buff is not None,
+                    'buffer for raw_metadata_view must not be None.')
+
+        expected = '\n'.join('%s: %s' % i for i in self.metadata.iteritems())
+        actual = buff.get_text(*buff.get_bounds())
+        msg = 'buffer content must be %s (got %s instead).'
+        self.assertEqual(actual, expected,
+                         msg % (expected, actual))
+
+    def test_on_metadata_ready_doesnt_update_if_last_path_doesnt_match(self):
+        """Callback on_metadata_ready updates the raw_metadata_view."""
+        self.patch(self.ui.raw_metadata_view.get_buffer(),
+                   'set_text', self.set_called)
+        path = 'bla'
+        self.ui.last_metadata_path = path + path
+        self.ui.on_metadata_ready(path, self.metadata)
+
+        self.assertFalse(self.called,
+                         'view should not be updated if key is not last one.')
+
+
+def override_input_output(input_args, output_args):
+    """Call 'f' but receive fixed input and return fixed output."""
+
+    def decorator(f):
+        """The decorator per se."""
+
+        @wraps(f)
+        def inner(*args, **kwargs):
+            """Feed 'f' with 'input_args' and return 'output_args'."""
+            f(input_args)
+            return output_args
+
+        return inner
+
+    return decorator
+
+
+class MagicicadaLoggingTestCase(MagicicadaUITestCase):
+    """UI test cases for logging."""
+
+    def setUp(self):
+        """Init."""
+        super(MagicicadaLoggingTestCase, self).setUp()
+
+        self.memento = MementoHandler()
+        self.memento.setLevel(logging.DEBUG)
+        logger = logging.getLogger('magicicada.ui')
+        logger.addHandler(self.memento)
+
+    def assert_function_logs(self, func, *args, **kwargs):
+        """Check 'funcion' logs its inputs as DEBUG."""
+        name = func.__name__
+        msg = '%s must be logged as DEBUG'
+        try:
+            func(*args, **kwargs)
+        except Exception:  # pylint: disable-msg=E0501, W0703
+            exc = sys.exc_info()
+            self.assertTrue(self.memento.check_error(name),
+                            'function (%s) must be logged as ERROR' % name)
+            self.assertTrue(self.memento.check_error(exc),
+                            'sys.exc_info (%s) must be logged as ERROR' % exc)
+        self.assertTrue(self.memento.check_debug(name), msg % name)
+        for arg in args:
+            self.assertTrue(self.memento.check_debug(str(arg)), msg % arg)
+        for key, val in kwargs.iteritems():
+            arg = "'%s': %r" % (key, val)
+            self.assertTrue(self.memento.check_debug(arg), msg % arg)
+
+    def test_on_shares_clicked_logs(self):
+        """Check _on_shares_clicked logs properly."""
+        args = ([0, object(), 'test', {}], object())
+        kwargs = dict(dialog=object())
+        self.assert_function_logs(self.ui._on_shares_clicked, *args, **kwargs)
+
+    def test_on_status_changed_logs(self):
+        """Check _on_status_changed logs properly."""
+        args = ('test status', 'status description', True, False, True)
+        kwargs = dict(queues='bla', connection=None)
+        self.assert_function_logs(self.ui.on_status_changed, *args, **kwargs)
+
+    def test_on_queue_changed_logs(self):
+        """Check _on_queue_changed logs properly."""
+        args = ('meta',)
+        kwargs = dict(items=[0, object(), 'test', {}], must_highlight=True)
+        self.assert_function_logs(self.ui._on_queue_changed, *args, **kwargs)
+
+    def test_on_metadata_ready_logs(self):
+        """Check on_metadata_ready logs properly."""
+        args = ()
+        kwargs = dict(path='test', metadata=True)
+        self.assert_function_logs(self.ui.on_metadata_ready, *args, **kwargs)
 
=== modified file 'magicicada/tests/test_syncdaemon.py'
--- magicicada/tests/test_syncdaemon.py	2010-06-08 10:53:02 +0000
+++ magicicada/tests/test_syncdaemon.py	2010-07-09 18:33:43 +0000
@@ -28,6 +28,10 @@
 from twisted.internet import defer, reactor
 
 
+# It's ok to access private data in the test suite
+# pylint: disable-msg=W0212
+
+
 class FakeDBusInterface(object):
     """Fake DBus Interface, for SD to not use dbus at all during tests."""
 
@@ -37,15 +41,18 @@
         pass
 
     def shutdown(self):
+        """Fake shutdown."""
         pass
 
     def get_status(self):
         """Fake status."""
         return defer.succeed(('fakename', 'fakedescrip', False, True,
                               False, 'fakequeues', 'fakeconnection'))
+
     def get_folders(self):
         """Fake folders."""
         return defer.succeed('fakedata')
+
     get_content_queue = get_meta_queue = get_folders
     start = quit = connect = disconnect = get_folders
     get_shares_to_me = get_shares_to_others = get_folders
@@ -133,8 +140,9 @@
 
     @defer.inlineCallbacks
     def test_initial_value(self):
-        """Fills the status info initially."""
+        """Fill the status info initially."""
         called = []
+
         def fake():
             """Fake method."""
             called.append(True)
@@ -167,7 +175,7 @@
         return deferred
 
     def test_status_changed_affects_cuurent_status(self):
-        """Makes changes to see how status are reflected."""
+        """Make changes to see how status are reflected."""
         # one set of values
         self.sd.on_sd_status_changed('name1', 'description1', False, True,
                                      False, 'queues1', 'connection1')
@@ -229,13 +237,42 @@
         self.assertEqual(self.sd.current_state.queues, '')
         self.assertEqual(self.sd.current_state.connection, '')
 
+    def test_processing_meta_if_working_on_meta_or_both(self):
+        """Status.processing_meta is True when WORKING_ON_{METADATA,BOTH}."""
+
+        msg = 'processing_meta must be False when %s.'
+        for state in ('WORKING_ON_CONTENT', ''):
+            self.sd.current_state.set(queues=state)
+            self.assertFalse(self.sd.current_state.processing_meta,
+                             msg % state)
+
+        msg = 'processing_meta must be True when %s.'
+        for state in ('WORKING_ON_METADATA', 'WORKING_ON_BOTH'):
+            self.sd.current_state.set(queues=state)
+            self.assertTrue(self.sd.current_state.processing_meta, msg % state)
+
+    def test_processing_content_if_working_on_content_or_both(self):
+        """Status.processing_content is True when WORKING_ON_{CONTENT,BOTH}."""
+
+        msg = 'processing_content must be False when %s.'
+        for state in ('WORKING_ON_METADATA', ''):
+            self.sd.current_state.set(queues=state)
+            self.assertFalse(self.sd.current_state.processing_content,
+                             msg % state)
+
+        msg = 'processing_content must be True when %s.'
+        for state in ('WORKING_ON_CONTENT', 'WORKING_ON_BOTH'):
+            self.sd.current_state.set(queues=state)
+            self.assertTrue(self.sd.current_state.processing_content,
+                            msg % state)
+
 
 class ContentQueueChangedTests(BaseTest):
     """Check the ContenQueueChanged handling."""
 
     @defer.inlineCallbacks
     def test_initial_value(self):
-        """Fills the content queue info initially."""
+        """Fill the content queue info initially."""
         called = []
         self.sd.dbus.get_content_queue = lambda: called.append(True)
         yield self.sd._get_initial_data()
@@ -311,13 +348,19 @@
     def setUp(self):
         """Set up."""
         BaseTest.setUp(self)
-        self.sd.current_state._set(queues='WORKING_ON_METADATA')
+        self.sd.current_state.set(queues='WORKING_ON_METADATA')
 
     @defer.inlineCallbacks
     def test_initial_value(self):
-        """Fills the meta queue info initially."""
+        """Fill the meta queue info initially."""
         called = []
-        self.sd.dbus.get_meta_queue = lambda: called.append(True)
+
+        def f():
+            """Helper function."""
+            called.append(True)
+            return []
+
+        self.sd.dbus.get_meta_queue = f
         yield self.sd._get_initial_data()
         self.assertTrue(called)
 
@@ -373,10 +416,12 @@
         """Check that it polls mq while working in metadata not being in QM."""
         # set the callback
         deferred = defer.Deferred()
+
         def fake():
             """Fake."""
             deferred.callback(True)
             return defer.succeed("foo")
+
         self.sd.dbus.get_meta_queue = fake
 
         # send status changed to working in metadata
@@ -389,10 +434,12 @@
         """Check that it polls mq while working in metadata being in QM."""
         # set the callback
         deferred = defer.Deferred()
+
         def fake():
             """Fake."""
             deferred.callback(True)
             return defer.succeed("foo")
+
         self.sd.dbus.get_meta_queue = fake
 
         # send status changed to working in metadata
@@ -405,10 +452,12 @@
         """Check that it polls mq while working in both."""
         # set the callback
         deferred = defer.Deferred()
+
         def fake():
             """Fake."""
             deferred.callback(True)
             return defer.succeed("foo")
+
         self.sd.dbus.get_meta_queue = fake
 
         # send status changed to working in metadata
@@ -417,14 +466,47 @@
                                      'connection')
         return deferred
 
+    def test_mq_polls_last_time(self):
+        """Was polling, state changed, it needs to poll a last time."""
+        # set the callback
+        deferred = defer.Deferred()
+        changed = self.sd.on_sd_status_changed
+        called = []
+
+        def fake():
+            """Fake."""
+            called.append(None)
+            if len(called) == 1:
+                changed('QUEUE_MANAGER', 'description', False, True, False,
+                        'WORKING_ON_CONTENT', 'connection')
+            elif len(called) == 2:
+                # check that the caller is set back to None
+                self.assertTrue(self.sd._mqcaller is None)
+                deferred.callback(True)
+            return defer.succeed("foo")
+
+        self.sd.dbus.get_meta_queue = fake
+
+        # send status changed to working in metadata
+        changed('QUEUE_MANAGER', 'description', False, True, False,
+                'WORKING_ON_BOTH', 'connection')
+        return deferred
+
+    def test_mq_caller_is_reset_last_time(self):
+        """When MQ is polled last time, the caller should be back to None."""
+        self.sd._mqcaller = reactor.callLater(100, lambda: None)
+        self.sd.current_state.set(name='QUEUE_MANAGER',
+                                  queues='WORKING_ON_CONTENT')
+
+        # call the method and check
+        self.sd._check_mq()
+        self.assertTrue(self.sd._mqcaller is None)
+
     def test_mq_polling_untilfinish(self):
         """Check that it polls mq until no more is needed."""
-        d2 = dict(name='QUEUE_MANAGER', queues='WORKING_ON_CONTENT',
-                  description='description', is_error='', is_connected='True',
-                  is_online='', connection='conn')
-
         # set the callback, and adjust the polling time to faster
         calls = []
+
         def fake_get(*a):
             """Fake get."""
             calls.append(None)
@@ -437,6 +519,8 @@
 
                 # allow time to see if a mistaken call happens
                 reactor.callLater(.5, deferred.callback, True)
+            elif len(calls) == 4:
+                pass    # last call after state changed
             else:
                 deferred.errback(ValueError("Too many calls"))
             return defer.succeed("foo")
@@ -480,7 +564,7 @@
     def test_set_one_value(self):
         """Set one value."""
         st = State()
-        st._set(name=55)
+        st.set(name=55)
 
         # check the one is set, the rest not
         self.assertEqual(st.name, 55)
@@ -489,7 +573,7 @@
     def test_set_two_values(self):
         """Set two values."""
         st = State()
-        st._set(name=55, description=77)
+        st.set(name=55, description=77)
 
         # check those two are set, the rest not
         self.assertEqual(st.name, 55)
@@ -499,7 +583,7 @@
     def test_bad_value(self):
         """Set a value that should not."""
         st = State()
-        self.assertRaises(AttributeError, st._set, not_really_allowed=44)
+        self.assertRaises(AttributeError, st.set, not_really_allowed=44)
 
 
 class APITests(unittest.TestCase):
@@ -617,7 +701,6 @@
         self.assertTrue(self.called)
 
 
-
 class TestLogs(unittest.TestCase):
     """Test logging."""
 
@@ -634,100 +717,128 @@
 
     def test_instancing(self):
         """Just logged SD instancing."""
-        self.assertTrue(self.hdlr.check_inf("SyncDaemon interface started!"))
+        self.assertTrue(self.hdlr.check_info("SyncDaemon interface started!"))
 
     def test_shutdown(self):
         """Log when SD shutdowns."""
         self.sd.shutdown()
-        self.assertTrue(self.hdlr.check_inf("SyncDaemon interface going down"))
+        msg = "SyncDaemon interface going down"
+        self.assertTrue(self.hdlr.check_info(msg))
 
     @defer.inlineCallbacks
     def test_initial_value(self):
         """Log the initial filling."""
         yield self.sd._get_initial_data()
-        self.assertTrue(self.hdlr.check_inf("Getting initial data"))
+        self.assertTrue(self.hdlr.check_info("Getting initial data"))
 
     def test_start(self):
         """Log the call to start."""
         self.sd.start()
-        self.assertTrue(self.hdlr.check_inf("Starting u1.SD"))
+        self.assertTrue(self.hdlr.check_info("Starting u1.SD"))
 
     def test_quit(self):
         """Log the call to quit."""
         self.sd.quit()
-        self.assertTrue(self.hdlr.check_inf("Stopping u1.SD"))
+        self.assertTrue(self.hdlr.check_info("Stopping u1.SD"))
 
     def test_connect(self):
         """Log the call to connect."""
         self.sd.connect()
-        self.assertTrue(self.hdlr.check_inf("Telling u1.SD to connect"))
+        self.assertTrue(self.hdlr.check_info("Telling u1.SD to connect"))
 
     def test_disconnect(self):
         """Log the call to disconnect."""
         self.sd.disconnect()
-        self.assertTrue(self.hdlr.check_inf("Telling u1.SD to disconnect"))
+        self.assertTrue(self.hdlr.check_info("Telling u1.SD to disconnect"))
 
     def test_check_mq_true(self):
         """Log the MQ check when it asks for info."""
-        self.sd.current_state._set(name='QUEUE_MANAGER',
+        self.sd.current_state.set(name='QUEUE_MANAGER',
                                    queues='WORKING_ON_METADATA')
         self.sd._check_mq()
-        self.assertTrue(self.hdlr.check_inf("Asking for MQ information"))
+        self.assertTrue(self.hdlr.check_info("Asking for MQ information"))
 
     def test_check_mq_noreally(self):
         """Log the MQ check when it should not work."""
-        self.sd.current_state._set(name='QUEUE_MANAGER',
+        self.sd.current_state.set(name='QUEUE_MANAGER',
                                    queues='WORKING_ON_CONTENT')
         self.sd._check_mq()
-        self.assertTrue(self.hdlr.check_inf(
-                        "Check MQ called but States not in MQ"))
+        self.assertTrue(self.hdlr.check_info(
+                        "Check MQ called, States not in MQ, call a last time"))
 
     def test_meta_queue_changed(self):
         """Log that MQ has new data."""
         self.sd.dbus.get_meta_queue = lambda: defer.succeed(['foo'])
-        self.sd.current_state._set(name='QUEUE_MANAGER',
+        self.sd.current_state.set(name='QUEUE_MANAGER',
                                    queues='WORKING_ON_METADATA')
         self.sd._check_mq()
-        self.assertTrue(self.hdlr.check_inf("SD Meta Queue changed: 1 items"))
+        self.assertTrue(self.hdlr.check_info("SD Meta Queue changed: 1 items"))
 
     def test_content_queue_changed(self):
         """Log that process_cq has new data."""
         self.sd.dbus.get_content_queue = lambda: defer.succeed(['foo'])
         self.sd.on_sd_content_queue_changed()
-        self.assertTrue(self.hdlr.check_inf("SD Content Queue changed"))
-        self.assertTrue(self.hdlr.check_inf(
+        self.assertTrue(self.hdlr.check_info("SD Content Queue changed"))
+        self.assertTrue(self.hdlr.check_info(
                         "Content Queue info is new! 1 items"))
 
     def test_on_status_changed(self):
         """Log status changed."""
         self.sd.on_sd_status_changed('name', 'description', False, True,
                                      False, 'queues', 'connection')
-        self.assertTrue(self.hdlr.check_inf("SD Status changed"))
-        self.assertTrue(self.hdlr.check_dbg("    new status: name=u'name', "
+        self.assertTrue(self.hdlr.check_info("SD Status changed"))
+        self.assertTrue(self.hdlr.check_debug("    new status: name=u'name', "
             "description=u'description', is_error=False, is_connected=True, "
             "is_online=False, queues=u'queues', connection=u'connection'"))
 
     def test_folders_changed(self):
         """Log when folders changed."""
         self.sd.on_sd_folders_changed()
-        self.assertTrue(self.hdlr.check_inf("SD Folders changed"))
+        self.assertTrue(self.hdlr.check_info("SD Folders changed"))
 
     def test_shares_changed(self):
         """Log when shares changed."""
         self.sd.on_sd_shares_changed()
-        self.assertTrue(self.hdlr.check_inf("SD Shares changed"))
+        self.assertTrue(self.hdlr.check_info("SD Shares changed"))
 
     def test_on_name_owner_changed(self):
         """Log name owner changed."""
         self.sd.on_sd_name_owner_changed(True)
-        self.assertTrue(self.hdlr.check_inf("SD Name Owner changed: True"))
+        self.assertTrue(self.hdlr.check_info("SD Name Owner changed: True"))
+
+
+class MetadataTests(BaseTest):
+    """Get Metadata info."""
+
+    def test_get_metadata_no_callback_set(self):
+        """It's mandatory to set the callback for this response."""
+        self.assertRaises(ValueError, self.sd.get_metadata, 'path')
+
+    def test_get_metadata_ok(self):
+        """Get the metadata for given path."""
+        called = []
+        self.sd.dbus.get_metadata = lambda p: defer.succeed('foo')
+        self.sd.on_metadata_ready_callback = lambda *a: called.extend(a)
+        self.sd.get_metadata('path')
+        self.assertEqual(called, ['path', 'foo'])
+
+    def test_get_metadata_double(self):
+        """Get the metadata twice."""
+        called = []
+        fake_md = {'path1': 'foo', 'path2': 'bar'}
+        self.sd.dbus.get_metadata = lambda p: defer.succeed(fake_md[p])
+        self.sd.on_metadata_ready_callback = lambda *a: called.append(a)
+        self.sd.get_metadata('path1')
+        self.sd.get_metadata('path2')
+        self.assertEqual(called[0], ('path1', 'foo'))
+        self.assertEqual(called[1], ('path2', 'bar'))
 
 
 class FoldersTests(BaseTest):
     """Folders checking."""
 
     def test_foldercreated_callback(self):
-        """Gets the new data after the folders changed."""
+        """Get the new data after the folders changed."""
         # set the callback
         called = []
         self.sd.dbus.get_folders = lambda: called.append(True)
@@ -740,7 +851,7 @@
 
     @defer.inlineCallbacks
     def test_initial_value(self):
-        """Fills the folder info initially."""
+        """Fill the folder info initially."""
         called = []
         self.sd.dbus.get_folders = lambda: called.append(True)
         yield self.sd._get_initial_data()
@@ -763,7 +874,7 @@
     """Shares checking."""
 
     def test_shares_changed_callback(self):
-        """Gets the new data after the shares changed."""
+        """Get the new data after the shares changed."""
         # set the callback
         called = []
         self.sd.dbus.get_shares_to_me = lambda: called.append(True)
@@ -777,7 +888,7 @@
 
     @defer.inlineCallbacks
     def test_initial_value(self):
-        """Fills the folder info initially."""
+        """Fill the folder info initially."""
         called = []
         self.sd.dbus.get_shares_to_me = lambda: called.append(True)
         self.sd.dbus.get_shares_to_others = lambda: called.append(True)
@@ -793,7 +904,7 @@
 
         # they changed!
         self.sd.shares_to_me = 'foo'
-        self.sd.shares_to_others = 'fakedata' # what fake dbus will return
+        self.sd.shares_to_others = 'fakedata'  # what fake dbus will return
         self.sd.on_sd_shares_changed()
 
         # test
@@ -808,7 +919,7 @@
 
         # they changed!
         self.sd.shares_to_others = 'foo'
-        self.sd.shares_to_me = 'fakedata' # what fake dbus will return
+        self.sd.shares_to_me = 'fakedata'  # what fake dbus will return
         self.sd.on_sd_shares_changed()
 
         # test
 
=== modified file 'setup.py'
--- setup.py	2010-06-08 10:53:02 +0000
+++ setup.py	2010-07-09 18:33:43 +0000
@@ -4,7 +4,9 @@
 # This file is in the public domain
 ### END LICENSE
 
-###################### DO NOT TOUCH THIS (HEAD TO THE SECOND PART) ######################
+"""Build tar.gz and related for magicicada."""
+
+################# DO NOT TOUCH THIS (HEAD TO THE SECOND PART) #################
 
 import os
 import sys
@@ -12,24 +14,28 @@
 try:
     import DistUtilsExtra.auto
 except ImportError:
-    print >> sys.stderr, 'To build magicicada you need https://launchpad.net/python-distutils-extra'
+    url = 'https://launchpad.net/python-distutils-extra'
+    print >> sys.stderr, 'To build magicicada you need', url
     sys.exit(1)
-assert DistUtilsExtra.auto.__version__ >= '2.18', 'needs DistUtilsExtra.auto >= 2.18'
+assert DistUtilsExtra.auto.__version__ >= '2.18', \
+       'needs DistUtilsExtra.auto >= 2.18'
+
 
 def update_data_path(prefix, oldvalue=None):
+    """Update data path."""
 
     try:
         fin = file('magicicada/magicicadaconfig.py', 'r')
         fout = file(fin.name + '.new', 'w')
 
-        for line in fin:            
-            fields = line.split(' = ') # Separate variable from value
+        for line in fin:
+            fields = line.split(' = ')  # Separate variable from value
             if fields[0] == '__magicicada_data_directory__':
                 # update to prefix, store oldvalue
                 if not oldvalue:
                     oldvalue = fields[1]
                     line = "%s = '%s'\n" % (fields[0], prefix)
-                else: # restore oldvalue
+                else:  # restore oldvalue
                     line = "%s = %s" % (fields[0], oldvalue)
             fout.write(line)
 
@@ -37,19 +43,20 @@
         fout.close()
         fin.close()
         os.rename(fout.name, fin.name)
-    except (OSError, IOError), e:
+    except (OSError, IOError):
         print ("ERROR: Can't find magicicada/magicicadaconfig.py")
         sys.exit(1)
     return oldvalue
 
 
 def update_desktop_file(datadir):
+    """Update desktop file."""
 
     try:
         fin = file('magicicada.desktop.in', 'r')
         fout = file(fin.name + '.new', 'w')
 
-        for line in fin:            
+        for line in fin:
             if 'Icon=' in line:
                 line = "Icon=%s\n" % (datadir + 'media/icon.png')
             fout.write(line)
@@ -57,33 +64,33 @@
         fout.close()
         fin.close()
         os.rename(fout.name, fin.name)
-    except (OSError, IOError), e:
+    except (OSError, IOError):
         print ("ERROR: Can't find magicicada.desktop.in")
         sys.exit(1)
 
 
 class InstallAndUpdateDataDirectory(DistUtilsExtra.auto.install_auto):
+    """Install and update data dir."""
+
     def run(self):
+        """Run."""
         previous_value = update_data_path(self.prefix + '/share/magicicada/')
         update_desktop_file(self.prefix + '/share/magicicada/')
         DistUtilsExtra.auto.install_auto.run(self)
         update_data_path(self.prefix, previous_value)
 
 
-        
-##################################################################################
-###################### YOU SHOULD MODIFY ONLY WHAT IS BELOW ######################
-##################################################################################
+##############################################################################
+#################### YOU SHOULD MODIFY ONLY WHAT IS BELOW ####################
+##############################################################################
 
 DistUtilsExtra.auto.setup(
     name='magicicada',
-    version='0.1.1',
+    version='0.1.2',
     license='GPL-3',
     author='Natalia Bidart',
     author_email='[e-mail]',
-    description='A GTK+ frontend for the "Chicharra" part of Ubuntu One client.',
+    description='A GTK+ frontend for the "Chicharra" part of Ubuntu One.',
     #long_description='Here a longer description',
     url='https://launchpad.net/magicicada',
-    cmdclass={'install': InstallAndUpdateDataDirectory}
-    )
-
+    cmdclass={'install': InstallAndUpdateDataDirectory})