Merge lp:~nataliabidart/magicicada-server/no-more-storms-3 into lp:magicicada-server

[Natalia Bidart]

- More datetime.utcnow() replcements.
- Completely removed the use_uuid flag for files.

[lp:~nataliabidart/magicicada-server/no-more-storms-3]

56. By Natalia Bidart on 2016-03-04

One more lint issue fixed.

57. By Natalia Bidart on 2016-03-04

Missing import.

[Facundo Batista (facundo)]

Remember the transition is done!!

review: Approve

[lp:~nataliabidart/magicicada-server/no-more-storms-3]

58. By Natalia Bidart on 2016-03-04

Completely removed the use_uuid flag for files.

59. By Natalia Bidart on 2016-03-04

Fixed test failures.

60. By Natalia Bidart on 2016-03-05

More tests fixes.

61. By Natalia Bidart on 2016-03-06

Fixed remaining failing tests.

=== modified file 'src/backends/db/errors.py'
--- src/backends/db/errors.py	2016-02-25 03:34:42 +0000
+++ src/backends/db/errors.py	2016-03-06 23:21:42 +0000
@@ -20,6 +20,8 @@
 
 from __future__ import unicode_literals
 
+from django.db import IntegrityError  # NOQA
+
 
 class RetryLimitReached(Exception):
     """Raised when there have been to many retries."""
@@ -29,9 +31,5 @@
         self.extra_info = extra_info
 
 
-class IntegrityError(Exception):
-    """Raised when there has been an integrity error."""
-
-
 class NoTimeoutTracer(Exception):
     """No timeout tracer was registered"""

=== modified file 'src/backends/filesync/admin.py'
--- src/backends/filesync/admin.py	2015-09-27 21:25:27 +0000
+++ src/backends/filesync/admin.py	2016-03-06 23:21:42 +0000
@@ -36,7 +36,7 @@
         self.filter = filter
 
     def _find_users(self):
-        """Perform storm query based on current filter."""
+        """Perform query based on current filter."""
         store = get_filesync_store()
         conditions = []
         if self.filter is not None:
@@ -67,7 +67,7 @@
 
     @fsync_readonly
     def is_empty(self):
-        """Return True if there are any results."""
+        """Return True if there are no results."""
         return self._find_users().is_empty()
 
     @fsync_readonly

=== modified file 'src/backends/filesync/models.py'
--- src/backends/filesync/models.py	2015-10-16 11:24:51 +0000
+++ src/backends/filesync/models.py	2016-03-06 23:21:42 +0000
@@ -20,13 +20,13 @@
 
 from __future__ import unicode_literals
 
-import datetime
 import os
 import re
 import uuid
 
 from types import NoneType
 
+from django.utils.timezone import now
 from storm.locals import (Int, DateTime, Unicode, RawStr, Reference, SQL,
                           Storm, Store, Bool, ReferenceSet)
 from storm.expr import Or, Sum, Desc
@@ -135,7 +135,7 @@
         for d in deleted[:limit]:
             leaf = parent.build_tree_from_path(d.path)
             d.undelete(leaf)
-        root.when_last_modified = datetime.datetime.utcnow()
+        root.when_last_modified = now()
         return parent
 
 
@@ -325,7 +325,7 @@
     when_created = DateTime(allow_none=True)
 
     def __init__(self):
-        self.when_created = datetime.datetime.utcnow()
+        self.when_created = now()
 
     @classmethod
     def make_empty(cls, store):
@@ -334,7 +334,7 @@
         o.hash = EMPTY_CONTENT_HASH
         o.crc32 = 0
         o.size = 0
-        o.when_created = datetime.datetime.utcnow()
+        o.when_created = now()
         store.add(o)
         return o
 
@@ -564,7 +564,7 @@
         curr_size = getattr(self.content, 'size', 0)
         self._update_used_bytes(new_content.size - curr_size)
         self._content = new_content
-        self.when_last_modified = datetime.datetime.utcnow()
+        self.when_last_modified = now()
         self.update_generation()
 
         from backends.txlog.models import TransactionLog
@@ -639,10 +639,10 @@
             self.parent_id = new_parent_id
             self.path = pypath.join(new_parent_path, new_parent_name)
         self.name = new_name
-        now = datetime.datetime.utcnow()
+        right_now = now()
         if old_parent.id != new_parent_id:
-            old_parent.when_last_modified = now
-        new_parent.when_last_modified = now
+            old_parent.when_last_modified = right_now
+        new_parent.when_last_modified = right_now
 
         from backends.txlog.models import TransactionLog
         TransactionLog.record_move(self, old_name, old_parent)
@@ -731,14 +731,14 @@
             if new_parent:
                 # if we have a suitable parent, update the parent
                 self.parent = new_parent
-                self.parent.when_last_modified = datetime.datetime.utcnow()
+                self.parent.when_last_modified = now()
             else:
                 # if we can't find a suitable parent, we need to restore the
                 # old one.
                 self.parent.undelete()
         else:
             # if the parent was live, we just need to update the timestamp
-            self.parent.when_last_modified = datetime.datetime.utcnow()
+            self.parent.when_last_modified = now()
 
     def unlink(self):
         """Mark the node as Dead."""
@@ -758,7 +758,7 @@
         # case unnecessary) implicit flush.
         with implicit_flushes_blocked_on(Store.of(self)):
             self.status = STATUS_DEAD
-            self.when_last_modified = datetime.datetime.utcnow()
+            self.when_last_modified = now()
             self.update_generation()
 
         from backends.txlog.models import TransactionLog
@@ -767,7 +767,7 @@
         if self.kind == StorageObject.FILE:
             self._update_used_bytes(0 - getattr(self.content, 'size', 0))
         if self.parent_id != ROOT_PARENTID:
-            self.parent.when_last_modified = datetime.datetime.utcnow()
+            self.parent.when_last_modified = now()
 
     def unlink_tree(self):
         """Unlink and entire directory and it's subdirectories"""
@@ -791,13 +791,13 @@
             TransactionLog.record_unlink_tree(self)
 
             self.descendants.set(status=STATUS_DEAD,
-                                 when_last_modified=datetime.datetime.utcnow())
+                                 when_last_modified=now())
 
         self.status = STATUS_DEAD
-        self.when_last_modified = datetime.datetime.utcnow()
+        self.when_last_modified = now()
 
         if self.parent_id != ROOT_PARENTID:
-            self.parent.when_last_modified = datetime.datetime.utcnow()
+            self.parent.when_last_modified = now()
 
     @property
     def tree_size(self):
@@ -844,7 +844,7 @@
                               kind=StorageObject.DIRECTORY,
                               parent=self)
         store.add(node)
