Merge "assertEquals is deprecated, use assertEqual"

4 files changed, 379 insertions, 379 deletions

diff --git a/test/unit/account/test_auditor.py b/test/unit/account/test_auditor.py
index 19f358aeb..90a323e94 100644
--- a/test/unit/account/test_auditor.py
+++ b/test/unit/account/test_auditor.py
@@ -88,8 +88,8 @@ class TestAuditor(unittest.TestCase):
             auditor.audit_location_generator = fake_audit_location_generator
 
             self.assertRaises(ValueError, test_auditor.run_forever)
-        self.assertEquals(test_auditor.account_failures, 2 * call_times)
-        self.assertEquals(test_auditor.account_passes, 3 * call_times)
+        self.assertEqual(test_auditor.account_failures, 2 * call_times)
+        self.assertEqual(test_auditor.account_passes, 3 * call_times)
 
     @mock.patch('swift.account.auditor.AccountBroker', FakeAccountBroker)
     def test_run_once(self):
@@ -103,8 +103,8 @@ class TestAuditor(unittest.TestCase):
         auditor.audit_location_generator = fake_audit_location_generator
 
         test_auditor.run_once()
-        self.assertEquals(test_auditor.account_failures, 2)
-        self.assertEquals(test_auditor.account_passes, 3)
+        self.assertEqual(test_auditor.account_failures, 2)
+        self.assertEqual(test_auditor.account_passes, 3)
 
     @mock.patch('swift.account.auditor.AccountBroker', FakeAccountBroker)
     def test_account_auditor(self):
@@ -114,8 +114,8 @@ class TestAuditor(unittest.TestCase):
         for f in files:
             path = os.path.join(self.testdir, f)
             test_auditor.account_audit(path)
-        self.assertEquals(test_auditor.account_failures, 2)
-        self.assertEquals(test_auditor.account_passes, 3)
+        self.assertEqual(test_auditor.account_failures, 2)
+        self.assertEqual(test_auditor.account_passes, 3)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/unit/account/test_backend.py b/test/unit/account/test_backend.py
index 2f59f9a4a..66f425038 100644
--- a/test/unit/account/test_backend.py
+++ b/test/unit/account/test_backend.py
@@ -54,7 +54,7 @@ class TestAccountBroker(unittest.TestCase):
             first_conn = conn
         try:
             with broker.get() as conn:
-                self.assertEquals(first_conn, conn)
+                self.assertEqual(first_conn, conn)
                 raise Exception('OMG')
         except Exception:
             pass
@@ -76,44 +76,44 @@ class TestAccountBroker(unittest.TestCase):
         broker.initialize(normalize_timestamp('1'))
         broker.put_container('c', normalize_timestamp(time()), 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 1)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 0)
         broker.reclaim(normalize_timestamp(time() - 999), time())
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 1)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 0)
         sleep(.00001)
         broker.put_container('c', 0, normalize_timestamp(time()), 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 0)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 1)
         broker.reclaim(normalize_timestamp(time() - 999), time())
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 0)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 1)
         sleep(.00001)
         broker.reclaim(normalize_timestamp(time()), time())
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 0)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 0)
         # Test reclaim after deletion. Create 3 test containers
@@ -121,7 +121,7 @@ class TestAccountBroker(unittest.TestCase):
         broker.put_container('y', 0, 0, 0, 0)
         broker.put_container('z', 0, 0, 0, 0)
         broker.reclaim(normalize_timestamp(time()), time())
-        # self.assertEquals(len(res), 2)
+        # self.assertEqual(len(res), 2)
         # self.assert_(isinstance(res, tuple))
         # containers, account_name = res
         # self.assert_(containers is None)
@@ -129,11 +129,11 @@ class TestAccountBroker(unittest.TestCase):
         # Now delete the account
         broker.delete_db(normalize_timestamp(time()))
         broker.reclaim(normalize_timestamp(time()), time())
-        # self.assertEquals(len(res), 2)
+        # self.assertEqual(len(res), 2)
         # self.assert_(isinstance(res, tuple))
         # containers, account_name = res
-        # self.assertEquals(account_name, 'test_account')
-        # self.assertEquals(len(containers), 3)
+        # self.assertEqual(account_name, 'test_account')
+        # self.assertEqual(len(containers), 3)
         # self.assert_('x' in containers)
         # self.assert_('y' in containers)
         # self.assert_('z' in containers)
@@ -145,19 +145,19 @@ class TestAccountBroker(unittest.TestCase):
         broker.initialize(normalize_timestamp('1'))
         broker.put_container('o', normalize_timestamp(time()), 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 1)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 0)
         sleep(.00001)
         broker.put_container('o', 0, normalize_timestamp(time()), 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 0").fetchone()[0], 0)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT count(*) FROM container "
                 "WHERE deleted = 1").fetchone()[0], 1)
 
@@ -170,25 +170,25 @@ class TestAccountBroker(unittest.TestCase):
         timestamp = normalize_timestamp(time())
         broker.put_container('"{<container \'&\' name>}"', timestamp, 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT put_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 0)
 
         # Reput same event
         broker.put_container('"{<container \'&\' name>}"', timestamp, 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT put_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 0)
 
         # Put new event
@@ -196,42 +196,42 @@ class TestAccountBroker(unittest.TestCase):
         timestamp = normalize_timestamp(time())
         broker.put_container('"{<container \'&\' name>}"', timestamp, 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT put_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 0)
 
         # Put old event
         otimestamp = normalize_timestamp(float(timestamp) - 1)
         broker.put_container('"{<container \'&\' name>}"', otimestamp, 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT put_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 0)
 
         # Put old delete event
         dtimestamp = normalize_timestamp(float(timestamp) - 1)
         broker.put_container('"{<container \'&\' name>}"', 0, dtimestamp, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT put_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT delete_timestamp FROM container").fetchone()[0],
                 dtimestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 0)
 
         # Put new delete event
@@ -239,13 +239,13 @@ class TestAccountBroker(unittest.TestCase):
         timestamp = normalize_timestamp(time())
         broker.put_container('"{<container \'&\' name>}"', 0, timestamp, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT delete_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 1)
 
         # Put new event
@@ -253,13 +253,13 @@ class TestAccountBroker(unittest.TestCase):
         timestamp = normalize_timestamp(time())
         broker.put_container('"{<container \'&\' name>}"', timestamp, 0, 0, 0)
         with broker.get() as conn:
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT name FROM container").fetchone()[0],
                 '"{<container \'&\' name>}"')
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT put_timestamp FROM container").fetchone()[0],
                 timestamp)
