Merge lp:~nataliabidart/magicicada-gui/get-metadata-ui into lp:magicicada-gui

[Natalia Bidart]

Get raw metadata functionality for the GUI.

Depends on lp:~facundo/magicicada/show-md for running the binary in real life, not for tests (since those use a faked syncdaemon).
This branch may be tweaked if we decide that the "code" for the SD will be the same as the path to which metadata is requested.

[Facundo Batista (facundo)]

User should be able to open two "metadata" popups (this is specially useful to compare information).

Right now, if you click again on metada to see other file, the previous content is lost.

review: Needs Fixing

[Natalia Bidart (nataliabidart)]

I opened a bug for the requested behavior: https://bugs.launchpad.net/magicicada/+bug/594268

[lp:~nataliabidart/magicicada-gui/get-metadata-ui]

50. By Natalia Bidart on 2010-06-14

API no longuer uses a dedicated code gor getting metadata but the path.

51. By Natalia Bidart on 2010-06-14

Stringifying the metadata dict.

[Facundo Batista (facundo)]

Ok, so.

review: Approve

[lp:~nataliabidart/magicicada-gui/get-metadata-ui]

52. By Natalia Bidart on 2010-06-14

Merged trunk in.

=== added directory 'data/tests'
=== added file 'data/tests/metadata-test.txt'
=== modified file 'data/ui/gui.glade'
--- data/ui/gui.glade	2010-06-05 19:46:04 +0000
+++ data/ui/gui.glade	2010-06-14 23:37:28 +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>
@@ -1051,4 +1052,130 @@
       <action-widget response="0">shares_to_others_close</action-widget>
     </action-widgets>
   </object>
+  <object class="GtkDialog" id="raw_metadata_dialog">
+    <property name="width_request">600</property>
+    <property name="height_request">300</property>
+    <property name="border_width">5</property>
+    <property name="title" translatable="yes">Raw metadata</property>
+    <property name="window_position">center</property>
+    <property name="type_hint">normal</property>
+    <property name="has_separator">False</property>
+    <signal name="close" handler="on_raw_metadata_close_clicked"/>
+    <child internal-child="vbox">
+      <object class="GtkVBox" id="dialog-vbox9">
+        <property name="visible">True</property>
+        <property name="spacing">2</property>
+        <child>
+          <object class="GtkTextView" id="raw_metadata_view">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="editable">False</property>
+            <property name="wrap_mode">word</property>
+          </object>
+          <packing>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkImage" id="raw_metadata_image">
+            <property name="visible">True</property>
+            <property name="stock">gtk-missing-image</property>
+          </object>
+          <packing>
+            <property name="position">2</property>
+          </packing>
+        </child>
+        <child internal-child="action_area">
+          <object class="GtkHButtonBox" id="dialog-action_area9">
+            <property name="visible">True</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="raw_metadata_close">
+                <property name="label">gtk-close</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_raw_metadata_close_clicked"/>
+                <signal name="activate" handler="on_raw_metadata_close_clicked"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="pack_type">end</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="0">raw_metadata_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>
+    <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 'magicicada/__init__.py'
--- magicicada/__init__.py	2010-06-08 21:14:28 +0000
+++ magicicada/__init__.py	2010-06-14 23:37:28 +0000
@@ -68,19 +68,26 @@
 
         widgets = (
             '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_store', 'shares_to_me_close',
+
             'shares_to_others', 'shares_to_others_dialog', # shares_to_others
             'shares_to_others_store', 'shares_to_others_close',
+
+            'raw_metadata', 'raw_metadata_dialog', # raw metadata
+            'raw_metadata_close', 'raw_metadata_view', 'raw_metadata_image',
+
             '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
+            'file_chooser', 'file_chooser_open', 'file_chooser_cancel',
             'main_window'
         )
         for widget in widgets:
@@ -111,11 +118,12 @@
         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.last_metadata_path = None
         self.update()
 
     # GTK callbacks
