Merge "AssertEquals is deprecated, use assertEqual partI"
This commit is contained in:
Jenkins
Gerrit Code Review
commit
a48f14ce02
@ -51,26 +51,26 @@ class TestAccount(unittest.TestCase):
|
||||
|
||||
resp = retry(post, '')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-account-meta-test'), None)
|
||||
self.assertEqual(resp.getheader('x-account-meta-test'), None)
|
||||
resp = retry(get)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-account-meta-test'), None)
|
||||
self.assertEqual(resp.getheader('x-account-meta-test'), None)
|
||||
resp = retry(post, 'Value')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-account-meta-test'), 'Value')
|
||||
self.assertEqual(resp.getheader('x-account-meta-test'), 'Value')
|
||||
resp = retry(get)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-account-meta-test'), 'Value')
|
||||
self.assertEqual(resp.getheader('x-account-meta-test'), 'Value')
|
||||
|
||||
def test_invalid_acls(self):
|
||||
def post(url, token, parsed, conn, headers):
|
||||
@ -655,24 +655,24 @@ class TestAccount(unittest.TestCase):
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader(uni_key.encode('utf-8')), '1')
|
||||
self.assertEqual(resp.getheader(uni_key.encode('utf-8')), '1')
|
||||
resp = retry(post, 'X-Account-Meta-uni', uni_value)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('X-Account-Meta-uni'),
|
||||
uni_value.encode('utf-8'))
|
||||
self.assertEqual(resp.getheader('X-Account-Meta-uni'),
|
||||
uni_value.encode('utf-8'))
|
||||
if (web_front_end == 'integral'):
|
||||
resp = retry(post, uni_key, uni_value)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader(uni_key.encode('utf-8')),
|
||||
uni_value.encode('utf-8'))
|
||||
self.assertEqual(resp.getheader(uni_key.encode('utf-8')),
|
||||
uni_value.encode('utf-8'))
|
||||
|
||||
def test_multi_metadata(self):
|
||||
if skip:
|
||||
@ -689,19 +689,19 @@ class TestAccount(unittest.TestCase):
|
||||
|
||||
resp = retry(post, 'X-Account-Meta-One', '1')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-account-meta-one'), '1')
|
||||
self.assertEqual(resp.getheader('x-account-meta-one'), '1')
|
||||
resp = retry(post, 'X-Account-Meta-Two', '2')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-account-meta-one'), '1')
|
||||
self.assertEquals(resp.getheader('x-account-meta-two'), '2')
|
||||
self.assertEqual(resp.getheader('x-account-meta-one'), '1')
|
||||
self.assertEqual(resp.getheader('x-account-meta-two'), '2')
|
||||
|
||||
def test_bad_metadata(self):
|
||||
if skip:
|
||||
@ -716,35 +716,35 @@ class TestAccount(unittest.TestCase):
|
||||
resp = retry(post,
|
||||
{'X-Account-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(
|
||||
post,
|
||||
{'X-Account-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
resp = retry(post,
|
||||
{'X-Account-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(
|
||||
post,
|
||||
{'X-Account-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
headers = {}
|
||||
for x in xrange(MAX_META_COUNT):
|
||||
headers['X-Account-Meta-%d' % x] = 'v'
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
headers = {}
|
||||
for x in xrange(MAX_META_COUNT + 1):
|
||||
headers['X-Account-Meta-%d' % x] = 'v'
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
headers = {}
|
||||
header_value = 'k' * MAX_META_VALUE_LENGTH
|
||||
@ -759,12 +759,12 @@ class TestAccount(unittest.TestCase):
|
||||
'v' * (MAX_META_OVERALL_SIZE - size - 1)
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
headers['X-Account-Meta-k'] = \
|
||||
'v' * (MAX_META_OVERALL_SIZE - size)
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@ -41,7 +41,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
def tearDown(self):
|
||||
if skip:
|
||||
@ -68,7 +68,7 @@ class TestContainer(unittest.TestCase):
|
||||
for obj in objs:
|
||||
resp = retry(delete, obj)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def delete(url, token, parsed, conn):
|
||||
conn.request('DELETE', parsed.path + '/' + self.name, '',
|
||||
@ -77,7 +77,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def test_multi_metadata(self):
|
||||
if skip:
|
||||
@ -95,19 +95,19 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post, 'X-Container-Meta-One', '1')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-one'), '1')
|
||||
self.assertEqual(resp.getheader('x-container-meta-one'), '1')
|
||||
resp = retry(post, 'X-Container-Meta-Two', '2')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-one'), '1')
|
||||
self.assertEquals(resp.getheader('x-container-meta-two'), '2')
|
||||
self.assertEqual(resp.getheader('x-container-meta-one'), '1')
|
||||
self.assertEqual(resp.getheader('x-container-meta-two'), '2')
|
||||
|
||||
def test_unicode_metadata(self):
|
||||
if skip:
|
||||
@ -128,28 +128,28 @@ class TestContainer(unittest.TestCase):
|
||||
if (web_front_end == 'integral'):
|
||||
resp = retry(post, uni_key, '1')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader(uni_key.encode('utf-8')), '1')
|
||||
self.assertEqual(resp.getheader(uni_key.encode('utf-8')), '1')
|
||||
resp = retry(post, 'X-Container-Meta-uni', uni_value)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('X-Container-Meta-uni'),
|
||||
uni_value.encode('utf-8'))
|
||||
self.assertEqual(resp.getheader('X-Container-Meta-uni'),
|
||||
uni_value.encode('utf-8'))
|
||||
if (web_front_end == 'integral'):
|
||||
resp = retry(post, uni_key, uni_value)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader(uni_key.encode('utf-8')),
|
||||
uni_value.encode('utf-8'))
|
||||
self.assertEqual(resp.getheader(uni_key.encode('utf-8')),
|
||||
uni_value.encode('utf-8'))
|
||||
|
||||
def test_PUT_metadata(self):
|
||||
if skip:
|
||||
@ -179,34 +179,34 @@ class TestContainer(unittest.TestCase):
|
||||
name = uuid4().hex
|
||||
resp = retry(put, name, 'Value')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
resp = retry(head, name)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), 'Value')
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), 'Value')
|
||||
resp = retry(get, name)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), 'Value')
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), 'Value')
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
name = uuid4().hex
|
||||
resp = retry(put, name, '')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
resp = retry(head, name)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), None)
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), None)
|
||||
resp = retry(get, name)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), None)
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), None)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def test_POST_metadata(self):
|
||||
if skip:
|
||||
@ -231,22 +231,22 @@ class TestContainer(unittest.TestCase):
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), None)
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), None)
|
||||
resp = retry(get)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), None)
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), None)
|
||||
resp = retry(post, 'Value')
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(head)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), 'Value')
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), 'Value')
|
||||
resp = retry(get)
|
||||
resp.read()
|
||||
self.assert_(resp.status in (200, 204), resp.status)
|
||||
self.assertEquals(resp.getheader('x-container-meta-test'), 'Value')
|
||||
self.assertEqual(resp.getheader('x-container-meta-test'), 'Value')
|
||||
|
||||
def test_PUT_bad_metadata(self):
|
||||
if skip:
|
||||
@ -268,38 +268,38 @@ class TestContainer(unittest.TestCase):
|
||||
put, name,
|
||||
{'X-Container-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
name = uuid4().hex
|
||||
resp = retry(
|
||||
put, name,
|
||||
{'X-Container-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
|
||||
name = uuid4().hex
|
||||
resp = retry(
|
||||
put, name,
|
||||
{'X-Container-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
name = uuid4().hex
|
||||
resp = retry(
|
||||
put, name,
|
||||
{'X-Container-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
|
||||
name = uuid4().hex
|
||||
headers = {}
|
||||
@ -307,20 +307,20 @@ class TestContainer(unittest.TestCase):
|
||||
headers['X-Container-Meta-%d' % x] = 'v'
|
||||
resp = retry(put, name, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
name = uuid4().hex
|
||||
headers = {}
|
||||
for x in xrange(MAX_META_COUNT + 1):
|
||||
headers['X-Container-Meta-%d' % x] = 'v'
|
||||
resp = retry(put, name, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
|
||||
name = uuid4().hex
|
||||
headers = {}
|
||||
@ -336,19 +336,19 @@ class TestContainer(unittest.TestCase):
|
||||
'v' * (MAX_META_OVERALL_SIZE - size - 1)
|
||||
resp = retry(put, name, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
name = uuid4().hex
|
||||
headers['X-Container-Meta-k'] = \
|
||||
'v' * (MAX_META_OVERALL_SIZE - size)
|
||||
resp = retry(put, name, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
resp = retry(delete, name)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
|
||||
def test_POST_bad_metadata(self):
|
||||
if skip:
|
||||
@ -364,36 +364,36 @@ class TestContainer(unittest.TestCase):
|
||||
post,
|
||||
{'X-Container-Meta-' + ('k' * MAX_META_NAME_LENGTH): 'v'})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(
|
||||
post,
|
||||
{'X-Container-Meta-' + ('k' * (MAX_META_NAME_LENGTH + 1)): 'v'})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
resp = retry(
|
||||
post,
|
||||
{'X-Container-Meta-Too-Long': 'k' * MAX_META_VALUE_LENGTH})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(
|
||||
post,
|
||||
{'X-Container-Meta-Too-Long': 'k' * (MAX_META_VALUE_LENGTH + 1)})
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
headers = {}
|
||||
for x in xrange(MAX_META_COUNT):
|
||||
headers['X-Container-Meta-%d' % x] = 'v'
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
headers = {}
|
||||
for x in xrange(MAX_META_COUNT + 1):
|
||||
headers['X-Container-Meta-%d' % x] = 'v'
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
headers = {}
|
||||
header_value = 'k' * MAX_META_VALUE_LENGTH
|
||||
@ -408,12 +408,12 @@ class TestContainer(unittest.TestCase):
|
||||
'v' * (MAX_META_OVERALL_SIZE - size - 1)
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
headers['X-Container-Meta-k'] = \
|
||||
'v' * (MAX_META_OVERALL_SIZE - size)
|
||||
resp = retry(post, headers)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
def test_public_container(self):
|
||||
if skip:
|
||||
@ -437,10 +437,10 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(get)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def post(url, token, parsed, conn):
|
||||
conn.request('POST', parsed.path + '/' + self.name, '',
|
||||
@ -449,7 +449,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
try:
|
||||
resp = retry(get)
|
||||
raise Exception('Should not have been able to GET')
|
||||
@ -479,7 +479,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(get2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Make the container accessible by the second account
|
||||
def post(url, token, parsed, conn):
|
||||
@ -491,11 +491,11 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# Ensure we can now use the container with the second account
|
||||
resp = retry(get2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# Make the container private again
|
||||
def post(url, token, parsed, conn):
|
||||
@ -506,11 +506,11 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# Ensure we can't access the container with the second account again
|
||||
resp = retry(get2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
def test_cross_account_public_container(self):
|
||||
if skip or skip2:
|
||||
@ -535,7 +535,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(get2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Make the container completely public
|
||||
def post(url, token, parsed, conn):
|
||||
@ -546,11 +546,11 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# Ensure we can now read the container with the second account
|
||||
resp = retry(get2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# But we shouldn't be able to write with the second account
|
||||
def put2(url, token, parsed, conn):
|
||||
@ -560,7 +560,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(put2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Now make the container also writeable by the second account
|
||||
def post(url, token, parsed, conn):
|
||||
@ -571,15 +571,15 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# Ensure we can still read the container with the second account
|
||||
resp = retry(get2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# And that we can now write with the second account
|
||||
resp = retry(put2, use_account=2)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
def test_nonadmin_user(self):
|
||||
if skip or skip3:
|
||||
@ -604,7 +604,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(get3, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Make the container accessible by the third account
|
||||
def post(url, token, parsed, conn):
|
||||
@ -615,11 +615,11 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# Ensure we can now read the container with the third account
|
||||
resp = retry(get3, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# But we shouldn't be able to write with the third account
|
||||
def put3(url, token, parsed, conn):
|
||||
@ -629,7 +629,7 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(put3, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Now make the container also writeable by the third account
|
||||
def post(url, token, parsed, conn):
|
||||
@ -640,15 +640,15 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# Ensure we can still read the container with the third account
|
||||
resp = retry(get3, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# And that we can now write with the third account
|
||||
resp = retry(put3, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
@requires_acls
|
||||
def test_read_only_acl_listings(self):
|
||||
@ -1313,9 +1313,9 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEquals(resp.getheader('Content-Type'),
|
||||
'text/html; charset=UTF-8')
|
||||
self.assertEqual(resp.status, 400)
|
||||
self.assertEqual(resp.getheader('Content-Type'),
|
||||
'text/html; charset=UTF-8')
|
||||
|
||||
def test_null_name(self):
|
||||
if skip:
|
||||
@ -1328,10 +1328,10 @@ class TestContainer(unittest.TestCase):
|
||||
|
||||
resp = retry(put)
|
||||
if (web_front_end == 'apache2'):
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
else:
|
||||
self.assertEquals(resp.read(), 'Invalid UTF8 or contains NULL')
|
||||
self.assertEquals(resp.status, 412)
|
||||
self.assertEqual(resp.read(), 'Invalid UTF8 or contains NULL')
|
||||
self.assertEqual(resp.status, 412)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@ -38,7 +38,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
self.obj = uuid4().hex
|
||||
|
||||
def put(url, token, parsed, conn):
|
||||
@ -48,7 +48,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
def tearDown(self):
|
||||
if skip:
|
||||
@ -68,13 +68,13 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(list)
|
||||
object_listing = resp.read()
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
# iterate over object listing and delete all objects
|
||||
for obj in object_listing.splitlines():
|
||||
resp = retry(delete, obj)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# delete the container
|
||||
def delete(url, token, parsed, conn):
|
||||
@ -83,7 +83,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def test_copy_object(self):
|
||||
if skip:
|
||||
@ -100,8 +100,8 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(get_source)
|
||||
source_contents = resp.read()
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEquals(source_contents, 'test')
|
||||
self.assertEqual(resp.status, 200)
|
||||
self.assertEqual(source_contents, 'test')
|
||||
|
||||
# copy source to dest with X-Copy-From
|
||||
def put(url, token, parsed, conn):
|
||||
@ -112,7 +112,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# contents of dest should be the same as source
|
||||
def get_dest(url, token, parsed, conn):
|
||||
@ -122,8 +122,8 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(get_dest)
|
||||
dest_contents = resp.read()
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEquals(dest_contents, source_contents)
|
||||
self.assertEqual(resp.status, 200)
|
||||
self.assertEqual(dest_contents, source_contents)
|
||||
|
||||
# delete the copy
|
||||
def delete(url, token, parsed, conn):
|
||||
@ -132,11 +132,11 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
# verify dest does not exist
|
||||
resp = retry(get_dest)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
|
||||
# copy source to dest with COPY
|
||||
def copy(url, token, parsed, conn):
|
||||
@ -146,18 +146,18 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(copy)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# contents of dest should be the same as source
|
||||
resp = retry(get_dest)
|
||||
dest_contents = resp.read()
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEquals(dest_contents, source_contents)
|
||||
self.assertEqual(resp.status, 200)
|
||||
self.assertEqual(dest_contents, source_contents)
|
||||
|
||||
# delete the copy
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def test_public_object(self):
|
||||
if skip:
|
||||
@ -180,10 +180,10 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
resp = retry(get)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
def post(url, token, parsed, conn):
|
||||
conn.request('POST', parsed.path + '/' + self.container, '',
|
||||
@ -191,7 +191,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
try:
|
||||
resp = retry(get)
|
||||
raise Exception('Should not have been able to GET')
|
||||
@ -210,7 +210,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(get, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# create a shared container writable by account3
|
||||
shared_container = uuid4().hex
|
||||
@ -224,7 +224,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# verify third account can not copy from private container
|
||||
def copy(url, token, parsed, conn):
|
||||
@ -236,7 +236,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(copy, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# verify third account can write "obj1" to shared container
|
||||
def put(url, token, parsed, conn):
|
||||
@ -246,7 +246,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# verify third account can copy "obj1" to shared container
|
||||
def copy2(url, token, parsed, conn):
|
||||
@ -257,7 +257,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(copy2, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# verify third account STILL can not copy from private container
|
||||
def copy3(url, token, parsed, conn):
|
||||
@ -269,7 +269,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(copy3, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# clean up "obj1"
|
||||
def delete(url, token, parsed, conn):
|
||||
@ -279,7 +279,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# clean up shared_container
|
||||
def delete(url, token, parsed, conn):
|
||||
@ -289,7 +289,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
@requires_acls
|
||||
def test_read_only(self):
|
||||
@ -551,7 +551,7 @@ class TestObject(unittest.TestCase):
|
||||
for objnum in xrange(len(segments1)):
|
||||
resp = retry(put, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Upload the manifest
|
||||
def put(url, token, parsed, conn):
|
||||
@ -563,7 +563,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Get the manifest (should get all the segments as the body)
|
||||
def get(url, token, parsed, conn):
|
||||
@ -571,9 +571,9 @@ class TestObject(unittest.TestCase):
|
||||
parsed.path, self.container), '', {'X-Auth-Token': token})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments1))
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEquals(resp.getheader('content-type'), 'text/jibberish')
|
||||
self.assertEqual(resp.read(), ''.join(segments1))
|
||||
self.assertEqual(resp.status, 200)
|
||||
self.assertEqual(resp.getheader('content-type'), 'text/jibberish')
|
||||
|
||||
# Get with a range at the start of the second segment
|
||||
def get(url, token, parsed, conn):
|
||||
@ -582,8 +582,8 @@ class TestObject(unittest.TestCase):
|
||||
'X-Auth-Token': token, 'Range': 'bytes=3-'})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments1[1:]))
|
||||
self.assertEquals(resp.status, 206)
|
||||
self.assertEqual(resp.read(), ''.join(segments1[1:]))
|
||||
self.assertEqual(resp.status, 206)
|
||||
|
||||
# Get with a range in the middle of the second segment
|
||||
def get(url, token, parsed, conn):
|
||||
@ -592,8 +592,8 @@ class TestObject(unittest.TestCase):
|
||||
'X-Auth-Token': token, 'Range': 'bytes=5-'})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments1)[5:])
|
||||
self.assertEquals(resp.status, 206)
|
||||
self.assertEqual(resp.read(), ''.join(segments1)[5:])
|
||||
self.assertEqual(resp.status, 206)
|
||||
|
||||
# Get with a full start and stop range
|
||||
def get(url, token, parsed, conn):
|
||||
@ -602,8 +602,8 @@ class TestObject(unittest.TestCase):
|
||||
'X-Auth-Token': token, 'Range': 'bytes=5-10'})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments1)[5:11])
|
||||
self.assertEquals(resp.status, 206)
|
||||
self.assertEqual(resp.read(), ''.join(segments1)[5:11])
|
||||
self.assertEqual(resp.status, 206)
|
||||
|
||||
# Upload the second set of segments
|
||||
def put(url, token, parsed, conn, objnum):
|
||||
@ -614,7 +614,7 @@ class TestObject(unittest.TestCase):
|
||||
for objnum in xrange(len(segments2)):
|
||||
resp = retry(put, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Get the manifest (should still be the first segments of course)
|
||||
def get(url, token, parsed, conn):
|
||||
@ -622,8 +622,8 @@ class TestObject(unittest.TestCase):
|
||||
parsed.path, self.container), '', {'X-Auth-Token': token})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments1))
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.read(), ''.join(segments1))
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
# Update the manifest
|
||||
def put(url, token, parsed, conn):
|
||||
@ -635,7 +635,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Get the manifest (should be the second set of segments now)
|
||||
def get(url, token, parsed, conn):
|
||||
@ -643,8 +643,8 @@ class TestObject(unittest.TestCase):
|
||||
parsed.path, self.container), '', {'X-Auth-Token': token})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments2))
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.read(), ''.join(segments2))
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
if not skip3:
|
||||
|
||||
@ -655,7 +655,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(get, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Grant access to the third account
|
||||
def post(url, token, parsed, conn):
|
||||
@ -665,7 +665,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# The third account should be able to get the manifest now
|
||||
def get(url, token, parsed, conn):
|
||||
@ -673,8 +673,8 @@ class TestObject(unittest.TestCase):
|
||||
parsed.path, self.container), '', {'X-Auth-Token': token})
|
||||
return check_response(conn)
|
||||
resp = retry(get, use_account=3)
|
||||
self.assertEquals(resp.read(), ''.join(segments2))
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.read(), ''.join(segments2))
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
# Create another container for the third set of segments
|
||||
acontainer = uuid4().hex
|
||||
@ -685,7 +685,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Upload the third set of segments in the other container
|
||||
def put(url, token, parsed, conn, objnum):
|
||||
@ -696,7 +696,7 @@ class TestObject(unittest.TestCase):
|
||||
for objnum in xrange(len(segments3)):
|
||||
resp = retry(put, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Update the manifest
|
||||
def put(url, token, parsed, conn):
|
||||
@ -708,7 +708,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
# Get the manifest to ensure it's the third set of segments
|
||||
def get(url, token, parsed, conn):
|
||||
@ -716,8 +716,8 @@ class TestObject(unittest.TestCase):
|
||||
parsed.path, self.container), '', {'X-Auth-Token': token})
|
||||
return check_response(conn)
|
||||
resp = retry(get)
|
||||
self.assertEquals(resp.read(), ''.join(segments3))
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.read(), ''.join(segments3))
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
if not skip3:
|
||||
|
||||
@ -731,7 +731,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(get, use_account=3)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 403)
|
||||
self.assertEqual(resp.status, 403)
|
||||
|
||||
# Grant access to the third account
|
||||
def post(url, token, parsed, conn):
|
||||
@ -741,7 +741,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(post)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# The third account should be able to get the manifest now
|
||||
def get(url, token, parsed, conn):
|
||||
@ -749,8 +749,8 @@ class TestObject(unittest.TestCase):
|
||||
parsed.path, self.container), '', {'X-Auth-Token': token})
|
||||
return check_response(conn)
|
||||
resp = retry(get, use_account=3)
|
||||
self.assertEquals(resp.read(), ''.join(segments3))
|
||||
self.assertEquals(resp.status, 200)
|
||||
self.assertEqual(resp.read(), ''.join(segments3))
|
||||
self.assertEqual(resp.status, 200)
|
||||
|
||||
# Delete the manifest
|
||||
def delete(url, token, parsed, conn, objnum):
|
||||
@ -760,7 +760,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# Delete the third set of segments
|
||||
def delete(url, token, parsed, conn, objnum):
|
||||
@ -771,7 +771,7 @@ class TestObject(unittest.TestCase):
|
||||
for objnum in xrange(len(segments3)):
|
||||
resp = retry(delete, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# Delete the second set of segments
|
||||
def delete(url, token, parsed, conn, objnum):
|
||||
@ -782,7 +782,7 @@ class TestObject(unittest.TestCase):
|
||||
for objnum in xrange(len(segments2)):
|
||||
resp = retry(delete, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# Delete the first set of segments
|
||||
def delete(url, token, parsed, conn, objnum):
|
||||
@ -793,7 +793,7 @@ class TestObject(unittest.TestCase):
|
||||
for objnum in xrange(len(segments1)):
|
||||
resp = retry(delete, objnum)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
# Delete the extra container
|
||||
def delete(url, token, parsed, conn):
|
||||
@ -802,7 +802,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEqual(resp.status, 204)
|
||||
|
||||
def test_delete_content_type(self):
|
||||
if skip:
|
||||
@ -814,7 +814,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
def delete(url, token, parsed, conn):
|
||||
conn.request('DELETE', '%s/%s/hi' % (parsed.path, self.container),
|
||||
@ -822,9 +822,9 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 204)
|
||||
self.assertEquals(resp.getheader('Content-Type'),
|
||||
'text/html; charset=UTF-8')
|
||||
self.assertEqual(resp.status, 204)
|
||||
self.assertEqual(resp.getheader('Content-Type'),
|
||||
'text/html; charset=UTF-8')
|
||||
|
||||
def test_delete_if_delete_at_bad(self):
|
||||
if skip:
|
||||
@ -837,7 +837,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 201)
|
||||
self.assertEqual(resp.status, 201)
|
||||
|
||||
def delete(url, token, parsed, conn):
|
||||
conn.request('DELETE', '%s/%s/hi' % (parsed.path, self.container),
|
||||
@ -846,7 +846,7 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(delete)
|
||||
resp.read()
|
||||
self.assertEquals(resp.status, 400)
|
||||
self.assertEqual(resp.status, 400)
|
||||
|
||||
def test_null_name(self):
|
||||
if skip:
|
||||
@ -859,10 +859,10 @@ class TestObject(unittest.TestCase):
|
||||
return check_response(conn)
|
||||
resp = retry(put)
|
||||
if (web_front_end == 'apache2'):
|
||||
self.assertEquals(resp.status, 404)
|
||||
self.assertEqual(resp.status, 404)
|
||||
else:
|
||||
self.assertEquals(resp.read(), 'Invalid UTF8 or contains NULL')
|
||||
self.assertEquals(resp.status, 412)
|
||||
self.assertEqual(resp.read(), 'Invalid UTF8 or contains NULL')
|
||||
self.assertEqual(resp.status, 412)
|
||||
|
||||
def test_cors(self):
|
||||
if skip:
|
||||
|
||||
@ -235,7 +235,7 @@ class TestAccount(Base):
|
||||
if try_count < 5:
|
||||
time.sleep(1)
|
||||
|
||||
self.assertEquals(info['container_count'], len(self.env.containers))
|
||||
self.assertEqual(info['container_count'], len(self.env.containers))
|
||||
self.assert_status(204)
|
||||
|
||||
def testContainerSerializedInfo(self):
|
||||
@ -259,11 +259,11 @@ class TestAccount(Base):
|
||||
|
||||
headers = dict(self.env.conn.response.getheaders())
|
||||
if format_type == 'json':
|
||||
self.assertEquals(headers['content-type'],
|
||||
'application/json; charset=utf-8')
|
||||
self.assertEqual(headers['content-type'],
|
||||
'application/json; charset=utf-8')
|
||||
elif format_type == 'xml':
|
||||
self.assertEquals(headers['content-type'],
|
||||
'application/xml; charset=utf-8')
|
||||
self.assertEqual(headers['content-type'],
|
||||
'application/xml; charset=utf-8')
|
||||
|
||||
def testListingLimit(self):
|
||||
limit = load_constraint('account_listing_limit')
|
||||
@ -287,7 +287,7 @@ class TestAccount(Base):
|
||||
if isinstance(b[0], dict):
|
||||
b = [x['name'] for x in b]
|
||||
|
||||
self.assertEquals(a, b)
|
||||
self.assertEqual(a, b)
|
||||
|
||||
def testInvalidAuthToken(self):
|
||||
hdrs = {'X-Auth-Token': 'bogus_auth_token'}
|
||||
@ -297,12 +297,12 @@ class TestAccount(Base):
|
||||
def testLastContainerMarker(self):
|
||||
for format_type in [None, 'json', 'xml']:
|
||||
containers = self.env.account.containers({'format': format_type})
|
||||
self.assertEquals(len(containers), len(self.env.containers))
|
||||
self.assertEqual(len(containers), len(self.env.containers))
|
||||
self.assert_status(200)
|
||||
|
||||
containers = self.env.account.containers(
|
||||
parms={'format': format_type, 'marker': containers[-1]})
|
||||
self.assertEquals(len(containers), 0)
|
||||
self.assertEqual(len(containers), 0)
|
||||
if format_type is None:
|
||||
self.assert_status(204)
|
||||
else:
|
||||
@ -330,8 +330,8 @@ class TestAccount(Base):
|
||||
parms={'format': format_type})
|
||||
if isinstance(containers[0], dict):
|
||||
containers = [x['name'] for x in containers]
|
||||
self.assertEquals(sorted(containers, cmp=locale.strcoll),
|
||||
containers)
|
||||
self.assertEqual(sorted(containers, cmp=locale.strcoll),
|
||||
containers)
|
||||
|
||||
|
||||
class TestAccountUTF8(Base2, TestAccount):
|
||||
@ -468,13 +468,13 @@ class TestContainer(Base):
|
||||
for format_type in [None, 'json', 'xml']:
|
||||
for prefix in prefixs:
|
||||
files = cont.files(parms={'prefix': prefix})
|
||||
self.assertEquals(files, sorted(prefix_files[prefix]))
|
||||
self.assertEqual(files, sorted(prefix_files[prefix]))
|
||||
|
||||
for format_type in [None, 'json', 'xml']:
|
||||
for prefix in prefixs:
|
||||
files = cont.files(parms={'limit': limit_count,
|
||||
'prefix': prefix})
|
||||
self.assertEquals(len(files), limit_count)
|
||||
self.assertEqual(len(files), limit_count)
|
||||
|
||||
for file_item in files:
|
||||
self.assert_(file_item.startswith(prefix))
|
||||
@ -498,7 +498,7 @@ class TestContainer(Base):
|
||||
container = self.env.account.container(valid_utf8)
|
||||
self.assert_(container.create(cfg={'no_path_quote': True}))
|
||||
self.assert_(container.name in self.env.account.containers())
|
||||
self.assertEquals(container.files(), [])
|
||||
self.assertEqual(container.files(), [])
|
||||
self.assert_(container.delete())
|
||||
|
||||
container = self.env.account.container(invalid_utf8)
|
||||
@ -564,12 +564,12 @@ class TestContainer(Base):
|
||||
def testLastFileMarker(self):
|
||||
for format_type in [None, 'json', 'xml']:
|
||||
files = self.env.container.files({'format': format_type})
|
||||
self.assertEquals(len(files), len(self.env.files))
|
||||
self.assertEqual(len(files), len(self.env.files))
|
||||
self.assert_status(200)
|
||||
|
||||
files = self.env.container.files(
|
||||
parms={'format': format_type, 'marker': files[-1]})
|
||||
self.assertEquals(len(files), 0)
|
||||
self.assertEqual(len(files), 0)
|
||||
|
||||
if format_type is None:
|
||||
self.assert_status(204)
|
||||
@ -615,14 +615,14 @@ class TestContainer(Base):
|
||||
files = self.env.container.files(parms={'format': format_type})
|
||||
if isinstance(files[0], dict):
|
||||
files = [x['name'] for x in files]
|
||||
self.assertEquals(sorted(files, cmp=locale.strcoll), files)
|
||||
self.assertEqual(sorted(files, cmp=locale.strcoll), files)
|
||||
|
||||
def testContainerInfo(self):
|
||||
info = self.env.container.info()
|
||||
self.assert_status(204)
|
||||
self.assertEquals(info['object_count'], self.env.file_count)
|
||||
self.assertEquals(info['bytes_used'],
|
||||
self.env.file_count * self.env.file_size)
|
||||
self.assertEqual(info['object_count'], self.env.file_count)
|
||||
self.assertEqual(info['bytes_used'],
|
||||
self.env.file_count * self.env.file_size)
|
||||
|
||||
def testContainerInfoOnContainerThatDoesNotExist(self):
|
||||
container = self.env.account.container(Utils.create_name())
|
||||
@ -633,7 +633,7 @@ class TestContainer(Base):
|
||||
for format_type in [None, 'json', 'xml']:
|
||||
files = self.env.container.files(parms={'format': format_type,
|
||||
'limit': 2})
|
||||
self.assertEquals(len(files), 2)
|
||||
self.assertEqual(len(files), 2)
|
||||
|
||||
def testTooLongName(self):
|
||||
cont = self.env.account.container('x' * 257)
|
||||
@ -787,7 +787,7 @@ class TestContainerPaths(Base):
|
||||
if isinstance(files[0], dict):
|
||||
files = [str(x['name']) for x in files]
|
||||
|
||||
self.assertEquals(files, self.env.stored_files)
|
||||
self.assertEqual(files, self.env.stored_files)
|
||||
|
||||
for format_type in ('json', 'xml'):
|
||||
for file_item in self.env.container.files(parms={'format':
|
||||
@ -795,13 +795,13 @@ class TestContainerPaths(Base):
|
||||
self.assert_(int(file_item['bytes']) >= 0)
|
||||
self.assert_('last_modified' in file_item)
|
||||
if file_item['name'].endswith('/'):
|
||||
self.assertEquals(file_item['content_type'],
|
||||
'application/directory')
|
||||
self.assertEqual(file_item['content_type'],
|
||||
'application/directory')
|
||||
|
||||
def testStructure(self):
|
||||
def assert_listing(path, file_list):
|
||||
files = self.env.container.files(parms={'path': path})
|
||||
self.assertEquals(sorted(file_list, cmp=locale.strcoll), files)
|
||||
self.assertEqual(sorted(file_list, cmp=locale.strcoll), files)
|
||||
if not normalized_urls:
|
||||
assert_listing('/', ['/dir1/', '/dir2/', '/file1', '/file A'])
|
||||
assert_listing('/dir1',
|
||||
@ -1125,7 +1125,7 @@ class TestFile(Base):
|
||||
for i in container.files(parms={'format': 'json'}):
|
||||
file_types_read[i['name'].split('.')[1]] = i['content_type']
|
||||
|
||||
self.assertEquals(file_types, file_types_read)
|
||||
self.assertEqual(file_types, file_types_read)
|
||||
|
||||
def testRangedGets(self):
|
||||
file_length = 10000
|
||||
@ -1150,7 +1150,7 @@ class TestFile(Base):
|
||||
self.assertRaises(ResponseError, file_item.read, hdrs=hdrs)
|
||||
self.assert_status(416)
|
||||
else:
|
||||
self.assertEquals(file_item.read(hdrs=hdrs), data[-i:])
|
||||
self.assertEqual(file_item.read(hdrs=hdrs), data[-i:])
|
||||
|
||||
range_string = 'bytes=%d-' % (i)
|
||||
hdrs = {'Range': range_string}
|
||||
@ -1299,9 +1299,9 @@ class TestFile(Base):
|
||||
info = file_item.info()
|
||||
|
||||
self.assert_status(200)
|
||||
self.assertEquals(info['content_length'], self.env.file_size)
|
||||
self.assertEquals(info['etag'], md5)
|
||||
self.assertEquals(info['content_type'], content_type)
|
||||
self.assertEqual(info['content_length'], self.env.file_size)
|
||||
self.assertEqual(info['etag'], md5)
|
||||
self.assertEqual(info['content_type'], content_type)
|
||||
self.assert_('last_modified' in info)
|
||||
|
||||
def testDeleteOfFileThatDoesNotExist(self):
|
||||
@ -1344,7 +1344,7 @@ class TestFile(Base):
|
||||
file_item = self.env.container.file(file_item.name)
|
||||
self.assert_(file_item.initialize())
|
||||
self.assert_status(200)
|
||||
self.assertEquals(file_item.metadata, metadata)
|
||||
self.assertEqual(file_item.metadata, metadata)
|
||||
|
||||
def testGetContentType(self):
|
||||
file_name = Utils.create_name()
|
||||
@ -1357,7 +1357,7 @@ class TestFile(Base):
|
||||
file_item = self.env.container.file(file_name)
|
||||
file_item.read()
|
||||
|
||||
self.assertEquals(content_type, file_item.content_type)
|
||||
self.assertEqual(content_type, file_item.content_type)
|
||||
|
||||
def testGetOnFileThatDoesNotExist(self):
|
||||
# in container that exists
|
||||
@ -1398,7 +1398,7 @@ class TestFile(Base):
|
||||
file_item = self.env.container.file(file_item.name)
|
||||
self.assert_(file_item.initialize())
|
||||
self.assert_status(200)
|
||||
self.assertEquals(file_item.metadata, metadata)
|
||||
self.assertEqual(file_item.metadata, metadata)
|
||||
|
||||
def testSerialization(self):
|
||||
container = self.env.account.container(Utils.create_name())
|
||||
@ -1427,9 +1427,9 @@ class TestFile(Base):
|
||||
if f['name'] != file_item['name']:
|
||||
continue
|
||||
|
||||
self.assertEquals(file_item['content_type'],
|
||||
f['content_type'])
|
||||
self.assertEquals(int(file_item['bytes']), f['bytes'])
|
||||
self.assertEqual(file_item['content_type'],
|
||||
f['content_type'])
|
||||
self.assertEqual(int(file_item['bytes']), f['bytes'])
|
||||
|
||||
d = datetime.strptime(
|
||||
file_item['last_modified'].split('.')[0],
|
||||
@ -1437,7 +1437,7 @@ class TestFile(Base):
|
||||
lm = time.mktime(d.timetuple())
|
||||
|
||||
if 'last_modified' in f:
|
||||
self.assertEquals(f['last_modified'], lm)
|
||||
self.assertEqual(f['last_modified'], lm)
|
||||
else:
|
||||
f['last_modified'] = lm
|
||||
|
||||
@ -1449,11 +1449,11 @@ class TestFile(Base):
|
||||
|
||||
headers = dict(self.env.conn.response.getheaders())
|
||||
if format_type == 'json':
|
||||
self.assertEquals(headers['content-type'],
|
||||
'application/json; charset=utf-8')
|
||||
self.assertEqual(headers['content-type'],
|
||||
'application/json; charset=utf-8')
|
||||
elif format_type == 'xml':
|
||||
self.assertEquals(headers['content-type'],
|
||||
'application/xml; charset=utf-8')
|
||||
self.assertEqual(headers['content-type'],
|
||||
'application/xml; charset=utf-8')
|
||||
|
||||
lm_diff = max([f['last_modified'] for f in files]) -\
|
||||
min([f['last_modified'] for f in files])
|
||||
@ -1496,7 +1496,7 @@ class TestFile(Base):
|
||||
self.assert_('etag' in headers.keys())
|
||||
|
||||
header_etag = headers['etag'].strip('"')
|
||||
self.assertEquals(etag, header_etag)
|
||||
self.assertEqual(etag, header_etag)
|
||||
|
||||
def testChunkedPut(self):
|
||||
if (web_front_end == 'apache2'):
|
||||
@ -1514,7 +1514,7 @@ class TestFile(Base):
|
||||
self.assert_(data == file_item.read())
|
||||
|
||||
info = file_item.info()
|
||||
self.assertEquals(etag, info['etag'])
|
||||
self.assertEqual(etag, info['etag'])
|
||||
|
||||
|
||||
class TestFileUTF8(Base2, TestFile):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user