Merge lp:~nataliabidart/ubuntuone-client/run-upload-run-stable-2-0 into lp:ubuntuone-client/stable-2-0

[Natalia Bidart]

- Make the Upload process do not close the tempfile until is finished
  (LP: #872924).
- Reset the tempfile on every Upload _run() (LP: #884959).

[lp:~nataliabidart/ubuntuone-client/run-upload-run-stable-2-0]

1144. By Natalia Bidart on 2011-11-07

All tests green, now for sure.

[Joshua Hoover (joshuahoover)]

Tested and passed using test case in bug #872924

review: Approve (tested)

[Facundo Batista (facundo)]

Like it!

review: Approve

=== modified file 'tests/platform/linux/eventlog/test_zglog.py'
--- tests/platform/linux/eventlog/test_zglog.py	2011-06-15 21:14:06 +0000
+++ tests/platform/linux/eventlog/test_zglog.py	2011-11-07 18:03:24 +0000
@@ -25,7 +25,7 @@
 
 from distutils.spawn import find_executable
 
-from twisted.internet.defer import Deferred
+from twisted.internet.defer import Deferred, inlineCallbacks
 from zeitgeist.client import ZeitgeistClient
 from zeitgeist.datamodel import Event, Subject, Interpretation, Manifestation
 
@@ -92,8 +92,9 @@
 class ZeitgeistTestCase(DBusTwistedTestCase):
     """Tests for the zeitgeist logging module."""
 
+    @inlineCallbacks
     def setUp(self):
-        super(ZeitgeistTestCase, self).setUp()
+        yield super(ZeitgeistTestCase, self).setUp()
         zgdaemon = find_executable("zeitgeist-daemon")
         if not zgdaemon:
             raise NotFoundError("zeitgeist-daemon was not found.")
 
=== modified file 'tests/platform/linux/test_dbus.py'
--- tests/platform/linux/test_dbus.py	2011-08-03 20:20:02 +0000
+++ tests/platform/linux/test_dbus.py	2011-11-07 18:03:24 +0000
@@ -2909,9 +2909,10 @@
         self._old_home = os.environ['HOME']
         os.environ['HOME'] = self.home_dir
 
+    @defer.inlineCallbacks
     def tearDown(self):
         os.environ['HOME'] = self._old_home
-        return DBusTwistedTestCase.tearDown(self)
+        yield super(FolderTests, self).tearDown()
 
     def _create_udf(self, id, node_id, suggested_path, subscribed=True):
         """Create an UDF and returns it and the volume."""
 
=== modified file 'tests/platform/linux/test_messaging.py'
--- tests/platform/linux/test_messaging.py	2011-03-29 22:47:53 +0000
+++ tests/platform/linux/test_messaging.py	2011-11-07 18:03:24 +0000
@@ -22,8 +22,7 @@
 """
 
 
-from mocker import Mocker, ANY
-from twisted.trial.unittest import TestCase
+from mocker import ANY, MockerTestCase as TestCase
 
 from ubuntuone.platform.linux.messaging import Messaging, _server_callback
 
@@ -42,13 +41,6 @@
 class MessagingTestCase(TestCase):
     """Test the Messaging API."""
 
-    def setUp(self):
-        self.mocker = Mocker()
-
-    def tearDown(self):
-        self.mocker.restore()
-        self.mocker.verify()
-
     # pylint: disable=R0913
     def _show_message_setup(self, message_time=None, message_count=None,
                             icon=None, update_count=None, real_callback=False):
 
=== modified file 'tests/platform/linux/test_notification.py'
--- tests/platform/linux/test_notification.py	2011-03-03 23:29:37 +0000
+++ tests/platform/linux/test_notification.py	2011-11-07 18:03:24 +0000
@@ -22,8 +22,7 @@
 """
 
 
-from mocker import Mocker
-from twisted.trial.unittest import TestCase
+from mocker import MockerTestCase as TestCase
 
 from ubuntuone.platform.linux.notification import Notification, ICON_NAME
 
@@ -45,13 +44,6 @@
 class NotificationTestCase(TestCase):
     """Test the Messaging API."""
 
-    def setUp(self):
-        self.mocker = Mocker()
-
-    def tearDown(self):
-        self.mocker.restore()
-        self.mocker.verify()
-
     def test_send_notification(self):
         """On notification, pynotify receives the proper calls."""
         mock_notify = self.mocker.replace("pynotify")
 
=== modified file 'tests/platform/linux/test_unity.py'
--- tests/platform/linux/test_unity.py	2011-07-06 20:41:33 +0000
+++ tests/platform/linux/test_unity.py	2011-11-07 18:03:24 +0000
@@ -18,6 +18,7 @@
 
 """Tests for the liblauncher interface."""
 
+from twisted.internet import defer
 from twisted.trial.unittest import TestCase
 
 from ubuntuone.platform.linux import launcher
@@ -55,8 +56,10 @@
 
     skip = None if launcher.use_libunity else "libunity not installed."
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(LauncherTestCase, self).setUp()
         self.patch(launcher.Unity, "LauncherEntry", FakeLauncherEntry)
         self.launcher = launcher.UbuntuOneLauncher()
 
 
=== modified file 'tests/platform/linux/test_vm.py'
--- tests/platform/linux/test_vm.py	2011-07-27 20:10:33 +0000
+++ tests/platform/linux/test_vm.py	2011-11-07 18:03:24 +0000
@@ -19,6 +19,8 @@
 import os
 import uuid
 
+from twisted.internet import defer
+
 from contrib.testing.testcase import FakeMain, environ
 from tests.syncdaemon.test_vm import MetadataTestCase, BaseVolumeManagerTests
 from ubuntuone.storageprotocol import request
@@ -44,8 +46,9 @@
 class MetadataOldLayoutTests(MetadataTestCase):
     """Tests for 'old' layouts and metadata upgrade"""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        MetadataTestCase.setUp(self)
+        yield super(MetadataOldLayoutTests, self).setUp()
         self.root_dir = os.path.join(self.u1_dir, 'My Files')
         self.shares_dir = os.path.join(self.u1_dir, 'Shared With Me')
         self.new_root_dir = self.u1_dir
@@ -451,8 +454,9 @@
 class MetadataNewLayoutTests(MetadataTestCase):
     """Test for 'new' layout and metadata upgrade."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        MetadataTestCase.setUp(self)
+        yield super(MetadataNewLayoutTests, self).setUp()
         self.share_md_dir = os.path.join(self.vm_data_dir, 'shares')
         self.shared_md_dir = os.path.join(self.vm_data_dir, 'shared')
         self.home_dir = os.path.join(self.tmpdir, 'home', 'ubuntuonehacker')
 
=== modified file 'tests/platform/test_interaction_interfaces.py'
--- tests/platform/test_interaction_interfaces.py	2011-07-27 14:26:36 +0000
+++ tests/platform/test_interaction_interfaces.py	2011-11-07 18:03:24 +0000
@@ -18,15 +18,18 @@
 """Test that the interaction_interfaces are correctly called."""
 
 from mocker import MockerTestCase, MATCH
+from twisted.internet import defer
+
 from tests.platform import IPCTestCase
 
 
 class TestStatusIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestStatusIPC, self).setUp()
+        yield super(TestStatusIPC, self).setUp()
         self.syncdaemon_status = self.mocker.mock()
         self.status.syncdaemon_status = self.syncdaemon_status
 
@@ -82,9 +85,10 @@
 class TestEventsIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestEventsIPC, self).setUp()
+        yield super(TestEventsIPC, self).setUp()
         self.events_mock = self.mocker.mock()
         self.events.events = self.events_mock
 
@@ -100,9 +104,10 @@
 class TestSyncDaemonIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestSyncDaemonIPC, self).setUp()
+        yield super(TestSyncDaemonIPC, self).setUp()
         self.service = self.mocker.mock()
         self.sync.service = self.service
 
@@ -174,9 +179,10 @@
 class TestFileSystemIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestFileSystemIPC, self).setUp()
+        yield super(TestFileSystemIPC, self).setUp()
         self.syncdaemon_filesystem = self.mocker.mock()
         self.fs.syncdaemon_filesystem = self.syncdaemon_filesystem
 
@@ -221,9 +227,10 @@
 class TestSharesIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestSharesIPC, self).setUp()
+        yield super(TestSharesIPC, self).setUp()
         self.syncdaemon_shares = self.mocker.mock()
         self.shares.syncdaemon_shares = self.syncdaemon_shares
 
@@ -316,9 +323,10 @@
 class TestConfigIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestConfigIPC, self).setUp()
+        yield super(TestConfigIPC, self).setUp()
         self.syncdaemon_config = self.mocker.mock()
         self.config.syncdaemon_config = self.syncdaemon_config
 
@@ -467,9 +475,10 @@
 class TestFoldersIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestFoldersIPC, self).setUp()
+        yield super(TestFoldersIPC, self).setUp()
         self.syncdaemon_folders = self.mocker.mock()
         self.folders.syncdaemon_folders = self.syncdaemon_folders
 
@@ -528,9 +537,10 @@
 class TestPublicFilesIPC(MockerTestCase, IPCTestCase):
     """Ensure that calls are correctly fowarded."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(TestPublicFilesIPC, self).setUp()
+        yield super(TestPublicFilesIPC, self).setUp()
         self.syncdaemon_public_files = self.mocker.mock()
         self.public_files.syncdaemon_public_files =\
             self.syncdaemon_public_files
 
=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2011-07-27 13:27:22 +0000
+++ tests/status/test_aggregator.py	2011-11-07 18:03:24 +0000
@@ -50,8 +50,10 @@
 
     TIMEOUT = 3.0
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(TimerTestCase, self).setUp()
         self.clock = PatchedClock()
         self.timer = aggregator.Timer(delay=3.0, clock=self.clock)
 
@@ -101,8 +103,10 @@
 
     DELAY = 0.5
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(DeadlineTimerTestCase, self).setUp()
         self.clock = PatchedClock()
         self.timer = aggregator.DeadlineTimer(delay=0.5, timeout=3.0,
                                             clock=self.clock)
@@ -242,8 +246,10 @@
 class ToggleableNotificationTestCase(TestCase):
     """Test the ToggleableNotification class."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(ToggleableNotificationTestCase, self).setUp()
         self.patch(aggregator, "Notification", FakeNotification)
         self.notification_switch = aggregator.NotificationSwitch()
         self.toggleable = self.notification_switch.get_notification()
@@ -282,8 +288,10 @@
 class NotificationSwitchTestCase(TestCase):
     """Test the NotificationSwitch class."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(NotificationSwitchTestCase, self).setUp()
         self.notification_switch = aggregator.NotificationSwitch()
 
     def test_get_notification(self):
@@ -306,8 +314,10 @@
 class FileDiscoveryBubbleTestCase(TestCase):
     """Test the FileDiscoveryBubble class."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(FileDiscoveryBubbleTestCase, self).setUp()
         self.patch(aggregator, "ToggleableNotification",
                    FakeNotificationSingleton())
         self.clock = PatchedClock()
@@ -487,8 +497,10 @@
 class FinalBubbleTestCase(TestCase):
     """Test for the final status notification bubble."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(FinalBubbleTestCase, self).setUp()
         self.patch(aggregator, "ToggleableNotification",
                    FakeNotificationSingleton())
         self.clock = PatchedClock()
@@ -542,8 +554,10 @@
 class ProgressBarTestCase(TestCase):
     """Tests for the progress bar."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(ProgressBarTestCase, self).setUp()
         self.patch(aggregator, "UbuntuOneLauncher", FakeLauncher)
         self.patch(aggregator.session, "Inhibitor", FakeInhibitor)
         self.clock = PatchedClock()
@@ -737,10 +751,10 @@
             self.files_uploading.remove(command)
         self.queued_commands.discard(command)
 
-    def progress_made(self, share_id, node_id, n_bytes_written, deflated_size):
+    def progress_made(self, share_id, node_id, n_bytes, deflated_size):
         """Progress made on up- or download."""
         self.progress_events.append(
-            (share_id, node_id, n_bytes_written, deflated_size))
+            (share_id, node_id, n_bytes, deflated_size))
 
     def connection_made(self):
         """The client made the connection to the server."""
@@ -1033,8 +1047,10 @@
     CLASS_KWARGS = {}
     status = None
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(StatusEventTestCase, self).setUp()
         if type(self) == StatusEventTestCase:
             self.assertRaises(AssertionError, self.CLASS, **self.CLASS_KWARGS)
         else:
@@ -1177,8 +1193,10 @@
 class StatusAggregatorTestCase(TestCase):
     """Test the backend of the status aggregator."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
+        yield super(StatusAggregatorTestCase, self).setUp()
         self.patch(aggregator, "FileDiscoveryBubble",
                    FakeFileDiscoveryBubble)
         self.patch(aggregator, "FinalStatusBubble",
 
=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2011-09-08 21:29:37 +0000
+++ tests/syncdaemon/test_action_queue.py	2011-11-07 18:03:24 +0000
@@ -104,11 +104,19 @@
         return self.check(logger.NOTE, *msgs)
 
 
+class FakeMagicHash(object):
+    """Fake magic hash."""
+    _magic_hash = '666'
+
+
 class FakeTempFile(object):
     """Fake temporary file."""
+
     def __init__(self, tmpdir):
+        self.closed = 0  # be able to count how may close calls we had
         self.name = os.path.join(tmpdir, 'remove-me.zip')
         open_file(self.name, 'w').close()
+        self.close = lambda: setattr(self, 'closed', self.closed + 1)
 
 
 class FakeCommand(object):
@@ -181,7 +189,7 @@
 
 class FakeRequest(object):
     """Fake Request."""
-    def __init__(self):
+    def __init__(self, *a, **k):
         self.deferred = defer.succeed(True)
         self.cancelled = False
 
@@ -442,8 +450,10 @@
 class TestRequestQueue(TwistedTestCase):
     """Tests for the RequestQueue."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(TestRequestQueue, self).setUp()
 
         class FakeAQ(object):
             """Fake AQ."""
@@ -765,8 +775,10 @@
 class TestDeferredMap(TwistedTestCase):
     """Test the deferred map."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(TestDeferredMap, self).setUp()
         self.dm = DeferredMap()
 
     def test_one_get_returns_stored_deferred(self):
@@ -853,8 +865,10 @@
 class TestZipQueue(TwistedTestCase):
     """Test the zipping queue."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(TestZipQueue, self).setUp()
         self.zq = ZipQueue()
 
     @defer.inlineCallbacks
@@ -3053,9 +3067,7 @@
     def test_fileobj_in_run(self):
         """Create it first time, reset after that."""
         # don't use the real protocol
-        obj = Mocker().mock()
-        obj.deferred
-        self.action_queue.client.get_content_request = lambda *a, **k: obj
+        self.action_queue.client.get_content_request = FakeRequest
 
         class FakeFileObjFactory(object):
             """Fake class to check behaviour."""
@@ -3099,10 +3111,6 @@
         """Init."""
         yield super(UploadUnconnectedTestCase, self).setUp()
 
-        class FakeMagicHash(object):
-            """Fake magic hash."""
-            _magic_hash = '666'
-
         self.rq = request_queue = RequestQueue(action_queue=self.action_queue)
         self.command = Upload(request_queue, share_id='a_share_id',
                               node_id='a_node_id', previous_hash='prev_hash',
@@ -3116,6 +3124,7 @@
     def test_upload_progress_wrapper_setup(self):
         """Test the setting up of the progress wrapper in ._run()."""
         self.command.action_queue.connect_in_progress = False
+        self.command.tempfile = StringIO()
         self.command._run()
 
         self.assertEqual(len(self.client.called), 1)
@@ -3306,16 +3315,29 @@
         events = [('AQ_UPLOAD_ERROR', kwargs)]
         self.assertEqual(events, self.command.action_queue.event_queue.events)
 
-    def test_handle_failure_removes_temp_file(self):
-        """Test temp file is removed on failure."""
+    def test_finish_closes_temp_file(self):
+        """Test temp file is closed when the command finishes."""
+        self.command.tempfile = FakeTempFile(self.tmpdir)
+        assert self.command.tempfile.closed == 0
+
+        self.command.finish()
+        self.assertEqual(1, self.command.tempfile.closed)
+
+    def test_finish_removes_temp_file(self):
+        """Test temp file is removed when the command finishes."""
         self.command.tempfile = FakeTempFile(self.tmpdir)
         assert path_exists(self.command.tempfile.name)
 
-        msg = 'Something went wrong'
-        failure = Failure(DefaultException(msg))
-        self.command.handle_failure(failure=failure)
+        self.command.finish()
         self.assertFalse(path_exists(self.command.tempfile.name))
 
+    def test_finish_handles_temp_file_none(self):
+        """Test temp file can be None when calling finish."""
+        self.command.tempfile = None
+
+        self.command.finish()
+        self.assertEqual(self.command.tempfile, None)  # nothing changed
+
     def test_retryable_failure_push_quota_exceeded_if_that_error(self):
         """Test SYS_QUOTA_EXCEEDED is pushed on QuotaExceededError."""
         protocol_msg = protocol_pb2.Message()
@@ -3641,6 +3663,18 @@
         tempfile = NamedTemporaryFile()
         self.assertEqual(tempfile.mode, 'w+b')
 
+    def test_fileobj_in_run(self):
+        """Create it first time, reset after that."""
+        # don't use the real protocol or magic hash
+        self.action_queue.client.put_content_request = FakeRequest
+        self.command.magic_hash = FakeMagicHash()
+
+        called = []
+        self.command.tempfile = StringIO()
+        self.command.tempfile.seek = lambda *a: called.extend(a)
+        self.command._run()
+        self.assertEqual(called, [0])
+
 
 class CreateShareTestCase(ConnectedBaseTestCase):
     """Test for CreateShare ActionQueueCommand."""
@@ -4919,8 +4953,10 @@
 class ActionQueueProtocolTests(TwistedTestCase):
     """Test the ACQ class."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(ActionQueueProtocolTests, self).setUp()
         # create an AQP and put a factory to it
         self.aqp = ActionQueueProtocol()
         obj = Mocker().mock()
@@ -4932,8 +4968,10 @@
         self.handler.setLevel(logging.DEBUG)
         self.aqp.log.addHandler(self.handler)
 
+    @defer.inlineCallbacks
     def tearDown(self):
         """Tear down."""
+        yield super(ActionQueueProtocolTests, self).tearDown()
         self.aqp.log.removeHandler(self.handler)
         if self.aqp.ping_manager is not None:
             self.aqp.ping_manager.stop()
@@ -5541,8 +5579,10 @@
 class ConditionsLockerTests(TwistedTestCase):
     """Test the ConditionsLocker."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(ConditionsLockerTests, self).setUp()
         self.cl = ConditionsLocker()
 
     def test_get_locking_deferred_returns_deferred(self):
@@ -5664,8 +5704,11 @@
 class PingManagerTestCase(TwistedTestCase):
     """Test the Ping manager."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(PingManagerTestCase, self).setUp()
+
         class FakeActionQueueProtocol(object):
             """Fake object for the tests."""
             log = logging.getLogger("ubuntuone.SyncDaemon.ActionQueue")
@@ -5677,8 +5720,10 @@
         self.fake_aqp.log.addHandler(self.handler)
         self.pm = PingManager(self.fake_aqp)
 
+    @defer.inlineCallbacks
     def tearDown(self):
         """Tear down."""
+        yield super(PingManagerTestCase, self).tearDown()
         self.fake_aqp.log.removeHandler(self.handler)
         self.pm.stop()
 
 
=== modified file 'tests/syncdaemon/test_logger.py'
--- tests/syncdaemon/test_logger.py	2011-08-10 12:01:01 +0000
+++ tests/syncdaemon/test_logger.py	2011-11-07 18:03:24 +0000
@@ -20,6 +20,7 @@
 
 import logging
 
+from twisted.internet import defer
 from twisted.trial import unittest
 
 from ubuntuone.devtools.handlers import MementoHandler
@@ -39,15 +40,19 @@
 class DebugCaptureTest(unittest.TestCase):
     """Tests for DebugCapture context manager."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Setup the logger and the handler"""
+        yield super(DebugCaptureTest, self).setUp()
         self.handler = MementoHandler()
         self.logger = logging.getLogger(self.__class__.__name__)
         self.logger.addHandler(self.handler)
         self.logger.setLevel(logging.DEBUG)
 
+    @defer.inlineCallbacks
     def tearDown(self):
         """close the handler and restore the logger (Logger's are global)"""
+        yield super(DebugCaptureTest, self).tearDown()
         self.handler.close()
         self.logger.removeHandler(self.handler)
         self.logger.setLevel(logging.DEBUG)
@@ -222,8 +227,10 @@
 class FilterTests(unittest.TestCase):
     """Tests log filters"""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Setup the logger and the handler"""
+        yield super(FilterTests, self).setUp()
         self.handler = MementoHandler()
         self.handler.setLevel(logging.DEBUG)
         root_logger.addHandler(self.handler)
@@ -253,15 +260,19 @@
 class MultiFilterTest(unittest.TestCase):
     """Tests for logger.MultiFilter"""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Setup the logger and the handler"""
+        yield super(MultiFilterTest, self).setUp()
         self.handler = MementoHandler()
         self.logger = logging.getLogger(self.__class__.__name__)
         self.logger.addHandler(self.handler)
         self.logger.setLevel(logging.DEBUG)
 
+    @defer.inlineCallbacks
     def tearDown(self):
         """close the handler and restore the logger (Logger's are global)"""
+        yield super(MultiFilterTest, self).tearDown()
         self.handler.close()
         self.logger.removeHandler(self.handler)
         self.logger.setLevel(logging.DEBUG)
 
=== modified file 'tests/syncdaemon/test_pathlockingtree.py'
--- tests/syncdaemon/test_pathlockingtree.py	2011-01-20 21:27:24 +0000
+++ tests/syncdaemon/test_pathlockingtree.py	2011-11-07 18:03:24 +0000
@@ -29,8 +29,10 @@
 class InternalDeferredTests(TwistedTestCase):
     """Test the internal deferreds handling functionality."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(InternalDeferredTests, self).setUp()
         self.plt = PathLockingTree()
 
     def test_single_element_old(self):
@@ -217,8 +219,10 @@
 class LockingTests(TwistedTestCase):
     """Test the locking between elements."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(LockingTests, self).setUp()
         self.plt = PathLockingTree()
 
     @defer.inlineCallbacks
@@ -417,8 +421,10 @@
 class CleaningTests(TwistedTestCase):
     """Test that the releases clean the tree."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(CleaningTests, self).setUp()
         self.plt = PathLockingTree()
 
     @defer.inlineCallbacks
@@ -547,8 +553,10 @@
 class LoggingTests(TwistedTestCase):
     """Test the logging."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up."""
+        yield super(LoggingTests, self).setUp()
         self.plt = PathLockingTree()
 
         self.handler = MementoHandler()
 
=== modified file 'tests/syncdaemon/test_states.py'
--- tests/syncdaemon/test_states.py	2011-01-18 20:25:54 +0000
+++ tests/syncdaemon/test_states.py	2011-11-07 18:03:24 +0000
@@ -107,7 +107,9 @@
 class Base(TwistedTestCase):
     """Base class for state tests."""
 
+    @defer.inlineCallbacks
     def setUp(self):
+        yield super(Base, self).setUp()
         # create fake classes
         self.eq = FakeEventQueue()
         self.aq = FakeActionQueue()
@@ -157,15 +159,18 @@
         reactor.callLater(.1, check, 0)
         return d
 
+    @defer.inlineCallbacks
     def tearDown(self):
+        yield super(Base, self).tearDown()
         self.sm.connection.shutdown()
 
 
 class QueueBase(Base):
     """Basic setup for QueueManager."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        Base.setUp(self)
+        yield super(QueueBase, self).setUp()
         self.sm.state = StateManager.QUEUE_MANAGER
 
 
@@ -223,8 +228,9 @@
 class TestConnectionManager(Base):
     """Test the "internal network" transitions."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        Base.setUp(self)
+        yield super(TestConnectionManager, self).setUp()
 
         # put SM on some state that does not generate further
         # transition-related efforts for this CM
@@ -341,8 +347,9 @@
 class TestConnectionManagerTimings(Base):
     """Times handled by ConnectionManager."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        Base.setUp(self)
+        yield super(TestConnectionManagerTimings, self).setUp()
 
         # set timeout values to really low, to make tests run quicker
         self.sm.connection.handshake_timeout = 0
@@ -843,8 +850,10 @@
 class TestStateManagerPassToNetworkManager(Base):
     """All network events should go to NetworkManager."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        Base.setUp(self)
+        yield super(TestStateManagerPassToNetworkManager,
+                    self).setUp()
 
         # put a function in the middle to log calls
         self.called_events = []
@@ -893,8 +902,10 @@
 class TestStateManagerPassToQueueManager(Base):
     """All queue events should go to QueueManager."""
 
+    @defer.inlineCallbacks
     def setUp(self):
-        Base.setUp(self)
+        yield super(TestStateManagerPassToQueueManager,
+                    self).setUp()
 
         # put a function in the middle to log calls
         self.called_events = []
 
=== modified file 'tests/syncdaemon/test_status_listener.py'
--- tests/syncdaemon/test_status_listener.py	2011-08-05 15:50:52 +0000
+++ tests/syncdaemon/test_status_listener.py	2011-11-07 18:03:24 +0000
@@ -96,9 +96,10 @@
 class StatusListenerTestCase(FakeMainTestCase):
     """Tests for StatusListener."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Initialize this instance."""
-        super(StatusListenerTestCase, self).setUp()
+        yield super(StatusListenerTestCase, self).setUp()
         self.status_frontend = FakeStatusFrontend()
         self.listener = status_listener.StatusListener(self.fs, self.vm,
                                                        self.status_frontend)
 
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2011-09-08 21:41:00 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2011-11-07 18:03:24 +0000
@@ -37,7 +37,7 @@
 import zlib
 
 from collections import deque, defaultdict
-from functools import wraps, partial
+from functools import partial
 from urllib import urlencode
 from urllib2 import urlopen, Request, HTTPError
 from urlparse import urljoin
@@ -72,18 +72,7 @@
 EREGEX = "^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$"
 
 # progress threshold to emit a download/upload progress event: 64Kb
-TRANSFER_PROGRESS_THRESHOLD = 64*1024*1024
-
-def passit(func):
-    """Pass the value on for the next deferred, while calling func with it."""
-
-    @wraps(func)
-    def wrapper(a):
-        """Do it."""
-        func(a)
-        return a
-
-    return wrapper
+TRANSFER_PROGRESS_THRESHOLD = 64 * 1024 * 1024
 
 
 class DeferredInterrupted(Exception):
@@ -116,7 +105,6 @@
             self.errback(DeferredInterrupted())
 
 
-
 class PathLockingTree(object):
     """Tree that stores deferreds in the nodes."""
 
@@ -214,7 +202,6 @@
             node, element = branch.pop()
             del node['children_nodes'][element]
 
-
         # finally, log and release the deferred
         logger.debug("pathlock releasing %s; remaining: %d", elements,
                                                              self.count)
@@ -250,8 +237,8 @@
         return ('start - processMessage: id: %s, type: %s',
                 message.id, message.type)
     elif message.type == protocol_pb2.Message.PUT_CONTENT:
-        lines = [ line for line in str(message).split("\n")
-                if not line.strip().startswith("magic_hash:") ]
+        lines = [line for line in str(message).split("\n")
+                if not line.strip().startswith("magic_hash:")]
         return ('start - processMessage: %s',
                 " ".join(lines))
     else:
@@ -461,12 +448,8 @@
                 magic_hasher.update(data)
             upload.deflated_size = f.tell()
 
-            # keep the file open, but reset its position
-            # to zero, ready to be read later
-            f.seek(0)
-
             upload.magic_hash = magic_hasher.content_hash()
-        except Exception, e: # pylint: disable-msg=W0703
+        except Exception, e:  # pylint: disable-msg=W0703
             failed = True
             reactor.callFromThread(deferred.errback, e)
         finally:
@@ -705,10 +688,10 @@
         self.token = None
         self.consumer = None
 
-        self.client = None # an instance of self.protocol
+        self.client = None  # an instance of self.protocol
 
         # is a twisted.internet.tcp/ssl.Connector instance
-        self.connector = None # created on reactor.connectTCP/SSL
+        self.connector = None  # created on reactor.connectTCP/SSL
         # we need to track down if a connection is in progress
         # to avoid double connections
         self.connect_in_progress = False
@@ -1029,8 +1012,8 @@
     @defer.inlineCallbacks
     def authenticate(self):
         """Authenticate against the server using stored credentials."""
-        metadata = {'version':clientdefs.VERSION,
-                    'platform':platform}
+        metadata = {'version': clientdefs.VERSION,
+                    'platform': platform}
         authenticate_d = self._send_request_and_handle_errors(
             request=self.client.oauth_authenticate,
             request_error=protocol_errors.AuthenticationFailedError,
@@ -2078,7 +2061,6 @@
         self.log = mklog(logger, 'GetDeltaFromScratch', self.volume_id, None)
 
 
-
 class ChangePublicAccess(ActionQueueCommand):
     """Change the public access of a file."""
 
@@ -2498,6 +2480,11 @@
 
     def finish(self):
         """Release the semaphore if already acquired."""
+        if self.tempfile is not None:
+            # clean the temporary file
+            self.tempfile.close()
+            remove_file(self.tempfile.name)
+
         if self.tx_semaphore is not None:
             self.tx_semaphore = self.tx_semaphore.release()
             self.log.debug('semaphore released')
@@ -2509,7 +2496,7 @@
                                            share_id=self.share_id,
                                            node_id=self.node_id,
                                            hash=self.hash)
-
+        self.tempfile.seek(0)
         f = UploadProgressWrapper(self.tempfile, self)
 
         # access here the magic hash value, don't log anywhere, and
@@ -2521,9 +2508,7 @@
             upload_id=self.upload_id, upload_id_cb=self._upload_id_cb,
             magic_hash=magic_hash)
         self.upload_req = req
-        d = req.deferred
-        d.addBoth(passit(lambda _: self.tempfile.close()))
-        return d
+        return req.deferred
 
     def _upload_id_cb(self, upload_id):
         """Handle the received upload_id, save it in the metadata."""
@@ -2545,9 +2530,6 @@
 
     def handle_success(self, request):
         """It worked! Push the event."""
-        # remove the temporary file
-        remove_file(self.tempfile.name)
-
         # send the event
         d = dict(share_id=self.share_id, node_id=self.node_id, hash=self.hash,
                  new_generation=request.new_generation)
@@ -2563,7 +2545,6 @@
 
     def handle_failure(self, failure):
         """It didn't work! Push the event."""
-        remove_file(self.tempfile.name)
         self.action_queue.event_queue.push('AQ_UPLOAD_ERROR',
                                            error=failure.getErrorMessage(),
                                            share_id=self.share_id,