Merge lp:~nataliabidart/magicicada-gui/multiple-metadata-for-real into lp:magicicada-gui

[Natalia Bidart]

Multiple metadata windows are now supported. Yeyyyy!

[Facundo Batista (facundo)]

===============================================================================
[FAIL]: magicicada.tests.test_magicicada.MagicicadaUIMetadataTestCase.test_metadata_dialog_properties

Traceback (most recent call last):
  File "/home/facundo/devel/reps/magicicada/review_multiple-metadata-for-real/magicicada/tests/test_magicicada.py", line 1268, in test_metadata_dialog_properties
    self.assert_dialog_properties(dialog=dialog, title=title, modal=False)
  File "/home/facundo/devel/reps/magicicada/review_multiple-metadata-for-real/magicicada/tests/test_magicicada.py", line 221, in assert_dialog_properties
    '%s must be centered.' % dialog_name)
twisted.trial.unittest.FailTest: None must be centered.
not equal:
a = <enum GTK_WIN_POS_CENTER of type GtkWindowPosition>
b = <enum GTK_WIN_POS_MOUSE of type GtkWindowPosition>

-------------------------------------------------------------------------------
Ran 336 tests in 11.971s

FAILED (failures=1, successes=335)

review: Needs Fixing

[lp:~nataliabidart/magicicada-gui/multiple-metadata-for-real]

68. By Natalia Bidart on 2010-08-01

Fixing failing test.

[Natalia Bidart (nataliabidart)]

> ==============================================================================
> =
> [FAIL]: magicicada.tests.test_magicicada.MagicicadaUIMetadataTestCase.test_met
> adata_dialog_properties

Fixed!

[lp:~nataliabidart/magicicada-gui/multiple-metadata-for-real]

69. By Natalia Bidart on 2010-08-01

Merged trunk in.

[Facundo Batista (facundo)]

Looks ok now!

review: Approve

=== modified file 'data/ui/gui.glade'
--- data/ui/gui.glade	2010-07-18 20:58:35 +0000
+++ data/ui/gui.glade	2010-08-01 14:53:41 +0000
@@ -256,13 +256,13 @@
               </packing>
             </child>
             <child>
-              <object class="GtkToolButton" id="raw_metadata">
+              <object class="GtkToolButton" id="metadata">
                 <property name="visible">True</property>
                 <property name="sensitive">False</property>
                 <property name="label" translatable="yes">Metadata</property>
                 <property name="use_underline">True</property>
                 <property name="stock_id">gtk-find</property>
-                <signal name="clicked" handler="on_raw_metadata_clicked"/>
+                <signal name="clicked" handler="on_metadata_clicked"/>
               </object>
               <packing>
                 <property name="expand">False</property>
@@ -980,6 +980,7 @@
   </object>
   <object class="GtkFileChooserDialog" id="file_chooser">
     <property name="border_width">5</property>
+    <property name="window_position">center</property>
     <property name="type_hint">normal</property>
     <property name="has_separator">False</property>
     <property name="create_folders">False</property>

=== modified file 'magicicada/__init__.py'
--- magicicada/__init__.py	2010-07-18 20:58:35 +0000
+++ magicicada/__init__.py	2010-08-01 14:53:41 +0000
@@ -57,6 +57,13 @@
     logger.addHandler(console)
 
 
+# Instance of 'A' has no 'y' member
+# pylint: disable-msg=E1101
+
+# Unused argument, we need them for GTK callbacks
+# pylint: disable-msg=W0613
+
+
 class MagicicadaUI(object):
     """Magicicada GUI main class."""
 
@@ -97,8 +104,7 @@
             'shares_to_me_view', 'shares_to_me_store', 'shares_to_me_close',
             'shares_to_others', 'shares_to_others_dialog',  # shares_to_others
             'shares_to_others_view', 'shares_to_others_store',