-        self.when_last_modified = datetime.datetime.utcnow()
+        self.when_last_modified = now()
         return node
 
     def make_file(self, name):
@@ -864,7 +864,7 @@
                               kind=StorageObject.FILE,
                               parent=self)
         store.add(node)
-        self.when_last_modified = datetime.datetime.utcnow()
+        self.when_last_modified = now()
         return node
 
     @staticmethod
@@ -1127,7 +1127,7 @@
         self.chunk_count = 0
         self.uploaded_bytes = 0
         self.multipart_key = multipart_key
-        self.when_last_active = datetime.datetime.utcnow()
+        self.when_last_active = now()
         self.status = STATUS_LIVE
 
     @classmethod
@@ -1195,7 +1195,7 @@
         self.path = path.strip('/')
         self.status = STATUS_LIVE
         self.generation = 0
-        self.when_created = datetime.datetime.utcnow()
+        self.when_created = now()
 
     def delete(self):
         """Delete the UDF."""
@@ -1337,7 +1337,7 @@
     def set_status(self, status):
         """Set the status of the download, and update the change date."""
         self._status = status
-        self.status_change_date = datetime.datetime.utcnow()
+        self.status_change_date = now()
     status = property(get_status, set_status)
 
 
@@ -1392,4 +1392,4 @@
         self.hash_context = hash_context
         self.magic_hash_context = magic_hash_context
         self.crc_context = crc_context
-        self.when_last_active = datetime.datetime.utcnow()
+        self.when_last_active = now()

=== modified file 'src/backends/filesync/services.py'
--- src/backends/filesync/services.py	2016-02-25 03:26:13 +0000
+++ src/backends/filesync/services.py	2016-03-06 23:21:42 +0000
@@ -25,7 +25,6 @@
 
 from __future__ import unicode_literals
 
-import datetime
 import mimetypes
 import os
 import posixpath as pypath
@@ -36,6 +35,7 @@
 from weakref import WeakValueDictionary
 
 from django.conf import settings
+from django.utils.timezone import now
 from storm.locals import SQL
 from storm.expr import Or, LeftJoin, Desc, And
 from storm.info import ClassAlias
@@ -555,10 +555,7 @@
     @property
     def public_key(self):
         """Return the public key for this node."""
-        if self.public_uuid:
-            return utils.get_node_public_key(self, True)
-        if self.public_id:
-            return utils.get_node_public_key(self)
+        return utils.get_node_public_key(self)
 
     @property
     def owner(self):
@@ -817,16 +814,14 @@
         """Add part info to this uploadjob."""
         self._gateway.add_uploadjob_part(self.id, size)
         # also update the when_last_active value.
-        self._gateway.set_uploadjob_when_last_active(
-            self.id, datetime.datetime.utcnow())
+        self._gateway.set_uploadjob_when_last_active(self.id, now())
         self._load()
 
     @retryable_transaction()
     @fsync_commit
     def touch(self):
         """Update the when_last_active attribute."""
-        self._gateway.set_uploadjob_when_last_active(
-            self.id, datetime.datetime.utcnow())
+        self._gateway.set_uploadjob_when_last_active(self.id, now())
         self._load()
 
 
@@ -1236,11 +1231,7 @@
 
     def create_or_update_user(self, user_id, username, visible_name,
                               max_storage_bytes):
-        """Create or update a StorageUser and related data.
-
-        This happens when a user subscribes to the service. If they upgrade or
-        reactivate a subscription, this would get called again.
-        """
+        """Create or update a StorageUser and related data."""
         user = self.store.get(StorageUser, user_id)
         if user is None:
             user = StorageUser.new(
@@ -1292,11 +1283,7 @@
 
     def claim_shareoffer(self, user_id, username, visible_name,
                          shareoffer_id):
-        """Claim a share offer sent to an email.
-
-        This is a strange function in that the user may not have subscribed yet
-        and may not have a storage user record.
-        """
+        """Claim a share offer sent to an email."""
         # A anonymous share offer is a share sent to an email address but not
         # to a specific user. We also don't let user's claim their own share
         share, byuser = self._get_shareoffer(shareoffer_id)
@@ -1316,7 +1303,7 @@
         self.queue_share_accepted(share_dao)
         return share_dao
 
-    def _get_public_node(self, public_key, use_uuid=False):
+    def _get_public_node(self, public_key):
         """Get a node from a public key."""
         if public_key is None:
             raise errors.DoesNotExist(self.publicfile_dne_error)
@@ -1325,14 +1312,9 @@
         except utils.Base62Error:
             raise errors.DoesNotExist(self.publicfile_dne_error)
 
-        if use_uuid:
-            public_id = uuid.UUID(int=public_id)
-            publicnode = self.store.find(
-                PublicNode, PublicNode.public_uuid == public_id).one()
-        else:
-            publicnode = self.store.find(
-                PublicNode, PublicNode.id == public_id,
-                PublicNode.public_uuid == None).one()  # NOQA
+        public_id = uuid.UUID(int=public_id)
+        publicnode = self.store.find(
+            PublicNode, PublicNode.public_uuid == public_id).one()
         if publicnode is None:
             raise errors.DoesNotExist(self.publicfile_dne_error)
 
@@ -1350,14 +1332,14 @@
     def get_public_directory(self, public_key, mimetypes=None):
         """Get a public directory."""
         # Use UUIDs instead of the old method
-        node = self._get_public_node(public_key, use_uuid=True)
+        node = self._get_public_node(public_key)
         if node.kind != StorageObject.DIRECTORY:
             raise errors.DoesNotExist(self.publicfile_dne_error)
         return node
 
-    def get_public_file(self, public_key, use_uuid=False):
+    def get_public_file(self, public_key):
         """Get a public file."""
-        node = self._get_public_node(public_key, use_uuid)
+        node = self._get_public_node(public_key)
         if (node.content is None or node.content.storage_key is None or
                 node.kind != StorageObject.FILE):
             # if the file has no content, we should not be able to get it
@@ -3105,10 +3087,10 @@
         return DAOUploadJob(job, gateway=self)
 
     @timing_metric
-    def set_uploadjob_when_last_active(self, job_id, datetime):
-        """Set when_last_active to datetime.utcnow()."""
+    def set_uploadjob_when_last_active(self, job_id, timestamp):
+        """Set when_last_active to timestamp."""
         job = self._get_uploadjob(job_id)
-        job.when_last_active = datetime
+        job.when_last_active = timestamp
         return DAOUploadJob(job, gateway=self)
 
     def _make_public(self, fnode):
@@ -3123,7 +3105,7 @@
                 # Flush the store to ensure the new PublicNode has
                 # a database ID.
                 self.store.flush()
-            if (utils.set_public_uuid and fnode.public_uuid is None):
+            if fnode.public_uuid is None:
                 fnode.public_uuid = uuid.uuid4()
                 publicfile.public_uuid = fnode.public_uuid
             fnode.publicfile_id = publicfile.id
@@ -3279,10 +3261,10 @@
 
 
 @fsync_readonly
-def get_public_file(public_key, use_uuid=False):
+def get_public_file(public_key):
     """Get a public file."""
     gw = SystemGateway()
-    return gw.get_public_file(public_key, use_uuid=use_uuid)
+    return gw.get_public_file(public_key)
 
 
 @fsync_readonly

=== modified file 'src/backends/filesync/tests/test_dao.py'
--- src/backends/filesync/tests/test_dao.py	2016-02-25 03:26:13 +0000
+++ src/backends/filesync/tests/test_dao.py	2016-03-06 23:21:42 +0000
@@ -23,10 +23,10 @@
 import re
 import uuid
 
-from datetime import datetime
 from operator import attrgetter
 
 from django.conf import settings
+from django.utils.timezone import now
 from mocker import Mocker, expect
 from storm.database import Connection
 from storm.tracer import install_tracer, remove_tracer_type
@@ -111,7 +111,7 @@
             ['id', 'kind', 'parent_id', 'owner_id', 'status', 'when_created',
              'when_last_modified', 'generation', 'generation_created',
              'mimetype', 'public_uuid'])
