Merge lp:~jderose/dmedia/filestore-tmp-api into lp:dmedia

[Jason Gerard DeRose]

Splits FileStore.finalize_transfer() into two simpler methods:

FileStore.tmp_move(tmp_fp, chash, ext) - only moves tmp_fp to canonical location, assumes higher level code has already computed/verified content hash

FileStore.tmp_verify_move(chash, ext) - basically same as finalize_transfer() except uses tmp_move() to do actually move

To fit these naming conventions, I also renamed:

FileStore.reltemp() => FileStore.reltmp()
FileStore.temp() => FileStore.tmp()

Meaning to do that for a while, so good excuse.

Probably easier to read the docstrings here - http://bazaar.launchpad.net/~jderose/dmedia/filestore-tmp-api/view/head:/dmedia/filestore.py#L625

[James Raymond (jamesmr)]

Looks decent :)

review: Approve

=== modified file 'dmedia/downloader.py'
--- dmedia/downloader.py	2011-02-11 16:55:18 +0000
+++ dmedia/downloader.py	2011-02-12 11:14:54 +0000
@@ -172,12 +172,12 @@
         self.ext = ext
 
     def get_tmp(self):
-        tmp = self.fs.temp(self.chash, self.ext, create=True)
+        tmp = self.fs.tmp(self.chash, self.ext, create=True)
         log.debug('Writting file to %r', tmp)
         return tmp
 
     def finalize(self):
-        dst = self.fs.finalize_transfer(self.chash, self.ext)
+        dst = self.fs.tmp_verify_move(self.chash, self.ext)
         log.debug('Canonical name is %r', dst)
         return dst
 

=== modified file 'dmedia/filestore.py'
--- dmedia/filestore.py	2011-02-11 17:22:08 +0000
+++ dmedia/filestore.py	2011-02-12 11:14:54 +0000
@@ -39,6 +39,7 @@
 
 import os
 from os import path
+import stat
 import tempfile
 from hashlib import sha1 as HASH
 from base64 import b32encode, b32decode
@@ -278,8 +279,6 @@
             if not chunk:
                 break
         self.thread.join()
-        if self.dst_fp is not None:
-            os.fchmod(self.dst_fp.fileno(), 0o444)
         return b32encode(self.h.digest())
 
 
@@ -450,18 +449,18 @@
         return (dname, fname)
 
     @staticmethod
-    def reltemp(chash, ext=None):
+    def reltmp(chash, ext=None):
         """
         Relative path of temporary file with *chash*, ending with *ext*.
 
         For example:
 
-        >>> FileStore.reltemp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')
+        >>> FileStore.reltmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')
         ('transfers', 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')
 
         Or with the file extension *ext*:
 
-        >>> FileStore.reltemp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', ext='mov')
+        >>> FileStore.reltmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', ext='mov')
         ('transfers', 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW.mov')
 
         Also see `FileStore.relpath()`.
@@ -472,6 +471,9 @@
         return (TRANSFERS_DIR, chash)
 
     def check_path(self, pathname):
+        """
+        Verify that *pathname* in inside this filestore base directory.
+        """
         abspath = path.abspath(pathname)
         if abspath.startswith(self.base + os.sep):
             return abspath
@@ -574,7 +576,7 @@
             self.create_parent(filename)
         return filename
 
-    def temp(self, chash, ext=None, create=False):
+    def tmp(self, chash, ext=None, create=False):
         """
         Returns path of temporary file with *chash*, ending with *ext*.
 
@@ -582,26 +584,26 @@
         in which case the content-hash is already known.  For example:
 
         >>> fs = FileStore()
-        >>> fs.temp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')  #doctest: +ELLIPSIS
+        >>> fs.tmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')  #doctest: +ELLIPSIS
         '/tmp/store.../transfers/NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'
 
 
         Or with a file extension:
 
