Merge lp:~nataliabidart/ubuntuone-client/yield-around into lp:ubuntuone-client

[Natalia Bidart]

- volume_manager.add_share returns a deferred now, yield on it (part of bug LP: #708335).

- Fix tests that were finishing before the dbus call was completed (LP: #689677).

[lp:~nataliabidart/ubuntuone-client/yield-around]

837. By Natalia Bidart on 2011-02-03

Merged trunk in.

838. By Natalia Bidart on 2011-02-03

ZG tests should also yield on vm.add_share.

[Eric Casteleijn (thisfred)]

Looks good!

review: Approve

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'tests/eventlog/test_zg_listener.py'
--- tests/eventlog/test_zg_listener.py	2011-01-28 15:23:20 +0000
+++ tests/eventlog/test_zg_listener.py	2011-02-03 17:29:42 +0000
@@ -213,7 +213,7 @@
         self.main.fs.set_node_id(path, sample_node_id)
         share = Shared(path=path, volume_id=sample_share_id,
                        node_id=sample_node_id, other_username=fake_username)
-        self.vm.add_shared(share)
+        yield self.vm.add_shared(share)
 
         def fake_delete_share(share_id):
             """Fake delete_share."""
@@ -250,6 +250,7 @@
         self.assertEqual(other_user.manifestation,
                           MANIFESTATION_U1_CONTACT_DATA_OBJECT)
 
+    @defer.inlineCallbacks
     def test_share_accepted_is_logged(self):
         """Test that an accepted share event is logged."""
         # initialize the the root
@@ -260,7 +261,7 @@
         share_path = os.path.join(self.shares_dir, 'fake_share')
         share = Share(path=share_path, volume_id='volume_id', node_id="node_id",
                       other_username=fake_username)
-        self.vm.add_share(share)
+        yield self.vm.add_share(share)
 
         self.assertEqual(len(self.listener.zg.events), 1)
         event = self.listener.zg.events[0]
@@ -300,7 +301,8 @@
                                                      fake_username,
                                                      u'visible_name', 'Read')
 
-        self.main.vm.add_share(Share.from_notify_holder(holder, share_path))
+        share = Share.from_notify_holder(holder, share_path)
+        yield self.main.vm.add_share(share)
         self._listen_for('VM_VOLUME_DELETED', d.callback, 1, collect=True)
         self.main.event_q.push('SV_SHARE_DELETED', share_id=holder.share_id)
         yield d
@@ -1092,8 +1094,8 @@
         public_url = 'http://example.com/foo.mp3'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share',
-                               other_username='other username'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share',
+                                           other_username='other username'))
         path = os.path.join(share_path, "foo.mp3")
         self.main.fs.create(path, str(share_id))
         self.main.fs.set_node_id(path, str(node_id))
@@ -1132,8 +1134,8 @@
         public_url = 'http://example.com/foo.mp3'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share',
-                               other_username='other username'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share',
+                                           other_username='other username'))
         path = os.path.join(share_path, "foo.mp3")
         self.main.fs.create(path, str(share_id))
         self.main.fs.set_node_id(path, str(node_id))
 
=== modified file 'tests/platform/linux/test_dbus.py'
--- tests/platform/linux/test_dbus.py	2011-02-02 13:10:59 +0000
+++ tests/platform/linux/test_dbus.py	2011-02-03 17:29:42 +0000
@@ -424,10 +424,11 @@
 
         return d
 