-            'shares_to_others_close',
-            'raw_metadata',  # raw metadata
+            'shares_to_others_close', 'metadata',  # 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
@@ -117,7 +123,7 @@
         self._make_view_sortable('shares_to_me')
         self._make_view_sortable('shares_to_others')
 
-        self.raw_metadata_dialog = self._new_metadata_dialog()
+        self.metadata_dialogs = {}
         self.volumes = (self.folders, self.shares_to_me, self.shares_to_others)
         self.windows = (self.main_window, self.about_dialog,
                          self.folders_dialog)
@@ -146,7 +152,6 @@
         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()
 
     def _make_view_sortable(self, view_name):
@@ -159,23 +164,24 @@
             col.connect('clicked', self.on_store_sort_column_changed, i, store)
             self._sorting_order[store][i] = gtk.SORT_ASCENDING
 
-    def _new_metadata_dialog(self):
+    def _new_metadata_dialog(self, path):
         """Return a new metadata dialog."""
-        dialog = gtk.Dialog(title='Raw metadata', parent=self.main_window,
+        dialog = gtk.Dialog(title='Metadata for %s' % path,
+                            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)
+        # gtk.WIN_POS_CENTER makes dialog overlap
+        dialog.set_position(gtk.WIN_POS_MOUSE)
 
         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)
+        close_button.connect('clicked', self.on_metadata_close_clicked, path)
+        close_button.connect('activate', self.on_metadata_close_clicked, path)
+        dialog.close = close_button
 
         image = gtk.Image()
         image.set_from_animation(self.loading_animation)
-        setattr(self, 'raw_metadata_image', image)
+        dialog.image = image
 
         dialog.get_child().add(image)
 
@@ -183,9 +189,9 @@
         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.view = text_view
 
-        dialog.hide()  # XXX to be fixed later
+        self.metadata_dialogs[path] = dialog
         return dialog
 
     # GTK callbacks
@@ -215,7 +221,7 @@
         """Stop syncdaemon."""
         for v in self.volumes:
             v.set_sensitive(False)
-        self.raw_metadata.set_sensitive(False)
+        self.metadata.set_sensitive(False)
 
         if self.widget_enabled(self.disconnect):
             self.on_disconnect_clicked(self.disconnect)
@@ -301,26 +307,28 @@
 
     def on_file_chooser_show(self, widget, data=None):
         """Close the file_chooser dialog."""
-        if self.last_metadata_path is None:
-            self.file_chooser.set_current_folder(self._u1_root)
-
-    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."""
+        #if self.last_metadata_path is None:
+        self.file_chooser.set_current_folder(self._u1_root)
+
+    def on_metadata_close_clicked(self, widget, path):
+        """Close the metadata dialog."""
+        self.metadata_dialogs[path].destroy()
+
+    def on_metadata_clicked(self, widget, data=None):
+        """Show 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()
+        path = self.file_chooser.get_filename()
+        assert path is not None
+        dialog = self._new_metadata_dialog(path)
+        self.sd.get_metadata(path)
+        dialog.view.hide()
+        dialog.image.show()
+        self._start_loading(dialog.image)
+        dialog.show()
 
     def on_status_icon_activate(self, widget, data=None):
         """Systray icon was clicked."""
@@ -362,7 +370,7 @@
 
         for v in self.volumes:
             v.set_sensitive(True)
-        self.raw_metadata.set_sensitive(True)
+        self.metadata.set_sensitive(True)
 
         self._update_queues_and_status(self.sd.current_state)
 
@@ -457,14 +465,15 @@
     @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:
+        logger.debug('on_metadata_ready: path: %r', path)
+        if path not in self.metadata_dialogs:
             return
-        self.raw_metadata_image.hide()
-        self.raw_metadata_view.show()
+
+        dialog = self.metadata_dialogs[path]
+        dialog.image.hide()
+        dialog.view.show()
         text = '\n'.join('%s: %s' % i for i in metadata.iteritems())