-        >>> fs.temp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', 'txt')  #doctest: +ELLIPSIS
+        >>> fs.tmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', 'txt')  #doctest: +ELLIPSIS
         '/tmp/store.../transfers/NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW.txt'
 
 
         If called with ``create=True``, the parent directory is created with
         `FileStore.create_parent()`.
         """
-        filename = self.join(*self.reltemp(chash, ext))
+        filename = self.join(*self.reltmp(chash, ext))
         if create:
             self.create_parent(filename)
         return filename
 
     def allocate_for_transfer(self, size, chash, ext=None):
-        filename = self.temp(chash, ext, create=True)
+        filename = self.tmp(chash, ext, create=True)
         fallocate(size, filename)
         try:
             fp = open(filename, 'r+b')
@@ -620,14 +622,99 @@
         fallocate(size, filename)
         return open(filename, 'r+b')
 
-    def finalize_transfer(self, chash, ext=None):
-        """
-        Move canonically named temporary file to its final canonical location.
+    def tmp_move(self, tmp_fp, chash, ext=None):
+        """
+        Move temporary file into its canonical location.
+
+        This method will securely and atomically move a temporary file into its
+        canonical location.
+
+        For example:
+
+        >>> fs = FileStore()
+        >>> tmp_fp = open(fs.join('foo.mov'), 'wb')
+        >>> chash = 'ZR765XWSF6S7JQHLUI4GCG5BHGPE252O'
+        >>> fs.tmp_move(tmp_fp, chash, 'mov')  #doctest: +ELLIPSIS
+        '/tmp/store.../ZR/765XWSF6S7JQHLUI4GCG5BHGPE252O.mov'
+
+
+        Note, however, that this method does *not* verify the content hash of
+        the temporary file!  This is by design as many operations will compute
+        the content hash as they write to the temporary file.  Other operations
+        should use `FileStore.tmp_verify_move()` to verify and move in one step.
+
+        Regardless, the full content hash should have been verified prior to
+        calling this method.  To ensure the content is not modified, operations
+        must take these steps:
+
+            1. Open *tmp_fp* and keep it open, thereby retaining a lock on the
+               file
+
+            2. Compute the full content hash, which can be done as content is
+               written to *tmp_fp* (open in mode ``'r+b'`` to resume a transfer,
+               but hash of previously transfered leaves must still be verified)
+
+            3. With *tmp_fp* still open, move the temporary file into its
+               canonical location using this method.
+
+        As a simple locking mechanism, this method takes an open ``file`` rather
+        than a filename, thereby preventing the file from being modified during
+        the move.  A ``ValueError`` is raised if *tmp_fp* is already closed.
+
+        For portability reasons, this method requires that *tmp_fp* be opened in
+        a binary mode: ``'rb'``, ``'wb'``, or ``'r+b'``.  A ``ValueError`` is
+        raised if opened in any other mode.
+
+        For security reasons, this method will only move a temporary file
+        located within the ``FileStore.base`` directory or a subdirectory
+        thereof.  If an attempt is made to move a file from outside the store,
+        `FileStoreTraversal` is raised.  See `FileStore.check_path()`.
+
+        Just prior to moving the file, a call to ``os.fchmod()`` is made to set
+        read-only permissions (0444).  After the move, *tmp_fp* is closed.
+
+        If the canonical file already exists, `DuplicateFile` is raised.
+
+        The return value is the absolute path of the canonical file.
+
+        :param tmp_fp: a ``file`` instance created with ``open()``
+        :param chash: base32-encoded content-hash
+        :param ext: normalized lowercase file extension, eg ``'mov'``
+        """
+        # Validate tmp_fp:
+        if not isinstance(tmp_fp, file):
+            raise TypeError(
+                TYPE_ERROR % ('tmp_fp', file, type(tmp_fp), tmp_fp)
+            )
+        if tmp_fp.mode not in ('rb', 'wb', 'r+b'):
+            raise ValueError(
+                "tmp_fp: mode must be 'rb', 'wb', or 'r+b'; got %r" % tmp_fp.mode
+            )
+        if tmp_fp.closed:
+            raise ValueError('tmp_fp is closed, must be open: %r' % tmp_fp.name)
+        self.check_path(tmp_fp.name)
+
+        # Get canonical name, check for duplicate:
+        dst = self.path(chash, ext, create=True)
+        if path.exists(dst):
+            raise DuplicateFile(chash=chash, src=tmp_fp.name, dst=dst)
+
+        # Set file to read-only (0444) and move into canonical location
+        os.fchmod(tmp_fp.fileno(), stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
+        os.rename(tmp_fp.name, dst)
+        tmp_fp.close()
+
+        # Return canonical filename:
+        return dst
+
+    def tmp_verify_move(self, chash, ext=None):
+        """
+        Verify temporary file, then move into its canonical location.
 
         This method will check the content hash of the canonically-named
         temporary file with content hash *chash* and extension *ext*.  If the
-        content hash is correct, it will do an ``os.fchmod()`` to set read-only
-        permissions, and then rename the file into its canonical location.
+        content hash is correct, this method will then move the temporary file
+        into its canonical location using `FileStore.tmp_move()`.
 
         If the content hash is incorrect, `IntegrityError` is raised.  If the
         canonical file already exists, `DuplicateFile` is raised.  Lastly, if
@@ -639,7 +726,7 @@
         temporary file name, like this:
 
         >>> fs = FileStore()
-        >>> tmp = fs.temp('ZR765XWSF6S7JQHLUI4GCG5BHGPE252O', 'mov', create=True)
+        >>> tmp = fs.tmp('ZR765XWSF6S7JQHLUI4GCG5BHGPE252O', 'mov', create=True)
         >>> tmp  #doctest: +ELLIPSIS
         '/tmp/store.../transfers/ZR765XWSF6S7JQHLUI4GCG5BHGPE252O.mov'
 
@@ -662,33 +749,23 @@
         Finally, the downloader will move the temporary file into its canonical
         location:
 
-        >>> dst = fs.finalize_transfer('ZR765XWSF6S7JQHLUI4GCG5BHGPE252O', 'mov')
+        >>> dst = fs.tmp_verify_move('ZR765XWSF6S7JQHLUI4GCG5BHGPE252O', 'mov')
         >>> dst  #doctest: +ELLIPSIS
         '/tmp/store.../ZR/765XWSF6S7JQHLUI4GCG5BHGPE252O.mov'
 
 
-        Note above that this method returns the full path of the canonically
-        named file.
+        The return value is the absolute path of the canonical file.
+
+        :param chash: base32-encoded content-hash
+        :param ext: normalized lowercase file extension, eg ``'mov'``
         """
-        # Open temporary file and check content hash:
-        tmp = self.temp(chash, ext)
+        tmp = self.tmp(chash, ext)
         tmp_fp = open(tmp, 'rb')
         h = HashList(tmp_fp)
         got = h.run()
         if got != chash:
             raise IntegrityError(got=got, expected=chash, filename=tmp_fp.name)
-
-        # Get canonical name, check for duplicate:
-        dst = self.path(chash, ext, create=True)
-        if path.exists(dst):
-            raise DuplicateFile(chash=chash, src=tmp_fp.name, dst=dst)
-
-        # Set file to read-only and rename into canonical location
-        os.fchmod(tmp_fp.fileno(), 0o444)
-        os.rename(tmp_fp.name, dst)
-
-        # Return canonical filename:
-        return dst
+        return self.tmp_move(tmp_fp, chash, ext)
 
     def import_file(self, src_fp, ext=None):
         """
@@ -696,8 +773,8 @@
 
         The method will compute the content-hash of *src_fp* as it copies it to
         a temporary file within this store.  Once the copying is complete, the
-        file will be renamed to its canonical location in the store, thus
-        ensuring an atomic operation.
+        temporary file will be moved to its canonical location using
+        `FileStore.tmp_move()`.
 
         A `DuplicatedFile` exception will be raised if the file already exists
         in this store.
@@ -708,15 +785,15 @@
 
         Note that *src_fp* must have been opened in ``'rb'`` mode.
 
-        :param src_fp: A ``file`` instance created with ``open()``
-        :param ext: The file's extension, e.g., ``'ogv'``
+        :param src_fp: a ``file`` instance created with ``open()``
+        :param ext: normalized lowercase file extension, eg ``'mov'``
         """
         size = os.fstat(src_fp.fileno()).st_size
-        tmp_fp = self.allocate_for_import(size, ext=ext)
+        tmp_fp = self.allocate_for_import(size, ext)
         h = HashList(src_fp, tmp_fp)
         chash = h.run()
-        dst = self.path(chash, ext, create=True)
-        if path.exists(dst):
-            raise DuplicateFile(chash=chash, src=src_fp.name, dst=dst)
-        os.rename(tmp_fp.name, dst)
+        try:
+            self.tmp_move(tmp_fp, chash, ext)
+        except DuplicateFile as e:
+            raise DuplicateFile(src=src_fp.name, dst=e.dst, chash=e.chash)
         return (chash, h.leaves)

=== modified file 'dmedia/tests/test_downloader.py'
--- dmedia/tests/test_downloader.py	2011-02-11 15:45:43 +0000
+++ dmedia/tests/test_downloader.py	2011-02-12 11:14:54 +0000
@@ -212,7 +212,7 @@
         self.assertFalse(path.exists(dst))
 
         # Test when transfers/ exists but file does not:
-        self.assertEqual(fs.temp(mov_hash, 'mov', create=True), src)
+        self.assertEqual(fs.tmp(mov_hash, 'mov', create=True), src)
         self.assertTrue(path.isdir(src_d))
         e = raises(IOError, inst.finalize)
         self.assertFalse(path.exists(src))

=== modified file 'dmedia/tests/test_filestore.py'
--- dmedia/tests/test_filestore.py	2011-02-11 01:50:20 +0000
+++ dmedia/tests/test_filestore.py	2011-02-12 11:14:54 +0000
@@ -26,6 +26,7 @@
 
 import os
 from os import path
+import stat
 from hashlib import sha1
 from base64 import b32encode, b32decode
 import shutil
@@ -530,24 +531,24 @@
             'ext %r does not match pattern %r' % (bad, EXT_PAT)
         )
 