-        self.assertTrue(isinstance(node_dao, services.FileNode))
+        self.assertIsInstance(node_dao, services.FileNode)
         # mimetype object will not be directly accessible
         self.assertEqual(node_dao.nodekey, utils.make_nodekey(None, node.id))
         self.assertEqual(node_dao.content, content)
@@ -121,11 +121,11 @@
         self.assertEqual(node_dao.can_delete, True)
         node_dao.public_id = 1
         # test public_key property
-        self.assertEqual(node_dao.public_key,
-                         utils.get_node_public_key(node_dao, True))
+        self.assertEqual(
+            node_dao.public_key, utils.get_node_public_key(node_dao))
         node_dao.public_uuid = None
-        self.assertEqual(node_dao.public_key,
-                         utils.get_node_public_key(node_dao, False))
+        self.assertEqual(
+            node_dao.public_key, utils.get_node_public_key(node_dao))
         node_dao.public_id = None
         self.assertEqual(node_dao.public_key, None)
         node.generation = None
@@ -138,7 +138,7 @@
         node.kind = StorageObject.DIRECTORY
         dir_dao = services.StorageNode.factory(
             None, node, owner=owner, content=content, permissions={})
-        self.assertTrue(isinstance(dir_dao, services.DirectoryNode))
+        self.assertIsInstance(dir_dao, services.DirectoryNode)
         # content for Directories is ignored
         self.assertEqual(dir_dao.content, None)
         self.assertEqual(dir_dao.can_read, False)
@@ -196,8 +196,8 @@
         upload = UploadJob(uuid.uuid4())
         upload.hash_hint = b'fake hash hint'
         upload.crc32_hint = 1234