-            self.assertEquals(conn.execute(
+            self.assertEqual(conn.execute(
                 "SELECT deleted FROM container").fetchone()[0], 0)
 
     def test_get_info(self):
@@ -268,35 +268,35 @@ class TestAccountBroker(unittest.TestCase):
         broker.initialize(normalize_timestamp('1'))
 
         info = broker.get_info()
-        self.assertEquals(info['account'], 'test1')
-        self.assertEquals(info['hash'], '00000000000000000000000000000000')
+        self.assertEqual(info['account'], 'test1')
+        self.assertEqual(info['hash'], '00000000000000000000000000000000')
 
         info = broker.get_info()
-        self.assertEquals(info['container_count'], 0)
+        self.assertEqual(info['container_count'], 0)
 
         broker.put_container('c1', normalize_timestamp(time()), 0, 0, 0)
         info = broker.get_info()
-        self.assertEquals(info['container_count'], 1)
+        self.assertEqual(info['container_count'], 1)
 
         sleep(.00001)
         broker.put_container('c2', normalize_timestamp(time()), 0, 0, 0)
         info = broker.get_info()
-        self.assertEquals(info['container_count'], 2)
+        self.assertEqual(info['container_count'], 2)
 
         sleep(.00001)
         broker.put_container('c2', normalize_timestamp(time()), 0, 0, 0)
         info = broker.get_info()
-        self.assertEquals(info['container_count'], 2)
+        self.assertEqual(info['container_count'], 2)
 
         sleep(.00001)
         broker.put_container('c1', 0, normalize_timestamp(time()), 0, 0)
         info = broker.get_info()
-        self.assertEquals(info['container_count'], 1)
+        self.assertEqual(info['container_count'], 1)
 
         sleep(.00001)
         broker.put_container('c2', 0, normalize_timestamp(time()), 0, 0)
         info = broker.get_info()
-        self.assertEquals(info['container_count'], 0)
+        self.assertEqual(info['container_count'], 0)
 
     def test_list_containers_iter(self):
         # Test AccountBroker.list_containers_iter
@@ -315,86 +315,86 @@ class TestAccountBroker(unittest.TestCase):
                                  normalize_timestamp(time()), 0, 0, 0)
 
         listing = broker.list_containers_iter(100, '', None, None, '')
-        self.assertEquals(len(listing), 100)
-        self.assertEquals(listing[0][0], '0-0000')
-        self.assertEquals(listing[-1][0], '0-0099')
+        self.assertEqual(len(listing), 100)
+        self.assertEqual(listing[0][0], '0-0000')
+        self.assertEqual(listing[-1][0], '0-0099')
 
         listing = broker.list_containers_iter(100, '', '0-0050', None, '')
-        self.assertEquals(len(listing), 50)
-        self.assertEquals(listing[0][0], '0-0000')
-        self.assertEquals(listing[-1][0], '0-0049')
+        self.assertEqual(len(listing), 50)
+        self.assertEqual(listing[0][0], '0-0000')
+        self.assertEqual(listing[-1][0], '0-0049')
 
         listing = broker.list_containers_iter(100, '0-0099', None, None, '')
-        self.assertEquals(len(listing), 100)
-        self.assertEquals(listing[0][0], '0-0100')
-        self.assertEquals(listing[-1][0], '1-0074')
+        self.assertEqual(len(listing), 100)
+        self.assertEqual(listing[0][0], '0-0100')
+        self.assertEqual(listing[-1][0], '1-0074')
 
         listing = broker.list_containers_iter(55, '1-0074', None, None, '')
-        self.assertEquals(len(listing), 55)
-        self.assertEquals(listing[0][0], '1-0075')
-        self.assertEquals(listing[-1][0], '2-0004')
+        self.assertEqual(len(listing), 55)
+        self.assertEqual(listing[0][0], '1-0075')
+        self.assertEqual(listing[-1][0], '2-0004')
 
         listing = broker.list_containers_iter(10, '', None, '0-01', '')
-        self.assertEquals(len(listing), 10)
-        self.assertEquals(listing[0][0], '0-0100')
-        self.assertEquals(listing[-1][0], '0-0109')
+        self.assertEqual(len(listing), 10)
+        self.assertEqual(listing[0][0], '0-0100')
+        self.assertEqual(listing[-1][0], '0-0109')
 
         listing = broker.list_containers_iter(10, '', None, '0-01', '-')
-        self.assertEquals(len(listing), 10)
-        self.assertEquals(listing[0][0], '0-0100')
-        self.assertEquals(listing[-1][0], '0-0109')
+        self.assertEqual(len(listing), 10)
+        self.assertEqual(listing[0][0], '0-0100')
+        self.assertEqual(listing[-1][0], '0-0109')
 
         listing = broker.list_containers_iter(10, '', None, '0-', '-')
-        self.assertEquals(len(listing), 10)
-        self.assertEquals(listing[0][0], '0-0000')
-        self.assertEquals(listing[-1][0], '0-0009')
+        self.assertEqual(len(listing), 10)
+        self.assertEqual(listing[0][0], '0-0000')
+        self.assertEqual(listing[-1][0], '0-0009')
 
         listing = broker.list_containers_iter(10, '', None, '', '-')
-        self.assertEquals(len(listing), 4)
-        self.assertEquals([row[0] for row in listing],
-                          ['0-', '1-', '2-', '3-'])
+        self.assertEqual(len(listing), 4)
+        self.assertEqual([row[0] for row in listing],
+                         ['0-', '1-', '2-', '3-'])
 
         listing = broker.list_containers_iter(10, '2-', None, None, '-')
-        self.assertEquals(len(listing), 1)
-        self.assertEquals([row[0] for row in listing], ['3-'])
+        self.assertEqual(len(listing), 1)
+        self.assertEqual([row[0] for row in listing], ['3-'])
 
         listing = broker.list_containers_iter(10, '', None, '2', '-')
-        self.assertEquals(len(listing), 1)
-        self.assertEquals([row[0] for row in listing], ['2-'])
+        self.assertEqual(len(listing), 1)
+        self.assertEqual([row[0] for row in listing], ['2-'])
 
         listing = broker.list_containers_iter(10, '2-0050', None, '2-', '-')
-        self.assertEquals(len(listing), 10)
-        self.assertEquals(listing[0][0], '2-0051')
-        self.assertEquals(listing[1][0], '2-0051-')
-        self.assertEquals(listing[2][0], '2-0052')
-        self.assertEquals(listing[-1][0], '2-0059')
+        self.assertEqual(len(listing), 10)
+        self.assertEqual(listing[0][0], '2-0051')
+        self.assertEqual(listing[1][0], '2-0051-')
+        self.assertEqual(listing[2][0], '2-0052')
+        self.assertEqual(listing[-1][0], '2-0059')
 
         listing = broker.list_containers_iter(10, '3-0045', None, '3-', '-')
-        self.assertEquals(len(listing), 10)
-        self.assertEquals([row[0] for row in listing],
-                          ['3-0045-', '3-0046', '3-0046-', '3-0047',
-                           '3-0047-', '3-0048', '3-0048-', '3-0049',
-                           '3-0049-', '3-0050'])
+        self.assertEqual(len(listing), 10)
+        self.assertEqual([row[0] for row in listing],
+                         ['3-0045-', '3-0046', '3-0046-', '3-0047',
+                          '3-0047-', '3-0048', '3-0048-', '3-0049',
+                          '3-0049-', '3-0050'])
 
         broker.put_container('3-0049-', normalize_timestamp(time()), 0, 0, 0)
         listing = broker.list_containers_iter(10, '3-0048', None, None, None)
-        self.assertEquals(len(listing), 10)
-        self.assertEquals([row[0] for row in listing],
-                          ['3-0048-0049', '3-0049', '3-0049-', '3-0049-0049',
-                           '3-0050', '3-0050-0049', '3-0051', '3-0051-0049',
-                           '3-0052', '3-0052-0049'])
+        self.assertEqual(len(listing), 10)
+        self.assertEqual([row[0] for row in listing],
+                         ['3-0048-0049', '3-0049', '3-0049-', '3-0049-0049',
+                          '3-0050', '3-0050-0049', '3-0051', '3-0051-0049',
+                          '3-0052', '3-0052-0049'])
 
         listing = broker.list_containers_iter(10, '3-0048', None, '3-', '-')
-        self.assertEquals(len(listing), 10)
-        self.assertEquals([row[0] for row in listing],
-                          ['3-0048-', '3-0049', '3-0049-', '3-0050',
-                           '3-0050-', '3-0051', '3-0051-', '3-0052',
-                           '3-0052-', '3-0053'])
+        self.assertEqual(len(listing), 10)
+        self.assertEqual([row[0] for row in listing],
+                         ['3-0048-', '3-0049', '3-0049-', '3-0050',
+                          '3-0050-', '3-0051', '3-0051-', '3-0052',
+                          '3-0052-', '3-0053'])
 
         listing = broker.list_containers_iter(10, None, None, '3-0049-', '-')
-        self.assertEquals(len(listing), 2)
-        self.assertEquals([row[0] for row in listing],
-                          ['3-0049-', '3-0049-0049'])
+        self.assertEqual(len(listing), 2)
+        self.assertEqual([row[0] for row in listing],
+                         ['3-0049-', '3-0049-0049'])
 
     def test_double_check_trailing_delimiter(self):
         # Test AccountBroker.list_containers_iter for an
@@ -412,21 +412,21 @@ class TestAccountBroker(unittest.TestCase):
         broker.put_container('b-b', normalize_timestamp(time()), 0, 0, 0)
         broker.put_container('c', normalize_timestamp(time()), 0, 0, 0)
         listing = broker.list_containers_iter(15, None, None, None, None)
-        self.assertEquals(len(listing), 10)
-        self.assertEquals([row[0] for row in listing],
-                          ['a', 'a-', 'a-a', 'a-a-a', 'a-a-b', 'a-b', 'b',
-                           'b-a', 'b-b', 'c'])
+        self.assertEqual(len(listing), 10)
+        self.assertEqual([row[0] for row in listing],
+                         ['a', 'a-', 'a-a', 'a-a-a', 'a-a-b', 'a-b', 'b',
+                          'b-a', 'b-b', 'c'])
         listing = broker.list_containers_iter(15, None, None, '', '-')
-        self.assertEquals(len(listing), 5)
-        self.assertEquals([row[0] for row in listing],
-                          ['a', 'a-', 'b', 'b-', 'c'])
+        self.assertEqual(len(listing), 5)
+        self.assertEqual([row[0] for row in listing],
+                         ['a', 'a-', 'b', 'b-', 'c'])
         listing = broker.list_containers_iter(15, None, None, 'a-', '-')
-        self.assertEquals(len(listing), 4)
-        self.assertEquals([row[0] for row in listing],
-                          ['a-', 'a-a', 'a-a-', 'a-b'])
+        self.assertEqual(len(listing), 4)
+        self.assertEqual([row[0] for row in listing],
+                         ['a-', 'a-a', 'a-a-', 'a-b'])
         listing = broker.list_containers_iter(15, None, None, 'b-', '-')
-        self.assertEquals(len(listing), 2)
-        self.assertEquals([row[0] for row in listing], ['b-a', 'b-b'])
+        self.assertEqual(len(listing), 2)
+        self.assertEqual([row[0] for row in listing], ['b-a', 'b-b'])
 
     def test_chexor(self):
         broker = AccountBroker(':memory:', account='a')
@@ -443,7 +443,7 @@ class TestAccountBroker(unittest.TestCase):
         ).digest()
         hashc = \
             ''.join(('%02x' % (ord(a) ^ ord(b)) for a, b in zip(hasha, hashb)))