-    def test_reltemp(self):
+    def test_reltmp(self):
         self.assertEqual(
-            self.klass.reltemp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'),
+            self.klass.reltmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'),
             ('transfers', 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')
         )
         self.assertEqual(
-            self.klass.reltemp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', ext='ogv'),
+            self.klass.reltmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', ext='ogv'),
             ('transfers', 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW.ogv')
         )
 
         # Test to make sure hashes are getting checked with safe_b32():
         bad = 'NWBNVXVK5..GIOW7MYR4K3KA5K22W7NW'
-        e = raises(ValueError, self.klass.reltemp, bad)
+        e = raises(ValueError, self.klass.reltmp, bad)
         self.assertEqual(
             str(e),
             'b32: cannot b32decode %r: Non-base32 digit found' % bad
         )
-        e = raises(ValueError, self.klass.reltemp, bad, ext='ogv')
+        e = raises(ValueError, self.klass.reltmp, bad, ext='ogv')
         self.assertEqual(
             str(e),
             'b32: cannot b32decode %r: Non-base32 digit found' % bad
@@ -556,7 +557,7 @@
         # Test to make sure ext is getting checked with safe_ext():
         chash = 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'
         bad = '/../../../.ssh/id_pub'
-        e = raises(ValueError, self.klass.reltemp, chash, bad)
+        e = raises(ValueError, self.klass.reltmp, chash, bad)
         self.assertEqual(
             str(e),
             'ext %r does not match pattern %r' % (bad, EXT_PAT)
@@ -750,27 +751,27 @@
         self.assertFalse(path.exists(f))
         self.assertTrue(path.isdir(d))
 
-    def test_temp(self):
+    def test_tmp(self):
         tmp = TempDir()
         inst = self.klass(tmp.path)
 
         self.assertEqual(
-            inst.temp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'),
+            inst.tmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'),
             tmp.join('transfers', 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW')
         )
         self.assertEqual(
-            inst.temp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', ext='ogv'),
+            inst.tmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', ext='ogv'),
             tmp.join('transfers', 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW.ogv')
         )
 
         # Test to make sure hashes are getting checked with safe_b32():
         bad = 'NWBNVXVK5..GIOW7MYR4K3KA5K22W7NW'
-        e = raises(ValueError, inst.temp, bad)
+        e = raises(ValueError, inst.tmp, bad)
         self.assertEqual(
             str(e),
             'b32: cannot b32decode %r: Non-base32 digit found' % bad
         )
-        e = raises(ValueError, inst.temp, bad, ext='ogv')
+        e = raises(ValueError, inst.tmp, bad, ext='ogv')
         self.assertEqual(
             str(e),
             'b32: cannot b32decode %r: Non-base32 digit found' % bad
@@ -779,7 +780,7 @@
         # Test to make sure ext is getting checked with safe_ext():
         chash = 'NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'
         bad = '/../../../.ssh/id_pub'
-        e = raises(ValueError, inst.temp, chash, bad)
+        e = raises(ValueError, inst.tmp, chash, bad)
         self.assertEqual(
             str(e),
             'ext %r does not match pattern %r' % (bad, EXT_PAT)
@@ -794,13 +795,13 @@
         self.assertFalse(path.exists(f))
         self.assertFalse(path.exists(d))
         self.assertEqual(
-            inst.temp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'),
+            inst.tmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW'),
             f
         )
         self.assertFalse(path.exists(f))
         self.assertFalse(path.exists(d))
         self.assertEqual(
-            inst.temp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', create=True),
+            inst.tmp('NWBNVXVK5DQGIOW7MYR4K3KA5K22W7NW', create=True),
             f
         )
         self.assertFalse(path.exists(f))
@@ -894,7 +895,113 @@
         self.assertEqual(path.dirname(fp.name), imports)
         self.assertTrue(fp.name.endswith('.mov'))
 
-    def test_finalize_transfer(self):
+    def test_tmp_move(self):
+        tmp = TempDir()
+        base = tmp.join('.dmedia')
+        dst_d = tmp.join('.dmedia', mov_hash[:2])
+        dst = tmp.join('.dmedia', mov_hash[:2], mov_hash[2:] + '.mov')
+        inst = self.klass(base)
+
+        # Test with wrong tmp_fp type
+        e = raises(TypeError, inst.tmp_move, 17, mov_hash, 'mov')
+        self.assertEqual(str(e), TYPE_ERROR % ('tmp_fp', file, int, 17))
+        self.assertFalse(path.exists(dst_d))
+        self.assertFalse(path.exists(dst))
+
+        # Test with tmp_fp opened in wrong mode
+        bad = tmp.touch('.dmedia', 'bad1.mov')
+        for mode in ('r', 'w', 'r+'):
+            fp = open(bad, mode)
+            e = raises(ValueError, inst.tmp_move, fp, mov_hash, 'mov')
+            self.assertEqual(
+                str(e),
+                "tmp_fp: mode must be 'rb', 'wb', or 'r+b'; got %r" % mode
+            )
+            self.assertFalse(path.exists(dst_d))
+            self.assertFalse(path.exists(dst))
+            self.assertFalse(fp.closed)
+
+        # Test when filename isn't contained in base (to ensure that
+        # FileStore.check_path() is used to validate tmp_fp.name)
+        bad = tmp.touch('.dmedia', '..', 'bad2.mov')
+        fp = open(bad, 'rb')
+        e = raises(FileStoreTraversal, inst.tmp_move, fp, mov_hash, 'mov')
+        self.assertEqual(e.pathname, bad)
+        self.assertEqual(e.abspath, tmp.join('bad2.mov'))
+        self.assertEqual(e.base, base)
+        self.assertFalse(path.exists(dst_d))
+        self.assertFalse(path.exists(dst))
+        self.assertFalse(fp.closed)
+
+        # Test that chash is validated with safe_b32()
+        good = tmp.write('yup', '.dmedia', 'imports', 'good.mov')
+        os.chmod(good, 0o660)
+        fp = open(good, 'rb')
+        b32 = 'NWBNVXVK5DQGIOW7MYR4K3KA'
+        e = raises(ValueError, inst.tmp_move, fp, b32, 'mov')
+        self.assertEqual(
+            str(e),
+            "len(b32) must be 32; got 24: 'NWBNVXVK5DQGIOW7MYR4K3KA'"
+        )
+        self.assertFalse(path.exists(dst_d))
+        self.assertFalse(path.exists(dst))
+        self.assertFalse(fp.closed)
+
+        # Test that ext is validate with safe_ext()
+        bad_ext = '/etc/ssh'
+        e = raises(ValueError, inst.tmp_move, fp, mov_hash, bad_ext)
+        self.assertEqual(
+            str(e),
+            'ext %r does not match pattern %r' % (bad_ext, EXT_PAT)
+        )
+        self.assertFalse(path.exists(dst_d))
+        self.assertFalse(path.exists(dst))
+        self.assertFalse(fp.closed)
+
+        # Test when tmp_fp is closed
+        fp.close()
+        e = raises(ValueError, inst.tmp_move, fp, mov_hash, 'mov')
+        self.assertEqual(
+            str(e),
+            'tmp_fp is closed, must be open: %r' % good
+        )
+        self.assertFalse(path.exists(dst_d))
+        self.assertFalse(path.exists(dst))
+        self.assertTrue(fp.closed)
+
+        # Test when it's all good
+        fp = open(good, 'rb')
+        self.assertEqual(stat.S_IMODE(os.stat(good).st_mode), 0o660)
+        self.assertEqual(inst.tmp_move(fp, mov_hash, 'mov'), dst)
+        self.assertFalse(path.exists(good))
+        self.assertTrue(path.isdir(dst_d))
+        self.assertTrue(path.isfile(dst))
+        self.assertEqual(stat.S_IMODE(os.stat(dst).st_mode), 0o444)
+        self.assertEqual(open(dst, 'rb').read(), 'yup')
+        self.assertTrue(fp.closed)
+
+        # Test when it's a duplicate
+        dup = tmp.write('wowza', '.dmedia', 'imports', 'dup')
+        os.chmod(dup, 0o660)
+        fp = open(dup, 'rb')
+        e = raises(DuplicateFile, inst.tmp_move, fp, mov_hash, 'mov')
+        self.assertEqual(e.chash, mov_hash)
+        self.assertEqual(e.src, dup)
+        self.assertEqual(e.dst, dst)
+        self.assertFalse(fp.closed)
+
+        # Make sure dup wasn't altered
+        self.assertTrue(path.isfile(dup))
+        self.assertEqual(stat.S_IMODE(os.stat(dup).st_mode), 0o660)
+        self.assertEqual(open(dup, 'rb').read(), 'wowza')
+
+        # Make sure dst wasn't altered
+        self.assertTrue(path.isdir(dst_d))
+        self.assertTrue(path.isfile(dst))
+        self.assertEqual(stat.S_IMODE(os.stat(dst).st_mode), 0o444)
+        self.assertEqual(open(dst, 'rb').read(), 'yup')
+
+    def test_tmp_verify_move(self):
         tmp = TempDir()
         inst = self.klass(tmp.path)
 
@@ -904,22 +1011,22 @@
         dst = tmp.join(mov_hash[:2], mov_hash[2:] + '.mov')
 
         # Test when transfers/ dir doesn't exist:
-        e = raises(IOError, inst.finalize_transfer, mov_hash, 'mov')
+        e = raises(IOError, inst.tmp_verify_move, mov_hash, 'mov')
         self.assertFalse(path.exists(src_d))
         self.assertFalse(path.exists(dst_d))
         self.assertFalse(path.exists(dst))
 
         # Test when transfers/ exists but file does not:
-        self.assertEqual(inst.temp(mov_hash, 'mov', create=True), src)
+        self.assertEqual(inst.tmp(mov_hash, 'mov', create=True), src)
         self.assertTrue(path.isdir(src_d))
-        e = raises(IOError, inst.finalize_transfer, mov_hash, 'mov')
+        e = raises(IOError, inst.tmp_verify_move, mov_hash, 'mov')
         self.assertFalse(path.exists(src))
         self.assertFalse(path.exists(dst_d))
         self.assertFalse(path.exists(dst))
 
         # Test when file has wrong content hash and wrong size:
         open(src, 'wb').write(open(sample_thm, 'rb').read())
-        e = raises(IntegrityError, inst.finalize_transfer, mov_hash, 'mov')
+        e = raises(IntegrityError, inst.tmp_verify_move, mov_hash, 'mov')
         self.assertEqual(e.got, thm_hash)
         self.assertEqual(e.expected, mov_hash)
         self.assertEqual(e.filename, src)
@@ -942,7 +1049,7 @@
         fp2.close()
         self.assertEqual(path.getsize(sample_mov), path.getsize(src))
 
-        e = raises(IntegrityError, inst.finalize_transfer, mov_hash, 'mov')
+        e = raises(IntegrityError, inst.tmp_verify_move, mov_hash, 'mov')
         self.assertEqual(e.got, 'UECTT7A7EIHZ2SGGBMMO5WTTSVU4SUWM')
         self.assertEqual(e.expected, mov_hash)
         self.assertEqual(e.filename, src)
@@ -959,7 +1066,7 @@
             fp2.write(chunk)
         fp1.close()
         fp2.close()
-        self.assertEqual(inst.finalize_transfer(mov_hash, 'mov'), dst)
+        self.assertEqual(inst.tmp_verify_move(mov_hash, 'mov'), dst)
         self.assertTrue(path.isdir(src_d))
         self.assertFalse(path.exists(src))
         self.assertTrue(path.isdir(dst_d))