-        self.raw_metadata_view.get_buffer().set_text(text)
+        dialog.view.get_buffer().set_text(text)
 
     # custom
 

=== modified file 'magicicada/tests/test_magicicada.py'
--- magicicada/tests/test_magicicada.py	2010-07-28 21:48:34 +0000
+++ magicicada/tests/test_magicicada.py	2010-08-01 14:53:41 +0000
@@ -39,9 +39,16 @@
 
 # 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
 
+# Instance of 'A' has no 'y' member
+# pylint: disable-msg=E1101
+
+# Instance of 'A' has no 'y' member (but some types could not be inferred)
+# pylint: disable-msg=E1103
+
 
 def process_gtk_pendings():
     """Process all gtk pending events."""
@@ -74,7 +81,7 @@
     """A faked syncdaemon."""
 
     def __init__(self):
-        self._meta_path = None
+        self._meta_paths = []
 
         self.current_state = syncdaemon.State()
         self.meta_queue = []
@@ -100,7 +107,7 @@
                                        'is_connected', True)
         self.disconnect = lambda: \
                           setattr(self.current_state, 'is_connected', False)
-        self.get_metadata = lambda path: setattr(self, '_meta_path', path)
+        self.get_metadata = lambda path: self._meta_paths.append(path)
 
 
 class MagicicadaUITestCase(TestCase):
@@ -220,10 +227,12 @@
         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):
+    def assert_dialog_properties(self, dialog_name=None, title=None,
+                                 size=(600, 300), modal=True, dialog=None):
         """The dialog 'dialog_name' has correct properties."""
-        dialog = getattr(self.ui, dialog_name)
+        assert (dialog_name is None) ^ (dialog is None)
+        if dialog is None:
+            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))
@@ -233,8 +242,10 @@
                          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)
+        expected = gtk.WIN_POS_CENTER if dialog_name is not None else \
+                                      gtk.WIN_POS_MOUSE
+        msg = 'dialog must have %s position (got %s instead).'
+        self.assertEqual(expected, position, msg % (expected, position))
 
         actual = dialog.get_title()
         msg = '%s title must be %s (got %s instead)'
@@ -1046,14 +1057,14 @@
     def test_volume_sorting(self):
         """Test volume panel can be re-sorted."""
         for i, col in enumerate(self.volume_view.get_columns()):
-            col.clicked() # click on the column
+            col.clicked()  # click on the column
             self.assert_sort_order_correct(col, i, gtk.SORT_ASCENDING)
             self.assert_sort_indicator_correct(col)
 
-            col.clicked() # click on the column, sort order must change
+            col.clicked()  # click on the column, sort order must change
             self.assert_sort_order_correct(col, i, gtk.SORT_DESCENDING)
 
-            col.clicked() # click again, sort order must be the first one
+            col.clicked()  # click again, sort order must be the first one
             self.assert_sort_order_correct(col, i, gtk.SORT_ASCENDING)
 
 
@@ -1125,7 +1136,7 @@
 class MagicicadaUIMetadataTestCase(MagicicadaUITestCase):
     """UI test cases for metadata display."""
 
-    name = 'raw_metadata'
+    name = 'metadata'
 
     def setUp(self):
         """Init."""
@@ -1138,23 +1149,38 @@
         s = super(MagicicadaUIMetadataTestCase, self)
         s.assert_widget_availability(self.name, enabled)
 
-    def assert_dialog_visibility(self, dialog, text_view, image):
+    def assert_dialog_visibility(self, dialog, text_view, image, path=None):
         """Check the visibility for dialog, text_view and image."""
+        if path is None:
+            path = self.path
+
         msg = '%s visibility should be %s (got %s instead).'
-        visible = self.ui.widget_is_visible(self.ui.raw_metadata_dialog)
+        metadata_dialog = self.ui.metadata_dialogs[path]
+        visible = self.ui.widget_is_visible(metadata_dialog)
         self.assertEqual(dialog, visible,
-                         msg % ('raw_metadata_dialog', dialog, visible))
+                         msg % ('metadata_dialog', dialog, visible))
 