-        self.assertEquals(broker.get_info()['hash'], hashc)
+        self.assertEqual(broker.get_info()['hash'], hashc)
         broker.put_container('b', normalize_timestamp(3),
                              normalize_timestamp(0), 0, 0)
         hashb = hashlib.md5(
@@ -451,7 +451,7 @@ class TestAccountBroker(unittest.TestCase):
         ).digest()
         hashc = \
             ''.join(('%02x' % (ord(a) ^ ord(b)) for a, b in zip(hasha, hashb)))
-        self.assertEquals(broker.get_info()['hash'], hashc)
+        self.assertEqual(broker.get_info()['hash'], hashc)
 
     def test_merge_items(self):
         broker1 = AccountBroker(':memory:', account='a')
@@ -464,15 +464,15 @@ class TestAccountBroker(unittest.TestCase):
         broker2.merge_items(broker1.get_items_since(
             broker2.get_sync(id), 1000), id)
         items = broker2.get_items_since(-1, 1000)
-        self.assertEquals(len(items), 2)
-        self.assertEquals(['a', 'b'], sorted([rec['name'] for rec in items]))
+        self.assertEqual(len(items), 2)
+        self.assertEqual(['a', 'b'], sorted([rec['name'] for rec in items]))
         broker1.put_container('c', normalize_timestamp(3), 0, 0, 0)
         broker2.merge_items(broker1.get_items_since(
             broker2.get_sync(id), 1000), id)
         items = broker2.get_items_since(-1, 1000)
-        self.assertEquals(len(items), 3)
-        self.assertEquals(['a', 'b', 'c'],
-                          sorted([rec['name'] for rec in items]))
+        self.assertEqual(len(items), 3)
+        self.assertEqual(['a', 'b', 'c'],
+                         sorted([rec['name'] for rec in items]))
 
 
 def premetadata_create_account_stat_table(self, conn, put_timestamp):
diff --git a/test/unit/account/test_reaper.py b/test/unit/account/test_reaper.py
index 81ea63b5e..4cd46fa5c 100644
--- a/test/unit/account/test_reaper.py
+++ b/test/unit/account/test_reaper.py
@@ -212,13 +212,13 @@ class TestReaper(unittest.TestCase):
 
     def test_delay_reaping_conf_default(self):
         r = reaper.AccountReaper({})
-        self.assertEquals(r.delay_reaping, 0)
+        self.assertEqual(r.delay_reaping, 0)
         r = reaper.AccountReaper({'delay_reaping': ''})
-        self.assertEquals(r.delay_reaping, 0)
+        self.assertEqual(r.delay_reaping, 0)
 
     def test_delay_reaping_conf_set(self):
         r = reaper.AccountReaper({'delay_reaping': '123'})