+    @defer.inlineCallbacks
     def test_get_metadata_path(self):
         """Test the FileSystem Object, getting MD by path."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, "foo")
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -446,12 +447,13 @@
         client = DBusClient(self.bus, '/filesystem', DBUS_IFACE_FS_NAME)
         client.call_method('get_metadata', path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_path_symlink(self):
         """Test the FileSystem Object, getting MD by path in a symlink."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, "foo")
         symlink_path = os.path.join(self.shares_dir, "share_symlink")
         share_context = self.main.fs._enable_share_write('share',
@@ -468,7 +470,8 @@
 
         def callback(result):
             """Callback to check the result."""
-            self.assertEquals(os.path.join(symlink_path, 'foo'), str(result['path']))
+            self.assertEquals(os.path.join(symlink_path, 'foo'),
+                              str(result['path']))
             self.assertEquals('share', result['share_id'])
             self.assertEquals('node_id', result['node_id'])
 
@@ -477,12 +480,13 @@
         client.call_method('get_metadata', os.path.join(symlink_path, 'foo'),
                            reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_share_node(self):
         """Test the FileSystem Object, getting MD by share and node."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, "foo")
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -502,7 +506,7 @@
         client.call_method('get_metadata_by_node', 'share', 'node_id',
                            reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
     def test_push_event(self):
         """Test the exposed method: push_event."""
@@ -540,6 +544,7 @@
         self.event_q.add_empty_event_queue_callback(empty_queue_cb)
         return push_deferred
 
+    @defer.inlineCallbacks
     def test_waiting_content(self):
         """Test Status.waiting_content.
 
@@ -552,7 +557,8 @@
 
         # prepare the VM so it lies for us
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         b_path = os.path.join(share_path, "path_b")
         c_path = os.path.join(share_path, "path_c")
         self.fs_manager.create(b_path, "share_id")
@@ -582,13 +588,15 @@
         client.call_method('waiting_content',
                            reply_handler=waiting_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_waiting_metadata(self):
         """Test Status.waiting_metadata with fake data in the AQ."""
         # prepare the VM so it lies for us
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         b_path = os.path.join(share_path, "path_b")
         c_path = os.path.join(share_path, "path_c")
         d_path = os.path.join(share_path, "path_d")
@@ -635,15 +643,17 @@
         client.call_method('waiting_metadata',
                            reply_handler=waiting_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_and_quick_tree_not_synced(self):
         """Test Status.get_metadata_and_quick_tree_status.
 
         Fake data in the AQ is used.
         """
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        share = Share(path=share_path, volume_id='share')
+        yield self.main.vm.add_share(share)
         path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -669,15 +679,16 @@
         client.call_method('get_metadata_and_quick_tree_synced',
                            path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_and_quick_tree_no_blow_up_kthxbye(self):
         """Test Status.get_metadata_and_quick_tree_status.
 
         Fake data in the AQ is used.
         """
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -704,15 +715,16 @@
         client.call_method('get_metadata_and_quick_tree_synced',
                            path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_and_quick_tree_not_synced_2(self):
         """Test Status.get_metadata_and_quick_tree_status.
 
         Fake data in the AQ is used.
         """
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -738,13 +750,14 @@
         client.call_method('get_metadata_and_quick_tree_synced',
                            path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_and_quick_tree_synced(self):
         """Test Status.get_metadata_and_quick_tree_status
         without fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -766,13 +779,14 @@
         client.call_method('get_metadata_and_quick_tree_synced',
                            path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_get_metadata_and_quick_tree_synced_symlink(self):
         """Test Status.get_metadata_and_quick_tree_status
         without fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -801,7 +815,7 @@
         client.call_method('get_metadata_and_quick_tree_synced',
                            expected_path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
     def test_content_queue_added(self):
         """Test the signal because a command was added to the queue."""
@@ -831,10 +845,12 @@
         self.main.event_q.push('SYS_QUEUE_REMOVED', FakeCommand())
         return d
 
+    @defer.inlineCallbacks
     def test_current_downloads(self):
         """Test Status.current_downloads with fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         down_path = os.path.join(share_path, "down_path")
         self.fs_manager.create(down_path, "share_id")
         self.fs_manager.set_node_id(down_path, "node_id")
@@ -853,12 +869,14 @@
         client.call_method('current_downloads',
                            reply_handler=downloads_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_current_uploads(self):
         """Test Status.current_uploads with fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         up_path = os.path.join(share_path, "up_path")
         self.fs_manager.create(up_path, "share_id")
         self.fs_manager.set_node_id(up_path, "node_id")
@@ -877,7 +895,7 @@
 
         client.call_method('current_uploads', reply_handler=uploads_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
     def test_current_uploads_with_marker(self):
         """Test Status.current_uploads with fake data in the AQ."""
@@ -895,17 +913,20 @@
                            error_handler=self.error_handler)
         return d
 
+    @defer.inlineCallbacks
     def test_two_current_downloads(self):
         """Test Status.current_downloads with fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         down_path = os.path.join(share_path, "down_path")
         self.fs_manager.create(down_path, "share_id")
         self.fs_manager.set_node_id(down_path, "node_id")
         self.action_q.downloading[('share_id', 'node_id')] = dict(
             deflated_size=10, size=100, n_bytes_read=8)
         share1_path = os.path.join(self.shares_dir, 'share1')
-        self.main.vm.add_share(Share(path=share1_path, volume_id='share_id_1'))
+        share1 = Share(path=share1_path, volume_id='share_id_1')
+        yield self.main.vm.add_share(share1)
         down_path_1 = os.path.join(share1_path, "down_path_1")
         self.fs_manager.create(down_path_1, "share_id_1")
         self.fs_manager.set_node_id(down_path_1, "node_id_1")
@@ -927,19 +948,22 @@
         client.call_method('current_downloads',
                            reply_handler=downloads_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_two_current_uploads(self):
         """Test Status.current_uploads with fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         up_path = os.path.join(share_path, "up_path")
         self.fs_manager.create(up_path, "share_id")
         self.fs_manager.set_node_id(up_path, "node_id")
         self.action_q.uploading[('share_id', 'node_id')] = dict(
             deflated_size=100, n_bytes_written=10)
         share1_path = os.path.join(self.shares_dir, 'share1')
-        self.main.vm.add_share(Share(path=share1_path, volume_id='share_id_1'))
+        share1 = Share(path=share1_path, volume_id='share_id_1')
+        yield self.main.vm.add_share(share1)
         up_path_1 = os.path.join(share1_path, "up_path_1")
         self.fs_manager.create(up_path_1, "share_id_1")
         self.fs_manager.set_node_id(up_path_1, "node_id_1")
@@ -961,12 +985,14 @@
 
         client.call_method('current_uploads', reply_handler=uploads_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_current_downloads_deflated_size_NA(self):
         """Test Status.current_downloads with fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         down_path = os.path.join(share_path, "down_path")
         self.fs_manager.create(down_path, "share_id")
         self.fs_manager.set_node_id(down_path, "node_id")
@@ -984,12 +1010,14 @@
         client.call_method('current_downloads',
                            reply_handler=downloads_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_current_uploads_deflated_size_NA(self):
         """Test Status.current_uploads with fake data in the AQ."""
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        share = Share(path=share_path, volume_id='share_id')
+        yield self.main.vm.add_share(share)
         up_path = os.path.join(share_path, "up_path")
         self.fs_manager.create(up_path, "share_id")
         self.fs_manager.set_node_id(up_path, "node_id")
@@ -1007,7 +1035,7 @@
 
         client.call_method('current_uploads', reply_handler=uploads_handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
     def test_nm_signals(self):
         """Test that NM signals are received and handled properly."""
@@ -1036,11 +1064,13 @@
         self.event_q.add_empty_event_queue_callback(empty_queue_cb)
         return d
 
+    @defer.inlineCallbacks
     def test_get_shares(self):
         """Test Shares.get_shares method."""
         share_path = os.path.join(self.main.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
-                                     access_level='Read', accepted=False))
+        share = Share(path=share_path, volume_id='share_id',
+                      access_level='Read', accepted=False)
+        yield self.main.vm.add_share(share)
         client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
         d = defer.Deferred()
         def check(shares):
@@ -1056,19 +1086,21 @@
                     self.assertEquals('share_id', str(share['volume_id']))
                     self.assertEquals(share_path, str(share['path']))
                     self.assertEquals('Read', str(share['access_level']))
-                    self.assertEquals('False', str(share['accepted']))
+                    self.assertEquals('', str(share['accepted']))
 
         def shares_handler(shares):
             d.callback(shares)
 
         client.call_method('get_shares', reply_handler=shares_handler,
                            error_handler=self.error_handler)
-        return d
+        d.addCallback(check)
+        yield d
 
+    @defer.inlineCallbacks
     def test_accept_share(self):
         """Test the accept_share method in dbus_interface.Share."""
         share_path = os.path.join(self.main.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
                                      access_level='Read', accepted=False,
                                      node_id="node_id"))
         self.assertEquals(False, self.main.vm.shares['share_id'].accepted)
@@ -1088,12 +1120,13 @@
             self.assertEquals(True, self.main.vm.shares['share_id'].accepted)
 
         d.addCallback(check)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_reject_share(self):
         """Test the reject_share method in dbus_interface.Share."""
         share_path = os.path.join(self.main.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share_id',
                                      access_level='Read', accepted=False))
         self.assertEquals(False, self.main.vm.shares['share_id'].accepted)
         client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
@@ -1112,7 +1145,7 @@
             self.assertEquals(False, self.main.vm.shares['share_id'].accepted)
 
         d.addCallback(check)
-        return d
+        yield d
 
     def test_get_root(self):
         """Check SycnDaemon.get_root exposed method."""
@@ -1349,18 +1382,20 @@
         share = Share(path=share_path, volume_id=str(uuid.uuid4()),
                       access_level='Modify', accepted=True,
                       node_id=str(uuid.uuid4()))
-        self.main.vm.add_share(share)
+        yield self.main.vm.add_share(share)
         client = DBusClient(self.bus, '/', DBUS_IFACE_SYNC_NAME)
+
+        rescan_d = defer.Deferred()
+        self.main.action_q.rescan_from_scratch = rescan_d.callback
+
         d = defer.Deferred()
-        def fake_rescan_from_scratch(volume_id):
-            """Stub method."""
-            d.callback(volume_id)
-        self.main.action_q.rescan_from_scratch = fake_rescan_from_scratch
-        d.addCallback(self.assertTrue)
         client.call_method('rescan_from_scratch', share.volume_id,
-                           reply_handler=lambda _: None,
+                           reply_handler=d.callback,
                            error_handler=d.errback)
-        vol_id = yield d
+
+        yield d
+
+        vol_id = yield rescan_d
         self.assertEqual(vol_id, share.volume_id)
 
     @defer.inlineCallbacks
@@ -1422,13 +1457,14 @@
 class DBusInterfaceUnicodeTests(DBusTwistedTestCase):
     """Unicode variant of basic tests to the objects exposed with D-Bus."""
 
+    @defer.inlineCallbacks
     def test_filesystem_unicode(self):
         """Test the FileSystem Object, registering it to the session bus.
 
         Excercise the API.
         """
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, u'ñoño'.encode('utf-8'))
         self.fs_manager.create(path, "share")
         self.fs_manager.set_node_id(path, "node_id")
@@ -1447,7 +1483,7 @@
         client = DBusClient(self.bus, '/filesystem', DBUS_IFACE_FS_NAME)
         client.call_method('get_metadata', path, reply_handler=handler,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
     def test_create_share_unicode(self):
         """Test share offering."""
@@ -1480,6 +1516,7 @@
                            error_handler=self.error_handler)
         return d
 
+    @defer.inlineCallbacks
     def test_get_shared_unicode(self):
         """Test that list_shared method behaves with unicode data."""
         a_dir = os.path.join(self.root_dir, u'ñoño'.encode('utf-8'))
@@ -1488,7 +1525,7 @@
         share = Shared(path=a_dir, volume_id='shared_id', name=u'ñoño_shared',
                       access_level='View', other_username=u'test_username',
                       node_id='node_id')
-        self.main.vm.add_shared(share)
+        yield self.main.vm.add_shared(share)
         client = DBusClient(self.bus, '/shares', DBUS_IFACE_SHARES_NAME)
         d = defer.Deferred()
 
@@ -1504,7 +1541,7 @@
         d.addCallback(check)
         client.call_method('get_shared',
                            reply_handler=d.callback, error_handler=d.errback)
-        return d
+        yield d
 
 
 class DBusSignalTest(DBusTwistedTestCase):
@@ -1823,6 +1860,7 @@
                                node_id='node', path=None, mdid=None)
         return d
 
+    @defer.inlineCallbacks
     def test_share_changed(self):
         """Test the ShareChanged signal."""
         share_path = os.path.join(self.main.shares_dir, 'share')
@@ -1831,7 +1869,7 @@
                                                      u'test_username',
                                                      u'visible_name', 'Write')
 
-        self.main.vm.add_share(Share(path=share_path,
+        yield self.main.vm.add_share(Share(path=share_path,
                                      volume_id=str(share_holder.share_id),
                                      node_id=str(share_holder.subtree),
                                      access_level='Read', accepted=False))
@@ -1850,8 +1888,9 @@
                                      signal_name='ShareChanged')
         self.signal_receivers.add(match)
         self.main.event_q.push('SV_SHARE_CHANGED', info=share_holder)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_share_deleted(self):
         """Test the ShareDeleted signal."""
         share_path = os.path.join(self.main.shares_dir, 'share')
@@ -1859,15 +1898,11 @@
                                                      u'fake_share',
                                                      u'test_username',
                                                      u'visible_name', 'Read')
-
-        self.main.vm.add_share(Share.from_notify_holder(share_holder, share_path))
+        share = Share.from_notify_holder(share_holder, share_path)
+        yield self.main.vm.add_share(share)
         d = defer.Deferred()
-        def share_handler(share_dict):
-            """Handler for ShareDeletedsignal."""
-            d.callback(share_dict)
-
-        match = self.bus.add_signal_receiver(share_handler,
-                                     signal_name='ShareDeleted')
+        match = self.bus.add_signal_receiver(d.callback,
+                                             signal_name='ShareDeleted')
         self.signal_receivers.add(match)
 
         def check(share_dict):
@@ -1888,13 +1923,9 @@
                 self.assertEquals(expected_dict[str(k)], str(v))
         d.addCallback(check)
 
-        match = self.bus.add_signal_receiver(share_handler,
-                                     signal_name='ShareDeleted')
-        self.signal_receivers.add(match)
-
         self.main.event_q.push('SV_SHARE_DELETED',
                                share_id=share_holder.share_id)
-        return d
+        yield d
 
     def test_share_created(self):
         """Test the ShareCreated signal."""
@@ -1960,6 +1991,7 @@
                                new_generation='new_generation')
         return d
 
+    @defer.inlineCallbacks
     def test_new_share(self):
         """Test the NewShare signal."""
         share_path = os.path.join(self.main.shares_dir, 'share')
@@ -1996,9 +2028,10 @@
             for k, v in share_dict.items():
                 self.assertEquals(expected_dict[str(k)], str(v))
         d.addCallback(check)
-        self.main.vm.add_share(share)
-        return d
+        yield self.main.vm.add_share(share)
+        yield d
 
+    @defer.inlineCallbacks
     def test_public_access_changed(self):
         """Test the PublicAccessChanged signal."""
         d = defer.Deferred()
@@ -2016,7 +2049,7 @@
         public_url = 'http://example.com'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, "foo")
         self.fs_manager.create(path, str(share_id))
         self.fs_manager.set_node_id(path, str(node_id))
@@ -2033,8 +2066,9 @@
         self.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_OK',
                           share_id=share_id, node_id=node_id,
                           is_public=is_public, public_url=public_url)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_public_access_change_error(self):
         """Test the PublicAccessChangeError signal."""
         d = defer.Deferred()
@@ -2051,7 +2085,7 @@
         expected_error = 'error message'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share'))
         path = os.path.join(share_path, "foo")
         self.fs_manager.create(path, str(share_id))
         self.fs_manager.set_node_id(path, str(node_id))
@@ -2067,7 +2101,7 @@
         self.event_q.push('AQ_CHANGE_PUBLIC_ACCESS_ERROR',
                           share_id=share_id, node_id=node_id,
                           error=expected_error)
-        return d
+        yield d
 
     def test_root_mismatch(self):
         """Test RootMismatch signal."""
@@ -2089,6 +2123,7 @@
         self.main.vm._got_root('another_root_id')
         return d
 
+    @defer.inlineCallbacks
     def test_public_files_list(self):
         """Test the PublicAccessChanged signal."""
         d = defer.Deferred()
@@ -2105,7 +2140,8 @@
         public_url = 'http://example.com'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id=volume_id))
+        share = Share(path=share_path, volume_id=volume_id)
+        yield self.main.vm.add_share(share)
         path = os.path.join(share_path, "foo")
         self.fs_manager.create(path, str(volume_id))
         self.fs_manager.set_node_id(path, str(node_id))
@@ -2120,7 +2156,7 @@
         d.addCallback(check)
         pf = dict(volume_id=volume_id, node_id=node_id, public_url=public_url)
         self.event_q.push('AQ_PUBLIC_FILES_LIST_OK', public_files=[pf])
-        return d
+        yield d
 
     def test_public_files_list_error(self):
         """Test the PublicFilesListError signal."""
@@ -2164,16 +2200,17 @@
                           volume_id=volume_id, free_bytes=123)
         return d
 
+    @defer.inlineCallbacks
     def test_quota_exceeded_for_share(self):
         """Test QuotaExceeded signal for share."""
         volume_id = 'test this please'
         path = 'test/path/bla'
         name = 'Beatiful Stranger'
-        a_share = Share(volume_id=volume_id, node_id=None, path=path, name=name,
-                        other_username=None, other_visible_name=None,
-                        accepted=False, access_level='View', free_bytes=None)
-        self.main.vm.add_share(a_share)
-        return self.assert_quota_exceeded(volume_id, _get_share_dict(a_share))
+        share = Share(volume_id=volume_id, node_id=None, path=path, name=name,
+                      other_username=None, other_visible_name=None,
+                      accepted=False, access_level='View', free_bytes=None)
+        yield self.main.vm.add_share(share)
+        yield self.assert_quota_exceeded(volume_id, _get_share_dict(share))
 
     def test_quota_exceeded_for_udf(self):
         """Test QuotaExceeded signal for UDF."""
@@ -2972,11 +3009,12 @@
                           'VM_UDF_CREATE_ERROR', path=path, error="I'm broken")
         return d
 
+    @defer.inlineCallbacks
     def test_delete(self):
         """Test for Folders.delete."""
         suggested_path = u'~/ñoño'
         udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
-        self.main.vm.add_udf(udf)
+        yield self.main.vm.add_udf(udf)
         d = defer.Deferred()
         def delete_volume(volume_id, path):
             """Fake delete_volume."""
@@ -3001,13 +3039,14 @@
         self.folders_client.call_method('delete', udf.volume_id,
                                         reply_handler=check_deleted,
                                         error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_delete_error_signal(self):
         """Test for FolderDeleteError."""
         suggested_path = u'~/ñoño'
         udf = self._create_udf(uuid.uuid4(), 'node_id', suggested_path)
-        self.main.vm.add_udf(udf)
+        yield self.main.vm.add_udf(udf)
         d = defer.Deferred()
         # patch delete_volume to fail
         def delete_volume(volume_id, path):
@@ -3026,8 +3065,8 @@
         self.folders_client.call_method('delete', udf.volume_id,
                                         reply_handler=lambda *args: None,
                                         error_handler=self.error_handler)
-        d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id))
-        return d
+        yield d
+        self.main.vm.udf_deleted(udf.volume_id)
 
     @defer.inlineCallbacks
     def test_delete_error_signal_folder_id(self):
@@ -3120,36 +3159,38 @@
         d.addCallback(lambda _: self.main.vm.udf_deleted(udf.volume_id))
         yield d
 
+    @defer.inlineCallbacks
     def test_refresh_volumes(self):
         """Just check that refresh_volumes method works."""
         client = DBusClient(self.bus, '/folders', DBUS_IFACE_FOLDERS_NAME)
+        list_volumes_d = defer.Deferred()
+        self.main.action_q.list_volumes = lambda: list_volumes_d.callback(True)
+
         d = defer.Deferred()
-        def list_volumes():
-            """Stub list_volumes."""
-            d.callback(True)
-        self.main.action_q.list_volumes = list_volumes
         client.call_method('refresh_volumes',
-                           reply_handler=lambda _: None,
+                           reply_handler=d.callback,
                            error_handler=self.error_handler)
-        return d
+        yield list_volumes_d
+        yield d
 
 
 class ShareTests(DBusTwistedTestCase):
     """Share specific tests."""
 
+    @defer.inlineCallbacks
     def test_delete_share(self):
         """Test for Shares.delete_share."""
         share_path = os.path.join(self.main.shares_dir, 'share')
         share = Share(path=share_path, volume_id='share_id',
                       node_id='node_id', accepted=True)
-        self.main.vm.add_share(share)
+        yield self.main.vm.add_share(share)
         d = defer.Deferred()
         def delete_volume(volume_id, path):
             """Fake delete_volume."""
             self.main.event_q.push("AQ_DELETE_VOLUME_OK", volume_id=volume_id)
         self.main.action_q.delete_volume = delete_volume
         def deleted_handler(info):
-            """FolderDeleted handler."""
+            """ShareDeleted handler."""
             self.assertRaises(KeyError, self.main.fs.get_by_path,
                               info['path'].decode('utf-8'))
             self.assertRaises(VolumeDoesNotExist,
@@ -3168,14 +3209,15 @@
         client.call_method('delete_share', share.volume_id,
                            reply_handler=check_deleted,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_delete_share_from_me(self):
         """Test for Shares.delete_share with share from_me."""
         share_path = os.path.join(self.main.shares_dir, 'share')
         share = Shared(path=share_path, volume_id='share_id',
                       node_id='node_id', accepted=True)
-        self.main.vm.add_shared(share)
+        yield self.main.vm.add_shared(share)
         d = defer.Deferred()
         def delete_share(volume_id):
             """Fake delete_volume."""
@@ -3193,14 +3235,15 @@
         client.call_method('delete_share', share.volume_id,
                            reply_handler=lambda _: None,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_delete_share_error_signal(self):
         """Test for Shares.delete_share with an error."""
         share_path = os.path.join(self.main.shares_dir, 'share')
         share = Share(path=share_path, volume_id='share_id',
                       node_id='node_id', accepted=True)
-        self.main.vm.add_share(share)
+        yield self.main.vm.add_share(share)
         d = defer.Deferred()
         # patch delete_volume to fail
         def delete_volume(volume_id, path):
@@ -3209,7 +3252,7 @@
                                    volume_id=volume_id, error="I'm broken")
         self.main.action_q.delete_volume = delete_volume
         def deleted_error_handler(info, error):
-            """FolderDeleteError handler."""
+            """ShareDeleteError handler."""
             self.assertEquals(info['volume_id'], share.volume_id)
             self.assertEquals(error, "I'm broken")
             d.callback(True)
@@ -3220,14 +3263,15 @@
         client.call_method('delete_share', share.volume_id,
                            reply_handler=lambda *args: None,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
+    @defer.inlineCallbacks
     def test_delete_share_from_me_error(self):
         """Test failure of Shares.delete_share with a share from_me."""
         share_path = os.path.join(self.main.shares_dir, 'share')
         share = Shared(path=share_path, volume_id='share_id',
                       node_id='node_id', accepted=True)
-        self.main.vm.add_shared(share)
+        yield self.main.vm.add_shared(share)
         d = defer.Deferred()
         # patch delete_share to fail
         def delete_share(share_id):
@@ -3236,7 +3280,7 @@
                                    share_id=share_id, error="I'm broken")
         self.patch(self.main.action_q, 'delete_share', delete_share)
         def deleted_error_handler(info, error):
-            """FolderDeleteError handler."""
+            """ShareDeleteError handler."""
             self.assertEquals(info['volume_id'], share.volume_id)
             self.assertEquals(error, "I'm broken")
             d.callback(True)
@@ -3247,14 +3291,14 @@
         client.call_method('delete_share', share.volume_id,
                            reply_handler=lambda *args: None,
                            error_handler=self.error_handler)
-        return d
+        yield d
 
     def test_delete_share_from_me_doesnotexist(self):
         """Test failure of Shares.delete_share with a share from_me."""
         d = defer.Deferred()
         # patch delete_share to fail
         def deleted_error_handler(info, error):
-            """FolderDeleteError handler."""
+            """ShareDeleteError handler."""
             self.assertEquals(info['volume_id'], 'missing_share_id')
             self.assertEquals(error, "DOES_NOT_EXIST")
             d.callback(True)
 
=== modified file 'tests/platform/linux/test_filesystem_notifications.py'
--- tests/platform/linux/test_filesystem_notifications.py	2011-01-20 21:27:24 +0000
+++ tests/platform/linux/test_filesystem_notifications.py	2011-02-03 17:29:42 +0000
@@ -291,12 +291,13 @@
 class WatchTests(BaseFSMonitorTestCase):
     """Test the EQ API to add and remove watchs."""
 
+    @defer.inlineCallbacks
     def _create_udf(self, path):
         """Create an UDF and returns it and the volume"""
         os.makedirs(path)
         udf = volume_manager.UDF("vol_id", "node_id", path.decode('utf-8'),
                                  path, True)
-        self.vm.add_udf(udf)
+        yield self.vm.add_udf(udf)
 
     def test_add_general_watch(self):
         """Test that general watchs can be added."""
@@ -311,11 +312,12 @@
         # nothing in the udf ancestors watch
         self.assertEqual(self.monitor._ancestors_watchs, {})
 
+    @defer.inlineCallbacks
     def test_add_watch_on_udf_ancestor(self):
         """Test that ancestors watchs can be added."""
         # create the udf and add the watch
         path_udf = os.path.join(self.home_dir, "path/to/UDF")
-        self._create_udf(path_udf)
+        yield self._create_udf(path_udf)
         path_ancestor = os.path.join(self.home_dir, "path")
         self.monitor.add_watch(path_ancestor)
 
@@ -327,22 +329,24 @@
         # nothing in the general watch
         self.assertEqual(self.monitor._general_watchs, {})
 
+    @defer.inlineCallbacks
     def test_add_watch_on_udf_exact(self):
         """Test adding the watch exactly on UDF."""
         # create the udf and add the watch
         path_udf = os.path.join(self.home_dir, "path/to/UDF")
-        self._create_udf(path_udf)
+        yield self._create_udf(path_udf)
         self.monitor.add_watch(path_udf)
 
         # pylint: disable-msg=W0212
         self.assertTrue(path_udf in self.monitor._general_watchs)
         self.assertEqual(self.monitor._ancestors_watchs, {})
 
+    @defer.inlineCallbacks
     def test_add_watch_on_udf_child(self):
         """Test adding the watch inside UDF."""
         # create the udf and add the watch
         path_udf = os.path.join(self.home_dir, "path/to/UDF")
-        self._create_udf(path_udf)
+        yield self._create_udf(path_udf)
         path_ancestor = os.path.join(self.home_dir, "path/to/UDF/inside")
         os.mkdir(path_ancestor)
         self.monitor.add_watch(path_ancestor)
@@ -364,12 +368,13 @@
         self.monitor.rm_watch(not_existing_dir)
         self.assertFalse(self.monitor.has_watch(not_existing_dir))
 
+    @defer.inlineCallbacks
     def test_rm_watch_wrong(self):
         """Test that general watchs can be removed."""
         # add two types of watchs
         self.monitor.add_watch(self.root_dir)
         path_udf = os.path.join(self.home_dir, "path/to/UDF")
-        self._create_udf(path_udf)
+        yield self._create_udf(path_udf)
         path_ancestor = os.path.join(self.home_dir, "path")
         self.monitor.add_watch(path_ancestor)
 
@@ -388,11 +393,12 @@
         self.assertEqual(self.monitor._general_watchs, {})
         self.assertEqual(self.monitor._ancestors_watchs, {})
 
+    @defer.inlineCallbacks
     def test_rm_watch_ancestor(self):
         """Test that ancestor watchs can be removed."""
         # create the udf and add the watch
         path_udf = os.path.join(self.home_dir, "path/to/UDF")
-        self._create_udf(path_udf)
+        yield self._create_udf(path_udf)
         path_ancestor = os.path.join(self.home_dir, "path")
         self.monitor.add_watch(path_ancestor)
 
@@ -414,10 +420,11 @@
         self.monitor.rm_watch(self.root_dir)
         self.assertFalse(self.monitor.has_watch(self.root_dir))
 
+    @defer.inlineCallbacks
     def test_has_watch_ancestor(self):
         """Test that an ancestor path is watched."""
         path_udf = os.path.join(self.home_dir, "path/to/UDF")
-        self._create_udf(path_udf)
+        yield self._create_udf(path_udf)
         path_ancestor = os.path.join(self.home_dir, "path")
 
         self.assertFalse(self.monitor.has_watch(path_ancestor))
 
=== modified file 'tests/platform/linux/test_tools.py'
--- tests/platform/linux/test_tools.py	2011-01-17 20:14:09 +0000
+++ tests/platform/linux/test_tools.py	2011-02-03 17:29:42 +0000
@@ -48,14 +48,15 @@
         self.rmtree(self.home_dir)
         return DBusTwistedTestCase.tearDown(self)
 
+    @defer.inlineCallbacks
     def create_file(self, path):
         """ creates a test file in fsm """
         share_path = os.path.join(self.shares_dir, 'share_tools')
-        self.main.vm.add_share(volume_manager.Share(share_path,
-                                                    volume_id='tools_share_id'))
+        share = volume_manager.Share(share_path, volume_id='tools_share_id')
+        yield self.main.vm.add_share(share)
         self.fs_manager.create(path, "tools_share_id")
         self.fs_manager.set_node_id(path, "node_id")
-        return 'tools_share_id', 'node_id'
+        defer.returnValue(('tools_share_id', 'node_id'))
 
 
 class TestToolsBasic(TestToolsBase):
 
=== modified file 'tests/syncdaemon/test_eq_inotify.py'
--- tests/syncdaemon/test_eq_inotify.py	2011-01-12 13:30:03 +0000
+++ tests/syncdaemon/test_eq_inotify.py	2011-02-03 17:29:42 +0000
@@ -1745,23 +1745,25 @@
         self._deferred.addCallback(check)
         return self._deferred
 
+    @defer.inlineCallbacks
     def _create_udf(self, vol_id, path):
         """Create an UDF and returns it and the volume"""
         os.makedirs(path)
         udf = volume_manager.UDF(vol_id, "node_id", path.decode('utf-8'),
                                  path, True)
-        self.vm.add_udf(udf)
+        yield self.vm.add_udf(udf)
 
+    @defer.inlineCallbacks
     def test_move_dir_across_volumes(self):
         """Dir move between volumes is deletion and creation."""
         # base dir 1
         base1 = os.path.join(self.home_dir, "dir1")
-        self._create_udf('vol1', base1)
+        yield self._create_udf('vol1', base1)
         self.fs.create(path=base1, share_id='vol1', is_dir=True)
 
         # base dir 2
         base2 = os.path.join(self.home_dir, "dir2")
-        self._create_udf('vol2', base2)
+        yield self._create_udf('vol2', base2)
         self.fs.create(path=base2, share_id='vol2', is_dir=True)
 
         # working stuff
@@ -1779,18 +1781,19 @@
 
         # generate the event
         os.rename(moving1, moving2)
-        return self._deferred
+        yield self._deferred
 
+    @defer.inlineCallbacks
     def test_move_file_across_volumes(self):
         """File ove between volumes is deletion and creation (and write)."""
         # base dir 1
         base1 = os.path.join(self.home_dir, "dir1")
-        self._create_udf('vol1', base1)
+        yield self._create_udf('vol1', base1)
         self.fs.create(path=base1, share_id='vol1', is_dir=True)
 
         # base dir 2
         base2 = os.path.join(self.home_dir, "dir2")
-        self._create_udf('vol2', base2)
+        yield self._create_udf('vol2', base2)
         self.fs.create(path=base2, share_id='vol2', is_dir=True)
 
         # working stuff
@@ -1809,7 +1812,7 @@
 
         # generate the event
         os.rename(moving1, moving2)
-        return self._deferred
+        yield self._deferred
 
 
 def test_suite():
 
=== modified file 'tests/syncdaemon/test_fsm.py'
--- tests/syncdaemon/test_fsm.py	2011-01-20 21:27:24 +0000
+++ tests/syncdaemon/test_fsm.py	2011-02-03 17:29:42 +0000
@@ -26,6 +26,8 @@
 import time
 import unittest
 
+from twisted.internet import defer
+
 from contrib.testing.testcase import (
     BaseTwistedTestCase,
     FakeVolumeManager,
@@ -56,9 +58,21 @@
 BROKEN_PICKLE = '\axb80\x02}q\x01(U\x01aU\x04testq\x02U\x01bU\x06brokenq\x03u.'
 
 
[e-mail]
+def _create_share(share_id, share_name, fsm, shares_dir, access_level='Modify'):
+    """Create a share."""
+    share_path = os.path.join(shares_dir, share_name)
+    os.makedirs(share_path)
+    share = Share(path=share_path, volume_id=share_id,
+                  access_level=access_level)
+    yield fsm.vm.add_share(share)
+    defer.returnValue(share)
+
+
 class FSMTestCase(unittest.TestCase):
     """ Base test case for FSM """
 
+    @defer.inlineCallbacks
     def setUp(self):
         """ Setup the test """
         unittest.TestCase.setUp(self)
@@ -80,8 +94,7 @@
                                      FakeVolumeManager(self.root_dir), self.db)
         self.eq = EventQueue(self.fsm)
         self.fsm.register_eq(self.eq)
-        self.share = self.create_share('share', 'share_name',
-                                            self.fsm, self.shares_dir)
+        self.share = yield self.create_share('share', 'share_name')
         self.share_path = self.share.path
 
         # add a in-memory logger handler
@@ -109,16 +122,17 @@
                 os.chmod(os.path.join(dirpath, dir), 0777)
         shutil.rmtree(path)
 
-    @staticmethod
-    def create_share(share_id, share_name, fsm, shares_dir,
+    @defer.inlineCallbacks
+    def create_share(self, share_id, share_name, fsm=None, shares_dir=None,
                      access_level='Modify'):
-        """ creates a share """
-        share_path = os.path.join(shares_dir, share_name)
-        os.makedirs(share_path)
-        share = Share(path=share_path, volume_id=share_id,
-                      access_level=access_level)
-        fsm.vm.add_share(share)
-        return share
+        """Create a share."""
+        if fsm is None:
+            fsm = self.fsm
+        if shares_dir is None:
+            shares_dir = self.shares_dir
+        share = yield _create_share(share_id, share_name, fsm, shares_dir,
+                                    access_level)
+        defer.returnValue(share)
 
     def create_node(self, name, is_dir=False, share=None):
         """Create a node."""
@@ -162,6 +176,7 @@
         self.assertTrue(os.path.exists(fsmdir))
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_complex_startup(self):
         """Test startup after having data."""
         # pylint: disable-msg=W0212
@@ -172,8 +187,8 @@
         db = Tritcask(fsmdir)
         fsm = FileSystemManager(fsmdir, partials_dir,
                                 FakeVolumeManager(fsmdir), db)
-        share = FSMTestCase.create_share('share', 'share_name',
-                                              fsm, fsmdir)
+        share = yield _create_share('share', 'share_name',
+                                    fsm=fsm, shares_dir=fsmdir)
         self.assertEqual(fsm._idx_path, {})
         self.assertEqual(fsm._idx_node_id, {})
 
@@ -299,6 +314,7 @@
         md_version = open(os.path.join(self.fsmdir, "metadata_version")).read()
         self.assertEqual(md_version, METADATA_VERSION)
 
+    @defer.inlineCallbacks
     def test_old_metadata_None(self):
         """Test old metadata situation, in None."""
         # create some stuff
@@ -307,8 +323,7 @@
         mdid = self.fsm.create(path, "share")
         self.fsm.set_node_id(path, "uuid")
         # create a path with the old layout
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid1")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -358,6 +373,7 @@
         self.assertFalse(old_path in newfsm._idx_path)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_old_metadata_1(self):
         """Test old metadata situation, in v1."""
         # create some stuff
@@ -369,8 +385,7 @@
         self.fsm.set_node_id(path2, "uuid2")
 
         # create a path with the old layout
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid1")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -423,6 +438,7 @@
         self.assertFalse(old_path in newfsm._idx_path)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_old_metadata_2(self):
         """Test old metadata situation, in v2."""
         # create some stuff
@@ -430,8 +446,7 @@
         mdid = self.fsm.create(path, "share")
         self.fsm.set_node_id(path, "uuid")
         # create a path with the old layout
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid1")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -480,6 +495,7 @@
         self.assertFalse(old_path in newfsm._idx_path)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_old_metadata_3(self):
         """Test old metadata situation, in v3."""
         # create a path with the old layout and metadata
@@ -487,8 +503,7 @@
         root_mdid = self.fsm.create(self.root_dir, "")
         self.fsm.set_node_id(self.root_dir, "uuid")
         # a share
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid1")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -1263,13 +1278,14 @@
         mdobj = self.fsm.get_by_node_id("share", "uuid")
         self.assertEquals(self.share_path, mdobj.path)
 
+    @defer.inlineCallbacks
     def test_get_all_by_share(self):
         """ Test that it returns all the mdids in a share. """
         # create the shares
-        share1 = self.create_share('share_id1', 'share_name1',  self.fsm,
-                                       self.shares_dir, access_level='View')
-        share2 = self.create_share('share_id2', 'share_name2',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share1 = yield self.create_share('share_id1', 'share_name1',
+                                         access_level='View')
+        share2 = yield self.create_share('share_id2', 'share_name2',
+                                         access_level='View')
         self.fsm.create(share1.path, "share_id1", is_dir=True)
         self.fsm.set_node_id(share1.path, "uuid1")
         self.fsm.create(share2.path, "share_id2", is_dir=True)
@@ -1330,11 +1346,12 @@
         self.assertTrue(mdid7 not in all)
         self.assertTrue(mdid8 not in all)
 
+    @defer.inlineCallbacks
     def test_get_all_by_share_mixed(self):
         """Test that it returns all the mdids in a share with mixed nodes."""
         # create the shares
-        share = self.create_share('share_id', 'sharetest',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share = yield self.create_share('share_id', 'sharetest',
+                                        access_level='View')
         self.fsm.create(share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(share.path, "uuid")
 
@@ -1441,10 +1458,10 @@
                                     os.path.join(self.share.path, 'a', 'b'))])
         self.assertEqual(expected, actual)
 
+    @defer.inlineCallbacks
     def test_with_two_shares(self):
         """Test having 2 shares."""
-        second_share = self.create_share('second_share', 'the_second',
-                                          self.fsm, self.shares_dir)
+        second_share = yield self.create_share('second_share', 'the_second')
         self.create_some_contents(second_share)
 
         expected = ['a']
@@ -1452,10 +1469,10 @@
                          self.fsm.get_mdobjs_in_dir(second_share.path)])
         self.assertEqual(expected, actual)
 
+    @defer.inlineCallbacks
     def test_both_shares(self):
         """Test having 2 shares and asking for mdobjs in shares_dir."""
-        second_share = self.create_share('second_share', 'the_second',
-                                          self.fsm, self.shares_dir)
+        second_share = yield self.create_share('second_share', 'the_second')
         self.create_some_contents(second_share)
 
         expected = []
@@ -1750,14 +1767,14 @@
         # it has no partial!
         self.fsm.remove_partial("uuid", "share")
 
+    @defer.inlineCallbacks
     def test_ro_share(self):
         """Test creating a partial of a RO share.
 
         It should leave the partials dir permissions intact.
         """
-        share = self.create_share('ro_share', 'ro_share_name',
-                                  self.fsm, self.shares_dir,
-                                  access_level='View')
+        share = yield self.create_share('ro_share', 'ro_share_name',
+                                        access_level='View')
         testdir = os.path.join(share.path, "path")
         mdid = self.fsm.create(testdir, share.volume_id, is_dir=False)
         self.fsm.set_node_id(testdir, "uuid")
@@ -2638,22 +2655,24 @@
         self.fsm.make_dir(mdid)
         self.assertTrue(os.path.exists(local_dir))
 
+    @defer.inlineCallbacks
     def test_make_dir_in_ro_share(self):
         """Also works in a read only share."""
-        share = self.create_share('ro_share_id', 'ro',  self.fsm,
-                                  self.shares_dir, access_level='View')
+        share = yield self.create_share('ro_share_id', 'ro',
+                                        access_level='View')
         testdir = os.path.join(share.path, "foo")
         mdid = self.fsm.create(testdir, 'ro_share_id', is_dir=True)
         self.fsm.make_dir(mdid)
         self.assertTrue(os.path.exists(testdir))
 
+    @defer.inlineCallbacks
     def test_make_dir_ro_watch(self):
         """Don't add the watch nor the mute on a RO share."""
         called = []
         self.eq.add_watch = lambda p: called.append(p)
         self.eq.add_to_mute_filter = lambda *a: called.append(a)
-        share = self.create_share('ro_share_id', 'ro',  self.fsm,
-                                  self.shares_dir, access_level='View')
+        share = yield self.create_share('ro_share_id', 'ro',
+                                        access_level='View')
         testdir = os.path.join(share.path, "foo")
         mdid = self.fsm.create(testdir, 'ro_share_id', is_dir=True)
 
@@ -2862,17 +2881,19 @@
                 os.chmod(os.path.join(dirpath, file), 0666)
         FSMTestCase.tearDown(self)
 
+    @defer.inlineCallbacks
     def test_file_ro_share_fail(self):
         """ Test that manual creation of a file, fails on a ro-share. """
-        share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share = yield self.create_share('ro_share', 'ro_share_name',
+                                        access_level='View')
         testfile = os.path.join(share.path, "a_file")
         self.assertRaises(IOError, open, testfile, 'w')
 
+    @defer.inlineCallbacks
     def test_dir_ro_share(self):
         """ Test that the creation of a file using fsm, works on a ro-share."""
-        share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share = yield self.create_share('ro_share', 'ro_share_name',
+                                        access_level='View')
         testdir = os.path.join(share.path, "path2")
         self.fsm.create(testdir, share.volume_id, is_dir=True)
         self.fsm.set_node_id(testdir, "uuid2")
@@ -2882,10 +2903,11 @@
         fd.close()
         self.assertTrue(os.path.exists(testdir))
 
+    @defer.inlineCallbacks
     def test_file_ro_share(self):
         """ Test that the creation of a file using fsm, works on a ro-share."""
-        self.share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        self.share = yield self.create_share('ro_share', 'ro_share_name',
+                                             access_level='View')
         testfile = os.path.join(self.share.path, "a_file")
         self.fsm.create(testfile, self.share.volume_id, is_dir=False)
         self.fsm.set_node_id(testfile, "uuid3")
@@ -2896,10 +2918,11 @@
         self.fsm.commit_partial('uuid3', self.share.volume_id, None)
         self.assertTrue(os.path.exists(testfile))
 
+    @defer.inlineCallbacks
     def test_delete_dir_ro_share(self):
         """ Test that fsm is able to delete a dir in a ro.share. """
-        share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share = yield self.create_share('ro_share', 'ro_share_name',
+                                        access_level='View')
         testdir = os.path.join(share.path, "path2")
         self.fsm.create(testdir, share.volume_id, is_dir=True)
         self.fsm.set_node_id(testdir, "uuid2")
@@ -2912,10 +2935,11 @@
         self.fsm.delete_file(testdir)
         self.assertFalse(os.path.exists(testdir))
 
+    @defer.inlineCallbacks
     def test_delete_non_empty_dir_ro_share(self):
         """Test that fsm is able to delete a non-empty dir in a ro.share."""
-        share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share = yield self.create_share('ro_share', 'ro_share_name',
+                                        access_level='View')
         testdir = os.path.join(share.path, "path2")
         mdid = self.fsm.create(testdir, share.volume_id, is_dir=True)
         self.fsm.set_node_id(testdir, "uuid2")
@@ -2941,10 +2965,11 @@
         self.assertFalse(os.path.exists(testdir))
         self.assertFalse(os.path.exists(testfile))
 
+    @defer.inlineCallbacks
     def test_delete_non_empty_dir_rw_share(self):
         """Test that fsm is able to delete a non-empty dir in a rw.share."""
-        share = self.create_share('rw_share', 'rw_share_name',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        share = yield self.create_share('rw_share', 'rw_share_name',
+                                        access_level='Modify')
         testdir = os.path.join(share.path, "path2")
         mdid = self.fsm.create(testdir, share.volume_id, is_dir=True)
         self.fsm.set_node_id(testdir, "uuid2")
@@ -2970,10 +2995,11 @@
         self.assertFalse(os.path.exists(testdir))
         self.assertFalse(os.path.exists(testfile))
 
+    @defer.inlineCallbacks
     def test_delete_non_empty_dir_bad_perms_rw_share(self):
         """Test that fsm is able to delete a non-empty dir in a rw.share."""
-        share = self.create_share('rw_share', 'rw_share_name',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        share = yield self.create_share('rw_share', 'rw_share_name',
+                                        access_level='Modify')
         testdir = os.path.join(share.path, "path2")
         mdid = self.fsm.create(testdir, share.volume_id, is_dir=True)
         self.fsm.set_node_id(testdir, "uuid2")
@@ -3001,10 +3027,11 @@
         self.assertTrue(os.path.exists(testdir))
         self.assertTrue(os.path.exists(testfile))
 
+    @defer.inlineCallbacks
     def test_delete_file_ro_share(self):
         """ Test that fsm is able to delete a file in a ro-share. """
-        self.share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        self.share = yield self.create_share('ro_share', 'ro_share_name',
+                                        access_level='View')
         testfile = os.path.join(self.share.path, "a_file")
         self.fsm.create(testfile, self.share.volume_id, is_dir=False)
         self.fsm.set_node_id(testfile, "uuid3")
@@ -3017,10 +3044,11 @@
         self.fsm.delete_file(testfile)
         self.assertFalse(os.path.exists(testfile))
 
+    @defer.inlineCallbacks
     def test_move_to_conflict_ro_share(self):
         """ Test that fsm is able to handle move_to_conflict in a ro-share. """
-        self.share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        self.share = yield self.create_share('ro_share', 'ro_share_name',
+                                             access_level='View')
         testfile = os.path.join(self.share.path, "a_file")
         file_mdid = self.fsm.create(testfile, self.share.volume_id,
                                     is_dir=False)
@@ -3034,18 +3062,18 @@
         self.fsm.move_to_conflict(file_mdid)
         self.assertTrue(os.path.exists(testfile + self.fsm.CONFLICT_SUFFIX))
 
+    @defer.inlineCallbacks
     def test_file_rw_share_no_fail(self):
         """ Test that manual creation of a file, ona  rw-share. """
-        share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir)
+        share = yield self.create_share('ro_share', 'ro_share_name')
         testfile = os.path.join(share.path, "a_file")
         open(testfile, 'w').close()
         self.assertTrue(os.path.exists(testfile))
 
+    @defer.inlineCallbacks
     def test_dir_rw_share(self):
         """ Test that the creation of a file using fsm, works on a rw-share."""
-        share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir)
+        share = yield self.create_share('ro_share', 'ro_share_name')
         testdir = os.path.join(share.path, "path2")
         self.fsm.create(testdir, share.volume_id, is_dir=True)
         self.fsm.set_node_id(testdir, "uuid2")
@@ -3055,10 +3083,10 @@
         fd.close()
         self.assertTrue(os.path.exists(testdir))
 
+    @defer.inlineCallbacks
     def test_file_rw_share(self):
         """ Test that the creation of a file using fsm, works on a rw-share."""
-        self.share = self.create_share('ro_share', 'ro_share_name',  self.fsm,
-                                       self.shares_dir)
+        self.share = yield self.create_share('ro_share', 'ro_share_name')
         testfile = os.path.join(self.share.path, "a_file")
         self.fsm.create(testfile, self.share.volume_id, is_dir=False)
         self.fsm.set_node_id(testfile, "uuid3")
@@ -3094,13 +3122,13 @@
 class TestEnableShareWrite(FSMTestCase):
     """Tests for EnableShareWrite context manager"""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Test setup"""
         FSMTestCase.setUp(self)
         # create a ro share
-        self.share_ro = self.create_share('share_ro', 'share_ro_name',
-                                          self.fsm, self.shares_dir,
-                                          access_level='View')
+        self.share_ro = yield self.create_share('share_ro', 'share_ro_name',
+                                                access_level='View')
         self.share_ro_path = self.share_ro.path
 
     def test_write_in_ro_share(self):
@@ -3140,6 +3168,7 @@
 
 class RealVMTestCase(FSMTestCase):
 
+    @defer.inlineCallbacks
     def setUp(self):
         """ Setup the test """
         unittest.TestCase.setUp(self)
@@ -3158,8 +3187,7 @@
         self.main = FakeMain(self.root_dir, self.shares_dir,
                              self.data_dir, self.partials_dir)
         self.fsm = self.main.fs
-        self.share = self.create_share('share', 'share_name',
-                                           self.fsm, self.shares_dir)
+        self.share = yield self.create_share('share', 'share_name')
         self.share_path = self.share.path
 
     def tearDown(self):
@@ -3167,14 +3195,16 @@
         self.main.shutdown()
         self.rmtree(TESTS_DIR)
 
-
-    @staticmethod
-    def create_share(share_id, share_name, fsm, shares_dir,
+    @defer.inlineCallbacks
+    def create_share(self, share_id, share_name,
                      access_level='Modify'):
-        with allow_writes(shares_dir):
-            return FSMTestCase.create_share(share_id, share_name, fsm,
-                                            shares_dir, access_level)
-
+        with allow_writes(self.shares_dir):
+            share = yield _create_share(share_id, share_name, self.fsm,
+                                        self.shares_dir, access_level)
+
+        defer.returnValue(share)
+
+    @defer.inlineCallbacks
     def test_old_metadata_None_missing_share(self):
         """test loading metadata v0. that points to a share that
         we don't have
@@ -3185,8 +3215,7 @@
         mdid = self.fsm.create(path, "share")
         self.fsm.set_node_id(path, "uuid")
         # create a path with the old layout
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid1")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -3238,6 +3267,7 @@
         self.assertRaises(KeyError, newfsm.get_by_mdid, share_mdid)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_old_metadata_1_missing_share(self):
         """test loading metadata v1. that points to a share that
         we don't have
@@ -3251,8 +3281,7 @@
         self.fsm.set_node_id(path2, "uuid2")
 
         # create a path with the old layout
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid3")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -3303,6 +3332,7 @@
         self.assertRaises(KeyError, newfsm.get_by_mdid, share_mdid)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_old_metadata_2_missing_share(self):
         """test loading metadata v2. that points to a share that
         we don't have
@@ -3312,8 +3342,7 @@
         mdid = self.fsm.create(path, "share")
         self.fsm.set_node_id(path, "uuid")
         # create a path with the old layout
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid3")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -3360,6 +3389,7 @@
         self.assertRaises(KeyError, newfsm.get_by_mdid, share_mdid)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_old_metadata_3_missing_share(self):
         """test loading metadata v3. that points to a share that
         we don't have
@@ -3369,8 +3399,7 @@
         root_mdid = self.fsm.get_by_path(self.root_dir).mdid
         self.fsm.set_node_id(self.root_dir, "uuid")
         # a share
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
         share_mdid = self.fsm.create(other_share.path, "share1")
         self.fsm.set_node_id(other_share.path, "uuid1")
         os.makedirs(os.path.join(self.root_dir, 'Ubuntu One'))
@@ -3416,6 +3445,7 @@
         self.assertRaises(KeyError, newfsm.get_by_mdid, share_mdid)
         db.shutdown()
 
+    @defer.inlineCallbacks
     def test_metadata_missing_share(self):
         """test loading current metadata that points to a share
         that we don't have
@@ -3425,8 +3455,7 @@
         self.assertEqual(md_version, METADATA_VERSION)
         path = os.path.join(self.share.path, 'path')
         path1 = os.path.join(self.share.path, 'path1')
-        other_share = self.create_share('share1', 'share1_name',
-                                            self.fsm, self.shares_dir)
+        other_share = yield self.create_share('share1', 'share1_name')
 
         path2 = os.path.join(other_share.path, 'broken_path2')
         for p in [path, path1, path2]:
 
=== modified file 'tests/syncdaemon/test_localrescan.py'
--- tests/syncdaemon/test_localrescan.py	2011-02-01 14:33:46 +0000
+++ tests/syncdaemon/test_localrescan.py	2011-02-03 17:29:42 +0000
@@ -119,19 +119,20 @@
         self.rmtree(self.tmpdir)
         testcase.BaseTwistedTestCase.tearDown(self)
 
-    @staticmethod
-    def create_share(share_id, share_name, fsm, shares_dir,
+    @defer.inlineCallbacks
+    def create_share(self, share_id, share_name,
                      access_level='Modify', accepted=True, subscribed=True):
         """Create a share."""
-        share_path = os.path.join(shares_dir, share_name)
+        share_path = os.path.join(self.shares_dir, share_name)
         os.makedirs(share_path)
         share = volume_manager.Share(path=share_path, volume_id=share_id,
                                      access_level=access_level,
                                      accepted=accepted,
                                      subscribed=subscribed)
-        fsm.vm.add_share(share)
-        return share
+        yield self.fsm.vm.add_share(share)
+        defer.returnValue(share)
 
+    @defer.inlineCallbacks
     def create_udf(self, udf_id, node_id, suggested_path, path, subscribed,
                    generation=None, free_bytes=100):
         """Create an UDF and add it to the volume manager."""
@@ -139,8 +140,8 @@
                                    suggested_path.decode('utf-8'))
         udf = volume_manager.UDF.from_udf_volume(volume, path)
         udf.subscribed = subscribed
-        self.fsm.vm.add_udf(udf)
-        return udf
+        yield self.fsm.vm.add_udf(udf)
+        defer.returnValue(udf)
 
     def create_node(self, path, is_dir, real=True, which_share=None):
         """Creates a node, really (maybe) and in the metadata."""
@@ -189,11 +190,12 @@
         lr.start()
         self.assertEqual(toscan, [self.vm.root.path])
 
+    @defer.inlineCallbacks
     def test_empty_rw(self):
         """Test with one empty Modify share."""
         # create the share
-        share = self.create_share('share_id', 'rw_share',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        share = yield self.create_share('share_id', 'rw_share',
+                                        access_level='Modify')
         self.fsm.create(share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(share.path, "uuid")
 
@@ -210,11 +212,12 @@
         lr.start()
         self.assertEqual(sorted(toscan), [share.path, self.vm.root.path])
 
+    @defer.inlineCallbacks
     def test_not_empty_rw(self):
         """Test with a Modify share with info."""
         # create the share
-        share = self.create_share('share_id', 'ro_share',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        share = yield self.create_share('share_id', 'ro_share',
+                                        access_level='Modify')
         self.fsm.create(share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(share.path, "uuid1")
 
@@ -237,11 +240,12 @@
         lr.start()
         self.assertEqual(sorted(toscan), [share.path, self.vm.root.path])
 
+    @defer.inlineCallbacks
     def test_deleted_rw(self):
         """Test with a deleted rw share."""
         # create the share
-        share = self.create_share('share_id', 'rw_share',  self.fsm,
-                                  self.shares_dir, access_level='Modify')
+        share = yield self.create_share('share_id', 'rw_share',
+                                        access_level='Modify')
         self.fsm.create(share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(share.path, "uuid")
 
@@ -266,11 +270,12 @@
         self.assertEqual(vol_id, share.volume_id)
         self.assertEqual(sorted(toscan), [self.vm.root.path])
 
+    @defer.inlineCallbacks
     def test_deleted_rw_not_empty(self):
         """Test with a deleted rw share with some nodes in it."""
         # create the share
-        share = self.create_share('share_id', 'rw_share',  self.fsm,
-                                  self.shares_dir, access_level='Modify')
+        share = yield self.create_share('share_id', 'rw_share',
+                                        access_level='Modify')
         self.fsm.create(share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(share.path, "uuid")
 
@@ -307,7 +312,7 @@
         """Test with a deleted udf."""
         # create the udf
         udf_path = os.path.expanduser("~/myudf")
-        udf = self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
+        udf = yield self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
                                     udf_path, True)
         os.makedirs(udf.path)
         self.fsm.create(udf.path, 'udf_id', is_dir=True)
@@ -337,9 +342,10 @@
 class VolumeTestCase(BaseTestCase):
     """Test how LocalRescan manages volumes."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Init."""
-        BaseTestCase.setUp(self)
+        yield BaseTestCase.setUp(self)
 
         self.env_var = 'HOME'
         self.old_value = os.environ.get(self.env_var, None)
@@ -355,7 +361,8 @@
             path = os.path.expanduser(suggested_path).encode("utf8")
             os.makedirs(path)
             udf_id, node_id = 'udf_id%i' % i, 'node_id%i' % i
-            udf = self.create_udf(udf_id, node_id, suggested_path, path, True)
+            udf = yield self.create_udf(udf_id, node_id, suggested_path,
+                                        path, True)
             self.volumes.append(udf)
 
             # make FSM aware of it
@@ -493,6 +500,7 @@
 
     timeout = 2
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up the test."""
         BaseTestCase.setUp(self)
@@ -500,8 +508,8 @@
         self.lr = LocalRescan(self.vm, self.fsm, self.eq, self.aq)
 
         # create a share
-        self.share = self.create_share('share_id', 'ro_share',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        self.share = yield self.create_share('share_id', 'ro_share',
+                                             access_level='Modify')
         self.fsm.create(self.share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(self.share.path, "uuidshare")
         self.share.node_id = "uuidshare"
@@ -535,14 +543,15 @@
 
     timeout = 20
 
+    @defer.inlineCallbacks
     def setUp(self):
-        TwistedBase.setUp(self)
+        yield TwistedBase.setUp(self)
 
         # create an udf
         udf_path = os.path.join(self.home_dir, "myudf")
         os.mkdir(udf_path)
-        self.udf = self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
-                                   udf_path, True)
+        self.udf = yield self.create_udf('udf_id', 'udf_root_node_id',
+                                         "~/myudf", udf_path, True)
         self.fsm.create(self.udf.path, 'udf_id', is_dir=True)
         self.fsm.set_node_id(self.udf.path, 'udf_root_node_id')
 
@@ -954,11 +963,12 @@
         reactor.callLater(.2, self.deferred.callback, None)
         return self.deferred
 
+    @defer.inlineCallbacks
     def test_one_dir_ro_share(self):
         """The dir is in a share that's RO, no error but no action."""
         # create the share
-        share = self.create_share('share_id', 'ro_share2',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        share = yield self.create_share('share_id', 'ro_share2',
+                                        access_level='View')
         self.fsm.create(share.path, "share_id", is_dir=True)
         self.fsm.set_node_id(share.path, "uuidshare")
 
@@ -1155,20 +1165,21 @@
     """Test that simultaneus calls are queued."""
     timeout = 2
 
+    @defer.inlineCallbacks
     def setUp(self):
         """set up the test."""
-        BaseTestCase.setUp(self)
+        yield BaseTestCase.setUp(self)
         self.deferred = defer.Deferred()
         self.eq = event_queue.EventQueue(self.fsm)
         self.lr = LocalRescan(self.vm, self.fsm, self.eq, self.aq)
 
         # create two shares
-        self.share1 = self.create_share('share_id1', 'ro_share_1',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        self.share1 = yield self.create_share('share_id1', 'ro_share_1',
+                                              access_level='Modify')
         self.fsm.create(self.share1.path, "share_id1", is_dir=True)
         self.fsm.set_node_id(self.share1.path, "uuidshare1")
-        self.share2 = self.create_share('share_id2', 'ro_share_2',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        self.share2 = yield self.create_share('share_id2', 'ro_share_2',
+                                              access_level='Modify')
         self.fsm.create(self.share2.path, "share_id2", is_dir=True)
         self.fsm.set_node_id(self.share2.path, "uuidshare2")
 
@@ -2007,11 +2018,12 @@
         self.startTest(check)
         return self.deferred
 
+    @defer.inlineCallbacks
     def test_SERVER_file_ro_share(self):
         """We were downloading the file, but it was interrupted in RO share."""
         # create the file in metadata
-        ro_share = self.create_share('share_ro_id', 'share_ro2',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        ro_share = yield self.create_share('share_ro_id', 'share_ro2',
+                                           access_level='View')
         self.fsm.create(ro_share.path, ro_share.id, is_dir=True)
         self.fsm.set_node_id(ro_share.path, "uuidshare")
         path = os.path.join(ro_share.path, "a")
@@ -2040,16 +2052,17 @@
             self.assertTrue(self.handler.check_debug("comp yield", "SERVER"))
 
         self.startTest(check)
-        return self.deferred
+        yield self.deferred
 
+    @defer.inlineCallbacks
     def test_SERVER_dir_ro_share(self):
         """Found a dir in SERVER in a ro_share.
 
         This was valid before, but no more, so we just fix and log in warning.
         """
         # create the dir in metadata
-        ro_share = self.create_share('share_ro_id', 'share_ro2',  self.fsm,
-                                       self.shares_dir, access_level='View')
+        ro_share = yield self.create_share('share_ro_id', 'share_ro2',
+                                           access_level='View')
         self.fsm.create(ro_share.path, ro_share.id, is_dir=True)
         self.fsm.set_node_id(ro_share.path, "uuidshare")
 
@@ -2078,7 +2091,7 @@
                                                 "Found a directory in SERVER"))
 
         self.startTest(check)
-        return self.deferred
+        yield self.deferred
 
     def test_check_stat_None(self):
         """Test check_stat with oldstat = None."""
@@ -2136,26 +2149,28 @@
         self.fsm.set_node_id(self.vm.root.path, self.vm.root.node_id)
         return self._test_it(self.vm.root)
 
+    @defer.inlineCallbacks
     def test_SERVER_share(self):
         """We were downloading the share root dir but it was interrupted."""
         # create a share
-        share = self.create_share('share_id_1', 'rw_share',  self.fsm,
-                                       self.shares_dir, access_level='Modify')
+        share = yield self.create_share('share_id_1', 'rw_share',
+                                        access_level='Modify')
         self.fsm.create(share.path, "share_id_1", is_dir=True)
         self.fsm.set_node_id(share.path, "uuid_share_1")
         share.node_id = "uuid_share_1"
         self.vm.shares['share_id_1'] = share
-        return self._test_it(share)
+        yield self._test_it(share)
 
+    @defer.inlineCallbacks
     def test_SERVER_udf(self):
         """We were downloading the udf root dir, but it was interrupted."""
         udf_path = os.path.join(self.home_dir, "myudf")
         os.mkdir(udf_path)
-        udf = self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
-                                   udf_path, True)
+        udf = yield self.create_udf('udf_id', 'udf_root_node_id', "~/myudf",
+                                    udf_path, True)
         self.fsm.create(udf.path, 'udf_id', is_dir=True)
         self.fsm.set_node_id(udf.path, 'udf_root_node_id')
-        return self._test_it(udf)
+        yield self._test_it(udf)
 
 
 class LimboTests(TwistedBase):
@@ -2339,9 +2354,10 @@
 
     timeout = 2
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Init."""
-        BaseTestCase.setUp(self)
+        yield BaseTestCase.setUp(self)
         self._deferred = defer.Deferred()
         self.eq = event_queue.EventQueue(self.fsm)
         self.original_add = self.eq.add_watch
@@ -2361,7 +2377,8 @@
         path = os.path.expanduser(suggested_path).encode("utf8")
         os.makedirs(path)
         udf_id, node_id = 'udf_id', 'node_id'
-        self.udf = self.create_udf(udf_id, node_id, suggested_path, path, True)
+        self.udf = yield self.create_udf(udf_id, node_id, suggested_path,
+                                         path, True)
         self.ancestors = self.udf.ancestors # need a fake HOME
 
         # make FSM aware of it
 
=== modified file 'tests/syncdaemon/test_status_listener.py'
--- tests/syncdaemon/test_status_listener.py	2011-01-27 20:44:23 +0000
+++ tests/syncdaemon/test_status_listener.py	2011-02-03 17:29:42 +0000
@@ -120,8 +120,8 @@
         public_url = 'http://example.com/foo.mp3'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share',
-                               other_username='other username'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share',
+                                           other_username='other username'))
         path = os.path.join(share_path, "foo.mp3")
         self.main.fs.create(path, str(share_id))
         self.main.fs.set_node_id(path, str(node_id))
@@ -144,8 +144,8 @@
         public_url = 'http://example.com/foo.mp3'
 
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share',
-                               other_username='other username'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share',
+                                           other_username='other username'))
         path = os.path.join(share_path, "foo.mp3")
         self.main.fs.create(path, str(share_id))
         self.main.fs.set_node_id(path, str(node_id))
@@ -210,7 +210,7 @@
         SHARE_ID = "fake share id"
         d = defer.Deferred()
         share = Share(volume_id=SHARE_ID)
-        self.main.vm.add_share(share)
+        yield self.main.vm.add_share(share)
         self._listen_for('VM_SHARE_CREATED', d.callback)
         self.main.event_q.push('VM_SHARE_CREATED', share)
         yield d
 
=== modified file 'tests/syncdaemon/test_sync.py'
--- tests/syncdaemon/test_sync.py	2011-01-25 18:29:04 +0000
+++ tests/syncdaemon/test_sync.py	2011-02-03 17:29:42 +0000
@@ -75,6 +75,7 @@
 class FSKeyTestCase(BaseTwistedTestCase):
     """ Base test case for FSKey """
 
+    @defer.inlineCallbacks
     def setUp(self):
         """ Setup the test """
         unittest.TestCase.setUp(self)
@@ -93,8 +94,7 @@
                                      self.db)
         self.eq = EventQueue(self.fsm)
         self.fsm.register_eq(self.eq)
-        self.share = self.create_share('share', 'share_name',
-                                            self.fsm, self.shares_dir)
+        self.share = yield self.create_share('share', 'share_name')
         self.share_path = self.share.path
 
     def tearDown(self):
@@ -103,16 +103,15 @@
         self.db.shutdown()
         shutil.rmtree(self.test_dir)
 
-    @staticmethod
-    def create_share(share_id, share_name, fsm, shares_dir,
-                     access_level='Modify'):
-        """ creates a share """
-        share_path = os.path.join(shares_dir, share_name)
+    @defer.inlineCallbacks
+    def create_share(self, share_id, share_name, access_level='Modify'):
+        """Create a share."""
+        share_path = os.path.join(self.shares_dir, share_name)
         os.makedirs(share_path)
         share = Share(path=share_path, volume_id=share_id,
                       access_level=access_level)
-        fsm.vm.add_share(share)
-        return share
+        yield self.fsm.vm.add_share(share)
+        defer.returnValue(share)
 
 
 class FSKeyTests(FSKeyTestCase):
 
=== modified file 'tests/syncdaemon/test_u1sdtool.py'
--- tests/syncdaemon/test_u1sdtool.py	2011-01-14 13:11:47 +0000
+++ tests/syncdaemon/test_u1sdtool.py	2011-02-03 17:29:42 +0000
@@ -179,12 +179,13 @@
         d.addCallback(check)
         return d
 
+    @defer.inlineCallbacks
     def test_show_current_transfers(self):
         """test the output of --current_transfers option with transfers in
         progress.
         """
         share_path = os.path.join(self.shares_dir, 'share')
-        self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
+        yield self.main.vm.add_share(Share(path=share_path, volume_id='share_id'))
         # create a download
         down_path = os.path.join(share_path, "down_path")
         self.fs_manager.create(down_path, "share_id")
@@ -203,15 +204,13 @@
                 "downloads:\n  path: %(down_path)s\n    deflated size: " + \
                 "10\n    bytes read: 1\n"
         expected = expected % dict(up_path=up_path, down_path=down_path)
-        d = self.tool.get_current_uploads()
-        d.addCallback(lambda result: show_uploads(result, out))
-        d.addCallback(lambda _: self.tool.get_current_downloads())
-        d.addCallback(lambda result: show_downloads(result, out))
-        def check(result):
-            """check the output"""
-            self.assertEquals(out.getvalue(), expected)
-        d.addCallback(check)
-        return d
+        result = yield self.tool.get_current_uploads()
+        show_uploads(result, out)
+
+        result = yield self.tool.get_current_downloads()
+        show_downloads(result, out)
+
+        self.assertEquals(out.getvalue(), expected)
 
     def test_show_state(self):
         """test the output of --status """