-        visible = self.ui.widget_is_visible(self.ui.raw_metadata_view)
+        visible = self.ui.widget_is_visible(metadata_dialog.view)
         self.assertEqual(text_view, visible,
-                         msg % ('raw_metadata_view', text_view, visible))
+                         msg % ('metadata_view', text_view, visible))
 
-        visible = self.ui.widget_is_visible(self.ui.raw_metadata_image)
+        visible = self.ui.widget_is_visible(metadata_dialog.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."""
+                         msg % ('metadata_image', image, visible))
+
+    def assert_buffer_content(self, path, expected):
+        """Check that the buffer content is correct for 'path'."""
+        buff = self.ui.metadata_dialogs[path].view.get_buffer()
+        self.assertTrue(buff is not None,
+                        'buffer for metadata_view must not be None.')
+
+        expected = '\n'.join('%s: %s' % i for i in expected.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_metadata_are_disabled_until_started(self):
+        """Metadata button is disabled until online."""
         # disabled at startup
         self.assert_widget_availability(enabled=False)
 
@@ -1162,8 +1188,8 @@
         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."""
+    def test_metadata_are_enabled_until_stopped(self):
+        """Metadata button is enabled until offline."""
         self.do_connect()
         self.assert_widget_availability(enabled=True)
 
@@ -1183,12 +1209,12 @@
         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_metadata_close_hides_the_dialog(self):
+        """Test metadata close button emits RESPONSE_CLOSE when clicked."""
+        dialog = self.ui._new_metadata_dialog(self.path)
+        dialog.close.clicked()
+        visible = self.ui.widget_is_visible(dialog)
+        self.assertFalse(visible, 'metadata_dialog should not be visible.')
 
     def test_file_chooser_open_emits_response_ok(self):
         """Test volume close button emits RESPONSE_CLOSE when clicked."""
@@ -1203,14 +1229,10 @@
         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."""
+    def test_on_metadata_clicked(self):
+        """Test on_metadata_clicked."""
         self.ui._u1_root = os.path.dirname(self.path)
 
-        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():
@@ -1220,34 +1242,37 @@
 
         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.ui.on_metadata_clicked(self.ui.metadata)
+
+        # dialog must exist now
+        dialog = self.ui.metadata_dialogs[self.path]
 
         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
+        # 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()
+        expected = dialog.image.get_animation()
         self.assertEqual(self.ui.loading_animation, expected,
-                     'raw_metadata_image must have the correct animation.')
+                     '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)
+        self.assertEqual(1, len(self.ui.sd._meta_paths))
+        self.assertEqual(self.ui.sd._meta_paths[0], 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
+        # 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.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.')
+        visible = self.ui.widget_is_visible(dialog)
+        self.assertFalse(visible, 'metadata_dialog should not be visible.')
 
     def test_file_chooser_folder_is_u1root_when_visible(self):
         """File chooser folder is ~/Ubuntu One only when visible."""
@@ -1256,19 +1281,20 @@
                             "shouldn't have U1 folder before becoming visible")
 
         gobject.timeout_add(100, self.ui.file_chooser_open.clicked)
-        self.ui.on_raw_metadata_clicked(self.ui.raw_metadata)
+        self.ui.file_chooser.run()
 
         self.assertEqual(self.ui.file_chooser.get_current_folder(),
                          UBUNTU_ONE_ROOT,
                          'should have U1 folder after becoming 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)
+    def test_metadata_dialog_properties(self):
+        """The metadata dialog has correct properties."""
+        title = '%s for %s' % (self.name.replace('_', ' ').capitalize(),
+                               self.path)
+        dialog = self.ui._new_metadata_dialog(self.path)
+        self.assert_dialog_properties(dialog=dialog, title=title, modal=False)
 
-        actual = self.ui.raw_metadata_view.get_wrap_mode()
+        actual = dialog.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)
 
@@ -1288,51 +1314,83 @@
         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.ui.on_metadata_clicked(self.ui.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.')
+        """Filename is stored in the metadata dicts if user clicked open."""
+        self.assertEqual(self.ui.metadata_dialogs, {},
+                        'dialogs must be empty.')
         self.ui._u1_root = os.path.dirname(self.path)
         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.ui.on_metadata_clicked(self.ui.metadata)
 
-        self.assertEqual(self.path, self.ui.last_metadata_path,
-                         'last_metadata_path should be what the user choose.')
+        self.assertEqual([self.path], self.ui.metadata_dialogs.keys(),
+                         'metadata dict keys should be what the user choose.')
 
     def test_on_metadata_ready(self):
-        """Callback on_metadata_ready updates the raw_metadata_view."""
+        """Callback on_metadata_ready updates the metadata_view."""
         path = 'bla'
-        self.ui.last_metadata_path = path
+        self.ui.metadata_dialogs = {path: self.ui._new_metadata_dialog(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))
+        self.assert_buffer_content(path, self.metadata)
 
     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)
+        """Callback on_metadata_ready updates the metadata_view."""
+        self.patch(self.ui, '_new_metadata_dialog', self.set_called)
         path = 'bla'
-        self.ui.last_metadata_path = path + path
+        assert path not in self.ui.metadata_dialogs
         self.ui.on_metadata_ready(path, self.metadata)
 
         self.assertFalse(self.called,
                          'view should not be updated if key is not last one.')
 
+    def test_two_metadata_windows(self):
+        """More than one metadata window is allowed."""
+        self.patch(self.ui.file_chooser, 'run',
+                   lambda: gtk.FILE_CHOOSER_ACTION_OPEN)
+
+        path1 = os.path.abspath(self.mktemp())
+        open(path1, 'w').close()
+        assert os.path.exists(path1)
+        meta1 = {'value': 'Lorem ipsum dolor sit amet.'}
+
+        path2 = os.path.abspath(self.mktemp())
+        open(path2, 'w').close()
+        assert os.path.exists(path2)
+        meta2 = {'value': 'Etiam iaculis congue nisl.'}
+
+        self.ui.file_chooser.get_filename = lambda: path1
+        self.ui.on_metadata_clicked(self.ui.metadata)
+
+        self.ui.file_chooser.get_filename = lambda: path2
+        self.ui.on_metadata_clicked(self.ui.metadata)
+
+        # Check that the UI has 2 metadata dialogs
+        self.assertTrue(2, len(self.ui.metadata_dialogs))
+
+        # Check that the metadata was asked to the SD
+        self.assertEqual(2, len(self.ui.sd._meta_paths))
+        self.assertEqual(self.ui.sd._meta_paths[0], path1)
+        self.assertEqual(self.ui.sd._meta_paths[1], path2)
+
+        # SD will eventually callback us with the metadata
+        self.ui.on_metadata_ready(path1, meta1)
+        # SD will eventually callback us with the metadata
+        self.ui.on_metadata_ready(path2, meta2)
+
+        self.assert_buffer_content(path1, meta1)
+        self.assert_buffer_content(path2, meta2)
+
+        # user closes the dialog
+        self.ui.metadata_dialogs[path1].close.clicked()
+        self.ui.metadata_dialogs[path2].close.clicked()
+
 
 def override_input_output(input_args, output_args):
     """Call 'f' but receive fixed input and return fixed output."""

=== modified file 'pylintrc'
--- pylintrc	2010-07-16 00:48:22 +0000
+++ pylintrc	2010-08-01 14:53:41 +0000
@@ -57,7 +57,8 @@
 
 # Disable the message(s) with the given id(s).
 W0108: Lambda may not be necessary
-disable-msg=W0142, W0613, W0108
+R0923: Interface not implemented
+disable-msg=W0142, W0613, W0108, R0923
 
 
 [REPORTS]