-        self.assertEquals(r.delay_reaping, 123)
+        self.assertEqual(r.delay_reaping, 123)
 
     def test_delay_reaping_conf_bad_value(self):
         self.assertRaises(ValueError, reaper.AccountReaper,
@@ -227,7 +227,7 @@ class TestReaper(unittest.TestCase):
     def test_reap_warn_after_conf_set(self):
         conf = {'delay_reaping': '2', 'reap_warn_after': '3'}
         r = reaper.AccountReaper(conf)
-        self.assertEquals(r.reap_not_done_after, 5)
+        self.assertEqual(r.reap_not_done_after, 5)
 
     def test_reap_warn_after_conf_bad_value(self):
         self.assertRaises(ValueError, reaper.AccountReaper,
diff --git a/test/unit/account/test_server.py b/test/unit/account/test_server.py
index ba56b6d85..c545ee050 100644
--- a/test/unit/account/test_server.py
+++ b/test/unit/account/test_server.py
@@ -50,7 +50,7 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'DELETE',
                                                   'HTTP_X_TIMESTAMP': '0'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
         self.assertTrue('X-Account-Status' not in resp.headers)
 
     def test_DELETE_empty(self):
@@ -60,8 +60,8 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'DELETE',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_DELETE_not_empty(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -77,8 +77,8 @@ class TestAccountController(unittest.TestCase):
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
         # We now allow deleting non-empty accounts
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_DELETE_now_empty(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -100,18 +100,18 @@ class TestAccountController(unittest.TestCase):
                      'X-Bytes-Used': '0',
                      'X-Timestamp': normalize_timestamp(0)})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'DELETE',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_DELETE_invalid_partition(self):
         req = Request.blank('/sda1/./a', environ={'REQUEST_METHOD': 'DELETE',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_DELETE_timestamp_not_float(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -120,7 +120,7 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'DELETE'},
                             headers={'X-Timestamp': 'not-float'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_DELETE_insufficient_storage(self):
         self.controller = AccountController({'devices': self.testdir})
@@ -128,13 +128,13 @@ class TestAccountController(unittest.TestCase):
             '/sda-null/p/a', environ={'REQUEST_METHOD': 'DELETE',
                                       'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 507)
+        self.assertEqual(resp.status_int, 507)
 
     def test_HEAD_not_found(self):
         # Test the case in which account does not exist (can be recreated)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
         self.assertTrue('X-Account-Status' not in resp.headers)
 
         # Test the case in which account was deleted but not yet reaped
@@ -152,8 +152,8 @@ class TestAccountController(unittest.TestCase):
         resp = req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 404)
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_HEAD_empty_account(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -161,10 +161,10 @@ class TestAccountController(unittest.TestCase):
         req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['x-account-container-count'], '0')
-        self.assertEquals(resp.headers['x-account-object-count'], '0')
-        self.assertEquals(resp.headers['x-account-bytes-used'], '0')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['x-account-container-count'], '0')
+        self.assertEqual(resp.headers['x-account-object-count'], '0')
+        self.assertEqual(resp.headers['x-account-bytes-used'], '0')
 
     def test_HEAD_with_containers(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
@@ -186,10 +186,10 @@ class TestAccountController(unittest.TestCase):
         req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['x-account-container-count'], '2')
-        self.assertEquals(resp.headers['x-account-object-count'], '0')
-        self.assertEquals(resp.headers['x-account-bytes-used'], '0')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['x-account-container-count'], '2')
+        self.assertEqual(resp.headers['x-account-object-count'], '0')
+        self.assertEqual(resp.headers['x-account-bytes-used'], '0')
         req = Request.blank('/sda1/p/a/c1', environ={'REQUEST_METHOD': 'PUT'},
                             headers={'X-Put-Timestamp': '1',
                                      'X-Delete-Timestamp': '0',
@@ -207,36 +207,36 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD',
                                                   'HTTP_X_TIMESTAMP': '5'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['x-account-container-count'], '2')
-        self.assertEquals(resp.headers['x-account-object-count'], '4')
-        self.assertEquals(resp.headers['x-account-bytes-used'], '6')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['x-account-container-count'], '2')
+        self.assertEqual(resp.headers['x-account-object-count'], '4')
+        self.assertEqual(resp.headers['x-account-bytes-used'], '6')
 
     def test_HEAD_invalid_partition(self):
         req = Request.blank('/sda1/./a', environ={'REQUEST_METHOD': 'HEAD',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_HEAD_invalid_content_type(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'},
                             headers={'Accept': 'application/plain'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 406)
+        self.assertEqual(resp.status_int, 406)
 
     def test_HEAD_insufficient_storage(self):
         self.controller = AccountController({'devices': self.testdir})
         req = Request.blank('/sda-null/p/a', environ={'REQUEST_METHOD': 'HEAD',
                                                       'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 507)
+        self.assertEqual(resp.status_int, 507)
 
     def test_HEAD_invalid_format(self):
         format = '%D1%BD%8A9'  # invalid UTF-8; should be %E1%BD%8A9 (E -> D)
         req = Request.blank('/sda1/p/a?format=' + format,
                             environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_PUT_not_found(self):
         req = Request.blank(
@@ -247,34 +247,34 @@ class TestAccountController(unittest.TestCase):
                      'X-Bytes-Used': '1',
                      'X-Timestamp': normalize_timestamp(0)})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
         self.assertTrue('X-Account-Status' not in resp.headers)
 
     def test_PUT(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
                                                   'HTTP_X_TIMESTAMP': '0'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 201)
+        self.assertEqual(resp.status_int, 201)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 202)
+        self.assertEqual(resp.status_int, 202)
 
     def test_PUT_after_DELETE(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
                             headers={'X-Timestamp': normalize_timestamp(1)})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 201)
+        self.assertEqual(resp.status_int, 201)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'DELETE'},
                             headers={'X-Timestamp': normalize_timestamp(1)})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
                             headers={'X-Timestamp': normalize_timestamp(2)})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 403)
-        self.assertEquals(resp.body, 'Recently deleted')
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 403)
+        self.assertEqual(resp.body, 'Recently deleted')
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_PUT_GET_metadata(self):
         # Set metadata header
@@ -283,140 +283,140 @@ class TestAccountController(unittest.TestCase):
             headers={'X-Timestamp': normalize_timestamp(1),
                      'X-Account-Meta-Test': 'Value'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 201)
+        self.assertEqual(resp.status_int, 201)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'Value')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'Value')
         # Set another metadata header, ensuring old one doesn't disappear
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'POST'},
             headers={'X-Timestamp': normalize_timestamp(1),
                      'X-Account-Meta-Test2': 'Value2'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'Value')
-        self.assertEquals(resp.headers.get('x-account-meta-test2'), 'Value2')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'Value')
+        self.assertEqual(resp.headers.get('x-account-meta-test2'), 'Value2')
         # Update metadata header
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
             headers={'X-Timestamp': normalize_timestamp(3),
                      'X-Account-Meta-Test': 'New Value'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 202)
+        self.assertEqual(resp.status_int, 202)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'New Value')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'New Value')
         # Send old update to metadata header
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
             headers={'X-Timestamp': normalize_timestamp(2),
                      'X-Account-Meta-Test': 'Old Value'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 202)
+        self.assertEqual(resp.status_int, 202)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'New Value')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'New Value')
         # Remove metadata header (by setting it to empty)
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
             headers={'X-Timestamp': normalize_timestamp(4),
                      'X-Account-Meta-Test': ''})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 202)
