diff --git a/test/unit/container/test_auditor.py b/test/unit/container/test_auditor.py index 4e1826bdce..6d9b28d640 100644 --- a/test/unit/container/test_auditor.py +++ b/test/unit/container/test_auditor.py @@ -90,8 +90,8 @@ class TestAuditor(unittest.TestCase): with mock.patch('swift.container.auditor.audit_location_generator', fake_audit_location_generator): self.assertRaises(ValueError, test_auditor.run_forever) - self.assertEquals(test_auditor.container_failures, 2 * call_times) - self.assertEquals(test_auditor.container_passes, 3 * call_times) + self.assertEqual(test_auditor.container_failures, 2 * call_times) + self.assertEqual(test_auditor.container_passes, 3 * call_times) @mock.patch('swift.container.auditor.ContainerBroker', FakeContainerBroker) def test_run_once(self): @@ -105,8 +105,8 @@ class TestAuditor(unittest.TestCase): with mock.patch('swift.container.auditor.audit_location_generator', fake_audit_location_generator): test_auditor.run_once() - self.assertEquals(test_auditor.container_failures, 2) - self.assertEquals(test_auditor.container_passes, 3) + self.assertEqual(test_auditor.container_failures, 2) + self.assertEqual(test_auditor.container_passes, 3) @mock.patch('swift.container.auditor.ContainerBroker', FakeContainerBroker) def test_container_auditor(self): @@ -116,8 +116,8 @@ class TestAuditor(unittest.TestCase): for f in files: path = os.path.join(self.testdir, f) test_auditor.container_audit(path) - self.assertEquals(test_auditor.container_failures, 2) - self.assertEquals(test_auditor.container_passes, 3) + self.assertEqual(test_auditor.container_failures, 2) + self.assertEqual(test_auditor.container_passes, 3) class TestAuditorMigrations(unittest.TestCase): diff --git a/test/unit/container/test_backend.py b/test/unit/container/test_backend.py index 1572265c2d..2a7aafc10e 100644 --- a/test/unit/container/test_backend.py +++ b/test/unit/container/test_backend.py @@ -84,7 +84,7 @@ class TestContainerBroker(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 @@ -109,44 +109,44 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('o', Timestamp(time()).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 1) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 0) broker.reclaim(Timestamp(time() - 999).internal, time()) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 1) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 0) sleep(.00001) broker.delete_object('o', Timestamp(time()).internal) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 0) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 1) broker.reclaim(Timestamp(time() - 999).internal, time()) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 0) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 1) sleep(.00001) broker.reclaim(Timestamp(time()).internal, time()) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 0) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 0) # Test the return values of reclaim() @@ -215,19 +215,19 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('o', Timestamp(time()).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 1) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 0) sleep(.00001) broker.delete_object('o', Timestamp(time()).internal) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 0").fetchone()[0], 0) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT count(*) FROM object " "WHERE deleted = 1").fetchone()[0], 1) @@ -242,20 +242,20 @@ class TestContainerBroker(unittest.TestCase): 'application/x-test', '5af83e3196bf99f440f31f2e1a6c9afe') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 123) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], '5af83e3196bf99f440f31f2e1a6c9afe') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # Reput same event @@ -263,20 +263,20 @@ class TestContainerBroker(unittest.TestCase): 'application/x-test', '5af83e3196bf99f440f31f2e1a6c9afe') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 123) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], '5af83e3196bf99f440f31f2e1a6c9afe') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # Put new event @@ -286,20 +286,20 @@ class TestContainerBroker(unittest.TestCase): 'application/x-test', 'aa0749bacbc79ec65fe206943d8fe449') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 124) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], 'aa0749bacbc79ec65fe206943d8fe449') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # Put old event @@ -308,20 +308,20 @@ class TestContainerBroker(unittest.TestCase): 'application/x-test', 'aa0749bacbc79ec65fe206943d8fe449') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 124) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], 'aa0749bacbc79ec65fe206943d8fe449') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # Put old delete event @@ -329,20 +329,20 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('"{}"', dtimestamp, 0, '', '', deleted=1) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 124) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], 'aa0749bacbc79ec65fe206943d8fe449') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # Put new delete event @@ -351,12 +351,12 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('"{}"', timestamp, 0, '', '', deleted=1) with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 1) # Put new event @@ -366,20 +366,20 @@ class TestContainerBroker(unittest.TestCase): 'application/x-test', '5af83e3196bf99f440f31f2e1a6c9afe') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 123) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], '5af83e3196bf99f440f31f2e1a6c9afe') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # We'll use this later @@ -391,21 +391,21 @@ class TestContainerBroker(unittest.TestCase): previous_timestamp = timestamp timestamp = Timestamp(time()).internal with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], previous_timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 123) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], '5af83e3196bf99f440f31f2e1a6c9afe') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) # Put event from after last put but before last post @@ -414,20 +414,20 @@ class TestContainerBroker(unittest.TestCase): 'application/x-test3', '6af83e3196bf99f440f31f2e1a6c9afe') with broker.get() as conn: - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT name FROM object").fetchone()[0], '"{}"') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT created_at FROM object").fetchone()[0], timestamp) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT size FROM object").fetchone()[0], 456) - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT content_type FROM object").fetchone()[0], 'application/x-test3') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT etag FROM object").fetchone()[0], '6af83e3196bf99f440f31f2e1a6c9afe') - self.assertEquals(conn.execute( + self.assertEqual(conn.execute( "SELECT deleted FROM object").fetchone()[0], 0) @patch_policies @@ -563,35 +563,35 @@ class TestContainerBroker(unittest.TestCase): broker.initialize(Timestamp(1).internal) info = broker.get_info() - self.assertEquals(info['account'], 'test1') - self.assertEquals(info['container'], 'test2') - self.assertEquals(info['hash'], '00000000000000000000000000000000') + self.assertEqual(info['account'], 'test1') + self.assertEqual(info['container'], 'test2') + self.assertEqual(info['hash'], '00000000000000000000000000000000') self.assertEqual(info['put_timestamp'], Timestamp(1).internal) self.assertEqual(info['delete_timestamp'], '0') info = broker.get_info() - self.assertEquals(info['object_count'], 0) - self.assertEquals(info['bytes_used'], 0) + self.assertEqual(info['object_count'], 0) + self.assertEqual(info['bytes_used'], 0) policy_stats = broker.get_policy_stats() # Act as policy-0 self.assertTrue(0 in policy_stats) - self.assertEquals(policy_stats[0]['bytes_used'], 0) - self.assertEquals(policy_stats[0]['object_count'], 0) + self.assertEqual(policy_stats[0]['bytes_used'], 0) + self.assertEqual(policy_stats[0]['object_count'], 0) broker.put_object('o1', Timestamp(time()).internal, 123, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 123) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 123) policy_stats = broker.get_policy_stats() self.assertTrue(0 in policy_stats) - self.assertEquals(policy_stats[0]['object_count'], 1) - self.assertEquals(policy_stats[0]['bytes_used'], 123) + self.assertEqual(policy_stats[0]['object_count'], 1) + self.assertEqual(policy_stats[0]['bytes_used'], 123) def test_get_info(self): # Test ContainerBroker.get_info @@ -600,9 +600,9 @@ class TestContainerBroker(unittest.TestCase): broker.initialize(Timestamp('1').internal, 0) info = broker.get_info() - self.assertEquals(info['account'], 'test1') - self.assertEquals(info['container'], 'test2') - self.assertEquals(info['hash'], '00000000000000000000000000000000') + self.assertEqual(info['account'], 'test1') + self.assertEqual(info['container'], 'test2') + self.assertEqual(info['hash'], '00000000000000000000000000000000') self.assertEqual(info['put_timestamp'], Timestamp(1).internal) self.assertEqual(info['delete_timestamp'], '0') if self.__class__ in (TestContainerBrokerBeforeMetadata, @@ -614,44 +614,44 @@ class TestContainerBroker(unittest.TestCase): Timestamp(1).internal) info = broker.get_info() - self.assertEquals(info['object_count'], 0) - self.assertEquals(info['bytes_used'], 0) + self.assertEqual(info['object_count'], 0) + self.assertEqual(info['bytes_used'], 0) broker.put_object('o1', Timestamp(time()).internal, 123, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 123) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 123) sleep(.00001) broker.put_object('o2', Timestamp(time()).internal, 123, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 2) - self.assertEquals(info['bytes_used'], 246) + self.assertEqual(info['object_count'], 2) + self.assertEqual(info['bytes_used'], 246) sleep(.00001) broker.put_object('o2', Timestamp(time()).internal, 1000, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 2) - self.assertEquals(info['bytes_used'], 1123) + self.assertEqual(info['object_count'], 2) + self.assertEqual(info['bytes_used'], 1123) sleep(.00001) broker.delete_object('o1', Timestamp(time()).internal) info = broker.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 1000) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 1000) sleep(.00001) broker.delete_object('o2', Timestamp(time()).internal) info = broker.get_info() - self.assertEquals(info['object_count'], 0) - self.assertEquals(info['bytes_used'], 0) + self.assertEqual(info['object_count'], 0) + self.assertEqual(info['bytes_used'], 0) info = broker.get_info() - self.assertEquals(info['x_container_sync_point1'], -1) - self.assertEquals(info['x_container_sync_point2'], -1) + self.assertEqual(info['x_container_sync_point1'], -1) + self.assertEqual(info['x_container_sync_point2'], -1) def test_set_x_syncs(self): broker = ContainerBroker(':memory:', account='test1', @@ -659,13 +659,13 @@ class TestContainerBroker(unittest.TestCase): broker.initialize(Timestamp('1').internal, 0) info = broker.get_info() - self.assertEquals(info['x_container_sync_point1'], -1) - self.assertEquals(info['x_container_sync_point2'], -1) + self.assertEqual(info['x_container_sync_point1'], -1) + self.assertEqual(info['x_container_sync_point2'], -1) broker.set_x_container_sync_points(1, 2) info = broker.get_info() - self.assertEquals(info['x_container_sync_point1'], 1) - self.assertEquals(info['x_container_sync_point2'], 2) + self.assertEqual(info['x_container_sync_point1'], 1) + self.assertEqual(info['x_container_sync_point2'], 2) def test_get_report_info(self): broker = ContainerBroker(':memory:', account='test1', @@ -673,66 +673,66 @@ class TestContainerBroker(unittest.TestCase): broker.initialize(Timestamp('1').internal, 0) info = broker.get_info() - self.assertEquals(info['account'], 'test1') - self.assertEquals(info['container'], 'test2') - self.assertEquals(info['object_count'], 0) - self.assertEquals(info['bytes_used'], 0) - self.assertEquals(info['reported_object_count'], 0) - self.assertEquals(info['reported_bytes_used'], 0) + self.assertEqual(info['account'], 'test1') + self.assertEqual(info['container'], 'test2') + self.assertEqual(info['object_count'], 0) + self.assertEqual(info['bytes_used'], 0) + self.assertEqual(info['reported_object_count'], 0) + self.assertEqual(info['reported_bytes_used'], 0) broker.put_object('o1', Timestamp(time()).internal, 123, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 123) - self.assertEquals(info['reported_object_count'], 0) - self.assertEquals(info['reported_bytes_used'], 0) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 123) + self.assertEqual(info['reported_object_count'], 0) + self.assertEqual(info['reported_bytes_used'], 0) sleep(.00001) broker.put_object('o2', Timestamp(time()).internal, 123, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 2) - self.assertEquals(info['bytes_used'], 246) - self.assertEquals(info['reported_object_count'], 0) - self.assertEquals(info['reported_bytes_used'], 0) + self.assertEqual(info['object_count'], 2) + self.assertEqual(info['bytes_used'], 246) + self.assertEqual(info['reported_object_count'], 0) + self.assertEqual(info['reported_bytes_used'], 0) sleep(.00001) broker.put_object('o2', Timestamp(time()).internal, 1000, 'text/plain', '5af83e3196bf99f440f31f2e1a6c9afe') info = broker.get_info() - self.assertEquals(info['object_count'], 2) - self.assertEquals(info['bytes_used'], 1123) - self.assertEquals(info['reported_object_count'], 0) - self.assertEquals(info['reported_bytes_used'], 0) + self.assertEqual(info['object_count'], 2) + self.assertEqual(info['bytes_used'], 1123) + self.assertEqual(info['reported_object_count'], 0) + self.assertEqual(info['reported_bytes_used'], 0) put_timestamp = Timestamp(time()).internal sleep(.001) delete_timestamp = Timestamp(time()).internal broker.reported(put_timestamp, delete_timestamp, 2, 1123) info = broker.get_info() - self.assertEquals(info['object_count'], 2) - self.assertEquals(info['bytes_used'], 1123) - self.assertEquals(info['reported_put_timestamp'], put_timestamp) - self.assertEquals(info['reported_delete_timestamp'], delete_timestamp) - self.assertEquals(info['reported_object_count'], 2) - self.assertEquals(info['reported_bytes_used'], 1123) + self.assertEqual(info['object_count'], 2) + self.assertEqual(info['bytes_used'], 1123) + self.assertEqual(info['reported_put_timestamp'], put_timestamp) + self.assertEqual(info['reported_delete_timestamp'], delete_timestamp) + self.assertEqual(info['reported_object_count'], 2) + self.assertEqual(info['reported_bytes_used'], 1123) sleep(.00001) broker.delete_object('o1', Timestamp(time()).internal) info = broker.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 1000) - self.assertEquals(info['reported_object_count'], 2) - self.assertEquals(info['reported_bytes_used'], 1123) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 1000) + self.assertEqual(info['reported_object_count'], 2) + self.assertEqual(info['reported_bytes_used'], 1123) sleep(.00001) broker.delete_object('o2', Timestamp(time()).internal) info = broker.get_info() - self.assertEquals(info['object_count'], 0) - self.assertEquals(info['bytes_used'], 0) - self.assertEquals(info['reported_object_count'], 2) - self.assertEquals(info['reported_bytes_used'], 1123) + self.assertEqual(info['object_count'], 0) + self.assertEqual(info['bytes_used'], 0) + self.assertEqual(info['reported_object_count'], 2) + self.assertEqual(info['reported_bytes_used'], 1123) def test_list_objects_iter(self): # Test ContainerBroker.list_objects_iter @@ -754,103 +754,103 @@ class TestContainerBroker(unittest.TestCase): 'd41d8cd98f00b204e9800998ecf8427e') listing = broker.list_objects_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_objects_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_objects_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_objects_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_objects_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_objects_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') # Same as above, but using the path argument. listing = broker.list_objects_iter(10, '', None, 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_objects_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_objects_iter(10, '2', None, None, '/') - self.assertEquals(len(listing), 2) - self.assertEquals([row[0] for row in listing], ['2/', '3/']) + self.assertEqual(len(listing), 2) + self.assertEqual([row[0] for row in listing], ['2/', '3/']) listing = broker.list_objects_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_objects_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_objects_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_object('3/0049/', Timestamp(time()).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') listing = broker.list_objects_iter(10, '3/0048', None, None, None) - self.assertEquals(len(listing), 10) - self.assertEquals( + 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_objects_iter(10, '3/0048', None, '3/', '/') - self.assertEquals(len(listing), 10) - self.assertEquals( + 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_objects_iter(10, None, None, '3/0049/', '/') - self.assertEquals(len(listing), 2) - self.assertEquals( + self.assertEqual(len(listing), 2) + self.assertEqual( [row[0] for row in listing], ['3/0049/', '3/0049/0049']) listing = broker.list_objects_iter(10, None, None, None, None, '3/0049') - self.assertEquals(len(listing), 1) - self.assertEquals([row[0] for row in listing], ['3/0049/0049']) + self.assertEqual(len(listing), 1) + self.assertEqual([row[0] for row in listing], ['3/0049/0049']) listing = broker.list_objects_iter(2, None, None, '3/', '/') - self.assertEquals(len(listing), 2) - self.assertEquals([row[0] for row in listing], ['3/0000', '3/0000/']) + self.assertEqual(len(listing), 2) + self.assertEqual([row[0] for row in listing], ['3/0000', '3/0000/']) listing = broker.list_objects_iter(2, None, None, None, None, '3') - self.assertEquals(len(listing), 2) - self.assertEquals([row[0] for row in listing], ['3/0000', '3/0001']) + self.assertEqual(len(listing), 2) + self.assertEqual([row[0] for row in listing], ['3/0000', '3/0001']) def test_list_objects_iter_non_slash(self): # Test ContainerBroker.list_objects_iter using a @@ -873,87 +873,87 @@ class TestContainerBroker(unittest.TestCase): 'd41d8cd98f00b204e9800998ecf8427e') listing = broker.list_objects_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_objects_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_objects_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_objects_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_objects_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_objects_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') # Same as above, but using the path argument, so nothing should be # returned since path uses a '/' as a delimiter. listing = broker.list_objects_iter(10, '', None, None, '', '0') - self.assertEquals(len(listing), 0) + self.assertEqual(len(listing), 0) listing = broker.list_objects_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_objects_iter(10, '2', None, None, ':') - self.assertEquals(len(listing), 2) - self.assertEquals([row[0] for row in listing], ['2:', '3:']) + self.assertEqual(len(listing), 2) + self.assertEqual([row[0] for row in listing], ['2:', '3:']) listing = broker.list_objects_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_objects_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_objects_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_object('3:0049:', Timestamp(time()).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') listing = broker.list_objects_iter(10, '3:0048', None, None, None) - self.assertEquals(len(listing), 10) - self.assertEquals( + 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_objects_iter(10, '3:0048', None, '3:', ':') - self.assertEquals(len(listing), 10) - self.assertEquals( + 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_objects_iter(10, None, None, '3:0049:', ':') - self.assertEquals(len(listing), 2) - self.assertEquals( + self.assertEqual(len(listing), 2) + self.assertEqual( [row[0] for row in listing], ['3:0049:', '3:0049:0049']) @@ -961,14 +961,14 @@ class TestContainerBroker(unittest.TestCase): # returned since path uses a '/' as a delimiter. listing = broker.list_objects_iter(10, None, None, None, None, '3:0049') - self.assertEquals(len(listing), 0) + self.assertEqual(len(listing), 0) listing = broker.list_objects_iter(2, None, None, '3:', ':') - self.assertEquals(len(listing), 2) - self.assertEquals([row[0] for row in listing], ['3:0000', '3:0000:']) + self.assertEqual(len(listing), 2) + self.assertEqual([row[0] for row in listing], ['3:0000', '3:0000:']) listing = broker.list_objects_iter(2, None, None, None, None, '3') - self.assertEquals(len(listing), 0) + self.assertEqual(len(listing), 0) def test_list_objects_iter_prefix_delim(self): # Test ContainerBroker.list_objects_iter @@ -997,14 +997,14 @@ class TestContainerBroker(unittest.TestCase): # def list_objects_iter(self, limit, marker, prefix, delimiter, # path=None, format=None): listing = broker.list_objects_iter(100, None, None, '/pets/f', '/') - self.assertEquals([row[0] for row in listing], - ['/pets/fish/', '/pets/fish_info.txt']) + self.assertEqual([row[0] for row in listing], + ['/pets/fish/', '/pets/fish_info.txt']) listing = broker.list_objects_iter(100, None, None, '/pets/fish', '/') - self.assertEquals([row[0] for row in listing], - ['/pets/fish/', '/pets/fish_info.txt']) + self.assertEqual([row[0] for row in listing], + ['/pets/fish/', '/pets/fish_info.txt']) listing = broker.list_objects_iter(100, None, None, '/pets/fish/', '/') - self.assertEquals([row[0] for row in listing], - ['/pets/fish/a', '/pets/fish/b']) + self.assertEqual([row[0] for row in listing], + ['/pets/fish/a', '/pets/fish/b']) def test_double_check_trailing_delimiter(self): # Test ContainerBroker.list_objects_iter for a @@ -1056,35 +1056,35 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('1/0', Timestamp(time()).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') listing = broker.list_objects_iter(25, None, None, None, None) - self.assertEquals(len(listing), 22) - self.assertEquals( + self.assertEqual(len(listing), 22) + self.assertEqual( [row[0] for row in listing], ['0', '0/', '0/0', '0/00', '0/1', '0/1/', '0/1/0', '00', '1', '1/', '1/0', 'a', 'a/', 'a/0', 'a/a', 'a/a/a', 'a/a/b', 'a/b', 'b', 'b/a', 'b/b', 'c']) listing = broker.list_objects_iter(25, None, None, '', '/') - self.assertEquals(len(listing), 10) - self.assertEquals( + self.assertEqual(len(listing), 10) + self.assertEqual( [row[0] for row in listing], ['0', '0/', '00', '1', '1/', 'a', 'a/', 'b', 'b/', 'c']) listing = broker.list_objects_iter(25, None, None, 'a/', '/') - self.assertEquals(len(listing), 5) - self.assertEquals( + self.assertEqual(len(listing), 5) + self.assertEqual( [row[0] for row in listing], ['a/', 'a/0', 'a/a', 'a/a/', 'a/b']) listing = broker.list_objects_iter(25, None, None, '0/', '/') - self.assertEquals(len(listing), 5) - self.assertEquals( + self.assertEqual(len(listing), 5) + self.assertEqual( [row[0] for row in listing], ['0/', '0/0', '0/00', '0/1', '0/1/']) listing = broker.list_objects_iter(25, None, None, '0/1/', '/') - self.assertEquals(len(listing), 2) - self.assertEquals( + self.assertEqual(len(listing), 2) + self.assertEqual( [row[0] for row in listing], ['0/1/', '0/1/0']) listing = broker.list_objects_iter(25, 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_double_check_trailing_delimiter_non_slash(self): # Test ContainerBroker.list_objects_iter for a @@ -1136,35 +1136,35 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('1:0', Timestamp(time()).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') listing = broker.list_objects_iter(25, None, None, None, None) - self.assertEquals(len(listing), 22) - self.assertEquals( + self.assertEqual(len(listing), 22) + self.assertEqual( [row[0] for row in listing], ['0', '00', '0:', '0:0', '0:00', '0:1', '0:1:', '0:1:0', '1', '1:', '1:0', 'a', 'a:', 'a:0', 'a:a', 'a:a:a', 'a:a:b', 'a:b', 'b', 'b:a', 'b:b', 'c']) listing = broker.list_objects_iter(25, None, None, '', ':') - self.assertEquals(len(listing), 10) - self.assertEquals( + self.assertEqual(len(listing), 10) + self.assertEqual( [row[0] for row in listing], ['0', '00', '0:', '1', '1:', 'a', 'a:', 'b', 'b:', 'c']) listing = broker.list_objects_iter(25, None, None, 'a:', ':') - self.assertEquals(len(listing), 5) - self.assertEquals( + self.assertEqual(len(listing), 5) + self.assertEqual( [row[0] for row in listing], ['a:', 'a:0', 'a:a', 'a:a:', 'a:b']) listing = broker.list_objects_iter(25, None, None, '0:', ':') - self.assertEquals(len(listing), 5) - self.assertEquals( + self.assertEqual(len(listing), 5) + self.assertEqual( [row[0] for row in listing], ['0:', '0:0', '0:00', '0:1', '0:1:']) listing = broker.list_objects_iter(25, None, None, '0:1:', ':') - self.assertEquals(len(listing), 2) - self.assertEquals( + self.assertEqual(len(listing), 2) + self.assertEqual( [row[0] for row in listing], ['0:1:', '0:1:0']) listing = broker.list_objects_iter(25, 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 = ContainerBroker(':memory:', account='a', container='c') @@ -1177,13 +1177,13 @@ class TestContainerBroker(unittest.TestCase): hashb = hashlib.md5('%s-%s' % ('b', Timestamp(2).internal)).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_object('b', Timestamp(3).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') hashb = hashlib.md5('%s-%s' % ('b', Timestamp(3).internal)).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_newid(self): # test DatabaseBroker.newid @@ -1203,8 +1203,8 @@ class TestContainerBroker(unittest.TestCase): broker.put_object('b', Timestamp(2).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') items = broker.get_items_since(max_row, 1000) - self.assertEquals(len(items), 1) - self.assertEquals(items[0]['name'], 'b') + self.assertEqual(len(items), 1) + self.assertEqual(items[0]['name'], 'b') def test_sync_merging(self): # exercise the DatabaseBroker sync functions a bit @@ -1212,10 +1212,10 @@ class TestContainerBroker(unittest.TestCase): broker1.initialize(Timestamp('1').internal, 0) broker2 = ContainerBroker(':memory:', account='a', container='c') broker2.initialize(Timestamp('1').internal, 0) - self.assertEquals(broker2.get_sync('12345'), -1) + self.assertEqual(broker2.get_sync('12345'), -1) broker1.merge_syncs([{'sync_point': 3, 'remote_id': '12345'}]) broker2.merge_syncs(broker1.get_syncs()) - self.assertEquals(broker2.get_sync('12345'), 3) + self.assertEqual(broker2.get_sync('12345'), 3) def test_merge_items(self): broker1 = ContainerBroker(':memory:', account='a', container='c') @@ -1230,16 +1230,16 @@ class TestContainerBroker(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_object('c', Timestamp(3).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') 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 test_merge_items_overwrite_unicode(self): # test DatabaseBroker.merge_items @@ -1260,13 +1260,13 @@ class TestContainerBroker(unittest.TestCase): broker2.merge_items(json.loads(json.dumps(broker1.get_items_since( broker2.get_sync(id), 1000))), id) items = broker2.get_items_since(-1, 1000) - self.assertEquals(['b', snowman], - sorted([rec['name'] for rec in items])) + self.assertEqual(['b', snowman], + sorted([rec['name'] for rec in items])) for rec in items: if rec['name'] == snowman: - self.assertEquals(rec['created_at'], Timestamp(4).internal) + self.assertEqual(rec['created_at'], Timestamp(4).internal) if rec['name'] == 'b': - self.assertEquals(rec['created_at'], Timestamp(3).internal) + self.assertEqual(rec['created_at'], Timestamp(3).internal) def test_merge_items_overwrite(self): # test DatabaseBroker.merge_items @@ -1286,12 +1286,12 @@ class TestContainerBroker(unittest.TestCase): broker2.merge_items(broker1.get_items_since( broker2.get_sync(id), 1000), id) items = broker2.get_items_since(-1, 1000) - self.assertEquals(['a', 'b'], sorted([rec['name'] for rec in items])) + self.assertEqual(['a', 'b'], sorted([rec['name'] for rec in items])) for rec in items: if rec['name'] == 'a': - self.assertEquals(rec['created_at'], Timestamp(4).internal) + self.assertEqual(rec['created_at'], Timestamp(4).internal) if rec['name'] == 'b': - self.assertEquals(rec['created_at'], Timestamp(3).internal) + self.assertEqual(rec['created_at'], Timestamp(3).internal) def test_merge_items_post_overwrite_out_of_order(self): # test DatabaseBroker.merge_items @@ -1311,32 +1311,32 @@ class TestContainerBroker(unittest.TestCase): broker2.merge_items(broker1.get_items_since( broker2.get_sync(id), 1000), id) items = broker2.get_items_since(-1, 1000) - self.assertEquals(['a', 'b'], sorted([rec['name'] for rec in items])) + self.assertEqual(['a', 'b'], sorted([rec['name'] for rec in items])) for rec in items: if rec['name'] == 'a': - self.assertEquals(rec['created_at'], Timestamp(4).internal) + self.assertEqual(rec['created_at'], Timestamp(4).internal) if rec['name'] == 'b': - self.assertEquals(rec['created_at'], Timestamp(3).internal) - self.assertEquals(rec['content_type'], 'text/plain') + self.assertEqual(rec['created_at'], Timestamp(3).internal) + self.assertEqual(rec['content_type'], 'text/plain') items = broker2.get_items_since(-1, 1000) - self.assertEquals(['a', 'b'], sorted([rec['name'] for rec in items])) + self.assertEqual(['a', 'b'], sorted([rec['name'] for rec in items])) for rec in items: if rec['name'] == 'a': - self.assertEquals(rec['created_at'], Timestamp(4).internal) + self.assertEqual(rec['created_at'], Timestamp(4).internal) if rec['name'] == 'b': - self.assertEquals(rec['created_at'], Timestamp(3).internal) + self.assertEqual(rec['created_at'], Timestamp(3).internal) broker1.put_object('b', Timestamp(5).internal, 0, 'text/plain', 'd41d8cd98f00b204e9800998ecf8427e') broker2.merge_items(broker1.get_items_since( broker2.get_sync(id), 1000), id) items = broker2.get_items_since(-1, 1000) - self.assertEquals(['a', 'b'], sorted([rec['name'] for rec in items])) + self.assertEqual(['a', 'b'], sorted([rec['name'] for rec in items])) for rec in items: if rec['name'] == 'a': - self.assertEquals(rec['created_at'], Timestamp(4).internal) + self.assertEqual(rec['created_at'], Timestamp(4).internal) if rec['name'] == 'b': - self.assertEquals(rec['created_at'], Timestamp(5).internal) - self.assertEquals(rec['content_type'], 'text/plain') + self.assertEqual(rec['created_at'], Timestamp(5).internal) + self.assertEqual(rec['content_type'], 'text/plain') def test_set_storage_policy_index(self): ts = (Timestamp(t).internal for t in @@ -1407,9 +1407,9 @@ class TestContainerBroker(unittest.TestCase): broker = ContainerBroker(':memory:', account='test_account', container='test_container') broker.initialize(Timestamp('1').internal, 0) - self.assertEquals(-1, broker.get_reconciler_sync()) + self.assertEqual(-1, broker.get_reconciler_sync()) broker.update_reconciler_sync(10) - self.assertEquals(10, broker.get_reconciler_sync()) + self.assertEqual(10, broker.get_reconciler_sync()) @with_tempdir def test_legacy_pending_files(self, tempdir): diff --git a/test/unit/container/test_server.py b/test/unit/container/test_server.py index e500fdd9ed..820bdebcc0 100644 --- a/test/unit/container/test_server.py +++ b/test/unit/container/test_server.py @@ -142,9 +142,9 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', environ={'REQUEST_METHOD': 'HEAD'}) response = req.get_response(self.controller) self.assertTrue(response.status.startswith('204')) - self.assertEquals(response.headers.get('x-container-read'), '.r:*') - self.assertEquals(response.headers.get('x-container-write'), - 'account:user') + self.assertEqual(response.headers.get('x-container-read'), '.r:*') + self.assertEqual(response.headers.get('x-container-write'), + 'account:user') # Ensure we can clear acls on POST req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, @@ -168,9 +168,9 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c2', environ={'REQUEST_METHOD': 'HEAD'}) response = req.get_response(self.controller) self.assertTrue(response.status.startswith('204')) - self.assertEquals(response.headers.get('x-container-read'), '.r:*') - self.assertEquals(response.headers.get('x-container-write'), - 'account:user') + self.assertEqual(response.headers.get('x-container-read'), '.r:*') + self.assertEqual(response.headers.get('x-container-write'), + 'account:user') def test_HEAD(self): start = int(time.time()) @@ -277,7 +277,7 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/./a/c', 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_insufficient_storage(self): self.controller = container_server.ContainerController( @@ -286,14 +286,14 @@ class TestContainerController(unittest.TestCase): '/sda-null/p/a/c', 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_content_type(self): req = Request.blank( '/sda1/p/a/c', 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_invalid_format(self): format = '%D1%BD%8A9' # invalid UTF-8; should be %E1%BD%8A9 (E -> D) @@ -301,7 +301,7 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c?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_OPTIONS(self): server_handler = container_server.ContainerController( @@ -309,25 +309,25 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c/o', {'REQUEST_METHOD': 'OPTIONS'}) req.content_length = 0 resp = server_handler.OPTIONS(req) - self.assertEquals(200, resp.status_int) + self.assertEqual(200, resp.status_int) for verb in 'OPTIONS GET POST PUT DELETE HEAD REPLICATE'.split(): self.assertTrue( verb in resp.headers['Allow'].split(', ')) - self.assertEquals(len(resp.headers['Allow'].split(', ')), 7) - self.assertEquals(resp.headers['Server'], - (self.controller.server_type + '/' + swift_version)) + self.assertEqual(len(resp.headers['Allow'].split(', ')), 7) + self.assertEqual(resp.headers['Server'], + (self.controller.server_type + '/' + swift_version)) def test_PUT(self): req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT', 'HTTP_X_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/c', environ={'REQUEST_METHOD': 'PUT', 'HTTP_X_TIMESTAMP': '2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 202) + self.assertEqual(resp.status_int, 202) def test_PUT_simulated_create_race(self): state = ['initial'] @@ -376,7 +376,7 @@ class TestContainerController(unittest.TestCase): headers={'X-Timestamp': '1', 'X-Size': '0', 'X-Content-Type': 'text/plain', 'X-ETag': 'e'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_PUT_good_policy_specified(self): policy = random.choice(list(POLICIES)) @@ -386,30 +386,30 @@ class TestContainerController(unittest.TestCase): 'X-Backend-Storage-Policy-Index': policy.idx}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.status_int, 201) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) # now make sure we read it back req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) def test_PUT_no_policy_specified(self): # Set metadata header req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(1).internal}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(POLICIES.default.idx)) + self.assertEqual(resp.status_int, 201) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(POLICIES.default.idx)) # now make sure the default was used (pol 1) req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(POLICIES.default.idx)) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(POLICIES.default.idx)) def test_PUT_bad_policy_specified(self): # Set metadata header @@ -418,7 +418,7 @@ class TestContainerController(unittest.TestCase): 'X-Backend-Storage-Policy-Index': 'nada'}) resp = req.get_response(self.controller) # make sure we get bad response - self.assertEquals(resp.status_int, 400) + self.assertEqual(resp.status_int, 400) self.assertFalse('X-Backend-Storage-Policy-Index' in resp.headers) def test_PUT_no_policy_change(self): @@ -429,13 +429,13 @@ class TestContainerController(unittest.TestCase): 'X-Timestamp': next(ts), 'X-Backend-Storage-Policy-Index': policy.idx}) 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') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # make sure we get the right index back - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) # now try to update w/o changing the policy for method in ('POST', 'PUT'): @@ -444,13 +444,13 @@ class TestContainerController(unittest.TestCase): 'X-Backend-Storage-Policy-Index': policy.idx }) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int // 100, 2) + self.assertEqual(resp.status_int // 100, 2) # make sure we get the right index back req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) def test_PUT_bad_policy_change(self): ts = (Timestamp(t).internal for t in itertools.count(time.time())) @@ -460,13 +460,13 @@ class TestContainerController(unittest.TestCase): 'X-Timestamp': next(ts), 'X-Backend-Storage-Policy-Index': policy.idx}) 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') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # make sure we get the right index back - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) other_policies = [p for p in POLICIES if p != policy] for other_policy in other_policies: @@ -476,18 +476,18 @@ class TestContainerController(unittest.TestCase): 'X-Backend-Storage-Policy-Index': other_policy.idx }) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 409) - self.assertEquals( + self.assertEqual(resp.status_int, 409) + self.assertEqual( resp.headers.get('X-Backend-Storage-Policy-Index'), str(policy.idx)) # and make sure there is no change! req = Request.blank('/sda1/p/a/c') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # make sure we get the right index back - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) def test_POST_ignores_policy_change(self): ts = (Timestamp(t).internal for t in itertools.count(time.time())) @@ -496,13 +496,13 @@ class TestContainerController(unittest.TestCase): 'X-Timestamp': next(ts), 'X-Backend-Storage-Policy-Index': policy.idx}) 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') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # make sure we get the right index back - self.assertEquals(resp.headers.get('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.headers.get('X-Backend-Storage-Policy-Index'), + str(policy.idx)) other_policies = [p for p in POLICIES if p != policy] for other_policy in other_policies: @@ -513,16 +513,16 @@ class TestContainerController(unittest.TestCase): }) resp = req.get_response(self.controller) # valid request - self.assertEquals(resp.status_int // 100, 2) + self.assertEqual(resp.status_int // 100, 2) # but it does nothing req = Request.blank('/sda1/p/a/c') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # make sure we get the right index back - self.assertEquals(resp.headers.get - ('X-Backend-Storage-Policy-Index'), - str(policy.idx)) + self.assertEqual(resp.headers.get + ('X-Backend-Storage-Policy-Index'), + str(policy.idx)) def test_PUT_no_policy_for_existing_default(self): ts = (Timestamp(t).internal for t in @@ -631,57 +631,57 @@ class TestContainerController(unittest.TestCase): headers={'X-Timestamp': Timestamp(1).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), 'Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), 'Value') # Set another metadata header, ensuring old one doesn't disappear req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(1).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), 'Value') - self.assertEquals(resp.headers.get('x-container-meta-test2'), 'Value2') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), 'Value') + self.assertEqual(resp.headers.get('x-container-meta-test2'), 'Value2') # Update metadata header req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(3).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), + 'New Value') # Send old update to metadata header req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(2).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), + 'New Value') # Remove metadata header (by setting it to empty) req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(4).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) self.assertTrue('x-container-meta-test' not in resp.headers) def test_PUT_GET_sys_metadata(self): @@ -693,60 +693,60 @@ class TestContainerController(unittest.TestCase): headers={'X-Timestamp': Timestamp(1).internal, key: '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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), 'Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), 'Value') # Set another metadata header, ensuring old one doesn't disappear req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(1).internal, key2: '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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), 'Value') - self.assertEquals(resp.headers.get(key2.lower()), 'Value2') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), 'Value') + self.assertEqual(resp.headers.get(key2.lower()), 'Value2') # Update metadata header req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(3).internal, key: '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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), + 'New Value') # Send old update to metadata header req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(2).internal, key: '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/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), + 'New Value') # Remove metadata header (by setting it to empty) req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(4).internal, key: ''}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 202) + self.assertEqual(resp.status_int, 202) req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) self.assertTrue(key.lower() not in resp.headers) def test_PUT_invalid_partition(self): req = Request.blank('/sda1/./a/c', 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_timestamp_not_float(self): req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT', @@ -755,7 +755,7 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, 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_PUT_insufficient_storage(self): self.controller = container_server.ContainerController( @@ -764,59 +764,59 @@ class TestContainerController(unittest.TestCase): '/sda-null/p/a/c', 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/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(1).internal}) 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/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(1).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), 'Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), 'Value') # Update metadata header req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(3).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), + 'New Value') # Send old update to metadata header req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(2).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get('x-container-meta-test'), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get('x-container-meta-test'), + 'New Value') # Remove metadata header (by setting it to empty) req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(4).internal, 'X-Container-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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) self.assertTrue('x-container-meta-test' not in resp.headers) def test_POST_HEAD_sys_metadata(self): @@ -825,55 +825,55 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-Timestamp': Timestamp(1).internal}) 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/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(1).internal, key: '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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), 'Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), 'Value') # Update metadata header req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(3).internal, key: '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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), + 'New Value') # Send old update to metadata header req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(2).internal, key: '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/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) - self.assertEquals(resp.headers.get(key.lower()), - 'New Value') + self.assertEqual(resp.status_int, 204) + self.assertEqual(resp.headers.get(key.lower()), + 'New Value') # Remove metadata header (by setting it to empty) req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': Timestamp(4).internal, key: ''}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) self.assertTrue(key.lower() not in resp.headers) def test_POST_invalid_partition(self): req = Request.blank('/sda1/./a/c', 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/c', environ={'REQUEST_METHOD': 'PUT', @@ -882,7 +882,7 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, 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 = container_server.ContainerController( @@ -891,7 +891,7 @@ class TestContainerController(unittest.TestCase): '/sda-null/p/a/c', 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_invalid_container_sync_to(self): self.controller = container_server.ContainerController( @@ -901,7 +901,7 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_TIMESTAMP': '1'}, headers={'x-container-sync-to': '192.168.0.1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 400) + self.assertEqual(resp.status_int, 400) def test_POST_after_DELETE_not_found(self): req = Request.blank('/sda1/p/a/c', @@ -916,7 +916,7 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'POST'}, headers={'X-Timestamp': '3'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_DELETE_obj_not_found(self): req = Request.blank( @@ -924,17 +924,17 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'DELETE'}, headers={'X-Timestamp': '1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_DELETE_container_not_found(self): req = Request.blank('/sda1/p/a/c', 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/c', environ={'REQUEST_METHOD': 'DELETE', 'HTTP_X_TIMESTAMP': '1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_PUT_utf8(self): snowman = u'\u2603' @@ -944,7 +944,7 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'PUT', 'HTTP_X_TIMESTAMP': '1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) def test_account_update_mismatched_host_device(self): req = Request.blank( @@ -957,7 +957,7 @@ class TestContainerController(unittest.TestCase): 'X-Account-Device': 'sda1,sda2'}) broker = self.controller._get_container_broker('sda1', 'p', 'a', 'c') resp = self.controller.account_update(req, 'a', 'c', broker) - self.assertEquals(resp.status_int, 400) + self.assertEqual(resp.status_int, 400) def test_account_update_account_override_deleted(self): bindsock = listen(('127.0.0.1', 0)) @@ -975,7 +975,7 @@ class TestContainerController(unittest.TestCase): new_connect = fake_http_connect(200, count=123) swift.container.server.http_connect = new_connect resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) def test_PUT_account_update(self): bindsock = listen(('127.0.0.1', 0)) @@ -989,16 +989,16 @@ class TestContainerController(unittest.TestCase): out.write('HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n' % return_code) out.flush() - self.assertEquals(inc.readline(), - 'PUT /sda1/123/a/c HTTP/1.1\r\n') + self.assertEqual(inc.readline(), + 'PUT /sda1/123/a/c HTTP/1.1\r\n') headers = {} line = inc.readline() while line and line != '\r\n': headers[line.split(':')[0].lower()] = \ line.split(':')[1].strip() line = inc.readline() - self.assertEquals(headers['x-put-timestamp'], - expected_timestamp) + self.assertEqual(headers['x-put-timestamp'], + expected_timestamp) except BaseException as err: return err return None @@ -1014,7 +1014,7 @@ class TestContainerController(unittest.TestCase): try: with Timeout(3): resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) finally: err = event.wait() if err: @@ -1024,7 +1024,7 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'DELETE'}, headers={'X-Timestamp': '2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, @@ -1036,7 +1036,7 @@ class TestContainerController(unittest.TestCase): try: with Timeout(3): resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) finally: err = event.wait() if err: @@ -1067,37 +1067,37 @@ class TestContainerController(unittest.TestCase): headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], -1) - self.assertEquals(info['x_container_sync_point2'], -1) + self.assertEqual(info['x_container_sync_point1'], -1) + self.assertEqual(info['x_container_sync_point2'], -1) db.set_x_container_sync_points(123, 456) info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], 123) - self.assertEquals(info['x_container_sync_point2'], 456) + self.assertEqual(info['x_container_sync_point1'], 123) + self.assertEqual(info['x_container_sync_point2'], 456) # Set to same value req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 202) + self.assertEqual(resp.status_int, 202) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], 123) - self.assertEquals(info['x_container_sync_point2'], 456) + self.assertEqual(info['x_container_sync_point1'], 123) + self.assertEqual(info['x_container_sync_point2'], 456) # Set to new value req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 202) + self.assertEqual(resp.status_int, 202) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], -1) - self.assertEquals(info['x_container_sync_point2'], -1) + self.assertEqual(info['x_container_sync_point1'], -1) + self.assertEqual(info['x_container_sync_point2'], -1) def test_POST_reset_container_sync(self): req = Request.blank( @@ -1105,68 +1105,68 @@ class TestContainerController(unittest.TestCase): headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], -1) - self.assertEquals(info['x_container_sync_point2'], -1) + self.assertEqual(info['x_container_sync_point1'], -1) + self.assertEqual(info['x_container_sync_point2'], -1) db.set_x_container_sync_points(123, 456) info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], 123) - self.assertEquals(info['x_container_sync_point2'], 456) + self.assertEqual(info['x_container_sync_point1'], 123) + self.assertEqual(info['x_container_sync_point2'], 456) # Set to same value req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], 123) - self.assertEquals(info['x_container_sync_point2'], 456) + self.assertEqual(info['x_container_sync_point1'], 123) + self.assertEqual(info['x_container_sync_point2'], 456) # Set to new value req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'POST'}, headers={'x-timestamp': '1', 'x-container-sync-to': 'http://127.0.0.1:12345/v1/a/c2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') info = db.get_info() - self.assertEquals(info['x_container_sync_point1'], -1) - self.assertEquals(info['x_container_sync_point2'], -1) + self.assertEqual(info['x_container_sync_point1'], -1) + self.assertEqual(info['x_container_sync_point2'], -1) def test_DELETE(self): req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-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/c', environ={'REQUEST_METHOD': 'DELETE'}, headers={'X-Timestamp': '2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank( '/sda1/p/a/c', environ={'REQUEST_METHOD': 'GET'}, headers={'X-Timestamp': '3'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_DELETE_PUT_recreate(self): path = '/sda1/p/a/c' req = Request.blank(path, method='PUT', headers={'X-Timestamp': '1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) req = Request.blank(path, method='DELETE', headers={'X-Timestamp': '2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank(path, method='GET') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) # sanity + self.assertEqual(resp.status_int, 404) # sanity # backend headers expectations = { 'x-backend-put-timestamp': Timestamp(1).internal, @@ -1180,20 +1180,20 @@ class TestContainerController(unittest.TestCase): db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') self.assertEqual(True, db.is_deleted()) info = db.get_info() - self.assertEquals(info['put_timestamp'], Timestamp('1').internal) - self.assertEquals(info['delete_timestamp'], Timestamp('2').internal) - self.assertEquals(info['status_changed_at'], Timestamp('2').internal) + self.assertEqual(info['put_timestamp'], Timestamp('1').internal) + self.assertEqual(info['delete_timestamp'], Timestamp('2').internal) + self.assertEqual(info['status_changed_at'], Timestamp('2').internal) # recreate req = Request.blank(path, method='PUT', headers={'X-Timestamp': '4'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') self.assertEqual(False, db.is_deleted()) info = db.get_info() - self.assertEquals(info['put_timestamp'], Timestamp('4').internal) - self.assertEquals(info['delete_timestamp'], Timestamp('2').internal) - self.assertEquals(info['status_changed_at'], Timestamp('4').internal) + self.assertEqual(info['put_timestamp'], Timestamp('4').internal) + self.assertEqual(info['delete_timestamp'], Timestamp('2').internal) + self.assertEqual(info['status_changed_at'], Timestamp('4').internal) for method in ('GET', 'HEAD'): req = Request.blank(path) resp = req.get_response(self.controller) @@ -1214,15 +1214,15 @@ class TestContainerController(unittest.TestCase): req = Request.blank(path, method='PUT', headers={'X-Timestamp': '1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') req = Request.blank(path, method='DELETE', headers={'X-Timestamp': '2'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank(path, method='GET') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) # sanity + self.assertEqual(resp.status_int, 404) # sanity self.assertEqual(True, db.is_deleted()) # now save a copy of this db (and remove it from the "current node") db = self.controller._get_container_broker('sda1', 'p', 'a', 'c') @@ -1232,7 +1232,7 @@ class TestContainerController(unittest.TestCase): # that should make it missing on this node req = Request.blank(path, method='GET') resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) # sanity + self.assertEqual(resp.status_int, 404) # sanity # setup the race in os.path.exists (first time no, then yes) mock_called = [] @@ -1261,8 +1261,8 @@ class TestContainerController(unittest.TestCase): [(exists, db.db_file) for exists in (False, True)]) # info was updated info = db.get_info() - self.assertEquals(info['put_timestamp'], Timestamp('4').internal) - self.assertEquals(info['delete_timestamp'], Timestamp('2').internal) + self.assertEqual(info['put_timestamp'], Timestamp('4').internal) + self.assertEqual(info['delete_timestamp'], Timestamp('2').internal) def test_DELETE_not_found(self): # Even if the container wasn't previously heard of, the container @@ -1272,7 +1272,7 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', environ={'REQUEST_METHOD': 'DELETE', 'HTTP_X_TIMESTAMP': '1'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_change_storage_policy_via_DELETE_then_PUT(self): ts = (Timestamp(t).internal for t in @@ -1344,33 +1344,33 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', method='PUT', headers={ 'X-Timestamp': Timestamp(2).internal}) 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/o', method='PUT', headers={ 'X-Timestamp': Timestamp(0).internal, 'X-Size': 1, 'X-Content-Type': 'text/plain', 'X-Etag': 'x'}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) ts = (Timestamp(t).internal for t in itertools.count(3)) req = Request.blank('/sda1/p/a/c', method='DELETE', headers={ 'X-Timestamp': next(ts)}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 409) + self.assertEqual(resp.status_int, 409) req = Request.blank('/sda1/p/a/c/o', method='DELETE', headers={ 'X-Timestamp': next(ts)}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank('/sda1/p/a/c', method='DELETE', headers={ 'X-Timestamp': next(ts)}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank('/sda1/p/a/c', method='GET', headers={ 'X-Timestamp': next(ts)}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) def test_object_update_with_offset(self): ts = (Timestamp(t).internal for t in @@ -1394,7 +1394,7 @@ class TestContainerController(unittest.TestCase): 'X-Content-Type': 'text/plain', 'X-Etag': 'x'}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # check listing req = Request.blank('/sda1/p/a/c', method='GET', query_string='format=json') @@ -1417,7 +1417,7 @@ class TestContainerController(unittest.TestCase): 'X-Content-Type': 'text/html', 'X-Etag': 'y'}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # check updated listing req = Request.blank('/sda1/p/a/c', method='GET', query_string='format=json') @@ -1439,7 +1439,7 @@ class TestContainerController(unittest.TestCase): 'X-Timestamp': delete_timestamp}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # check empty listing req = Request.blank('/sda1/p/a/c', method='GET', query_string='format=json') @@ -1457,7 +1457,7 @@ class TestContainerController(unittest.TestCase): 'X-Content-Type': 'text/enriched', 'X-Etag': 'z'}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # check un-deleted listing req = Request.blank('/sda1/p/a/c', method='GET', query_string='format=json') @@ -1479,7 +1479,7 @@ class TestContainerController(unittest.TestCase): 'X-Timestamp': delete_timestamp}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # check empty listing req = Request.blank('/sda1/p/a/c', method='GET', query_string='format=json') @@ -1502,16 +1502,16 @@ class TestContainerController(unittest.TestCase): out.write('HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n' % return_code) out.flush() - self.assertEquals(inc.readline(), - 'PUT /sda1/123/a/c HTTP/1.1\r\n') + self.assertEqual(inc.readline(), + 'PUT /sda1/123/a/c HTTP/1.1\r\n') headers = {} line = inc.readline() while line and line != '\r\n': headers[line.split(':')[0].lower()] = \ line.split(':')[1].strip() line = inc.readline() - self.assertEquals(headers['x-delete-timestamp'], - expected_timestamp) + self.assertEqual(headers['x-delete-timestamp'], + expected_timestamp) except BaseException as err: return err return None @@ -1520,7 +1520,7 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', environ={'REQUEST_METHOD': 'PUT'}, headers={'X-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/c', environ={'REQUEST_METHOD': 'DELETE'}, @@ -1532,7 +1532,7 @@ class TestContainerController(unittest.TestCase): try: with Timeout(3): resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) finally: err = event.wait() if err: @@ -1541,7 +1541,7 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', method='PUT', headers={ 'X-Timestamp': Timestamp(2).internal}) 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': 'DELETE'}, @@ -1553,7 +1553,7 @@ class TestContainerController(unittest.TestCase): try: with Timeout(3): resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 404) + self.assertEqual(resp.status_int, 404) finally: err = event.wait() if err: @@ -1562,7 +1562,7 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', method='PUT', headers={ 'X-Timestamp': Timestamp(4).internal}) 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': 'DELETE'}, @@ -1588,7 +1588,7 @@ class TestContainerController(unittest.TestCase): '/sda1/./a/c', 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( @@ -1599,7 +1599,7 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/c', 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 = container_server.ContainerController( @@ -1608,7 +1608,7 @@ class TestContainerController(unittest.TestCase): '/sda-null/p/a/c', 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_GET_over_limit(self): req = Request.blank( @@ -1616,7 +1616,7 @@ class TestContainerController(unittest.TestCase): (constraints.CONTAINER_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_json(self): # make a container @@ -1629,8 +1629,8 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/jsonc?format=json', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 200) - self.assertEquals(simplejson.loads(resp.body), []) + self.assertEqual(resp.status_int, 200) + self.assertEqual(simplejson.loads(resp.body), []) # fill the container for i in range(3): req = Request.blank( @@ -1642,7 +1642,7 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # test format json_body = [{"name": "0", "hash": "x", @@ -1664,15 +1664,15 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/jsonc?format=json', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'application/json') - self.assertEquals(simplejson.loads(resp.body), json_body) - self.assertEquals(resp.charset, 'utf-8') + self.assertEqual(resp.content_type, 'application/json') + self.assertEqual(simplejson.loads(resp.body), json_body) + self.assertEqual(resp.charset, 'utf-8') req = Request.blank( '/sda1/p/a/jsonc?format=json', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'application/json') + self.assertEqual(resp.content_type, 'application/json') for accept in ('application/json', 'application/json;q=1.0,*/*;q=0.9', '*/*;q=0.9,application/json;q=1.0', 'application/*'): @@ -1681,10 +1681,10 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'GET'}) req.accept = accept resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( simplejson.loads(resp.body), json_body, 'Invalid body for Accept: %s' % accept) - self.assertEquals( + self.assertEqual( resp.content_type, 'application/json', 'Invalid content_type for Accept: %s' % accept) @@ -1693,7 +1693,7 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'HEAD'}) req.accept = accept resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( resp.content_type, 'application/json', 'Invalid content_type for Accept: %s' % accept) @@ -1707,7 +1707,7 @@ class TestContainerController(unittest.TestCase): req = Request.blank( '/sda1/p/a/plainc', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) # fill the container for i in range(3): req = Request.blank( @@ -1719,20 +1719,20 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) plain_body = '0\n1\n2\n' req = Request.blank('/sda1/p/a/plainc', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'text/plain') - self.assertEquals(resp.body, plain_body) - self.assertEquals(resp.charset, 'utf-8') + self.assertEqual(resp.content_type, 'text/plain') + self.assertEqual(resp.body, plain_body) + self.assertEqual(resp.charset, 'utf-8') req = Request.blank('/sda1/p/a/plainc', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'text/plain') + self.assertEqual(resp.content_type, 'text/plain') for accept in ('', 'text/plain', 'application/xml;q=0.8,*/*;q=0.9', '*/*;q=0.9,application/xml;q=0.8', '*/*', @@ -1742,10 +1742,10 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'GET'}) req.accept = accept resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( resp.body, plain_body, 'Invalid body for Accept: %s' % accept) - self.assertEquals( + self.assertEqual( resp.content_type, 'text/plain', 'Invalid content_type for Accept: %s' % accept) @@ -1754,7 +1754,7 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'GET'}) req.accept = accept resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( resp.content_type, 'text/plain', 'Invalid content_type for Accept: %s' % accept) @@ -1764,17 +1764,17 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'GET'}) req.accept = 'application/json' resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'text/plain') - self.assertEquals(resp.body, plain_body) + self.assertEqual(resp.content_type, 'text/plain') + self.assertEqual(resp.body, plain_body) # test unknown format uses default plain req = Request.blank( '/sda1/p/a/plainc?format=somethingelse', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 200) - self.assertEquals(resp.content_type, 'text/plain') - self.assertEquals(resp.body, plain_body) + self.assertEqual(resp.status_int, 200) + self.assertEqual(resp.content_type, 'text/plain') + self.assertEqual(resp.body, plain_body) def test_GET_json_last_modified(self): # make a container @@ -1793,7 +1793,7 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # test format # last_modified format must be uniform, even when there are not msecs json_body = [{"name": "0", @@ -1811,9 +1811,9 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/jsonc?format=json', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'application/json') - self.assertEquals(simplejson.loads(resp.body), json_body) - self.assertEquals(resp.charset, 'utf-8') + self.assertEqual(resp.content_type, 'application/json') + self.assertEqual(simplejson.loads(resp.body), json_body) + self.assertEqual(resp.charset, 'utf-8') def test_GET_xml(self): # make a container @@ -1833,7 +1833,7 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) xml_body = '\n' \ '' \ '0x0' \ @@ -1855,15 +1855,15 @@ class TestContainerController(unittest.TestCase): '/sda1/p/a/xmlc?format=xml', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'application/xml') - self.assertEquals(resp.body, xml_body) - self.assertEquals(resp.charset, 'utf-8') + self.assertEqual(resp.content_type, 'application/xml') + self.assertEqual(resp.body, xml_body) + self.assertEqual(resp.charset, 'utf-8') req = Request.blank( '/sda1/p/a/xmlc?format=xml', environ={'REQUEST_METHOD': 'HEAD'}) resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'application/xml') + self.assertEqual(resp.content_type, 'application/xml') for xml_accept in ( 'application/xml', 'application/xml;q=1.0,*/*;q=0.9', @@ -1873,10 +1873,10 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'GET'}) req.accept = xml_accept resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( resp.body, xml_body, 'Invalid body for Accept: %s' % xml_accept) - self.assertEquals( + self.assertEqual( resp.content_type, 'application/xml', 'Invalid content_type for Accept: %s' % xml_accept) @@ -1885,7 +1885,7 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'HEAD'}) req.accept = xml_accept resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( resp.content_type, 'application/xml', 'Invalid content_type for Accept: %s' % xml_accept) @@ -1894,8 +1894,8 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'GET'}) req.accept = 'text/xml' resp = req.get_response(self.controller) - self.assertEquals(resp.content_type, 'text/xml') - self.assertEquals(resp.body, xml_body) + self.assertEqual(resp.content_type, 'text/xml') + self.assertEqual(resp.body, xml_body) def test_GET_marker(self): # make a container @@ -1913,13 +1913,13 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_ETAG': 'x', 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # test limit with marker req = Request.blank('/sda1/p/a/c?limit=2&marker=1', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) result = resp.body.split() - self.assertEquals(result, ['2', ]) + self.assertEqual(result, ['2', ]) def test_weird_content_types(self): snowman = u'\u2603' @@ -1936,12 +1936,12 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_ETAG': 'x', 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) 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?format=json', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) result = [x['content_type'] for x in simplejson.loads(resp.body)] - self.assertEquals(result, [u'\u2603', 'text/plain;charset="utf-8"']) + self.assertEqual(result, [u'\u2603', 'text/plain;charset="utf-8"']) def test_GET_accept_not_valid(self): req = Request.blank('/sda1/p/a/c', method='PUT', headers={ @@ -1951,7 +1951,7 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c', 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_limit(self): # make a container @@ -1971,13 +1971,13 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 201) + self.assertEqual(resp.status_int, 201) # test limit req = Request.blank( '/sda1/p/a/c?limit=2', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) result = resp.body.split() - self.assertEquals(result, ['0', '1']) + self.assertEqual(result, ['0', '1']) def test_GET_prefix(self): req = Request.blank( @@ -1995,18 +1995,18 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) 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?prefix=a', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals(resp.body.split(), ['a1', 'a2', 'a3']) + self.assertEqual(resp.body.split(), ['a1', 'a2', 'a3']) def test_GET_delimiter_too_long(self): req = Request.blank('/sda1/p/a/c?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_delimiter(self): req = Request.blank( @@ -2022,12 +2022,12 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) 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?prefix=US-&delimiter=-&format=json', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( simplejson.loads(resp.body), [{"subdir": "US-OK-"}, {"subdir": "US-TX-"}, @@ -2047,12 +2047,12 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) 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?prefix=US-&delimiter=-&format=xml', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( resp.body, '' '\n' 'US-OK-' @@ -2072,7 +2072,7 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) 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?delimiter=/&format=xml', environ={'REQUEST_METHOD': 'GET'}) @@ -2082,12 +2082,12 @@ class TestContainerController(unittest.TestCase): container = dom.getElementsByTagName('container')[0] self.assertTrue(len(container.getElementsByTagName('subdir')) == 1) subdir = container.getElementsByTagName('subdir')[0] - self.assertEquals(unicode(subdir.attributes['name'].value), - u'<\'sub\' "dir">/') + self.assertEqual(unicode(subdir.attributes['name'].value), + u'<\'sub\' "dir">/') self.assertTrue(len(subdir.getElementsByTagName('name')) == 1) name = subdir.getElementsByTagName('name')[0] - self.assertEquals(unicode(name.childNodes[0].data), - u'<\'sub\' "dir">/') + self.assertEqual(unicode(name.childNodes[0].data), + u'<\'sub\' "dir">/') def test_GET_path(self): req = Request.blank( @@ -2103,12 +2103,12 @@ class TestContainerController(unittest.TestCase): 'HTTP_X_SIZE': 0}) self._update_object_put_headers(req) 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?path=US&format=json', environ={'REQUEST_METHOD': 'GET'}) resp = req.get_response(self.controller) - self.assertEquals( + self.assertEqual( simplejson.loads(resp.body), [{"name": "US/OK", "hash": "x", "bytes": 0, "content_type": "text/plain", @@ -2124,7 +2124,7 @@ class TestContainerController(unittest.TestCase): '/sda-null/p/a/c', 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 = BytesIO() @@ -2149,8 +2149,8 @@ class TestContainerController(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 = BytesIO() @@ -2175,8 +2175,8 @@ class TestContainerController(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 = BytesIO() @@ -2201,8 +2201,8 @@ class TestContainerController(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() @@ -2214,8 +2214,8 @@ class TestContainerController(unittest.TestCase): self.controller.__call__({'REQUEST_METHOD': 'method_doesnt_exist', 'PATH_INFO': '/sda1/p/a/c'}, 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() @@ -2227,8 +2227,8 @@ class TestContainerController(unittest.TestCase): self.controller.__call__({'REQUEST_METHOD': '__init__', 'PATH_INFO': '/sda1/p/a/c'}, 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): req = Request.blank( @@ -2239,7 +2239,7 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c?format=%s' % format, 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 @@ -2248,14 +2248,14 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c?%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/c?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)) req = Request.blank('/sda1/p/a/c', method='PUT', headers={'X-Timestamp': Timestamp(1).internal}) req.get_response(self.controller) @@ -2265,8 +2265,8 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/c?%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-timestamp': Timestamp(1).internal, @@ -2278,25 +2278,25 @@ class TestContainerController(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/o', 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/o', 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/.o', 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_delete_auto_create(self): headers = {'x-timestamp': Timestamp(1).internal} @@ -2305,25 +2305,25 @@ class TestContainerController(unittest.TestCase): environ={'REQUEST_METHOD': 'DELETE'}, 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/o', environ={'REQUEST_METHOD': 'DELETE'}, headers=dict(headers)) resp = req.get_response(self.controller) - self.assertEquals(resp.status_int, 204) + self.assertEqual(resp.status_int, 204) req = Request.blank('/sda1/p/a/.c/o', environ={'REQUEST_METHOD': 'DELETE'}, 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/.o', environ={'REQUEST_METHOD': 'DELETE'}, 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/o', @@ -2335,30 +2335,30 @@ class TestContainerController(unittest.TestCase): req = Request.blank('/sda1/p/a/o?format=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') req = Request.blank('/sda1/p/a/o?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/o', 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/o', 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/o', 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_updating_multiple_container_servers(self): http_connect_args = [] @@ -2403,8 +2403,8 @@ class TestContainerController(unittest.TestCase): http_connect_args.sort(key=operator.itemgetter('ipaddr')) - self.assertEquals(len(http_connect_args), 2) - self.assertEquals( + self.assertEqual(len(http_connect_args), 2) + self.assertEqual( http_connect_args[0], {'ipaddr': '1.2.3.4', 'port': '5', @@ -2422,7 +2422,7 @@ class TestContainerController(unittest.TestCase): 'referer': 'PUT http://localhost/sda1/p/a/c', 'user-agent': 'container-server %d' % os.getpid(), 'x-trans-id': '-'})}) - self.assertEquals( + self.assertEqual( http_connect_args[1], {'ipaddr': '6.7.8.9', 'port': '10', @@ -2445,7 +2445,7 @@ class TestContainerController(unittest.TestCase): # Test replication_server flag was set from configuration file. container_controller = container_server.ContainerController conf = {'devices': self.testdir, 'mount_check': 'false'} - self.assertEquals(container_controller(conf).replication_server, None) + self.assertEqual(container_controller(conf).replication_server, None) for val in [True, '1', 'True', 'true']: conf['replication_server'] = val self.assertTrue(container_controller(conf).replication_server) @@ -2462,7 +2462,7 @@ class TestContainerController(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 @@ -2568,8 +2568,8 @@ class TestContainerController(unittest.TestCase): 'wsgi.multiprocess': False, 'wsgi.run_once': False} self.controller(env, start_response) - self.assertEquals(errbuf.getvalue(), '') - self.assertEquals(outbuf.getvalue()[:4], '405 ') + self.assertEqual(errbuf.getvalue(), '') + self.assertEqual(outbuf.getvalue()[:4], '405 ') def test_GET_log_requests_true(self): self.controller.logger = FakeLogger() diff --git a/test/unit/container/test_sync.py b/test/unit/container/test_sync.py index 2b1637ed7e..0a97e843e2 100644 --- a/test/unit/container/test_sync.py +++ b/test/unit/container/test_sync.py @@ -85,22 +85,22 @@ class TestContainerSync(unittest.TestCase): got = flo.read(2) self.assertTrue(len(got) <= 2) - self.assertEquals(got, expect[:len(got)]) + self.assertEqual(got, expect[:len(got)]) expect = expect[len(got):] got = flo.read(5) self.assertTrue(len(got) <= 5) - self.assertEquals(got, expect[:len(got)]) + self.assertEqual(got, expect[:len(got)]) expect = expect[len(got):] - self.assertEquals(flo.read(), expect) - self.assertEquals(flo.read(), '') - self.assertEquals(flo.read(2), '') + self.assertEqual(flo.read(), expect) + self.assertEqual(flo.read(), '') + self.assertEqual(flo.read(2), '') flo = sync.FileLikeIter(iter(['123', '4567', '89', '0'])) - self.assertEquals(flo.read(), '1234567890') - self.assertEquals(flo.read(), '') - self.assertEquals(flo.read(2), '') + self.assertEqual(flo.read(), '1234567890') + self.assertEqual(flo.read(), '') + self.assertEqual(flo.read(2), '') def assertLogMessage(self, msg_level, expected, skip=0): for line in self.logger.get_lines_for_level(msg_level)[skip:]: @@ -129,8 +129,8 @@ class TestContainerSync(unittest.TestCase): self.assertTrue(mock_ic.called) conf_path, name, retry = mock_ic.call_args[0] self.assertTrue(isinstance(conf_path, ConfigString)) - self.assertEquals(conf_path.contents.getvalue(), - dedent(sync.ic_conf_body)) + self.assertEqual(conf_path.contents.getvalue(), + dedent(sync.ic_conf_body)) self.assertLogMessage('warning', 'internal_client_conf_path') self.assertLogMessage('warning', 'internal-client.conf-sample') @@ -143,7 +143,7 @@ class TestContainerSync(unittest.TestCase): self.assertTrue(cs.container_ring is cring) self.assertTrue(mock_ic.called) conf_path, name, retry = mock_ic.call_args[0] - self.assertEquals(conf_path, ic_conf_path) + self.assertEqual(conf_path, ic_conf_path) sample_conf_filename = os.path.join( os.path.dirname(test.__file__), @@ -207,12 +207,12 @@ class TestContainerSync(unittest.TestCase): sync.audit_location_generator = orig_audit_location_generator sync.ContainerBroker = orig_ContainerBroker - self.assertEquals(time_calls, [9]) - self.assertEquals(len(sleep_calls), 2) + self.assertEqual(time_calls, [9]) + self.assertEqual(len(sleep_calls), 2) self.assertTrue(sleep_calls[0] <= cs.interval) self.assertTrue(sleep_calls[1] == cs.interval - 1) - self.assertEquals(audit_location_generator_calls, [2]) - self.assertEquals(cs.reported, 3602) + self.assertEqual(audit_location_generator_calls, [2]) + self.assertEqual(cs.reported, 3602) def test_run_once(self): # This runs runs_once with fakes twice, the first causing an interim @@ -255,9 +255,9 @@ class TestContainerSync(unittest.TestCase): cs = sync.ContainerSync({}, container_ring=FakeRing()) sync.audit_location_generator = fake_audit_location_generator cs.run_once(1, 2, a=3, b=4, verbose=True) - self.assertEquals(time_calls, [6]) - self.assertEquals(audit_location_generator_calls, [1]) - self.assertEquals(cs.reported, 3602) + self.assertEqual(time_calls, [6]) + self.assertEqual(audit_location_generator_calls, [1]) + self.assertEqual(cs.reported, 3602) cs.run_once() except Exception as err: if str(err) != 'we are now done': @@ -267,22 +267,22 @@ class TestContainerSync(unittest.TestCase): sync.audit_location_generator = orig_audit_location_generator sync.ContainerBroker = orig_ContainerBroker - self.assertEquals(time_calls, [10]) - self.assertEquals(audit_location_generator_calls, [2]) - self.assertEquals(cs.reported, 3604) + self.assertEqual(time_calls, [10]) + self.assertEqual(audit_location_generator_calls, [2]) + self.assertEqual(cs.reported, 3604) def test_container_sync_not_db(self): cring = FakeRing() with mock.patch('swift.container.sync.InternalClient'): cs = sync.ContainerSync({}, container_ring=cring) - self.assertEquals(cs.container_failures, 0) + self.assertEqual(cs.container_failures, 0) def test_container_sync_missing_db(self): cring = FakeRing() with mock.patch('swift.container.sync.InternalClient'): cs = sync.ContainerSync({}, container_ring=cring) cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) + self.assertEqual(cs.container_failures, 1) def test_container_sync_not_my_db(self): # Db could be there due to handoff replication so test that we ignore @@ -302,24 +302,24 @@ class TestContainerSync(unittest.TestCase): cs._myips = ['127.0.0.1'] # No match cs._myport = 1 # No match cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 0) + self.assertEqual(cs.container_failures, 0) cs._myips = ['10.0.0.0'] # Match cs._myport = 1 # No match cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 0) + self.assertEqual(cs.container_failures, 0) cs._myips = ['127.0.0.1'] # No match cs._myport = 1000 # Match cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 0) + self.assertEqual(cs.container_failures, 0) cs._myips = ['10.0.0.0'] # Match cs._myport = 1000 # Match # This complete match will cause the 1 container failure since the # broker's info doesn't contain sync point keys cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) + self.assertEqual(cs.container_failures, 1) finally: sync.ContainerBroker = orig_ContainerBroker @@ -337,7 +337,7 @@ class TestContainerSync(unittest.TestCase): # This complete match will cause the 1 container failure since the # broker's info doesn't contain sync point keys cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) + self.assertEqual(cs.container_failures, 1) sync.ContainerBroker = lambda p: FakeContainerBroker( p, info={'account': 'a', 'container': 'c', @@ -345,7 +345,7 @@ class TestContainerSync(unittest.TestCase): # This complete match will not cause any more container failures # since the broker indicates deletion cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) + self.assertEqual(cs.container_failures, 1) finally: sync.ContainerBroker = orig_ContainerBroker @@ -365,8 +365,8 @@ class TestContainerSync(unittest.TestCase): # This complete match will be skipped since the broker's metadata # has no x-container-sync-to or x-container-sync-key cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 0) - self.assertEquals(cs.container_skips, 1) + self.assertEqual(cs.container_failures, 0) + self.assertEqual(cs.container_skips, 1) sync.ContainerBroker = lambda p: FakeContainerBroker( p, info={'account': 'a', 'container': 'c', @@ -379,8 +379,8 @@ class TestContainerSync(unittest.TestCase): # This complete match will be skipped since the broker's metadata # has no x-container-sync-key cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 0) - self.assertEquals(cs.container_skips, 2) + self.assertEqual(cs.container_failures, 0) + self.assertEqual(cs.container_skips, 2) sync.ContainerBroker = lambda p: FakeContainerBroker( p, info={'account': 'a', 'container': 'c', @@ -393,8 +393,8 @@ class TestContainerSync(unittest.TestCase): # This complete match will be skipped since the broker's metadata # has no x-container-sync-to cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 0) - self.assertEquals(cs.container_skips, 3) + self.assertEqual(cs.container_failures, 0) + self.assertEqual(cs.container_skips, 3) sync.ContainerBroker = lambda p: FakeContainerBroker( p, info={'account': 'a', 'container': 'c', @@ -409,8 +409,8 @@ class TestContainerSync(unittest.TestCase): # This complete match will cause a container failure since the # sync-to won't validate as allowed. cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 3) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 3) sync.ContainerBroker = lambda p: FakeContainerBroker( p, info={'account': 'a', 'container': 'c', @@ -425,8 +425,8 @@ class TestContainerSync(unittest.TestCase): # This complete match will succeed completely since the broker # get_items_since will return no new rows. cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 3) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 3) finally: sync.ContainerBroker = orig_ContainerBroker @@ -450,8 +450,8 @@ class TestContainerSync(unittest.TestCase): cs.allowed_sync_hosts = ['127.0.0.1'] # This sync will fail since the items_since data is bad. cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 0) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 0) # Set up fake times to make the sync short-circuit as having taken # too long @@ -468,8 +468,8 @@ class TestContainerSync(unittest.TestCase): # as to be time to move on (before it ever actually tries to do # anything). cs.container_sync('isa.db') - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 0) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 0) finally: sync.ContainerBroker = orig_ContainerBroker sync.time = orig_time @@ -501,10 +501,10 @@ class TestContainerSync(unittest.TestCase): cs.allowed_sync_hosts = ['127.0.0.1'] cs.container_sync('isa.db') # Succeeds because no rows match - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, None) - self.assertEquals(fcb.sync_point2, -1) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, None) + self.assertEqual(fcb.sync_point2, -1) def fake_hash_path(account, container, obj, raw_digest=False): # Ensures that all rows match for full syncing, ordinal is 0 @@ -529,10 +529,10 @@ class TestContainerSync(unittest.TestCase): cs.allowed_sync_hosts = ['127.0.0.1'] cs.container_sync('isa.db') # Succeeds because the two sync points haven't deviated yet - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, -1) - self.assertEquals(fcb.sync_point2, -1) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, -1) + self.assertEqual(fcb.sync_point2, -1) fcb = FakeContainerBroker( 'path', @@ -550,10 +550,10 @@ class TestContainerSync(unittest.TestCase): cs.container_sync('isa.db') # Fails because container_sync_row will fail since the row has no # 'deleted' key - self.assertEquals(cs.container_failures, 2) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, None) - self.assertEquals(fcb.sync_point2, -1) + self.assertEqual(cs.container_failures, 2) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, None) + self.assertEqual(fcb.sync_point2, -1) def fake_delete_object(*args, **kwargs): raise ClientException @@ -577,10 +577,10 @@ class TestContainerSync(unittest.TestCase): cs.allowed_sync_hosts = ['127.0.0.1'] cs.container_sync('isa.db') # Fails because delete_object fails - self.assertEquals(cs.container_failures, 3) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, None) - self.assertEquals(fcb.sync_point2, -1) + self.assertEqual(cs.container_failures, 3) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, None) + self.assertEqual(fcb.sync_point2, -1) fcb = FakeContainerBroker( 'path', @@ -602,10 +602,10 @@ class TestContainerSync(unittest.TestCase): cs.allowed_sync_hosts = ['127.0.0.1'] cs.container_sync('isa.db') # Succeeds because delete_object succeeds - self.assertEquals(cs.container_failures, 3) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, None) - self.assertEquals(fcb.sync_point2, 1) + self.assertEqual(cs.container_failures, 3) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, None) + self.assertEqual(fcb.sync_point2, 1) def test_container_second_loop(self): cring = FakeRing() @@ -640,10 +640,10 @@ class TestContainerSync(unittest.TestCase): cs.allowed_sync_hosts = ['127.0.0.1'] cs.container_sync('isa.db') # Succeeds because no rows match - self.assertEquals(cs.container_failures, 0) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, 1) - self.assertEquals(fcb.sync_point2, None) + self.assertEqual(cs.container_failures, 0) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, 1) + self.assertEqual(fcb.sync_point2, None) def fake_hash_path(account, container, obj, raw_digest=False): # Ensures that all rows match for second loop, ordinal is 0 and @@ -671,10 +671,10 @@ class TestContainerSync(unittest.TestCase): cs.container_sync('isa.db') # Fails because row is missing 'deleted' key # Nevertheless the fault is skipped - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, 1) - self.assertEquals(fcb.sync_point2, None) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, 1) + self.assertEqual(fcb.sync_point2, None) fcb = FakeContainerBroker( 'path', @@ -693,10 +693,10 @@ class TestContainerSync(unittest.TestCase): cs.container_sync('isa.db') # Succeeds because row now has 'deleted' key and delete_object # succeeds - self.assertEquals(cs.container_failures, 1) - self.assertEquals(cs.container_skips, 0) - self.assertEquals(fcb.sync_point1, 1) - self.assertEquals(fcb.sync_point2, None) + self.assertEqual(cs.container_failures, 1) + self.assertEqual(cs.container_skips, 0) + self.assertEqual(fcb.sync_point1, 1) + self.assertEqual(fcb.sync_point2, None) finally: sync.ContainerBroker = orig_ContainerBroker sync.hash_path = orig_hash_path @@ -720,18 +720,18 @@ class TestContainerSync(unittest.TestCase): def fake_delete_object(path, name=None, headers=None, proxy=None, logger=None, timeout=None): - self.assertEquals(path, 'http://sync/to/path') - self.assertEquals(name, 'object') + self.assertEqual(path, 'http://sync/to/path') + self.assertEqual(name, 'object') if realm: - self.assertEquals(headers, { + self.assertEqual(headers, { 'x-container-sync-auth': 'US abcdef 90e95aabb45a6cdc0892a3db5535e7f918428c90', 'x-timestamp': '1.2'}) else: - self.assertEquals( + self.assertEqual( headers, {'x-container-sync-key': 'key', 'x-timestamp': '1.2'}) - self.assertEquals(proxy, 'http://proxy') + self.assertEqual(proxy, 'http://proxy') self.assertEqual(timeout, 5.0) self.assertEqual(logger, self.logger) @@ -749,7 +749,7 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_deletes, 1) + self.assertEqual(cs.container_deletes, 1) exc = [] @@ -766,9 +766,9 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_deletes, 1) - self.assertEquals(len(exc), 1) - self.assertEquals(str(exc[-1]), 'test exception') + self.assertEqual(cs.container_deletes, 1) + self.assertEqual(len(exc), 1) + self.assertEqual(str(exc[-1]), 'test exception') def fake_delete_object(*args, **kwargs): exc.append(ClientException('test client exception')) @@ -783,9 +783,9 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_deletes, 1) - self.assertEquals(len(exc), 2) - self.assertEquals(str(exc[-1]), 'test client exception') + self.assertEqual(cs.container_deletes, 1) + self.assertEqual(len(exc), 2) + self.assertEqual(str(exc[-1]), 'test client exception') def fake_delete_object(*args, **kwargs): exc.append(ClientException('test client exception', @@ -801,9 +801,9 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_deletes, 2) - self.assertEquals(len(exc), 3) - self.assertEquals(str(exc[-1]), 'test client exception: 404') + self.assertEqual(cs.container_deletes, 2) + self.assertEqual(len(exc), 3) + self.assertEqual(str(exc[-1]), 'test client exception: 404') finally: sync.uuid = orig_uuid sync.delete_object = orig_delete_object @@ -829,8 +829,8 @@ class TestContainerSync(unittest.TestCase): def fake_put_object(sync_to, name=None, headers=None, contents=None, proxy=None, logger=None, timeout=None): - self.assertEquals(sync_to, 'http://sync/to/path') - self.assertEquals(name, 'object') + self.assertEqual(sync_to, 'http://sync/to/path') + self.assertEqual(name, 'object') if realm: self.assertEqual(headers, { 'x-container-sync-auth': @@ -840,14 +840,14 @@ class TestContainerSync(unittest.TestCase): 'other-header': 'other header value', 'content-type': 'text/plain'}) else: - self.assertEquals(headers, { + self.assertEqual(headers, { 'x-container-sync-key': 'key', 'x-timestamp': '1.2', 'other-header': 'other header value', 'etag': 'etagvalue', 'content-type': 'text/plain'}) - self.assertEquals(contents.read(), 'contents') - self.assertEquals(proxy, 'http://proxy') + self.assertEqual(contents.read(), 'contents') + self.assertEqual(proxy, 'http://proxy') self.assertEqual(timeout, 5.0) self.assertEqual(logger, self.logger) @@ -876,12 +876,12 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 1) + self.assertEqual(cs.container_puts, 1) def fake_get_object(acct, con, obj, headers, acceptable_statuses): - self.assertEquals(headers['X-Newest'], True) - self.assertEquals(headers['X-Backend-Storage-Policy-Index'], - '0') + self.assertEqual(headers['X-Newest'], True) + self.assertEqual(headers['X-Backend-Storage-Policy-Index'], + '0') return (200, {'date': 'date value', 'last-modified': 'last modified value', @@ -902,14 +902,14 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 2) + self.assertEqual(cs.container_puts, 2) exc = [] def fake_get_object(acct, con, obj, headers, acceptable_statuses): - self.assertEquals(headers['X-Newest'], True) - self.assertEquals(headers['X-Backend-Storage-Policy-Index'], - '0') + self.assertEqual(headers['X-Newest'], True) + self.assertEqual(headers['X-Backend-Storage-Policy-Index'], + '0') exc.append(Exception('test exception')) raise exc[-1] @@ -922,16 +922,16 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 2) - self.assertEquals(len(exc), 1) - self.assertEquals(str(exc[-1]), 'test exception') + self.assertEqual(cs.container_puts, 2) + self.assertEqual(len(exc), 1) + self.assertEqual(str(exc[-1]), 'test exception') exc = [] def fake_get_object(acct, con, obj, headers, acceptable_statuses): - self.assertEquals(headers['X-Newest'], True) - self.assertEquals(headers['X-Backend-Storage-Policy-Index'], - '0') + self.assertEqual(headers['X-Newest'], True) + self.assertEqual(headers['X-Backend-Storage-Policy-Index'], + '0') exc.append(ClientException('test client exception')) raise exc[-1] @@ -945,14 +945,14 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 2) - self.assertEquals(len(exc), 1) - self.assertEquals(str(exc[-1]), 'test client exception') + self.assertEqual(cs.container_puts, 2) + self.assertEqual(len(exc), 1) + self.assertEqual(str(exc[-1]), 'test client exception') def fake_get_object(acct, con, obj, headers, acceptable_statuses): - self.assertEquals(headers['X-Newest'], True) - self.assertEquals(headers['X-Backend-Storage-Policy-Index'], - '0') + self.assertEqual(headers['X-Newest'], True) + self.assertEqual(headers['X-Backend-Storage-Policy-Index'], + '0') return (200, {'other-header': 'other header value', 'x-timestamp': '1.2', 'etag': '"etagvalue"'}, iter('contents')) @@ -970,7 +970,7 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 2) + self.assertEqual(cs.container_puts, 2) self.assertLogMessage('info', 'Unauth') def fake_put_object(*args, **kwargs): @@ -985,7 +985,7 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 2) + self.assertEqual(cs.container_puts, 2) self.assertLogMessage('info', 'Not found', 1) def fake_put_object(*args, **kwargs): @@ -1000,7 +1000,7 @@ class TestContainerSync(unittest.TestCase): 'key', FakeContainerBroker('broker'), {'account': 'a', 'container': 'c', 'storage_policy_index': 0}, realm, realm_key)) - self.assertEquals(cs.container_puts, 2) + self.assertEqual(cs.container_puts, 2) self.assertLogMessage('error', 'ERROR Syncing') finally: sync.uuid = orig_uuid diff --git a/test/unit/container/test_updater.py b/test/unit/container/test_updater.py index ae8a0d6056..c682967046 100644 --- a/test/unit/container/test_updater.py +++ b/test/unit/container/test_updater.py @@ -68,10 +68,10 @@ class TestContainerUpdater(unittest.TestCase): }) self.assertTrue(hasattr(cu, 'logger')) self.assertTrue(cu.logger is not None) - self.assertEquals(cu.devices, self.devices_dir) - self.assertEquals(cu.interval, 1) - self.assertEquals(cu.concurrency, 2) - self.assertEquals(cu.node_timeout, 5) + self.assertEqual(cu.devices, self.devices_dir) + self.assertEqual(cu.interval, 1) + self.assertEqual(cu.concurrency, 2) + self.assertEqual(cu.node_timeout, 5) self.assertTrue(cu.get_account_ring() is not None) def test_run_once(self): @@ -96,19 +96,19 @@ class TestContainerUpdater(unittest.TestCase): cb.initialize(normalize_timestamp(1), 0) cu.run_once() info = cb.get_info() - self.assertEquals(info['object_count'], 0) - self.assertEquals(info['bytes_used'], 0) - self.assertEquals(info['reported_object_count'], 0) - self.assertEquals(info['reported_bytes_used'], 0) + self.assertEqual(info['object_count'], 0) + self.assertEqual(info['bytes_used'], 0) + self.assertEqual(info['reported_object_count'], 0) + self.assertEqual(info['reported_bytes_used'], 0) cb.put_object('o', normalize_timestamp(2), 3, 'text/plain', '68b329da9893e34099c7d8ad5cb9c940') cu.run_once() info = cb.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 3) - self.assertEquals(info['reported_object_count'], 0) - self.assertEquals(info['reported_bytes_used'], 0) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 3) + self.assertEqual(info['reported_object_count'], 0) + self.assertEqual(info['reported_bytes_used'], 0) def accept(sock, addr, return_code): try: @@ -118,8 +118,8 @@ class TestContainerUpdater(unittest.TestCase): out.write('HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n' % return_code) out.flush() - self.assertEquals(inc.readline(), - 'PUT /sda1/0/a/c HTTP/1.1\r\n') + self.assertEqual(inc.readline(), + 'PUT /sda1/0/a/c HTTP/1.1\r\n') headers = {} line = inc.readline() while line and line != '\r\n': @@ -154,10 +154,10 @@ class TestContainerUpdater(unittest.TestCase): if err: raise err info = cb.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 3) - self.assertEquals(info['reported_object_count'], 1) - self.assertEquals(info['reported_bytes_used'], 3) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 3) + self.assertEqual(info['reported_object_count'], 1) + self.assertEqual(info['reported_bytes_used'], 3) @mock.patch('os.listdir') def test_listdir_with_exception(self, mock_listdir): @@ -250,10 +250,10 @@ class TestContainerUpdater(unittest.TestCase): if err: raise err info = cb.get_info() - self.assertEquals(info['object_count'], 1) - self.assertEquals(info['bytes_used'], 3) - self.assertEquals(info['reported_object_count'], 1) - self.assertEquals(info['reported_bytes_used'], 3) + self.assertEqual(info['object_count'], 1) + self.assertEqual(info['bytes_used'], 3) + self.assertEqual(info['reported_object_count'], 1) + self.assertEqual(info['reported_bytes_used'], 3) if __name__ == '__main__':