@@ -145,6 +153,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)
@@ -221,8 +230,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."""
@@ -243,6 +271,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)
 
@@ -332,6 +361,14 @@
         highlight = state.processing_meta and state.is_online
         self._on_queue_changed(META_QUEUE, items, highlight)
 
+    def on_metadata_ready(self, path, metadata):
+        """Lower layer has the requested metadata for 'path'."""
+        if path != self.last_metadata_path:
+            return
+        self.raw_metadata_image.hide()
+        self.raw_metadata_view.show()
+        self.raw_metadata_view.get_buffer().set_text(str(metadata))
+
     # custom
 
     def _start_loading(self, what):

=== modified file 'magicicada/tests/test_magicicada.py'
--- magicicada/tests/test_magicicada.py	2010-06-08 21:14:28 +0000
+++ magicicada/tests/test_magicicada.py	2010-06-14 23:37:28 +0000
@@ -28,20 +28,28 @@
 
 from magicicada import MagicicadaUI, CONTENT_QUEUE, META_QUEUE, 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
 
 def process_gtk_pendings():
     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()
+    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
 
 
@@ -49,6 +57,8 @@
     """A faked syncdaemon."""
 
     def __init__(self):
+        self._meta_path = None
+
         self.current_state = syncdaemon.State()
         self.meta_queue = []
         self.content_queue = []
@@ -64,13 +74,15 @@
         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.disconnect = lambda: \
+                          setattr(self.current_state, 'is_connected', False)
+        self.get_metadata = lambda path: setattr(self, '_meta_path', path)
 
 
 class MagicicadaUITestCase(TestCase):
@@ -79,13 +91,13 @@
     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.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."""
@@ -134,21 +146,34 @@
 
     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')
+        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')
+        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 '))
 
 
 class MagicicadaUIBasicTestCase(MagicicadaUITestCase):
@@ -163,7 +188,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):
@@ -198,7 +223,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.')
 
 
@@ -221,7 +246,7 @@
         """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."""
@@ -240,7 +265,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."""
@@ -249,7 +274,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))
@@ -265,13 +290,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."""
@@ -286,7 +311,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):
@@ -431,7 +456,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
@@ -560,7 +585,7 @@
         """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."""
@@ -600,7 +625,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):
@@ -767,6 +792,7 @@
         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."""
@@ -774,46 +800,42 @@
         res = super(_MagicicadaUIVolumeTestCase, self).build_some_data(**kwargs)
         return res
 
-    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):
@@ -824,10 +846,9 @@
             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):
@@ -882,7 +903,7 @@
         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)
@@ -900,6 +921,7 @@
         self.assertEqual(expected, actual,
                          msg % (self.volume_dialog_name, expected, actual))
 
+
 class MagicicadaUIFoldersTestCase(_MagicicadaUIVolumeTestCase):
     """UI test cases for folders."""
 
@@ -945,3 +967,203 @@
 
     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."""
+        self.response = None
+        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."""
+        dialog = 'raw_metadata_dialog'
+        size = self.ui.raw_metadata_dialog.size_request()
+        self.assertEquals((600, 300), size)
+
+        self.assertFalse(self.ui.raw_metadata_dialog.get_modal(),
+                         '%s must not be modal.' % dialog)
+
+        position = self.ui.raw_metadata_dialog.get_property('window-position')
+        self.assertEqual(gtk.WIN_POS_CENTER, position,
+                        '%s must be centered.' % dialog)
+
+        actual = self.ui.raw_metadata_dialog.get_title()
+        expected = self.name.replace('_', ' ').capitalize()
+        msg = '%s title must be %s (got %s instead)'
+        self.assertEqual(expected, actual, msg % (dialog, expected, actual))
+
+        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_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)
+
+        buffer = self.ui.raw_metadata_view.get_buffer()
+        self.assertTrue(buffer is not None,
+                    'buffer for raw_metadata_view must not be None.')
+        actual = buffer.get_text(*buffer.get_bounds())
+        msg = 'buffer content must be %s (got %s instead).'
+        self.assertEqual(actual, str(self.metadata),
+                         msg % (self.metadata, 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.')