+        self.assertEqual(resp.status_int, 202)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         self.assert_('x-account-meta-test' not in resp.headers)
 
     def test_PUT_invalid_partition(self):
         req = Request.blank('/sda1/./a', environ={'REQUEST_METHOD': 'PUT',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_PUT_insufficient_storage(self):
         self.controller = AccountController({'devices': self.testdir})
         req = Request.blank('/sda-null/p/a', environ={'REQUEST_METHOD': 'PUT',
                                                       'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 507)
+        self.assertEqual(resp.status_int, 507)
 
     def test_POST_HEAD_metadata(self):
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'PUT'},
             headers={'X-Timestamp': normalize_timestamp(1)})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 201)
+        self.assertEqual(resp.status_int, 201)
         # Set metadata header
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'POST'},
             headers={'X-Timestamp': normalize_timestamp(1),
                      'X-Account-Meta-Test': 'Value'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'Value')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'Value')
         # Update metadata header
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'POST'},
             headers={'X-Timestamp': normalize_timestamp(3),
                      'X-Account-Meta-Test': 'New Value'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'New Value')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'New Value')
         # Send old update to metadata header
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'POST'},
             headers={'X-Timestamp': normalize_timestamp(2),
                      'X-Account-Meta-Test': 'Old Value'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers.get('x-account-meta-test'), 'New Value')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers.get('x-account-meta-test'), 'New Value')
         # Remove metadata header (by setting it to empty)
         req = Request.blank(
             '/sda1/p/a', environ={'REQUEST_METHOD': 'POST'},
             headers={'X-Timestamp': normalize_timestamp(4),
                      'X-Account-Meta-Test': ''})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'HEAD'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