-        upload.when_started = datetime.utcnow()
-        upload.when_last_active = datetime.utcnow()
+        upload.when_started = now()
+        upload.when_last_active = now()
         upload_dao = services.DAOUploadJob(upload)
         self._compare_props(upload, upload_dao,
                             ['storage_object_id', 'chunk_count',
@@ -1128,24 +1128,7 @@
         self.assertEqual(5, len(nodes))
 
     def test_change_public_access_file(self):
-        """Test the basics of changing public access to a file."""
-        utils.set_public_uuid = False
-        user = self.create_user()
-        f1 = user.root.make_file('a-file.txt')
-        # It has no public ID
-        self.assertEqual(f1.public_uuid, None)
-        self.assertEqual(f1.public_url, None)
-        # It now has a public ID
-        f1.change_public_access(True)
-        self.assertEqual(f1.public_uuid, None)
-        self.assertNotEqual(f1.public_url, None)
-        f1.change_public_access(False)
-        self.assertEqual(f1.public_uuid, None)
-        self.assertEqual(f1.public_url, None)
-
-    def test_change_public_access_file_uuid(self):
         """Test the basics of changing public access to a file using uuid."""
-        utils.set_public_uuid = True
         user = self.create_user()
         f1 = user.root.make_file('a-file.txt')
         # It has no public ID

=== modified file 'src/backends/filesync/tests/test_gateway.py'
--- src/backends/filesync/tests/test_gateway.py	2016-02-25 03:34:42 +0000
+++ src/backends/filesync/tests/test_gateway.py	2016-03-06 23:21:42 +0000
@@ -20,15 +20,16 @@
 
 from __future__ import unicode_literals
 
-import datetime
 import logging
 import posixpath
 import os
 import types
 import uuid
 
+from datetime import timedelta
 from operator import attrgetter
 
+from django.utils.timezone import now
 from mock import patch
 from psycopg2 import IntegrityError
 from storm.locals import Store
@@ -320,7 +321,8 @@
         self.setup_shares()
         node = get_filesync_store().get(StorageObject, self.d3.id)
         share = self.user1.get_share(self.share1.id)
-        vgw = ReadWriteVolumeGateway(self.user1, share=share)
+        vgw = ReadWriteVolumeGateway(
+            self.user1, share=share, notifier=self.dummy_notifier)
         vgw.handle_node_change(node)
         transaction.commit()
 
@@ -968,12 +970,11 @@
             # change the when_started date for the test.
             store = get_filesync_store()
             uploadjob = store.get(UploadJob, up1.id)
-            uploadjob.when_last_active = (
-                datetime.datetime.now() - datetime.timedelta(uid))
+            uploadjob.when_last_active = now() - timedelta(uid)
         transaction.commit()
         # check that filtering by date works as expected.
         for idx in range(0, 10):
-            date = datetime.datetime.now() - datetime.timedelta(idx)
+            date = now() - timedelta(idx)
             jobs = list(self.gw.get_abandoned_uploadjobs(date))
             self.assertEqual(len(jobs), 10 - idx)
 
@@ -996,11 +997,10 @@
             # change the when_started date for the test.
             store = get_filesync_store()
             uploadjob = store.get(UploadJob, up1.id)
-            uploadjob.when_last_active = (
-                datetime.datetime.now() - datetime.timedelta(10))
+            uploadjob.when_last_active = now() - timedelta(10)
         transaction.commit()
         # check that filtering by date works as expected.
-        date = datetime.datetime.now() - datetime.timedelta(9)
+        date = now() - timedelta(9)
         jobs = self.gw.get_abandoned_uploadjobs(date)
         self.assertEqual(len(jobs), 10)
         self.gw.cleanup_uploadjobs(jobs)
@@ -1026,11 +1026,6 @@
             self.root.id, name, hash, crc, size, deflated_size, storage_key,
             mimetype='fakemime')
         self.file = self.vgw._get_node_simple(file1.id)
-        self.save_flag = utils.set_public_uuid
-
-    def tearDown(self):
-        utils.set_public_uuid = self.save_flag
-        super(SystemGatewayPublicFileTestCase, self).tearDown()
 
     def get_get_public_file_DoesNotExist(self):
         """Get get_public_file with unknown key."""
@@ -1040,7 +1035,6 @@
 
     def test_get_public_file_no_content(self):
         """Test get_public_file when file has no content."""
-        utils.set_public_uuid = False
         file_dao = self.vgw.change_public_access(self.file.id, True)
         self.file._content_hash = None
         self.assertRaises(errors.DoesNotExist,
@@ -1048,7 +1042,6 @@
 
     def test_get_public_file_no_storage_key(self):
         """Test get_public_file when file has no storage_key."""
-        utils.set_public_uuid = False
         file_dao = self.vgw.change_public_access(self.file.id, True)
         self.file.content.storage_key = None
         self.assertRaises(errors.DoesNotExist,
@@ -1056,57 +1049,23 @@
 
     def test_get_public_file(self):
         """Tests for get_public_file."""
-        utils.set_public_uuid = False
         file_dao = self.vgw.change_public_access(self.file.id, True)
-        self.assertNotEquals(file_dao.public_id, None)
+        self.assertIsNotNone(file_dao.public_id)
         self.assertIsNotNone(file_dao.public_uuid)
         public_id = file_dao.public_id
-        public_key = file_dao.public_key
-        # Once a file has been made public, it can be looked up by its ID.
-        file2 = self.gw.get_public_file(public_key)
-        self.assertEqual(file2.id, self.file.id)
-        self.assertEqual(file2.mimetype, 'fakemime')
-        # this file was created with content, the content must be returned
-        self.assertNotEquals(file2.content, None)
-
-        # DoesNotExist is raised if that file is made private.
-        file_dao = self.vgw.change_public_access(self.file.id, False)
-        self.assertRaises(errors.DoesNotExist,
-                          self.gw.get_public_file, public_key)
-
-        # public stays the same when set back to public
-        self.assertEqual(file_dao.public_id, None)
-        file_dao = self.vgw.change_public_access(file_dao.id, True)
-        self.assertEqual(file_dao.public_id, public_id)
-
-        # DoesNotExist is raised if the underlying file is deleted.
-        self.vgw.delete_node(self.file.id)
-        self.assertRaises(errors.DoesNotExist,
-                          self.gw.get_public_file, public_key)
-
-    def test_get_public_file_public_uuid(self):
-        """Tests for get_public_file."""
-        utils.set_public_uuid = True
-        file_dao = self.vgw.change_public_access(self.file.id, True)
-        self.assertNotEquals(file_dao.public_id, None)
-        self.assertNotEquals(file_dao.public_uuid, None)
-        public_id = file_dao.public_id
         public_uuid = file_dao.public_uuid
         public_key = file_dao.public_key
         # Once a file has been made public, it can be looked up by its UUID.
-        file2 = self.gw.get_public_file(public_key, use_uuid=True)
+        file2 = self.gw.get_public_file(public_key)
         self.assertEqual(file2.id, self.file.id)
         self.assertEqual(file2.mimetype, self.file.mimetype)
         # this file was created with content, the content must be returned
         self.assertNotEquals(file2.content, None)
-        # but not it's public_id since the config is set to use uuid
-        self.assertRaises(errors.DoesNotExist,
-                          self.gw.get_public_file, public_key)
 
         # DoesNotExist is raised if that file is made private.
         file_dao = self.vgw.change_public_access(self.file.id, False)
         self.assertRaises(errors.DoesNotExist,
-                          self.gw.get_public_file, public_key, True)
+                          self.gw.get_public_file, public_key)
 
         # public_id stays the same when set back to public
         self.assertEqual(file_dao.public_id, None)
@@ -1116,15 +1075,13 @@
 
         # DoesNotExist is raised if the underlying file is deleted.
         self.vgw.delete_node(self.file.id)
-        self.assertRaises(errors.DoesNotExist,
-                          self.gw.get_public_file, public_key, use_uuid=True)
+        self.assertRaises(
+            errors.DoesNotExist, self.gw.get_public_file, public_key)
 
     def test_get_public_file_user_locked(self):
         """get_public_file works with a locked user."""
-        utils.set_public_uuid = False
         file_dao = self.vgw.change_public_access(self.file.id, True)
-        self.assertNotEquals(file_dao.public_id, None)
-        self.assertEqual(file_dao.public_uuid, None)
+        self.assertIsNotNone(file_dao.public_uuid)
         public_key = file_dao.public_key
         # lock the user
         suser = self.store.get(StorageUser, self.user1.id)
@@ -1146,12 +1103,6 @@
         self.root = self.vgw.get_root()
         dir1 = self.vgw.make_subdirectory(self.root.id, 'a-folder')
         self.dir = self.vgw._get_node_simple(dir1.id)
-        self.save_flag = utils.set_public_uuid
-        utils.set_public_uuid = True
-
-    def tearDown(self):
-        utils.set_public_uuid = self.save_flag
-        super(SystemGatewayPublicDirectoryTestCase, self).tearDown()
 
     def get_get_public_directory_DoesNotExist(self):
         """Get get_public_file with unknown key."""
@@ -2932,7 +2883,7 @@
         job = self.vgw.make_uploadjob(
             file1.id, file1.content_hash, new_hash, crc, size,
             multipart_key=uuid.uuid4())
-        new_last_active = datetime.datetime.utcnow() + datetime.timedelta(1)
+        new_last_active = now() + timedelta(1)
         self.vgw.set_uploadjob_when_last_active(job.id, new_last_active)
         up_job = self.vgw.get_uploadjob(job.id)
         self.assertEqual(up_job.when_last_active, new_last_active)
@@ -4289,22 +4240,8 @@
         self.assertEqual(f1.generation, 2)
         self.assertEqual(f1.generation_created, 1)
 
-    def test_change_public_access_without_public_uuid(self):
-        """Test change public access."""
-        saved_flag = utils.set_public_uuid
-        utils.set_public_uuid = False
-        a_file = self.vgw.make_file(self.vgw.get_root().id, 'the file name')
-        a_file = self.vgw.change_public_access(a_file.id, True)
-        f1 = self.storage_store.get(StorageObject, a_file.id)
-        self.assertEqual(f1.generation, 2)
-        self.assertEqual(f1.generation_created, 1)
-        self.assertEqual(f1.public_uuid, None)
-        utils.set_public_uuid = saved_flag
-
-    def test_change_public_access_with_public_uuid(self):
-        """Test change public access."""
-        saved_flag = utils.set_public_uuid
-        utils.set_public_uuid = True
+    def test_change_public_access(self):
+        """Test change public access."""
         a_file = self.vgw.make_file(self.vgw.get_root().id, 'the file name')
         a_file = self.vgw.change_public_access(a_file.id, True)
         f1 = self.storage_store.get(StorageObject, a_file.id)
@@ -4321,7 +4258,6 @@
         a_file = self.vgw.change_public_access(a_file.id, True)
         f1 = self.storage_store.get(StorageObject, a_file.id)
         self.assertEqual(f1.public_uuid, public_uuid)
-        utils.set_public_uuid = saved_flag
 
     def test_deltas_across_volumes(self):
         """Test deltas across volumes to make sure they don't intermingle."""

=== modified file 'src/backends/filesync/tests/test_models.py'
--- src/backends/filesync/tests/test_models.py	2015-10-16 11:24:51 +0000
+++ src/backends/filesync/tests/test_models.py	2016-03-06 23:21:42 +0000
@@ -24,8 +24,10 @@
 import threading
 import unittest
 import uuid
-import datetime
-
+
+from datetime import datetime
+
+from django.utils.timezone import now
 from mock import patch
 from storm.expr import Or, Max
 
@@ -1372,9 +1374,9 @@
         self.store.add(content)
         root = StorageObject.get_root(self.store, user.id)
         file = root.make_file('a_File')
-        before = datetime.datetime.utcnow()
+        before = now()
         file.content = content
-        after = datetime.datetime.utcnow()
+        after = now()
         self.assertTrue(after > file.when_last_modified > before)
 
     def test_update_last_modified_on_make(self):
@@ -1382,14 +1384,14 @@
         user = self.make_user(1, 'a_test_user')
         root = StorageObject.get_root(self.store, user.id)
         subdir = root.make_subdirectory('subdir')
-        before_file = datetime.datetime.utcnow()
+        before_file = now()
         subdir.make_file('a_File')
-        after_file = datetime.datetime.utcnow()
+        after_file = now()
         self.assertTrue(after_file > subdir.when_last_modified > before_file)
 
-        before_dir = datetime.datetime.utcnow()
+        before_dir = now()
         subdir.make_subdirectory('subsubdir')
-        after_dir = datetime.datetime.utcnow()
+        after_dir = now()
         self.assertTrue(after_dir > subdir.when_last_modified > before_dir)
 
     def test_max_used_bytes(self):
@@ -2198,8 +2200,7 @@
         self.assertEqual(download.file_path, 'file_path')
         self.assertEqual(download.download_url, 'http://download/url')
         self.assertEqual(download.status, Download.STATUS_QUEUED)
-        self.assertTrue(
-            isinstance(download.status_change_date, datetime.datetime))
+        self.assertIsInstance(download.status_change_date, datetime)
         self.assertEqual(download.node_id, None)
         self.assertEqual(download.error_message, None)
 

=== modified file 'src/backends/filesync/tests/test_resthelper.py'
--- src/backends/filesync/tests/test_resthelper.py	2016-02-20 17:03:19 +0000
+++ src/backends/filesync/tests/test_resthelper.py	2016-03-06 23:21:42 +0000
@@ -26,9 +26,8 @@
 import unittest
 import uuid
 
-from datetime import datetime
-
 from django.conf import settings
+from django.utils.timezone import now
 
 from metrics.tests import FakeMetrics
 from backends.filesync import errors
@@ -64,7 +63,7 @@
     id = uuid.uuid4()
     is_root = False
     path = "~/Documents"
-    when_created = datetime.utcnow()
+    when_created = now()
 
 
 class MockNode(object):
@@ -76,8 +75,8 @@
     full_path = '/a/b/c/d/file.txt'
     name = 'file.txt'
     content_hash = 'abcdefg'
-    when_created = datetime.utcnow()
-    when_last_modified = datetime.utcnow()
+    when_created = now()
+    when_last_modified = now()
     generation = 1
     generation_created = 1
     mimetype = 'text'

=== modified file 'src/backends/filesync/tests/test_services.py'
--- src/backends/filesync/tests/test_services.py	2015-09-27 21:25:27 +0000
+++ src/backends/filesync/tests/test_services.py	2016-03-06 23:21:42 +0000
@@ -21,7 +21,8 @@
 from __future__ import unicode_literals
 
 import uuid
-import datetime
+
+from django.utils.timezone import now
 
 from backends.filesync import errors, utils
 from backends.filesync.models import StorageUser
@@ -107,13 +108,11 @@
     def test_get_abandoned_uploadjobs(self):
         """Test the get_abandoned_uploadjobs function."""
         self.assertRaises(TypeError, get_abandoned_uploadjobs)
-        jobs = get_abandoned_uploadjobs(datetime.datetime.now(), 100)
+        jobs = get_abandoned_uploadjobs(now(), 100)
         self.assertTrue(isinstance(jobs, list))
 
     def test_get_public_file(self):
         """Test the get_public_file function."""
-        save_setting = utils.set_public_uuid
-        utils.set_public_uuid = False
         user = self.factory.make_user(
             1, "Cool UserName", "Visible Name", 10)
         a_file = user.volume().root.make_file_with_content(
@@ -123,9 +122,7 @@
         f1 = get_public_file(public_key)
         self.assertEqual(f1, a_file)
         a_file.change_public_access(False)
-        self.assertRaises(errors.DoesNotExist,
-                          get_public_file, public_key, use_uuid=False)
-        utils.set_public_uuid = save_setting
+        self.assertRaises(errors.DoesNotExist, get_public_file, public_key)
 
     def test_get_public_directory(self):
         """Test the get_public_directory function."""
@@ -144,8 +141,6 @@
 
     def test_get_public_file_public_uuid(self):
         """Test the get_public_file function."""
-        save_setting = utils.set_public_uuid
-        utils.set_public_uuid = True
         user = self.factory.make_user(
             1, "Cool UserName", "Visible Name", 10)
         a_file = user.volume().root.make_file_with_content(
@@ -153,12 +148,7 @@
         a_file.change_public_access(True)
         public_key = a_file.public_key
         # get the file using the public uuid
-        f1 = get_public_file(public_key, use_uuid=True)
+        f1 = get_public_file(public_key)
         self.assertEqual(f1, a_file)
-        # can't get the file using the old id
-        self.assertRaises(errors.DoesNotExist,
-                          get_public_file, public_key)
         a_file.change_public_access(False)
-        self.assertRaises(errors.DoesNotExist,
-                          get_public_file, public_key, use_uuid=True)
-        utils.set_public_uuid = save_setting
+        self.assertRaises(errors.DoesNotExist, get_public_file, public_key)

=== modified file 'src/backends/filesync/tests/test_utils.py'
--- src/backends/filesync/tests/test_utils.py	2016-02-25 03:26:13 +0000
+++ src/backends/filesync/tests/test_utils.py	2016-03-06 23:21:42 +0000
@@ -122,24 +122,21 @@
     def test_get_node_public_key(self):
         """Test get_node_public_key."""
         node = FakeNode()
-        node.public_id = 1
         node.public_uuid = uuid.UUID(int=12)
-        self.assertTrue(get_node_public_key(node, False),
-                        encode_base62(node.public_id))
-        self.assertTrue(get_node_public_key(node, True),
-                        encode_base62(node.public_uuid.int, padded_to=22))
+        self.assertEqual(
+            get_node_public_key(node),
+            encode_base62(node.public_uuid.int, padded_to=22))
 
     def test_get_public_url(self):
         """Test get_public_url function."""
         node = FakeNode()
-        self.assertTrue(get_public_file_url(node) is None)
-        node.public_id = 1
-        self.assertTrue(get_public_file_url(node).endswith(
-            '/%s/' % encode_base62(node.public_id)))
+        self.assertIsNone(get_public_file_url(node))
         # using a short value here to make sure padding works
         node.public_uuid = uuid.UUID(int=12)
-        self.assertTrue(get_public_file_url(node).endswith(
-            '/%s' % encode_base62(node.public_uuid.int, padded_to=22)))
+        key = encode_base62(node.public_uuid.int, padded_to=22)
+        self.assertEqual(
+            get_public_file_url(node),
+            '%s/%s' % (settings.PUBLIC_URL_PREFIX, key))
 
 
 class Base62Tests(unittest.TestCase):

=== modified file 'src/backends/filesync/tests/testcase.py'
--- src/backends/filesync/tests/testcase.py	2015-09-27 21:25:27 +0000
+++ src/backends/filesync/tests/testcase.py	2016-03-06 23:21:42 +0000
@@ -52,12 +52,6 @@
         super(StorageDALTestCase, self).setUp()
         self.factory = Factory()
         self.store = get_filesync_store()
-        self.save_utils_set_public_uuid = utils.set_public_uuid
-
-    def tearDown(self):
-        """Tear down."""
-        utils.set_public_uuid = self.save_utils_set_public_uuid
-        super(StorageDALTestCase, self).tearDown()
 
     def patch(self, obj, attr_name, new_val):
         """Patch!"""
@@ -168,7 +162,7 @@
         """Return a hashkey."""
         return b'sha1:' + hashlib.sha1(key or str(uuid.uuid4())).hexdigest()
 
-    def get_test_contentblob(self, content=None):
+    def get_test_contentblob(self, content=None, magic_hash=None):
         """Get a content blob."""
         if content:
             content = content.encode('utf-8')
@@ -180,6 +174,12 @@
         cb.storage_key = uuid.uuid4()
         cb.content = content
         cb.status = STATUS_LIVE
+        cb.magic_hash = magic_hash
+        return cb
+
+    def make_content_blob(self, content=None, magic_hash=None):
+        cb = self.get_test_contentblob(content, magic_hash)
+        get_filesync_store().add(cb)
         return cb
 
     def content_blob_args(self):

=== modified file 'src/backends/filesync/utils.py'
--- src/backends/filesync/utils.py	2015-09-29 03:06:37 +0000
+++ src/backends/filesync/utils.py	2016-03-06 23:21:42 +0000
@@ -161,29 +161,17 @@
     return value
 
 
-# This is a setting used during testing and transition to the new public files
-# urls and will be removed once we enable the new public URL feature.
-# Since there is no way to go back once this setting is enabled,
-# it is not used in a configuration file.
-set_public_uuid = True
-
-
-def get_node_public_key(node, from_uuid=False):
+def get_node_public_key(node):
     """Get a node's public_key."""
-    if from_uuid:
+    if node.public_uuid is not None:
         return encode_base62(node.public_uuid.int, padded_to=22)
-    else:
-        return encode_base62(node.publicfile_id)
 
 
 def get_public_file_url(node):
     """Return the url to a public file."""
-    if settings.UPDOWN_PUBLIC_URL_PREFIX_2 and node.public_uuid:
-        return '%s%s' % (settings.UPDOWN_PUBLIC_URL_PREFIX_2,
-                         get_node_public_key(node, True))
-    elif node.publicfile_id:
-        return '%s%s/' % (settings.UPDOWN_PUBLIC_URL_PREFIX,
-                          get_node_public_key(node, False))
+    public_key = get_node_public_key(node)
+    if public_key is not None:
+        return '%s/%s' % (settings.PUBLIC_URL_PREFIX.rstrip('/'), public_key)
 
 
 def get_keywords_from_path(volume_path):

=== modified file 'src/backends/txlog/testing/__init__.py'
--- src/backends/txlog/testing/__init__.py	2015-09-27 17:01:04 +0000
+++ src/backends/txlog/testing/__init__.py	2016-03-06 23:21:42 +0000
@@ -18,9 +18,9 @@
 
 """Testing helpers for txlog."""
 
-import datetime
 import uuid
 
+from django.utils.timezone import now
 from backends.txlog.models import TransactionLog
 
 
@@ -38,7 +38,7 @@
     if path is None:
         path = u'/%s' % unicode(uuid.uuid4())
     if timestamp is None:
-        timestamp = datetime.datetime.utcnow()
+        timestamp = now()
     return dict(
         txn_id=txn_id, node_id=node_id, owner_id=owner_id, volume_id=volume_id,
         op_type=op_type, path=path, generation=generation, timestamp=timestamp,

=== modified file 'src/backends/txlog/tests/test_utils.py'
--- src/backends/txlog/tests/test_utils.py	2015-09-27 19:24:27 +0000
+++ src/backends/txlog/tests/test_utils.py	2016-03-06 23:21:42 +0000
@@ -20,8 +20,9 @@
 
 from __future__ import unicode_literals
 
-import datetime
+from datetime import timedelta
 
+from django.utils.timezone import now
 from mock import patch
 
 from backends.filesync import dbmanager
@@ -142,7 +143,7 @@
             self.assertRaises(
                 RuntimeError, utils.update_last_row,
                 worker_name=b'test_worker_name', row_id=1,
-                timestamp=datetime.datetime.utcnow())
+                timestamp=now())
 
     def _convert_txlogs_to_dicts(self, txlogs):
         """Convert a list of TransactionLog objects into dictionaries.
@@ -315,10 +316,10 @@
         """Test that txnlogs not old enough are maintained, instead of being
         deleted."""
 
-        now = datetime.datetime.utcnow()
-        limit_datetime = now - datetime.timedelta(days=7)
+        right_now = now()
+        limit_datetime = right_now - timedelta(days=7)
         # Not so old
-        old_datetime = limit_datetime + datetime.timedelta(seconds=1)
+        old_datetime = limit_datetime + timedelta(seconds=1)
 
         self.factory.make_transaction_log(tx_id=1)
         self.factory.make_transaction_log(tx_id=2, timestamp=old_datetime)
@@ -339,8 +340,8 @@
     def test_deletes_old_enough_txlogs(self):
         """Test that txnlogs old enough are deleted."""
 
-        now = datetime.datetime.utcnow()
-        timestamp_limit = now - datetime.timedelta(days=7)
+        right_now = now()
+        timestamp_limit = right_now - timedelta(days=7)
         # Old enough
         old_datetime = timestamp_limit
 
@@ -368,8 +369,8 @@
         """Test that txnlogs old enough are deleted and are within the quantity
         limit given."""
 
-        now = datetime.datetime.utcnow()
-        timestamp_limit = now - datetime.timedelta(days=7)
+        right_now = now()
+        timestamp_limit = right_now - timedelta(days=7)
         # Old enough
         old_datetime = timestamp_limit
         quantity_limit = 2
@@ -400,8 +401,8 @@
     def test_deletes_txlogs_slice(self):
         """Delete a txlog slice by date and quantity."""
 
-        now = datetime.datetime.utcnow()
-        timestamp_limit = now - datetime.timedelta(days=7)
+        right_now = now()
+        timestamp_limit = right_now - timedelta(days=7)
         # Old enough
         old_dt = timestamp_limit
         quantity_limit = 2
@@ -415,7 +416,7 @@
         ]
         self.store.commit()
 
-        removed = utils.delete_txlogs_slice(date=now.date(),
+        removed = utils.delete_txlogs_slice(date=right_now.date(),
                                             quantity_limit=quantity_limit)
 
         self.store.rollback()  # Shouldn't affect the deletion result
@@ -429,15 +430,15 @@
 
     def test_get_row_by_time_with_no_data(self):
         """Test the get_row_by_time function when no data is present."""
-        txid, _ = utils.get_row_by_time(datetime.datetime.utcnow())
+        txid, _ = utils.get_row_by_time(now())
         self.assertEqual(txid, None)
 
     def test_get_row_by_time_with_data(self):
         """Test get_row_by_time function when data is present."""
-        ts = datetime.datetime.utcnow()
+        ts = now()
         txlogs = [
-            self.factory.make_transaction_log(
-                timestamp=ts + datetime.timedelta(i, 0)) for i in range(5)]
+            self.factory.make_transaction_log(timestamp=ts + timedelta(i, 0))
+            for i in range(5)]
         tstamp = txlogs[2].timestamp
         txid, newtstamp = utils.get_row_by_time(tstamp)
         self.assertEqual(txid, txlogs[2].id)
@@ -445,10 +446,10 @@
 
     def test_get_row_by_time_timestamp_twice(self):
         """Test get_row_by_time having two lines with same timestamp."""
-        ts = datetime.datetime.utcnow()
+        ts = now()
         txlogs = [
-            self.factory.make_transaction_log(
-                timestamp=ts + datetime.timedelta(i, 0)) for i in range(5)]
+            self.factory.make_transaction_log(timestamp=ts + timedelta(i, 0))
+            for i in range(5)]
         # put the timestamp of [3] into [1], the function should return the
         # id of [1]
         tstamp = txlogs[1].timestamp = txlogs[3].timestamp
@@ -459,10 +460,10 @@
 
     def test_get_row_by_time_not_exact(self):
         """Test get_row_by_time not giving an exact timestamp."""
-        ts = datetime.datetime.utcnow()
+        ts = now()
         txlogs = [
-            self.factory.make_transaction_log(
-                timestamp=ts + datetime.timedelta(i, 0)) for i in range(5)]
+            self.factory.make_transaction_log(timestamp=ts + timedelta(i, 0))
+            for i in range(5)]
 
         # get a timestamp in the middle of [2] and [3], the function should
         # return the id of [3]
@@ -477,7 +478,7 @@
     def test_get_row_by_time_nothing_found(self):
         """Test get_row_by_time with a big enough timestamp."""
         txlogs = [self.factory.make_transaction_log() for i in range(2)]
-        tstamp = txlogs[-1].timestamp + datetime.timedelta(seconds=1)
+        tstamp = txlogs[-1].timestamp + timedelta(seconds=1)
         txid, newtstamp = utils.get_row_by_time(tstamp)
         self.assertEqual(txid, None)
         self.assertEqual(newtstamp, None)

=== modified file 'src/backends/utils.py'
--- src/backends/utils.py	2015-09-27 16:59:15 +0000
+++ src/backends/utils.py	2016-03-06 23:21:42 +0000
@@ -18,24 +18,21 @@
 
 """Some generic utilities."""
 
-from datetime import datetime
-
+from __future__ import unicode_literals
 from django.contrib.auth.models import User
 
 from backends.filesync import services
 
 
-def create_test_user(username=u"fred", email=u"[e-mail]",
-                     first_name=u"Fredrick", last_name=u"Flintsone",
-                     id=None, password=None):
+def create_test_user(
+        username='fred', email='[e-mail]', first_name='Fredrick',
+        last_name='Flintsone', password=None, id=None):
     """Create a user used for testing."""
     try:
         user = User.objects.get(username=username)
     except User.DoesNotExist:
-        now = datetime.utcnow()
         user = User(id=id, username=unicode(username), email=unicode(email),
-                    is_staff=False, is_active=True, is_superuser=False,
-                    last_login=now, date_joined=now)
+                    is_staff=False, is_active=True, is_superuser=False)
         user.set_password(password)
         user.save()
     user.first_name = unicode(first_name)

=== modified file 'src/magicicada/settings/__init__.py'
--- src/magicicada/settings/__init__.py	2016-02-20 16:11:52 +0000
+++ src/magicicada/settings/__init__.py	2016-03-06 23:21:42 +0000
@@ -184,6 +184,7 @@
 LOG_LEVEL = 5
 LOG_TO_SYSLOG = False
 OOPS_PATH = os.path.join(BASE_DIR, 'tmp', 'oops')
+PUBLIC_URL_PREFIX = 'http://some_url'
 ROOT_USERVOLUME_NAME = 'Magicicada'
 ROOT_USERVOLUME_PATH = '~/' + ROOT_USERVOLUME_NAME
 SERVICE_GROUP = 'filesync'
@@ -192,9 +193,6 @@
 STORAGE_PROXY_PORT = None
 SYSLOG_FORMAT = (
     '%(processName)-13s %(levelname)-8s %(name)s[%(process)d]: %(message)s')
-UPDOWN_PUBLIC_URL_PREFIX = 'http://some_url/p/'
-UPDOWN_PUBLIC_URL_PREFIX_2 = 'http://some_url/'
-
 
 from . import api_server  # noqa
 from . import ssl_proxy  # noqa

=== modified file 'src/magicicada/wsgi.py'
--- src/magicicada/wsgi.py	2015-08-17 04:52:41 +0000
+++ src/magicicada/wsgi.py	2016-03-06 23:21:42 +0000
@@ -11,6 +11,6 @@
 
 from django.core.wsgi import get_wsgi_application
 
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "filesync.settings")
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "magicicada.settings")
 
 application = get_wsgi_application()

=== modified file 'src/monitoring/dump.py'
--- src/monitoring/dump.py	2015-09-19 16:32:27 +0000
+++ src/monitoring/dump.py	2016-03-06 23:21:42 +0000
@@ -20,9 +20,9 @@
 
 import os
 import gc
-import datetime
 
 from django.conf import settings
+from django.utils.timezone import now
 
 
 SIGMELIAE = 44
@@ -35,7 +35,7 @@
 
         dump_dir = settings.LOG_FOLDER
         filename = os.path.join(dump_dir, 'meliae-%s.json' % (
-            datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S",)))
+            now().strftime("%Y%m%d%H%M%S",)))
         gc.collect()
         scanner.dump_all_objects(filename)
     except ImportError as e:
@@ -50,7 +50,7 @@
     """Dump GC usage."""
     try:
         dump_dir = settings.LOG_FOLDER
-        tstamp = datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S")
+        tstamp = now().strftime("%Y%m%d%H%M%S")
         fname = os.path.join(dump_dir, 'gcdump-%s.txt' % (tstamp,))
         fh = open(fname, "w")
 

=== modified file 'src/monitoring/reactor.py'
--- src/monitoring/reactor.py	2015-09-19 16:32:27 +0000
+++ src/monitoring/reactor.py	2016-03-06 23:21:42 +0000
@@ -18,6 +18,8 @@
 
 """A thread that measures responsiveness of the twisted reactor."""
 
+from __future__ import unicode_literals
+
 import os
 import sys
 import time

=== modified file 'src/monitoring/stats_worker.py'
--- src/monitoring/stats_worker.py	2015-09-19 16:32:27 +0000
+++ src/monitoring/stats_worker.py	2016-03-06 23:21:42 +0000
@@ -18,6 +18,7 @@
 
 """Process that inform metrics about other processes and the machine."""
 
+from __future__ import unicode_literals
 from __future__ import with_statement
 
 import os

=== modified file 'src/monitoring/tests/test_dump.py'
--- src/monitoring/tests/test_dump.py	2015-09-19 16:32:27 +0000
+++ src/monitoring/tests/test_dump.py	2016-03-06 23:21:42 +0000
@@ -18,6 +18,8 @@
 
 """Tests for monitoring dump."""
 
+from __future__ import unicode_literals
+
 import gc
 import shutil
 import tempfile

=== modified file 'src/monitoring/tests/test_reactor.py'
--- src/monitoring/tests/test_reactor.py	2015-09-19 16:32:27 +0000
+++ src/monitoring/tests/test_reactor.py	2016-03-06 23:21:42 +0000
@@ -18,6 +18,8 @@
 
 """Tests for the ReactorInspector."""
 
+from __future__ import unicode_literals
+
 import time
 import logging
 import threading

=== modified file 'src/monitoring/tests/test_stats_worker.py'
--- src/monitoring/tests/test_stats_worker.py	2015-09-19 16:32:27 +0000
+++ src/monitoring/tests/test_stats_worker.py	2016-03-06 23:21:42 +0000
@@ -18,6 +18,8 @@
 
 """Tests for the stats worker."""
 
+from __future__ import unicode_literals
+
 import logging
 
 from mocker import Mocker, expect

=== modified file 'src/server/tests/test_server.py'
--- src/server/tests/test_server.py	2016-02-20 17:03:19 +0000
+++ src/server/tests/test_server.py	2016-03-06 23:21:42 +0000
@@ -21,7 +21,6 @@
 """Test Storage Server requests/responses."""
 
 import collections
-import datetime
 import logging
 import os
 import types
@@ -29,6 +28,7 @@
 import uuid
 import weakref
 
+from django.utils.timezone import now
 from metrics.metricsconnector import MetricsConnector
 from mocker import expect, Mocker, MockerTestCase, ARGS, KWARGS, ANY
 from twisted.python.failure import Failure
@@ -2433,7 +2433,7 @@
         self.patch(settings.api_server, 'MAX_DELTA_INFO', 5)
         # create a few fake nodes
         nodes = []
-        now = datetime.datetime.utcnow()
+        right_now = now()
         for i in range(10):
             node = FakeNode()
             node.id = str(uuid.uuid4())
@@ -2446,7 +2446,7 @@
             node.content_hash = 'sha1:foo'
             node.crc32 = 10
             node.size = 1024
-            node.last_modified = int(time.mktime(now.timetuple()))
+            node.last_modified = int(time.mktime(right_now.timetuple()))
             nodes.append(node)
         gen = self.response._send_delta_info(nodes, 'share_id')
         gen.next()
@@ -2508,7 +2508,7 @@
         self.patch(settings.api_server, 'GET_FROM_SCRATCH_LIMIT', 5)
         # build fake nodes
         nodes = []
-        now = datetime.datetime.now()
+        right_now = now()
         for i in range(20):
             node = FakeNode()
             node.id = str(uuid.uuid4())
@@ -2522,7 +2522,7 @@
             node.content_hash = 'sha1:foo'
             node.crc32 = 10
             node.size = 1024
-            node.last_modified = int(time.mktime(now.timetuple()))
+            node.last_modified = int(time.mktime(right_now.timetuple()))
             nodes.append(node)
         # set required caps
         self.response.protocol.working_caps = server.PREFERRED_CAP