+        self.assertEqual(resp.status_int, 204)
         self.assert_('x-account-meta-test' not in resp.headers)
 
     def test_POST_invalid_partition(self):
         req = Request.blank('/sda1/./a', environ={'REQUEST_METHOD': 'POST',
                                                   'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_POST_timestamp_not_float(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'POST',
                                                   'HTTP_X_TIMESTAMP': '0'},
                             headers={'X-Timestamp': 'not-float'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 400)
+        self.assertEqual(resp.status_int, 400)
 
     def test_POST_insufficient_storage(self):
         self.controller = AccountController({'devices': self.testdir})
         req = Request.blank('/sda-null/p/a', environ={'REQUEST_METHOD': 'POST',
                                                       'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 507)
+        self.assertEqual(resp.status_int, 507)
 
     def test_POST_after_DELETE_not_found(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -428,14 +428,14 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'POST',
                                                   'HTTP_X_TIMESTAMP': '2'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 404)
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_GET_not_found_plain(self):
         # Test the case in which account does not exist (can be recreated)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
         self.assertTrue('X-Account-Status' not in resp.headers)
 
         # Test the case in which account was deleted but not yet reaped
@@ -453,20 +453,20 @@ class TestAccountController(unittest.TestCase):
         resp = req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
-        self.assertEquals(resp.headers['X-Account-Status'], 'Deleted')
+        self.assertEqual(resp.status_int, 404)
+        self.assertEqual(resp.headers['X-Account-Status'], 'Deleted')
 
     def test_GET_not_found_json(self):
         req = Request.blank('/sda1/p/a?format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
 
     def test_GET_not_found_xml(self):
         req = Request.blank('/sda1/p/a?format=xml',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
 
     def test_GET_empty_account_plain(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -474,9 +474,9 @@ class TestAccountController(unittest.TestCase):
         req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 204)
-        self.assertEquals(resp.headers['Content-Type'],
-                          'text/plain; charset=utf-8')
+        self.assertEqual(resp.status_int, 204)
+        self.assertEqual(resp.headers['Content-Type'],
+                         'text/plain; charset=utf-8')
 
     def test_GET_empty_account_json(self):
         req = Request.blank('/sda1/p/a?format=json',
@@ -486,9 +486,9 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.headers['Content-Type'],
-                          'application/json; charset=utf-8')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.headers['Content-Type'],
+                         'application/json; charset=utf-8')
 
     def test_GET_empty_account_xml(self):
         req = Request.blank('/sda1/p/a?format=xml',
@@ -498,16 +498,16 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?format=xml',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.headers['Content-Type'],
-                          'application/xml; charset=utf-8')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.headers['Content-Type'],
+                         'application/xml; charset=utf-8')
 
     def test_GET_over_limit(self):
         req = Request.blank(
             '/sda1/p/a?limit=%d' % (ACCOUNT_LISTING_LIMIT + 1),
             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 412)
+        self.assertEqual(resp.status_int, 412)
 
     def test_GET_with_containers_plain(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -529,8 +529,8 @@ class TestAccountController(unittest.TestCase):
         req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'), ['c1', 'c2'])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'), ['c1', 'c2'])
         req = Request.blank('/sda1/p/a/c1', environ={'REQUEST_METHOD': 'PUT'},
                             headers={'X-Put-Timestamp': '1',
                                      'X-Delete-Timestamp': '0',
@@ -547,19 +547,19 @@ class TestAccountController(unittest.TestCase):
         req.get_response(self.controller)
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'), ['c1', 'c2'])
-        self.assertEquals(resp.content_type, 'text/plain')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'), ['c1', 'c2'])
+        self.assertEqual(resp.content_type, 'text/plain')
+        self.assertEqual(resp.charset, 'utf-8')
 
         # test unknown format uses default plain
         req = Request.blank('/sda1/p/a?format=somethinglese',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'), ['c1', 'c2'])
-        self.assertEquals(resp.content_type, 'text/plain')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'), ['c1', 'c2'])
+        self.assertEqual(resp.content_type, 'text/plain')
+        self.assertEqual(resp.charset, 'utf-8')
 
     def test_GET_with_containers_json(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -582,10 +582,10 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(simplejson.loads(resp.body),
-                          [{'count': 0, 'bytes': 0, 'name': 'c1'},
-                           {'count': 0, 'bytes': 0, 'name': 'c2'}])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(simplejson.loads(resp.body),
+                         [{'count': 0, 'bytes': 0, 'name': 'c1'},
+                          {'count': 0, 'bytes': 0, 'name': 'c2'}])
         req = Request.blank('/sda1/p/a/c1', environ={'REQUEST_METHOD': 'PUT'},
                             headers={'X-Put-Timestamp': '1',
                                      'X-Delete-Timestamp': '0',
@@ -603,12 +603,12 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(simplejson.loads(resp.body),
-                          [{'count': 1, 'bytes': 2, 'name': 'c1'},
-                           {'count': 3, 'bytes': 4, 'name': 'c2'}])
-        self.assertEquals(resp.content_type, 'application/json')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(simplejson.loads(resp.body),
+                         [{'count': 1, 'bytes': 2, 'name': 'c1'},
+                          {'count': 3, 'bytes': 4, 'name': 'c2'}])
+        self.assertEqual(resp.content_type, 'application/json')
+        self.assertEqual(resp.charset, 'utf-8')
 
     def test_GET_with_containers_xml(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -631,34 +631,34 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?format=xml',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.content_type, 'application/xml')
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.content_type, 'application/xml')
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
-        self.assertEquals(dom.firstChild.nodeName, 'account')
+        self.assertEqual(dom.firstChild.nodeName, 'account')
         listing = \
             [n for n in dom.firstChild.childNodes if n.nodeName != '#text']
-        self.assertEquals(len(listing), 2)
-        self.assertEquals(listing[0].nodeName, 'container')
+        self.assertEqual(len(listing), 2)
+        self.assertEqual(listing[0].nodeName, 'container')
         container = [n for n in listing[0].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c1')
+        self.assertEqual(node.firstChild.nodeValue, 'c1')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '0')
+        self.assertEqual(node.firstChild.nodeValue, '0')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '0')
-        self.assertEquals(listing[-1].nodeName, 'container')
+        self.assertEqual(node.firstChild.nodeValue, '0')
+        self.assertEqual(listing[-1].nodeName, 'container')
         container = \
             [n for n in listing[-1].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c2')
+        self.assertEqual(node.firstChild.nodeValue, 'c2')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '0')
+        self.assertEqual(node.firstChild.nodeValue, '0')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '0')
+        self.assertEqual(node.firstChild.nodeValue, '0')
         req = Request.blank('/sda1/p/a/c1', environ={'REQUEST_METHOD': 'PUT'},
                             headers={'X-Put-Timestamp': '1',
                                      'X-Delete-Timestamp': '0',
@@ -676,34 +676,34 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?format=xml',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
-        self.assertEquals(dom.firstChild.nodeName, 'account')
+        self.assertEqual(dom.firstChild.nodeName, 'account')
         listing = \
             [n for n in dom.firstChild.childNodes if n.nodeName != '#text']
-        self.assertEquals(len(listing), 2)
-        self.assertEquals(listing[0].nodeName, 'container')
+        self.assertEqual(len(listing), 2)
+        self.assertEqual(listing[0].nodeName, 'container')
         container = [n for n in listing[0].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c1')
+        self.assertEqual(node.firstChild.nodeValue, 'c1')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '1')
+        self.assertEqual(node.firstChild.nodeValue, '1')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '2')
-        self.assertEquals(listing[-1].nodeName, 'container')
+        self.assertEqual(node.firstChild.nodeValue, '2')
+        self.assertEqual(listing[-1].nodeName, 'container')
         container = [
             n for n in listing[-1].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c2')
+        self.assertEqual(node.firstChild.nodeValue, 'c2')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '3')
+        self.assertEqual(node.firstChild.nodeValue, '3')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '4')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(node.firstChild.nodeValue, '4')
+        self.assertEqual(resp.charset, 'utf-8')
 
     def test_GET_xml_escapes_account_name(self):
         req = Request.blank(
@@ -717,7 +717,7 @@ class TestAccountController(unittest.TestCase):
         resp = req.get_response(self.controller)
 
         dom = xml.dom.minidom.parseString(resp.body)
-        self.assertEquals(dom.firstChild.attributes['name'].value, '"\'')
+        self.assertEqual(dom.firstChild.attributes['name'].value, '"\'')
 
     def test_GET_xml_escapes_container_name(self):
         req = Request.blank(
@@ -738,7 +738,7 @@ class TestAccountController(unittest.TestCase):
         resp = req.get_response(self.controller)
         dom = xml.dom.minidom.parseString(resp.body)
 
-        self.assertEquals(
+        self.assertEqual(
             dom.firstChild.firstChild.nextSibling.firstChild.firstChild.data,
             '"<word')
 
@@ -761,7 +761,7 @@ class TestAccountController(unittest.TestCase):
         resp = req.get_response(self.controller)
         dom = xml.dom.minidom.parseString(resp.body)
 
-        self.assertEquals(
+        self.assertEqual(
             dom.firstChild.firstChild.nextSibling.attributes['name'].value,
             '"<word-')
 
@@ -782,13 +782,13 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?limit=3',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'), ['c0', 'c1', 'c2'])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'), ['c0', 'c1', 'c2'])
         req = Request.blank('/sda1/p/a?limit=3&marker=c2',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'), ['c3', 'c4'])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'), ['c3', 'c4'])
 
     def test_GET_limit_marker_json(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -807,18 +807,18 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?limit=3&format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(simplejson.loads(resp.body),
-                          [{'count': 2, 'bytes': 3, 'name': 'c0'},
-                           {'count': 2, 'bytes': 3, 'name': 'c1'},
-                           {'count': 2, 'bytes': 3, 'name': 'c2'}])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(simplejson.loads(resp.body),
+                         [{'count': 2, 'bytes': 3, 'name': 'c0'},
+                          {'count': 2, 'bytes': 3, 'name': 'c1'},
+                          {'count': 2, 'bytes': 3, 'name': 'c2'}])
         req = Request.blank('/sda1/p/a?limit=3&marker=c2&format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(simplejson.loads(resp.body),
-                          [{'count': 2, 'bytes': 3, 'name': 'c3'},
-                           {'count': 2, 'bytes': 3, 'name': 'c4'}])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(simplejson.loads(resp.body),
+                         [{'count': 2, 'bytes': 3, 'name': 'c3'},
+                          {'count': 2, 'bytes': 3, 'name': 'c4'}])
 
     def test_GET_limit_marker_xml(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -837,63 +837,63 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?limit=3&format=xml',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
-        self.assertEquals(dom.firstChild.nodeName, 'account')
+        self.assertEqual(dom.firstChild.nodeName, 'account')
         listing = \
             [n for n in dom.firstChild.childNodes if n.nodeName != '#text']
-        self.assertEquals(len(listing), 3)
-        self.assertEquals(listing[0].nodeName, 'container')
+        self.assertEqual(len(listing), 3)
+        self.assertEqual(listing[0].nodeName, 'container')
         container = [n for n in listing[0].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c0')
+        self.assertEqual(node.firstChild.nodeValue, 'c0')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '2')
+        self.assertEqual(node.firstChild.nodeValue, '2')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '3')
-        self.assertEquals(listing[-1].nodeName, 'container')
+        self.assertEqual(node.firstChild.nodeValue, '3')
+        self.assertEqual(listing[-1].nodeName, 'container')
         container = [
             n for n in listing[-1].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c2')
+        self.assertEqual(node.firstChild.nodeValue, 'c2')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '2')
+        self.assertEqual(node.firstChild.nodeValue, '2')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '3')
+        self.assertEqual(node.firstChild.nodeValue, '3')
         req = Request.blank('/sda1/p/a?limit=3&marker=c2&format=xml',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
-        self.assertEquals(dom.firstChild.nodeName, 'account')
+        self.assertEqual(dom.firstChild.nodeName, 'account')
         listing = \
             [n for n in dom.firstChild.childNodes if n.nodeName != '#text']
-        self.assertEquals(len(listing), 2)
-        self.assertEquals(listing[0].nodeName, 'container')
+        self.assertEqual(len(listing), 2)
+        self.assertEqual(listing[0].nodeName, 'container')
         container = [n for n in listing[0].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c3')
+        self.assertEqual(node.firstChild.nodeValue, 'c3')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '2')
+        self.assertEqual(node.firstChild.nodeValue, '2')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '3')
-        self.assertEquals(listing[-1].nodeName, 'container')
+        self.assertEqual(node.firstChild.nodeValue, '3')
+        self.assertEqual(listing[-1].nodeName, 'container')
         container = [
             n for n in listing[-1].childNodes if n.nodeName != '#text']
-        self.assertEquals(sorted([n.nodeName for n in container]),
-                          ['bytes', 'count', 'name'])
+        self.assertEqual(sorted([n.nodeName for n in container]),
+                         ['bytes', 'count', 'name'])
         node = [n for n in container if n.nodeName == 'name'][0]
-        self.assertEquals(node.firstChild.nodeValue, 'c4')
+        self.assertEqual(node.firstChild.nodeValue, 'c4')
         node = [n for n in container if n.nodeName == 'count'][0]
-        self.assertEquals(node.firstChild.nodeValue, '2')
+        self.assertEqual(node.firstChild.nodeValue, '2')
         node = [n for n in container if n.nodeName == 'bytes'][0]
-        self.assertEquals(node.firstChild.nodeValue, '3')
+        self.assertEqual(node.firstChild.nodeValue, '3')
 
     def test_GET_accept_wildcard(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -909,8 +909,8 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         req.accept = '*/*'
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body, 'c1\n')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body, 'c1\n')
 
     def test_GET_accept_application_wildcard(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -926,8 +926,8 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         req.accept = 'application/*'
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(len(simplejson.loads(resp.body)), 1)
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(len(simplejson.loads(resp.body)), 1)
 
     def test_GET_accept_json(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -943,8 +943,8 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         req.accept = 'application/json'
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(len(simplejson.loads(resp.body)), 1)
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(len(simplejson.loads(resp.body)), 1)
 
     def test_GET_accept_xml(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -960,12 +960,12 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         req.accept = 'application/xml'
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
-        self.assertEquals(dom.firstChild.nodeName, 'account')
+        self.assertEqual(dom.firstChild.nodeName, 'account')
         listing = \
             [n for n in dom.firstChild.childNodes if n.nodeName != '#text']
-        self.assertEquals(len(listing), 1)
+        self.assertEqual(len(listing), 1)
 
     def test_GET_accept_conflicting(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -982,8 +982,8 @@ class TestAccountController(unittest.TestCase):
                             environ={'REQUEST_METHOD': 'GET'})
         req.accept = 'application/json'
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body, 'c1\n')
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body, 'c1\n')
 
     def test_GET_accept_not_valid(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -999,14 +999,14 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
         req.accept = 'application/xml*'
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 406)
+        self.assertEqual(resp.status_int, 406)
 
     def test_GET_delimiter_too_long(self):
         req = Request.blank('/sda1/p/a?delimiter=xx',
                             environ={'REQUEST_METHOD': 'GET',
                                      'HTTP_X_TIMESTAMP': '0'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 412)
+        self.assertEqual(resp.status_int, 412)
 
     def test_GET_prefix_delimiter_plain(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -1035,21 +1035,21 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?delimiter=.',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'), ['sub.'])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'), ['sub.'])
         req = Request.blank('/sda1/p/a?prefix=sub.&delimiter=.',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(
             resp.body.strip().split('\n'),
             ['sub.0', 'sub.0.', 'sub.1', 'sub.1.', 'sub.2', 'sub.2.'])
         req = Request.blank('/sda1/p/a?prefix=sub.1.&delimiter=.',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(resp.body.strip().split('\n'),
-                          ['sub.1.0', 'sub.1.1', 'sub.1.2'])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(resp.body.strip().split('\n'),
+                         ['sub.1.0', 'sub.1.1', 'sub.1.2'])
 
     def test_GET_prefix_delimiter_json(self):
         req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
@@ -1078,22 +1078,22 @@ class TestAccountController(unittest.TestCase):
         req = Request.blank('/sda1/p/a?delimiter=.&format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals([n.get('name', 's:' + n.get('subdir', 'error'))
-                           for n in simplejson.loads(resp.body)], ['s:sub.'])
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual([n.get('name', 's:' + n.get('subdir', 'error'))
+                          for n in simplejson.loads(resp.body)], ['s:sub.'])
         req = Request.blank('/sda1/p/a?prefix=sub.&delimiter=.&format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(
             [n.get('name', 's:' + n.get('subdir', 'error'))
              for n in simplejson.loads(resp.body)],
             ['sub.0', 's:sub.0.', 'sub.1', 's:sub.1.', 'sub.2', 's:sub.2.'])
         req = Request.blank('/sda1/p/a?prefix=sub.1.&delimiter=.&format=json',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
-        self.assertEquals(
+        self.assertEqual(resp.status_int, 200)
+        self.assertEqual(
             [n.get('name', 's:' + n.get('subdir', 'error'))
              for n in simplejson.loads(resp.body)],
             ['sub.1.0', 'sub.1.1', 'sub.1.2'])
@@ -1126,7 +1126,7 @@ class TestAccountController(unittest.TestCase):
             '/sda1/p/a?delimiter=.&format=xml',
             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
         listing = []
         for node1 in dom.firstChild.childNodes:
@@ -1136,12 +1136,12 @@ class TestAccountController(unittest.TestCase):
                 for node2 in node1.childNodes:
                     if node2.nodeName == 'name':
                         listing.append(node2.firstChild.nodeValue)
-        self.assertEquals(listing, ['s:sub.'])
+        self.assertEqual(listing, ['s:sub.'])
         req = Request.blank(
             '/sda1/p/a?prefix=sub.&delimiter=.&format=xml',
             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
         listing = []
         for node1 in dom.firstChild.childNodes:
@@ -1151,14 +1151,14 @@ class TestAccountController(unittest.TestCase):
                 for node2 in node1.childNodes:
                     if node2.nodeName == 'name':
                         listing.append(node2.firstChild.nodeValue)
-        self.assertEquals(
+        self.assertEqual(
             listing,
             ['sub.0', 's:sub.0.', 'sub.1', 's:sub.1.', 'sub.2', 's:sub.2.'])
         req = Request.blank(
             '/sda1/p/a?prefix=sub.1.&delimiter=.&format=xml',
             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 200)
+        self.assertEqual(resp.status_int, 200)
         dom = xml.dom.minidom.parseString(resp.body)
         listing = []
         for node1 in dom.firstChild.childNodes:
@@ -1168,14 +1168,14 @@ class TestAccountController(unittest.TestCase):
                 for node2 in node1.childNodes:
                     if node2.nodeName == 'name':
                         listing.append(node2.firstChild.nodeValue)
-        self.assertEquals(listing, ['sub.1.0', 'sub.1.1', 'sub.1.2'])
+        self.assertEqual(listing, ['sub.1.0', 'sub.1.1', 'sub.1.2'])
 
     def test_GET_insufficient_storage(self):
         self.controller = AccountController({'devices': self.testdir})
         req = Request.blank('/sda-null/p/a', environ={'REQUEST_METHOD': 'GET',
                                                       'HTTP_X_TIMESTAMP': '1'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 507)
+        self.assertEqual(resp.status_int, 507)
 
     def test_through_call(self):
         inbuf = StringIO()
@@ -1200,8 +1200,8 @@ class TestAccountController(unittest.TestCase):
                                   'wsgi.multiprocess': False,
                                   'wsgi.run_once': False},
                                  start_response)
-        self.assertEquals(errbuf.getvalue(), '')
-        self.assertEquals(outbuf.getvalue()[:4], '404 ')
+        self.assertEqual(errbuf.getvalue(), '')
+        self.assertEqual(outbuf.getvalue()[:4], '404 ')
 
     def test_through_call_invalid_path(self):
         inbuf = StringIO()
@@ -1226,8 +1226,8 @@ class TestAccountController(unittest.TestCase):
                                   'wsgi.multiprocess': False,
                                   'wsgi.run_once': False},
                                  start_response)
-        self.assertEquals(errbuf.getvalue(), '')
-        self.assertEquals(outbuf.getvalue()[:4], '400 ')
+        self.assertEqual(errbuf.getvalue(), '')
+        self.assertEqual(outbuf.getvalue()[:4], '400 ')
 
     def test_through_call_invalid_path_utf8(self):
         inbuf = StringIO()
@@ -1252,8 +1252,8 @@ class TestAccountController(unittest.TestCase):
                                   'wsgi.multiprocess': False,
                                   'wsgi.run_once': False},
                                  start_response)
-        self.assertEquals(errbuf.getvalue(), '')
-        self.assertEquals(outbuf.getvalue()[:4], '412 ')
+        self.assertEqual(errbuf.getvalue(), '')
+        self.assertEqual(outbuf.getvalue()[:4], '412 ')
 
     def test_invalid_method_doesnt_exist(self):
         errbuf = StringIO()
@@ -1265,8 +1265,8 @@ class TestAccountController(unittest.TestCase):
         self.controller.__call__({'REQUEST_METHOD': 'method_doesnt_exist',
                                   'PATH_INFO': '/sda1/p/a'},
                                  start_response)
-        self.assertEquals(errbuf.getvalue(), '')
-        self.assertEquals(outbuf.getvalue()[:4], '405 ')
+        self.assertEqual(errbuf.getvalue(), '')
+        self.assertEqual(outbuf.getvalue()[:4], '405 ')
 
     def test_invalid_method_is_not_public(self):
         errbuf = StringIO()
@@ -1278,8 +1278,8 @@ class TestAccountController(unittest.TestCase):
         self.controller.__call__({'REQUEST_METHOD': '__init__',
                                   'PATH_INFO': '/sda1/p/a'},
                                  start_response)
-        self.assertEquals(errbuf.getvalue(), '')
-        self.assertEquals(outbuf.getvalue()[:4], '405 ')
+        self.assertEqual(errbuf.getvalue(), '')
+        self.assertEqual(outbuf.getvalue()[:4], '405 ')
 
     def test_params_format(self):
         Request.blank('/sda1/p/a',
@@ -1290,7 +1290,7 @@ class TestAccountController(unittest.TestCase):
             req = Request.blank('/sda1/p/a?format=%s' % format,
                                 environ={'REQUEST_METHOD': 'GET'})
             resp = req.get_response(self.controller)
-            self.assertEquals(resp.status_int, 200)
+            self.assertEqual(resp.status_int, 200)
 
     def test_params_utf8(self):
         # Bad UTF8 sequence, all parameters should cause 400 error
@@ -1299,14 +1299,14 @@ class TestAccountController(unittest.TestCase):
             req = Request.blank('/sda1/p/a?%s=\xce' % param,
                                 environ={'REQUEST_METHOD': 'GET'})
             resp = req.get_response(self.controller)
-            self.assertEquals(resp.status_int, 400,
-                              "%d on param %s" % (resp.status_int, param))
+            self.assertEqual(resp.status_int, 400,
+                             "%d on param %s" % (resp.status_int, param))
         # Good UTF8 sequence for delimiter, too long (1 byte delimiters only)
         req = Request.blank('/sda1/p/a?delimiter=\xce\xa9',
                             environ={'REQUEST_METHOD': 'GET'})
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 412,
-                          "%d on param delimiter" % (resp.status_int))
+        self.assertEqual(resp.status_int, 412,
+                         "%d on param delimiter" % (resp.status_int))
         Request.blank('/sda1/p/a',
                       headers={'X-Timestamp': normalize_timestamp(1)},
                       environ={'REQUEST_METHOD': 'PUT'}).get_response(
@@ -1316,8 +1316,8 @@ class TestAccountController(unittest.TestCase):
             req = Request.blank('/sda1/p/a?%s=\xce\xa9' % param,
                                 environ={'REQUEST_METHOD': 'GET'})
             resp = req.get_response(self.controller)
-            self.assertEquals(resp.status_int, 204,
-                              "%d on param %s" % (resp.status_int, param))
+            self.assertEqual(resp.status_int, 204,
+                             "%d on param %s" % (resp.status_int, param))
 
     def test_put_auto_create(self):
         headers = {'x-put-timestamp': normalize_timestamp(1),
@@ -1329,19 +1329,19 @@ class TestAccountController(unittest.TestCase):
                             environ={'REQUEST_METHOD': 'PUT'},
                             headers=dict(headers))
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
 
         req = Request.blank('/sda1/p/.a/c',
                             environ={'REQUEST_METHOD': 'PUT'},
                             headers=dict(headers))
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 201)
+        self.assertEqual(resp.status_int, 201)
 
         req = Request.blank('/sda1/p/a/.c',
                             environ={'REQUEST_METHOD': 'PUT'},
                             headers=dict(headers))
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.status_int, 404)
+        self.assertEqual(resp.status_int, 404)
 
     def test_content_type_on_HEAD(self):
         Request.blank('/sda1/p/a',
@@ -1353,34 +1353,34 @@ class TestAccountController(unittest.TestCase):
 
         req = Request.blank('/sda1/p/a?format=xml', environ=env)
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.content_type, 'application/xml')
+        self.assertEqual(resp.content_type, 'application/xml')
 
         req = Request.blank('/sda1/p/a?format=json', environ=env)
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.content_type, 'application/json')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.content_type, 'application/json')
+        self.assertEqual(resp.charset, 'utf-8')
 
         req = Request.blank('/sda1/p/a', environ=env)
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.content_type, 'text/plain')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.content_type, 'text/plain')
+        self.assertEqual(resp.charset, 'utf-8')
 
         req = Request.blank(
             '/sda1/p/a', headers={'Accept': 'application/json'}, environ=env)
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.content_type, 'application/json')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.content_type, 'application/json')
+        self.assertEqual(resp.charset, 'utf-8')
 
         req = Request.blank(
             '/sda1/p/a', headers={'Accept': 'application/xml'}, environ=env)
         resp = req.get_response(self.controller)
-        self.assertEquals(resp.content_type, 'application/xml')
-        self.assertEquals(resp.charset, 'utf-8')
+        self.assertEqual(resp.content_type, 'application/xml')
+        self.assertEqual(resp.charset, 'utf-8')
 
     def test_serv_reserv(self):
         # Test replication_server flag was set from configuration file.
         conf = {'devices': self.testdir, 'mount_check': 'false'}
-        self.assertEquals(AccountController(conf).replication_server, None)
+        self.assertEqual(AccountController(conf).replication_server, None)
         for val in [True, '1', 'True', 'true']:
             conf['replication_server'] = val
             self.assertTrue(AccountController(conf).replication_server)
@@ -1397,7 +1397,7 @@ class TestAccountController(unittest.TestCase):
             self.assertFalse(hasattr(method, 'replication'))
         for method_name in repl_methods:
             method = getattr(self.controller, method_name)
-            self.assertEquals(method.replication, True)
+            self.assertEqual(method.replication, True)
 
     def test_correct_allowed_method(self):
         # Test correct work for allowed method using